Methods

{
  "name": "Pipeline",
  "namespace": "sofa::core::collision",
  "module": "Sofa.framework.Core",
  "include": "sofa/core/collision/Pipeline.h",
  "doc": "Pipeline component gather list of collision models and control the sequence of computations",
  "inherits": [
    "BaseObject"
  ],
  "templates": [],
  "data_fields": [],
  "links": [],
  "methods": [
    {
      "name": "toPipeline",
      "return_type": "const Pipeline *",
      "params": [],
      "is_virtual": true,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "reset",
      "return_type": "void",
      "params": [],
      "is_virtual": true,
      "is_pure_virtual": true,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "computeCollisionReset",
      "return_type": "void",
      "params": [],
      "is_virtual": true,
      "is_pure_virtual": true,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "computeCollisionDetection",
      "return_type": "void",
      "params": [],
      "is_virtual": true,
      "is_pure_virtual": true,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "computeCollisionResponse",
      "return_type": "void",
      "params": [],
      "is_virtual": true,
      "is_pure_virtual": true,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "computeCollisions",
      "return_type": "void",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "getBroadPhaseDetection",
      "return_type": "const BroadPhaseDetection *",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "getNarrowPhaseDetection",
      "return_type": "const NarrowPhaseDetection *",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "getResponseList",
      "return_type": "int",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "doCollisionReset",
      "return_type": "void",
      "params": [],
      "is_virtual": true,
      "is_pure_virtual": true,
      "is_static": false,
      "access": "protected"
    },
    {
      "name": "doCollisionDetection",
      "return_type": "void",
      "params": [
        {
          "name": "collisionModels",
          "type": "const int &"
        }
      ],
      "is_virtual": true,
      "is_pure_virtual": true,
      "is_static": false,
      "access": "protected"
    },
    {
      "name": "doCollisionResponse",
      "return_type": "void",
      "params": [],
      "is_virtual": true,
      "is_pure_virtual": true,
      "is_static": false,
      "access": "protected"
    },
    {
      "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"
    }
  ],
  "description": "The `Pipeline` component in the SOFA framework is part of the collision detection and response system, specifically within the `sofa::core::collision` namespace. It gathers lists of collision models and controls the sequence of computations involved in detecting and responding to collisions. This component inherits from `BaseObject`, indicating its role as a fundamental object within the simulation environment.\n\nThe Pipeline interacts with other components through several virtual methods, such as `reset()`, `computeCollisionReset()`, `computeCollisionDetection()`, and `computeCollisionResponse()`—these define key stages of collision processing. It also provides accessors to retrieve broad-phase (`getBroadPhaseDetection()`) and narrow-phase detection algorithms (`getNarrowPhaseDetection()`), which are essential for detecting collisions at different levels of detail.\n\nIn practical usage, the Pipeline manages the sequence of computational steps necessary for handling collisions in a simulation. It ensures that collision responses from previous steps are removed (`computeCollisionReset`), new collisions are detected without modifying the simulation graph (`computeCollisionDetection`), and appropriate responses are added to the simulation graph (`computeCollisionResponse`). This sequential process is encapsulated within `computeCollisions()`. The component also includes methods for insertion into and removal from a node in the scene graph, ensuring proper integration within the broader simulation structure.",
  "maths": "The `Pipeline` component in the SOFA framework is primarily concerned with managing collision detection and response within a simulation. While it does not directly contribute to any governing equations or operators such as mass matrix \\(M\\), stiffness matrix \\(K\\), internal force \\(f_{int}\\), or residual \\(R\\) that are central to the FEM framework, its role is pivotal in ensuring physical consistency and numerical stability by handling collision interactions. Here is a detailed description of the mathematical and physical aspects related to this component:\n\n### Governing Equations and Operators\n- **Collision Detection**: The `Pipeline` does not directly implement any governing equations but rather orchestrates the detection of collisions between objects within the simulation. This is essential for ensuring that constraints are applied correctly when objects come into contact, thereby preserving physical consistency.\n\n- **Collision Response**: Similarly, the response to detected collisions involves enforcing boundary conditions and applying forces or constraints based on collision interactions. These responses must be consistent with the overall dynamics of the system.\n\n### Constitutive Laws and Kinematic Models\n- **Constraints Handling**: The component manages constraints arising from collision detection. When two objects come into contact, these constraints ensure that the kinematics and dynamics are properly updated to reflect incompressibility or other physical properties at the contact interface.\n\n- **Broad-Phase Detection**: This phase involves identifying pairs of potential colliding objects using spatial partitioning techniques such as bounding volume hierarchies (BVH). It reduces the number of pairwise comparisons needed for detailed collision detection, making the process computationally efficient.\n\n- **Narrow-Phase Detection**: Once candidate pairs are identified in the broad phase, the narrow phase uses more precise geometric algorithms to determine if an actual collision has occurred. This ensures that only true collisions are considered and processed further.\n\n### Role in FEM Pipeline\nThe `Pipeline` fits into the broader variational/Lagrangian mechanics framework as follows:\n\n- **Assembly Phase**: During assembly, the component does not directly contribute to the construction of global matrices or forces but instead ensures that all collision-related interactions are properly accounted for. This includes managing collision models and ensuring they are processed in a specific sequence.\n\n- **Time Integration**: The `computeCollisionReset`, `computeCollisionDetection`, and `computeCollisionResponse` methods ensure that collisions are handled at each time step of the simulation. By doing so, it supports implicit time integration schemes by enforcing constraints and applying contact forces correctly at each step.\n\n### Numerical Methods and Discretization Choices\n- **Sequence Control**: The component controls the sequence of computations involved in collision detection and response. This includes ensuring that collisions are detected accurately and that appropriate responses are applied without modifying the simulation graph.\n\n- **Broad/Narrow Phase Techniques**: It leverages broad-phase techniques to efficiently reduce the number of pairwise comparisons, followed by narrow-phase detailed geometric checks for actual collisions. These methods ensure robust collision handling while maintaining computational efficiency.\n\n### Constraint Handling\nThe `Pipeline` plays a critical role in constraint handling within the simulation framework:\n\n- **Constraint Jacobians**: While not explicitly calculating them, it ensures that constraints arising from collisions are properly enforced during the nonlinear solve phase.\n\nIn summary, although the `Pipeline` component does not directly contribute to the governing equations of FEM, its role in managing collision detection and response is essential for maintaining physical consistency and numerical stability within the simulation. It operates as a key part of the broader SOFA framework, ensuring that all interactions between objects are handled correctly and efficiently.",
  "abstract": "The `Pipeline` component manages collision detection and response sequences, ensuring proper constraint enforcement in SOFA simulations.",
  "sheet": "# Pipeline\n\n## Overview\nThe `Pipeline` component is part of the collision detection and response system within the SOFA framework. It gathers lists of collision models and controls the sequence of computations involved in detecting and responding to collisions. This ensures that all interactions between objects are handled correctly and efficiently, maintaining physical consistency.\n\n## Dependencies and Connections\nThe `Pipeline` typically requires other components such as `BroadPhaseDetection`, `NarrowPhaseDetection`, and various collision models (e.g., `CollisionModel`). It fits into the scene graph by managing the sequence of computational steps for handling collisions. The component interacts with these elements to ensure that collisions are detected accurately and appropriate responses are applied without modifying the simulation graph."
}