{
  "name": "BehaviorModel",
  "main": {
    "name": "BehaviorModel",
    "namespace": "sofa::core",
    "module": "Sofa.framework.Core",
    "include": "sofa/core/BehaviorModel.h",
    "doc": "Abstract Interface of components defining the behavior of a simulated object.\n This Interface is used by \"black-box\" objects (such as some fluid algorithms)\n that are present in a SOFA simulation but which do not use the internal\n behavior components (MechanicalState, ForceField, etc) defined in the\n sofa::core::behavior namespace.\n A BehaviorModel simply has to implement the updatePosition method\n to compute a new simulation step.",
    "inherits": [
      "BaseObject"
    ],
    "templates": [],
    "data_fields": [],
    "links": [],
    "methods": [
      {
        "name": "toBehaviorModel",
        "return_type": "const BehaviorModel *",
        "params": [],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "updatePosition",
        "return_type": "void",
        "params": [
          {
            "name": "dt",
            "type": "SReal"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": true,
        "is_static": false,
        "access": "public"
      },
      {
        "name": "addBBox",
        "return_type": "bool",
        "params": [
          {
            "name": "",
            "type": "SReal *"
          },
          {
            "name": "",
            "type": "SReal *"
          }
        ],
        "is_virtual": true,
        "is_pure_virtual": false,
        "is_static": false,
        "access": "public"
      },
      {
        "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"
      }
    ]
  },
  "desc": {
    "description": "The `BehaviorModel` is an abstract interface in the SOFA framework that defines the behavior of a simulated object, particularly for 'black-box' objects such as certain fluid algorithms. It allows components to be part of a SOFA simulation without relying on internal behavior components like MechanicalState or ForceField. The primary role of `BehaviorModel` is to implement the `updatePosition` method, which computes a new simulation step based on the given time increment (`dt`). This interface enables integration into the scene graph architecture by providing methods for inserting and removing itself from a `BaseNode`. It also includes an optional method `addBBox` for adding bounding boxes. The component inherits from `sofa::core::objectmodel::BaseObject`, ensuring it can interact seamlessly with other SOFA components within the simulation framework."
  },
  "maths": {
    "maths": "The `BehaviorModel` is an abstract interface in the SOFA framework designed to define the behavior of simulated objects, particularly for 'black-box' components such as certain fluid algorithms. This interface allows these components to integrate into a SOFA simulation without relying on internal behavior components like MechanicalState or ForceField.\n\n### Key Methods:\n- **updatePosition(SReal dt)**: This pure virtual method is responsible for computing the new positions of the object based on the given time increment (`dt`). The implementation details will depend on the specific derived class, but generally, it involves advancing the state of the object in the simulation. For example, if the `BehaviorModel` represents a fluid algorithm, this method might compute new velocities and positions for particles in the fluid domain.\n\n- **addBBox(SReal* minBBox, SReal* maxBBox)**: This virtual method is optional and can be implemented to add bounding boxes. The default implementation returns false, indicating that the behavior model does not provide bounding box information by default.\n\n### Integration in Scene Graph:\n- **insertInNode(objectmodel::BaseNode* node)**: Inserts the `BehaviorModel` into a specified `BaseNode`, allowing it to be part of the SOFA scene graph. This method is used for managing hierarchical relationships within the simulation environment.\n\n- **removeInNode(objectmodel::BaseNode* node)**: Removes the `BehaviorModel` from a specified `BaseNode`. This is useful when the behavior model needs to be dynamically added or removed during the course of a simulation.\n\n### Mathematical and Physical Context:\nWhile `BehaviorModel` itself does not define specific mathematical or physical equations, it serves as an interface that derived classes can implement. These derived classes might involve various physics-based simulations such as rigid body dynamics, fluid dynamics, soft tissue deformation, etc., each with their own set of governing equations.\n\nFor example:\n- **Rigid Body Dynamics**: The `updatePosition` method could solve the equations of motion for a rigid body, updating positions based on forces and torques over the time step `dt`.\n- **Fluid Dynamics**: The `updatePosition` method might implement numerical methods like finite difference or particle-based techniques to update fluid velocities and positions.\n\nIn summary, while `BehaviorModel` itself does not define specific mathematical models, it provides a flexible framework for integrating various behavior models into the SOFA simulation environment."
  },
  "summary": {
    "abstract": "`BehaviorModel` is an abstract interface in SOFA that defines the behavior of simulated objects by implementing the `updatePosition` method to compute new positions based on a time increment `dt`. It supports 'black-box' components without relying on internal behavior components like MechanicalState or ForceField.",
    "sheet": "# BehaviorModel\n\n**Overview**\n\nThe `BehaviorModel` is an abstract interface in SOFA that defines the behavior of simulated objects, particularly for 'black-box' components such as certain fluid algorithms. It does not rely on internal behavior components like MechanicalState or ForceField but instead implements the `updatePosition` method to compute new positions based on a time increment (`dt`). This allows integration into the scene graph architecture by providing methods for inserting and removing itself from a `BaseNode`. The optional `addBBox` method can be implemented to add bounding boxes.\n\n**Practical Notes**\n\nThe `updatePosition` method must be implemented in derived classes, which will define specific behaviors such as rigid body dynamics or fluid dynamics. Numerical stability and correctness depend on the implementation details of these derived classes. The optional `addBBox` method can provide bounding box information if needed for collision detection or visualization purposes."
  }
}