Methods

{
  "name": "UnbuiltConstraintSolver",
  "namespace": "sofa::component::constraint::lagrangian::solver",
  "module": "Sofa.Component.Constraint.Lagrangian.Solver",
  "include": "sofa/component/constraint/lagrangian/solver/UnbuiltConstraintSolver.h",
  "doc": "This component implements a generic way of preparing system for solvers that doesn't need\n a build version of the constraint matrix. Any solver that are based on an unbuilt system should\n inherit from this.\n This component is purely virtual because doSolve is not defined and needs to be defined in the\n inherited class",
  "inherits": [
    "GenericConstraintSolver"
  ],
  "templates": [],
  "data_fields": [],
  "links": [],
  "methods": [
    {
      "name": "initializeConstraintProblems",
      "return_type": "void",
      "params": [],
      "is_virtual": true,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "doBuildSystem",
      "return_type": "void",
      "params": [
        {
          "name": "cParams",
          "type": "const core::ConstraintParams *"
        },
        {
          "name": "problem",
          "type": "GenericConstraintProblem *"
        },
        {
          "name": "numConstraints",
          "type": "unsigned int"
        }
      ],
      "is_virtual": true,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "protected"
    }
  ],
  "description": "The `UnbuiltConstraintSolver` is an abstract class in the SOFA framework designed for preparing systems for solvers that do not require a built version of the constraint matrix. It serves as a base class for any solver that operates on an unbuilt system and must be inherited from to define specific solving methods.\n\n### Role and Purpose:\n- Implements a generic approach to prepare systems without building the constraint matrix, which is useful in scenarios where solvers need only the initial state or specific properties of constraints rather than their fully assembled form.\n- It ensures that subclasses properly initialize and manage the system for solving, particularly when dealing with constraints.\n\n### Interactions:\n- Inherits from `GenericConstraintSolver`, indicating it operates within the broader constraint-solving framework of SOFA.\n- Defines virtual methods (`initializeConstraintProblems` and `doBuildSystem`) which must be implemented by subclasses to handle specific preparation and initialization steps for solving constraint problems. These methods interact with other components such as constraint resolution mechanisms, ensuring that constraints are appropriately managed before being passed to a solver.\n\n### Practical Usage:\n- Subclasses of `UnbuiltConstraintSolver` should implement the `doSolve` method to define their specific solving logic, while leveraging the generic initialization and building processes provided by this class.\n- This component is typically used in scenarios where constraints are dynamically managed or where a full matrix build would be unnecessary or computationally expensive.",
  "maths": "The `UnbuiltConstraintSolver` is an abstract class designed for preparing systems in the SOFA framework without constructing a built version of the constraint matrix. This component serves as a base class for solvers that operate on unbuilt systems, and it must be inherited from to define specific solving methods.\n\n### Mathematical and Physical Description:\n\n#### Governing Equations or Operators:\n- The `UnbuiltConstraintSolver` does not directly implement any governing equations or operators such as the mass matrix \\( M \\), stiffness matrix \\( K \\), internal force \\( f_{int} \\), or residual \\( R \\). Instead, it is designed to prepare systems for solvers that do not require these matrices in a fully assembled form.\n\n#### Constitutive or Kinematic Laws Involved:\n- The `UnbuiltConstraintSolver` does not define any specific constitutive laws (strain measures, stress tensors, hyperelastic potentials) or kinematic laws. It is agnostic to the type of constraints it manages and interacts with other components that handle such details.\n\n#### Role in the Global FEM Pipeline:\n- **Assembly Phase:** The `UnbuiltConstraintSolver` contributes to preparing the system for solving without constructing a full constraint matrix, which can be beneficial in scenarios where dynamic or partial updates are required. It initializes and manages the constraints through methods like `initializeConstraintProblems` and `doBuildSystem`, ensuring that all necessary data structures (e.g., sequences of constraints) are properly set up.\n- **Nonlinear Solve:** The solver does not define a nonlinear solve method (`doSolve`). This must be implemented by any subclass, leveraging the generic initialization provided by this class.\n\n#### Numerical Methods or Discretization Choices:\n- The `UnbuiltConstraintSolver` is designed to handle constraints without requiring a full matrix build. It operates on unbuilt systems and ensures that all necessary data structures are initialized correctly. This approach can be more efficient in scenarios where dynamic updates or partial system evaluations are required.\n\n#### Integration into the Variational/Lagrangian Mechanics Framework:\n- The `UnbuiltConstraintSolver` fits into the broader variational mechanics framework by preparing the constraint problems for solvers that do not require a fully assembled constraint matrix. It ensures that all necessary structures and data (such as sequences of constraints, compliance matrices) are initialized properly before passing them to specific solving methods implemented in subclasses.\n\n### Key Mathematical Insight:\n- The `UnbuiltConstraintSolver` is primarily concerned with initializing and preparing the system for solvers that operate on unbuilt systems. It does not directly contribute to any specific mathematical operations or governing equations but ensures that the necessary structures are correctly set up, enabling efficient and dynamic constraint management.",
  "abstract": "The `UnbuiltConstraintSolver` prepares systems for solvers without constructing a built version of the constraint matrix, serving as an abstract base class for specific solving methods.",
  "sheet": "<h1>UnbuiltConstraintSolver</h1>\n\n<h2>Overview</h2>\n<p>The `UnbuiltConstraintSolver` is an abstract component in the SOFA framework designed to prepare systems for solvers that do not require a built version of the constraint matrix. It inherits from <code>GenericConstraintSolver</code> and defines virtual methods such as <code>initializeConstraintProblems</code> and <code>doBuildSystem</code>, which must be implemented by subclasses to handle specific initialization and preparation steps for solving constraint problems.</p>\n\n<h2>Dependencies and Connections</h2>\n<p>This component is purely abstract and serves as a base class. It inherits from <code>GenericConstraintSolver</code> and interacts with other components that manage constraints, ensuring they are properly initialized before being passed to specific solvers implemented in subclasses.</p>"
}