{
  "name": "BaseLinearSolver",
  "main": {
    "name": "BaseLinearSolver",
    "namespace": "sofa::core::behavior",
    "module": "Sofa.framework.Core",
    "include": "sofa/core/behavior/BaseLinearSolver.h",
    "doc": "Abstract base class (as type identifier) for linear system solvers without any API",
    "inherits": [
      "BaseObject"
    ],
    "templates": [],
    "data_fields": [],
    "links": [],
    "methods": [
      {
        "name": "toBaseLinearSolver",
        "return_type": "const BaseLinearSolver *",
        "params": [],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "insertInNode",
        "return_type": "bool",
        "params": [
          {
            "name": "node",
            "type": "objectmodel::BaseNode *"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "removeInNode",
        "return_type": "bool",
        "params": [
          {
            "name": "node",
            "type": "objectmodel::BaseNode *"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      }
    ]
  },
  "desc": {
    "description": "The `BaseLinearSolver` is an abstract base class in the SOFA framework, identified by its namespace `sofa::core::behavior`. It serves as a type identifier for linear system solvers but does not provide any API or direct functionality itself. Instead, it inherits from `objectmodel::BaseObject` and provides virtual methods to insert and remove instances of itself within nodes in the SOFA scene graph (`insertInNode`, `removeInNode`). These methods facilitate the integration of specific linear solvers into the simulation framework, enabling them to participate in solving linear systems that arise during simulations. The component is a foundational element for implementing concrete linear solver classes."
  },
  "maths": {
    "maths": "The `BaseLinearSolver` is an abstract base class in the SOFA framework that serves as a type identifier for linear system solvers. It does not provide any direct mathematical or physical functionality but rather establishes the necessary infrastructure to integrate specific linear solvers into the simulation framework.\n\n### Governing Equations and Operators:\n- **Linear System Solvers**: The `BaseLinearSolver` class is intended to be inherited by concrete implementations of linear system solvers. These solvers are responsible for solving systems of linear equations that arise during various stages of FEM simulations, such as the assembly phase or during time integration.\n\n### Constitutive and Kinematic Laws:\n- **None**: The `BaseLinearSolver` itself does not implement any constitutive or kinematic laws. It is a purely abstract class designed to be extended by concrete solver implementations that handle specific mathematical operations.\n\n### Role in the Global FEM Pipeline:\n- **Assembly**: During the assembly phase of FEM simulations, linear systems are constructed from the stiffness matrix $K$, mass matrix $M$, and internal force vector $f_{int}$. The `BaseLinearSolver` class is part of the infrastructure that enables these systems to be solved efficiently.\n\n- **Time Integration**: Implicit time integration schemes often require solving a system of linear equations. For example, in an implicit Euler scheme, the equation to solve at each step is:\n  \\\\[ M \\dot{x}(t + dt) + K x(t+dt) = f_{ext}(t+dt) - f_{int}(x(t), t+dt) \\\\]\n\n- **Nonlinear Solve**: In nonlinear FEM simulations, the Newton-Raphson method often requires solving a linear system at each iteration. The `BaseLinearSolver` class supports these operations by enabling the integration of specific solvers.\n\n- **Linear Solve**: During the solution phase of an FEM simulation, systems like $Ax = b$ must be solved where $A$ can represent various matrices (e.g., stiffness matrix, mass matrix).\n\n### Numerical Methods and Discretization Choices:\n- **None**: The `BaseLinearSolver` itself does not encode any specific numerical methods or discretization choices. It is an abstract class that facilitates the integration of such methods through its subclasses.\n\n### Variational/Lagrangian Mechanics Framework:\n- **Integration in FEM Pipeline**: The `BaseLinearSolver` fits into the broader variational and Lagrangian mechanics framework by providing a mechanism for integrating linear solvers into the SOFA simulation pipeline. This allows for the efficient solution of the linear systems that arise during assembly, time integration, and nonlinear solve steps.\n\n### Summary:\n- **Role**: The `BaseLinearSolver` is foundational for implementing concrete linear solver classes within the SOFA framework. It does not contribute directly to mathematical or physical operations but provides necessary infrastructure and type identification."
  },
  "summary": {
    "abstract": "`BaseLinearSolver` is an abstract base class for linear system solvers in SOFA, providing necessary infrastructure and type identification without direct functionality.",
    "sheet": "# BaseLinearSolver\n\n## Overview\nThe `BaseLinearSolver` is an abstract base class that serves as a type identifier for linear system solvers within the SOFA framework. It does not provide any direct mathematical or physical functionality but establishes the necessary infrastructure to integrate specific linear solvers into the simulation pipeline through virtual methods (`insertInNode`, `removeInNode`). These methods facilitate the insertion and removal of solver instances within nodes in the scene graph."
  }
}