{
  "name": "ConstantSparsityProjectionMethod",
  "main": {
    "name": "ConstantSparsityProjectionMethod",
    "namespace": "sofa::component::linearsystem",
    "module": "Sofa.Component.LinearSystem",
    "include": "sofa/component/linearsystem/ConstantSparsityProjectionMethod.h",
    "doc": "Matrix mapping computing the matrix projection taking advantage of the constant sparsity pattern.\n\nMatrix projection method computing the matrix projection taking advantage of the constant sparsity pattern",
    "inherits": [
      "MatrixProjectionMethod"
    ],
    "templates": [
      "sofa::linearalgebra::CompressedRowSparseMatrix<SReal>"
    ],
    "data_fields": [
      {
        "name": "d_parallelProduct",
        "type": "bool",
        "xmlname": "parallelProduct",
        "help": "Compute the matrix product in parallel"
      }
    ],
    "links": [],
    "methods": [
      {
        "name": "init",
        "return_type": "void",
        "params": [],
        "is_virtual": false,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "reinit",
        "return_type": "void",
        "params": [],
        "is_virtual": false,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "computeProjection",
        "return_type": "void",
        "params": [
          {
            "name": "KMap",
            "type": "const int"
          },
          {
            "name": "",
            "type": "const int"
          }
        ],
        "is_virtual": false,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "protected"
      }
    ]
  },
  "desc": {
    "description": "The `ConstantSparsityProjectionMethod` is a component in the SOFA framework under the namespace `sofa::component::linearsystem`, part of the module `Sofa.Component.LinearSystem`. It extends the `MatrixProjectionMethod` to perform matrix projection computations while taking advantage of a constant sparsity pattern, which can enhance performance by optimizing operations on sparse matrices.\n\nThis component inherits from `MatrixProjectionMethod` and is specifically templated for use with `sofa::linearalgebra::CompressedRowSparseMatrix<SReal>`. It provides methods to initialize (`init`) and reinitialize (`reinit`). The core functionality is encapsulated in the protected method `computeProjection`, which computes the projection of matrices taking advantage of constant sparsity.\n\nThe component includes a data field `d_parallelProduct` (boolean), accessible via the XML attribute `parallelProduct`, to control whether matrix products are computed in parallel. If enabled, this feature uses task schedulers from SOFA's simulation module for parallel processing, potentially speeding up computations."
  },
  "maths": {
    "maths": "<maths>\n\n### Mathematical Description\n\nThe `ConstantSparsityProjectionMethod` is designed to compute matrix projections while leveraging the constant sparsity pattern of matrices. This approach aims to optimize performance by minimizing operations on zero-valued elements in sparse matrices.\n\n#### Matrix Projection Computation\n\nGiven a sparse matrix \\(K\\) and two Jacobian matrices \\(J_0\\) and \\(J_1\\), the component computes the projection \\(JT_K_J\\) defined as:\n\n$$\nJT_K_J = J_0^T K J_1\n$$\n\nWhere:\n- \\(K\\): Sparse matrix representing a stiffness or transformation matrix.\n- \\(J_0\\), \\(J_1\\): Jacobian matrices, which may be used to represent constraints or mappings between different spaces.\n- \\(JT_K_J\\): The resulting projection of the matrix product.\n\n#### Constant Sparsity Pattern Optimization\n\nThe constant sparsity pattern refers to the fixed positions of non-zero elements in sparse matrices. By leveraging this pattern, the component avoids unnecessary computations on zero-valued entries, thus improving computational efficiency.\n\n#### Parallel Matrix Product\n\nTo further enhance performance, the component can optionally compute matrix products in parallel using a task scheduler from SOFA's simulation module. This feature is controlled by the boolean data field `d_parallelProduct`:\n- When `d_parallelProduct` is set to `true`, matrix multiplications are computed in parallel.\n- Otherwise, computations are performed sequentially.\n\n### Physical Interpretation\n\nIn the context of physical simulations within SOFA, this component can be used for various tasks such as constraint enforcement or transformation operations between different coordinate systems. The optimization via constant sparsity pattern is particularly useful when dealing with large sparse matrices that arise in complex physical models.\n\n#### Example Usage\n\nConsider a physical system where constraints are imposed on a set of particles. These constraints can be represented by Jacobian matrices \\(J_0\\) and \\(J_1\\), while the stiffness matrix \\(K\\) describes the elastic properties of the system. The projection \\(JT_K_J\\) computed by `ConstantSparsityProjectionMethod` helps in enforcing these constraints efficiently.\n\n#### Summary\n\nThe `ConstantSparsityProjectionMethod` is a specialized component that optimizes sparse matrix operations, particularly useful for large-scale physical simulations. By leveraging constant sparsity patterns and optionally using parallel processing, it enhances computational efficiency while maintaining the accuracy of the underlying physical models.\n</maths>"
  },
  "summary": {
    "abstract": "The ConstantSparsityProjectionMethod computes matrix projections while optimizing operations on sparse matrices with constant sparsity patterns. It optionally supports parallel computation of matrix products.",
    "sheet": "<p># ConstantSparsityProjectionMethod</p>\n\n<p><strong>Overview:</strong></p>\n\n<p>The <code>ConstantSparsityProjectionMethod</code> is a specialized component for computing matrix projections in the SOFA framework. It leverages constant sparsity patterns to optimize performance, particularly useful for large-scale physical simulations involving sparse matrices.</p>\n\n<p><strong>Mathematical Model:</strong></p>\n\n<p>The <code>ConstantSparsityProjectionMethod</code> computes the projection of a matrix product while taking advantage of the constant sparsity pattern. Given a sparse matrix <span class=\"math-inline\">\\(K\\)</span>, and two Jacobian matrices <span class=\"math-inline\">\\(J_0\\)</span> and <span class=\"math-inline\">\\(J_1\\)</span>, it computes:</p>\n\n<p><span class=\"math-display\">\\[JT_K_J = J_0^T K J_1\\]</span></p>\n\n<p>This projection leverages the constant sparsity pattern to avoid unnecessary computations on zero-valued entries, thus improving efficiency.</p>\n\n<p><strong>Parameters and Data:</strong></p>\n\n<ul>\n<li><code>d_parallelProduct</code>: A boolean parameter that controls whether matrix products are computed in parallel. When set to <code>true</code>, the component uses task schedulers from SOFA's simulation module for parallel processing.</li>\n</ul>"
  }
}