Methods

{
  "name": "ParallelCGLinearSolver",
  "namespace": "multithreading::component::linearsolver::iterative",
  "module": "MultiThreading",
  "include": "MultiThreading/component/linearsolver/iterative/ParallelCGLinearSolver.h",
  "doc": "Parallel version of the linear solver using the conjugate gradient iterative algorithm.",
  "inherits": [
    "CGLinearSolver",
    "TaskSchedulerUser"
  ],
  "templates": [
    "ParallelCompressedRowSparseMatrixMechanical<SReal>, sofa::linearalgebra::FullVector<SReal>",
    "ParallelCompressedRowSparseMatrixMechanical<sofa::type::Mat<3,3,SReal>>, sofa::linearalgebra::FullVector<SReal>"
  ],
  "data_fields": [],
  "links": [],
  "methods": [
    {
      "name": "init",
      "return_type": "void",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "solve",
      "return_type": "void",
      "params": [
        {
          "name": "A",
          "type": "Matrix &"
        },
        {
          "name": "x",
          "type": "Vector &"
        },
        {
          "name": "b",
          "type": "Vector &"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    }
  ],
  "description": "The `ParallelCGLinearSolver` is a parallel version of the linear solver using the conjugate gradient iterative algorithm in the SOFA framework. This component belongs to the `MultiThreading` module and inherits from both `CGLinearSolver` and `TaskSchedulerUser`. It operates on matrices and vectors, specifically designed for parallel processing within SOFA simulations.\n\nThe primary role of this component is to provide a high-performance solution for large-scale linear systems by leveraging multiple threads. It interacts with other components through the API by implementing methods like `init()` and `solve()`, where `solve` takes three parameters: matrix A, vector x (solution), and vector b (right-hand side). This method sets up task scheduling to optimize parallel execution.\n\nThis component is suitable for scenarios requiring efficient linear system solving in parallel environments. The data fields are not explicitly listed, indicating that it primarily relies on inherited functionalities from its parent classes.",
  "maths": "The `ParallelCGLinearSolver` is a parallel implementation of the conjugate gradient (CG) iterative algorithm within the SOFA framework. It is designed to solve large-scale linear systems efficiently by leveraging multiple threads, making it suitable for high-performance computing environments. The component inherits from `CGLinearSolver`, which itself implements the standard CG method, and from `TaskSchedulerUser` for parallel execution management.\n\n### Governing Equations or Operators\nThe primary governing equation this component addresses is a linear system of equations:\n\\[\nA \\mathbf{x} = \\mathbf{b}\n\\]\nwhere \\( A \\) is the matrix representing the linear operator (e.g., stiffness matrix in FEM), \\( \\mathbf{x} \\) is the solution vector, and \\( \\mathbf{b} \\) is the right-hand side vector. The `solve` method takes these as input parameters.\n\n### Numerical Methods or Discretization Choices\nThe component uses the Conjugate Gradient (CG) algorithm, which is an iterative method for solving symmetric positive-definite linear systems. Given a matrix \\( A \\) and vectors \\( \\mathbf{x} \\) and \\( \\mathbf{b} \\), the CG method iteratively improves the solution until convergence criteria are met.\n\nThe `ParallelCGLinearSolver` specifically employs parallel processing to speed up this iterative process, utilizing task scheduling for efficient thread management. The `solve` method sets up the task scheduler via:\n\\[\nA.setTaskScheduler(this->m_taskScheduler)\n\\]\nwhich optimizes the execution of CG iterations across multiple threads.\n\n### Role in the Global FEM Pipeline\nIn the context of the Finite Element Method (FEM) pipeline, this component plays a crucial role during the linear solve phase. Specifically, it is involved in solving the following systems:\n- **Mass Matrix and Internal Force Contributions:** During each time step, after assembling global contributions such as mass matrix \\( M \\) and internal forces \\( f_{int} \\), these are combined into a large linear system of equations.\n\\[\nM \frac{\triangle x}{\triangle t} - \triangle t K(x_k)\triangle x = \triangle t (f_{ext} - f_{int}(x_k))\n\\]\nThe solution \\( \triangle x \\) is then used to update the state of the system.\n\n- **Nonlinear Solve:** In the nonlinear resolution phase, within each Newton iteration, the linear system \\( J(x)\triangle x = -R(x) \\) needs to be solved. Here, \\( J(x) \\) represents the Jacobian matrix and \\( R(x) \\) is the residual vector.\n\n### Constraints and Extensibility\nThe `ParallelCGLinearSolver` does not directly handle constraints or mappings itself but works in conjunction with other components that define such constraints (e.g., Lagrange multipliers for holonomic constraints). The CG method inherently supports symmetric positive-definite matrices, which can be modified to accommodate constraint equations through appropriate preconditioning techniques.\n\n### Summary\nThe `ParallelCGLinearSolver` is a key component in the SOFA framework's linear solver hierarchy. It provides efficient parallel execution of the conjugate gradient algorithm for solving large-scale linear systems that arise from FEM simulations. By leveraging task scheduling and multithreading, it significantly enhances computational performance, making it suitable for high-fidelity real-time or offline simulations involving complex deformable bodies.",
  "abstract": "The `ParallelCGLinearSolver` provides a parallel implementation of the conjugate gradient algorithm for solving large-scale symmetric positive-definite linear systems in SOFA simulations, enhancing computational performance through multithreading.",
  "sheet": "<h1>ParallelCGLinearSolver</h1>\n\n<h2>Overview</h2>\n<p>The `ParallelCGLinearSolver` is an iterative linear solver component that leverages parallel processing for solving large-scale symmetric positive-definite systems. It inherits from <code>CGLinearSolver</code> and <code>TaskSchedulerUser</code>, indicating its role in managing task scheduling for efficient multithreading.</p>\n\n<h2>Mathematical Model</h2>\n<p>The `ParallelCGLinearSolver` addresses the standard linear system:</p>\n\\[ A \\mathbf{x} = \\mathbf{b} \\]\n<p>where <code>A</code> is a matrix representing the linear operator (e.g., stiffness matrix), <code>\\mathbf{x}</code> is the solution vector, and <code>\\mathbf{b}</code> is the right-hand side vector. The component uses the Conjugate Gradient (CG) algorithm to iteratively solve this system.</p>\n\n<h2>Parameters and Data</h2>\n<p>The `ParallelCGLinearSolver` does not expose any significant data fields beyond those inherited from its parent classes, indicating that it primarily relies on inherited functionalities for configuration.</p>\n\n<h2>Dependencies and Connections</h2>\n<p>This component typically requires a matrix <code>A</code>, solution vector <code>x</code>, and right-hand side vector <code>b</code>. It fits into the scene graph by interacting with other components that define these matrices and vectors, such as mechanical models or constraint systems.</p>\n\n<h2>Practical Notes</h2>\n<p>The `ParallelCGLinearSolver` is designed for high-performance computing environments where parallel processing can significantly enhance computational performance. Users should ensure that the matrix <code>A</code> is symmetric positive-definite to guarantee convergence of the CG algorithm. Additionally, proper task scheduling and thread management are crucial for optimal performance.</p>"
}