{
  "name": "CollisionAnimationLoop",
  "main": {
    "name": "CollisionAnimationLoop",
    "namespace": "sofa::simulation",
    "module": "Sofa.framework.Simulation.Core",
    "include": "sofa/simulation/CollisionAnimationLoop.h",
    "doc": "Component responsible for main simulation algorithms, managing how\n and when collisions and integrations computations happen.\n This class can optionally replace the default computation scheme of computing\n collisions then doing an integration step.\n Note that it is in a preliminary stage, hence its functionalities and API will\n certainly change soon.",
    "inherits": [
      "BaseAnimationLoop"
    ],
    "templates": [],
    "data_fields": [],
    "links": [],
    "methods": [
      {
        "name": "preCollisionComputation",
        "return_type": "void",
        "params": [
          {
            "name": "params",
            "type": "const core::ExecParams *"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "protected"
      },
      {
        "name": "internalCollisionComputation",
        "return_type": "void",
        "params": [
          {
            "name": "params",
            "type": "const core::ExecParams *"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "protected"
      },
      {
        "name": "postCollisionComputation",
        "return_type": "void",
        "params": [
          {
            "name": "params",
            "type": "const core::ExecParams *"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "protected"
      },
      {
        "name": "computeCollision",
        "return_type": "void",
        "params": [
          {
            "name": "params",
            "type": "const core::ExecParams *"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "protected"
      },
      {
        "name": "integrate",
        "return_type": "void",
        "params": [
          {
            "name": "params",
            "type": "const core::ExecParams *"
          },
          {
            "name": "dt",
            "type": "SReal"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "protected"
      },
      {
        "name": "getSolverSequence",
        "return_type": "const Solvers &",
        "params": [],
        "is_virtual": false,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "protected"
      }
    ]
  },
  "desc": {
    "description": "The `CollisionAnimationLoop` is a component in the SOFA framework, specifically part of the Sofa.framework.Simulation.Core module. It inherits from `BaseAnimationLoop` and is responsible for managing main simulation algorithms that control how and when collision computations and integration steps occur during a simulation.\n\nThis class can replace the default computation scheme by computing collisions before performing an integration step. However, it is noted to be in a preliminary stage, meaning its functionalities and API are subject to change.\n\nThe `CollisionAnimationLoop` interacts with other components through virtual methods such as `preCollisionComputation`, `internalCollisionComputation`, `postCollisionComputation`, `computeCollision`, and `integrate`. These methods facilitate the collision detection and integration process by executing visitors within the scene graph. The component also provides a method to retrieve the solver sequence, facilitating access to the ODE solvers used during the simulation.\n\nPractical usage involves employing this class for simulations where precise control over collision computation and integration timing is required. It primarily operates on `core::ExecParams` parameters and manages events such as collision begin, collision end, and integrate events through event visitors."
  },
  "maths": {
    "maths": "The `CollisionAnimationLoop` is a key component in the SOFA framework responsible for orchestrating simulation algorithms, particularly managing collision computations and integration steps during a simulation. Although it does not directly involve mathematical operations or physical laws per se, its role is critical in ensuring that these processes occur at the appropriate times within the simulation loop.\n\n### Mathematical and Physical Context:\n\n#### 1. Collision Detection and Management:\n- **Collision Computation:** The component manages collision computations through a series of virtual methods: `preCollisionComputation`, `internalCollisionComputation`, and `postCollisionComputation`. These methods allow for the execution of visitors within the scene graph, which are responsible for detecting collisions between objects.\n  - *Mathematical Operations:* Collision detection often involves geometric operations such as checking for intersections between shapes (e.g., spheres, boxes) or using distance metrics to determine if two objects have come into contact. These operations are typically based on linear algebra and geometry principles.\n\n#### 2. Integration Steps:\n- **Integration:** The `integrate` method is responsible for advancing the simulation in time by integrating equations of motion. This involves updating positions, velocities, and other state variables using numerical integration schemes (e.g., Euler's method, Runge-Kutta methods).\n  - *Mathematical Operations:* Integration typically involves solving differential equations that describe the physical behavior of objects. For example, Newton’s laws are used to update the position and velocity of rigid bodies.\n\n### Key Methods:\n- **preCollisionComputation:**\n  - *Purpose:* Executes actions before collision detection begins.\n  - *Mechanism:* Propagates a `CollisionBeginEvent` through the scene graph using event visitors.\n\n- **internalCollisionComputation:**\n  - *Purpose:* Performs actual collision detection between objects in the simulation.\n  - *Mechanism:* Uses a `CollisionVisitor` to execute collision detection algorithms.\n\n- **postCollisionComputation:**\n  - *Purpose:* Executes actions after all collisions have been computed and processed.\n  - *Mechanism:* Propagates a `CollisionEndEvent` through the scene graph using event visitors.\n\n- **integrate:**\n  - *Purpose:* Advances the simulation by integrating equations of motion over time steps.\n  - *Mechanism:* Uses an `IntegrateBeginEvent` and `IntegrateEndEvent` to mark the beginning and end of integration. It also employs a `MechanicalIntegrationVisitor` to update physical state variables.\n\n### Event Handling:\n- **Events:** The component manages various events such as collision begin, collision end, integrate begin, and integrate end using event visitors (`PropagateEventVisitor`). These events ensure that all necessary pre-processing and post-processing steps are performed at the appropriate times.\n\n#### Integration Pipeline:\n- **OdeSolvers:** The `getSolverSequence` method provides access to a sequence of ODE solvers used in the simulation. This allows for flexibility in choosing integration schemes that best fit the physical models being simulated.\n\n### Summary:\nWhile `CollisionAnimationLoop` itself does not perform direct mathematical or physical computations, it is fundamental in orchestrating the simulation pipeline by managing collision detection and integration steps. Its methods ensure that these processes occur at the correct times within the overall simulation loop, thereby enabling accurate and efficient simulation of complex physical systems."
  },
  "summary": {
    "abstract": "The `CollisionAnimationLoop` manages collision detection and integration steps during simulations by controlling when collisions are computed and integrated into the simulation loop.",
    "sheet": "# CollisionAnimationLoop\n\n## Overview\n\nThe `CollisionAnimationLoop` is a component in the SOFA framework responsible for orchestrating main simulation algorithms. It controls how and when collision computations and integration steps occur, replacing the default computation scheme by computing collisions before performing an integration step.\n\n## Practical Notes\n\nThis component is in a preliminary stage, meaning its functionalities and API are subject to change. Practitioners should be aware of potential updates and ensure compatibility with future versions."
  }
}