`SceneCheckAPIChange` verifies that components have not changed in behavior since a specified reference version of SOFA, ensuring backward compatibility and detecting changes in API usage across diffe…

The `SceneCheckCollisionResponse` ensures that necessary collision response components and configurations are present in the scene, verifying conditions for proper collision handling.

The `SceneCheckDeprecatedComponents` identifies and reports deprecated components in a SOFA scenegraph to maintain up-to-date simulations.

The `SceneCheckDuplicatedName` component checks for duplicate object and node names within the SOFA scenegraph, ensuring consistent naming to prevent potential crashes or unexpected behavior.

The `SceneCheckEmptyNodeName` component ensures all nodes within a SOFA simulation have non-empty names, generating warnings for unnamed nodes during initialization and runtime.

This SceneCheck is motivated by the visitor mechanism that assumes: If both a mechanical state and a mapping are present in a Node, the state is considered mapped, no matter if they are related or not…

The `SceneCheckMissingRequiredPlugin` ensures that all required plugins are correctly imported into a SOFA simulation scene, preventing errors due to missing dependencies.

The `SceneCheckUsingAlias` component monitors and reports on instances where SOFA components are instantiated with aliases differing from their true class names to prevent confusion in simulation setu…

`SceneCheckerVisitor` validates nodes within the SOFA scene graph for correctness and consistency by applying a set of checks during top-down traversal.

Computes the atrial pressure with sigmoids Computes Pat(t)

Computes the next phase of the ventricle cardiac cycle

Parallel animation loop, using the Intel tbb library.

Set the positions and velocities of points attached to a beam using linear interpolation between DOFs.

Component for data memory sharing in the context of multi-threading applications

Compute the mean of the input elements. This class merge 2 coordinate vectors.

Parallel version of the narrow phase collision detection based on boundary volume hierarchy.

Parallel version of the collision detection using extensive pair-wise tests performed concurrently. A parallel implementation of the component BruteForceBroadPhase The work is divided into n tasks ex…

Parallel version of the linear solver using the conjugate gradient iterative algorithm.

Parallel implementation of a linear elastic material using hexahedral finite elements. Parallel implementation of HexahedronFEMForceField This implementation is the most efficient when: 1) the number…

Parallel stiff springs acting along the edges of a mesh.

Parallel stiff springs.

Parallel implementation of a linear elastic material using tetrahedral finite elements.. Parallel implementation of TetrahedronFEMForceField This implementation is the most efficient when: 1) the num…

SceneCheckMultithreading identifies sequential components within the SOFA scene graph that can be replaced with their multithreaded equivalents to improve simulation performance.

Constraint animation loop manager

( The animation loop to use with constraints. You must add this loop at the beginning of the scene if you are using constraints.

Multi steps animation loop, multi integration steps in a single animation step are managed.

Simple animation loop that given a list of tags, animate the graph one tag after another.

Narrow phase collision detection based on boundary volume hierarchy. Narrow phase collision detection based on bounding volume hierarchy The algorithm uses the result of a broad phase collision detec…

Broad phase collision detection using extensive pair-wise tests. Perform an extensive pair-wise collision test based on the bounding volume of collision models This component is a broad phase algorit…

Combination of brute force broad phase and BVH narrow phase collision detection.

The default collision detection and modeling pipeline.

Collision detection using sweep and prune.

Narrow phase of the collision detection using sweep and prune. This class is an implementation of sweep and prune in its "direct" version, i.e. at each step it sorts all the primitives along an axis …

Collision detection using incremental sweep and prune. Implementation of incremental sweep and prune. i.e. collision primitives are stored and updated which should speed up the collision detection co…

Collision detection using TriangleOctreeModel. It is a Ray Trace based collision detection algorithm For each point in one object, we trace a ray following the opposite of the point's normal up t…

Narrow phase of the collision detection using TriangleOctreeModel It is a Ray Trace based collision detection algorithm For each point in one object, we trace a ray following the opposite of the po…

Base class for intersections methods using proximities. It introduces Datas for the alarm distance and contact distance. Cubes intersection is modified to use proximities.

A set of methods to compute (for constraint methods) if two primitives are close enough to consider they collide Intersection methods using proximities. Filters are added to limit the number of conta…

Detect intersection using discrete methods.

A set of methods to compute (for constraint methods) if two primitives are close enough to consider they collide Intersection methods using proximities. Filters are added to limit the number of conta…

A set of methods to compute if two primitives are close enough to consider they collide. Basic intersection methods using proximities It uses proximities on cubes and spheres, but supported pairs of …

Optimized Proximity Intersection based on Triangle-Triangle tests, ignoring Edge-Edge cases It uses proximities on cubes and spheres, but supported pairs of collision models can be extended. For exam…

Collision model representing a cube.

Collision model which represents a set of rigid cylinders. CylinderModel templated by RigidTypes (frames), direction is given by Y direction of the frame.

Collision model using a linear mesh, as described in MeshTopology.

Collision model which represents a set of points.

Collision model representing a ray in space, e.g. a mouse click

Collision model which represents a set of Spheres.

Collision model using a tetrahedral mesh, as described in BaseMeshTopology.

Collision model using a triangular mesh, as described in BaseMeshTopology. This class will create collision elements based on a triangle and/or quad mesh. It uses directly the information of the topo…

The BarycentricPenalityContact component handles contact interactions between different collision models in SOFA using a penalty method that computes repulsive forces based on penetration depth.

The BarycentricStickContact component manages forces between colliding objects using stick-like spring elements, ensuring realistic physical behavior through elasticity and damping.

Default class to create reactions to the collisions.

The `ContactIdentifier` generates unique identifiers for each detected contact point in collision response systems, ensuring efficient management of interaction data between colliding objects.

Utility component to retrieve information about contacts.

Contact using repulsive springs. Distance-based, frictionless penalty force. The force is applied to vertices attached to collision elements.

Create different response to the collisions based on a set of rules.

The `StickContactConstraint` component enforces stick-like contact constraints between various collision models by creating bilateral Lagrangian constraints and managing detection outputs within SOFA …

Base class for all mappers using BarycentricMapping

Base class common to all mappers able to provide a MechanicalState of a given type

Base class for IdentityMapping based mappers

Base class for all mappers using RigidMapping

Base class for all mappers using SubsetMapping

Component computing constraint forces within a simulated body using the compliance method.

Component computing constraint forces within a simulated body using the compliance method. Component computing constrained forces within a simulated body using the compliance method.

Component precomputing constraint forces within a simulated body using the compliance method. It approximates the compliance matrix by a precomputed matrix inverse. The approximation can be updated ba…

Component computing constraint forces within a simulated body using the compliance method, approximating the compliance matrix by a diagonal matrix. Component computing constraint forces within a sim…

BilateralLagrangianConstraint defining an holonomic equality constraint (attachment).

Lagrangian-based fixation of DOFs of the model.

Lagrangian-based partial fixation of DOFs of the model, along an axis.

Lagrangian-based constraint forcing a 1D DoF to be inside a given range.

A constraint equation applied on all dofs.

A Constraint Solver using the Linear Complementarity Problem formulation to solve Constraint based components using a Block Gauss-Seidel iterative method

This component implements a generic way of building system for solvers that use a built version of the constraint matrix. Any solver that uses a build matrix should inherit from this. This component…

The `ConstraintSolverImpl` class serves as an abstract base for implementing constraint solvers within the Lagrangian solver context in SOFA, handling constraints using Lagrange multipliers and iterat…

The `ConstraintStoreLambdaVisitor` stores Lagrangian multipliers associated with constraint forces into a vector during simulation steps, inheriting from `BaseMechanicalVisitor` to process mechanical …

The `GenericConstraintSolver` handles general constraint problems in Lagrangian mechanics by solving systems of constraints using iterative methods like Gauss-Seidel with Successive Over Relaxation (S…

A Constraint Solver using the Linear Complementarity Problem formulation to solve Constraint based components using a Projected Jacobi iterative method

A Constraint Solver using the Linear Complementarity Problem formulation to solve BaseConstraint based components.

The `MechanicalGetConstraintResolutionVisitor` collects constraint resolutions from `BaseConstraintSet` objects within a SOFA simulation node, facilitating the nonlinear resolution phase of FEM simula…

Gets the vector of constraint violation values

A Constraint Solver using the Linear Complementarity Problem formulation to solve Constraint based components using the Non-smooth Non-linear Conjugate Gradient method

This component implements a generic way of preparing system for solvers that doesn't need a build version of the constraint matrix. Any solver that are based on an unbuilt system should inherit from…

A Constraint Solver using the Linear Complementarity Problem formulation to solve Constraint based components using an Unbuilt version of the Gauss-Seidel iterative method

Constraint the movement by a rigid transform. Impose a motion to all the boundary points of a mesh. The motion of the 4 corners are given in the data m_cornerMovements and the movements of the edge p…

Attach given pair of particles, projecting the positions of the second particles to the first ones.

Attach given particles to their initial positions. Project particles to an affine straight line going through the particle original position.

Project particles on a given plane.

Attach given particles to their initial positions. Maintain a constant velocity. If the particle is initially fixed then it is attached to its initial position. Otherwise it keeps on drifting. For ma…

Prevents rotation around x or/and y or/and z axis. Prevents rotation around X or Y or Z axis

Attach given rigids to their initial positions but they still can have rotations. Attach given particles to their initial positions.

Apply a hermite cubic spline trajectory to given points. Impose a trajectory to given Dofs following a Hermite cubic spline constraint. Control parameters are : - begin and end points - deriva…

Attach given particles to their initial positions. Project particles to an affine straight line. @author Francois Faure, 2012 @todo Optimized versions for lines parallel to the main directions

Impose a motion to given DOFs (translation and rotation). impose a motion to given DOFs (translation and rotation) The motion between 2 key times is linearly interpolated Rigid version doesn't h…

Impose a velocity to given DOFs (translation and rotation). impose a motion to given DOFs (translation and rotation) The motion between 2 key times is linearly interpolated

Apply a sinusoidal trajectory to given points. Apply sinusoidal trajectories to particles. Defined as \f$ x = x_m A \sin ( \omega t + \phi )\f$ where \f$ x_m, A , \omega t , \phi \f$ are the mean val…

Apply a parabolic trajectory to given points. Apply a parabolic trajectory to particles going through 3 points specified by the user. The DOFs set in the "indices" list follow the computed parabol f…

Attach given particles to their initial positions, in some directions only. Attach given particles to their initial positions, in some directions only. The fixed and free directioons are the same for…

Impose a motion to given DOFs (translation and rotation) in some directions only. impose a motion to given DOFs (translation and rotation) in some directions only. The moved and free directions are…

Impose a motion to all the boundary points of a mesh. Impose a motion to all the boundary points of a mesh. The motion of the 4 corners are given in the data d_cornerMovements and the movements of th…

Project particles to an affine plane. Project particles to an affine plane. @author Francois Faure, 2012 @todo Optimized versions for planes parallel to the main directions

Project particles to a point Attach given particles to their initial positions. Contrary to FixedConstraint, this one stops the particles even if they have a non-null initial velocity. @sa FixedConst…

Position-based dynamics Position-based dynamics as described in [Muller06]: input: target positions X output : x(t) <- x(t) + stiffness.( X - x(t) ) v(t) <- [ x(t) - x(t-1) ] / dt = v(t) + stiffne…

Animate a skeleton.

Controller Class. Interface of user interaction on SOFA Components. Provides also an interface for BeginAnimation and EndAnimation events launched at the beginning and the end of a time step.

Provides a Mouse & Keyboard user control on a Mechanical State. MechanicalStateController Class Provides a Mouse & Keyboard user control on a Mechanical State. On a Rigid Particle, relative and absol…

Isotropic or anisotropic diffusion on Tetrahedral Meshes.

Compute the average of coordinates. This class computes the average of a set of Coordinates

Group points into overlapping clusters according to a user defined number of clusters and radius. This class groups points into overlapping clusters according to a user defined number of clusters and…

Compute distances based on a grid. This class computes distances between to set of mechanical objects.

Compute the Hausdorff distance of two point clouds. This class compute the Hausdorff distance of two point clouds \todo: mean and mean square error

Compute target positions using shape matching deformation method by Mueller et al. This class computes target positions using shape matching deformation [Muller05][Muller11]

Computing the sum between two vector of dofs. Computing the Sum between two vector of dofs output = input - substractor

Engine extruding an edge-based curve into a quad surface patch. This engine extrudes an edge-based curve into a quad surface patch

Engine extruding a quad-based surface into a set of hexahedral elements. This class extrudes a quad surface into a set of hexahedra

Engine creating a mesh from the extrusion of the surface of a given mesh. This class extrudes a surface

Engine generating a cylindrical tetrahedral mesh.

Engine generating a grid tetrahedral or hexahedral mesh. This class generates a cylinder mesh given its radius, length and height. The output mesh is composed of tetrahedra elements

Engine computing the RigidMass of a mesh: mass, volume and inertia matrix.

Engine generating a spherical (Bezier) tetrahedral and triangular mesh. This class creates a mesh on the sphere as the tessellation of a regular tetrahedron, regular octahedron or regular dodecahedr…

Engine defining a vector of young modulus according of a list of defined groups. This class returns a vector of Young modulus, according a list of groups

Merge points from a set of points within a given distance.

Merge several meshes. This class merge several meshes.

Merge 2 coordinate vectors. This class merge 2 coordinate vectors.

Merge two sets of indices using specified boolean operation. This class merge 2 coordinate vectors.

Apply a merge operation to combine several inputs.

Engine mapping a set of points in a topological model and provide barycentric coordinates

Close a given mesh. This class closes a triangle mesh and provides : - a closed mesh (position, and triangles) - a index list of closing points (in closed mesh) - a mesh of the closing (position, and…

Create a tetrahedral volume mesh from a surface, using the algorithm from F. Labelle and J.R. Shewchuk, \"Isosurface Stuffing: Fast Tetrahedral Meshes with Good Dihedral Angles\", SIGGRAPH 2007. Crea…

Convert Vec in Real convert a vector of Vecs in a vector of their l-norms

Compute vertex normals by averaging face normals. This class compute vertex normals by averaging face normals

Engine distributing points over a surface randomly. This class extrudes a surface

Engine turning on spiral any topological model. This class turns on spiral any topological model

This component computes the volume of a given volumetric mesh. This class returns the volumes of a given volumic mesh.

This component computes the volume of a given closed surfacic mesh. This class computes the volume of a given closed surfacic mesh. Based on the divergence theorem with F(x,y,z)=<x,0,0> so that div(F…

Find the points that are NOT in the input sets. Output the positions and their indices in the global mesh not in the specified sets @todo make it general as other ROI (edges, triangles,...) @author T…

Engine finding the indices of a list of values within a larger set of values. This class returns the indices given a list of values.

Merge a list of ROIs (vector<Indices>) into a single Data (vector<svector<Indices>>). This class merges a list of ROIs (vector<Indices>) into a single Data (vector<svector<Indices>>)

Outputs indices of boundary vertices of a triangle/quad mesh This class outputs indices of boundary vertices of a triangle/quad mesh The boundary is detected using the number elements associated to t…

Select uniformly distributed points on a mesh based on Euclidean or Geodesic distance measure. Select uniformly distributed points on a mesh based on Euclidean or Geodesic distance measure The method…

Engine breaking a mesh in multiple parts, based on selected vertices or cells. This class breaks a mesh in multiple parts, based on selected vertices or cells. It provide a map to be used in subsetMu…

Extract a mesh subset based on selected vertices. This class extracts a mesh subset based on selected vertices

Attach given pair of particles, projecting the positions of the second particles to the first ones. Given two mechanical states, find correspondence between degrees of freedom, based on the minimal d…

Find the primitives inside a given plane. This class find all the points located inside a given box.

Find the points given a list of indices. This class returns the points given a list of indices.

Find the N closest primitives from a given position. This class find the point at a given distance from a set of points

Select a subset of points or cells labeled from different sources, that are connected given a list of connection pairs.

Select a subset of labeled points or cells stored in (vector<svector<label>>) given certain labels.

Engine used to create subset topology given box, sphere, plan, ... This class find all the points located inside a given box.

Find the values given a list of indices. This class returns the values given a list of indices.

Assign values to primitives (vertex/edge/triangle/tetrahedron) based on a linear interpolation of values along a direction. This class find all the points/edges/triangles/tetrahedra located inside a …

Computing the difference between two vector of dofs. Computing the difference between two vector of dofs output = input - substractor

Dilates a given mesh by moving vertices along their normal. This class dilates a given mesh by moving vertices along their normal.

Input values to output values mapper. Includes indices rules, such as replacement, resize.

Input multiple values to output values mapper. Includes indices rules, such as replacement, resize.

Apply a permutation to a set of indices. This class apply a permutation to a set of indices

Apply a math operation to combine several inputs.

Project the position of 3d points onto a plane according to a projection matrix. This class transforms the positions of one DataFields into new positions after applying a transformation This transfor…

Transform a vector of Rigids into two independent vectors for positions (Vec3) and orientations (Quat).

Generate a list of values from value-indices pairs. This class returns a list of values from value-indices pairs

Transform a couple of Vec3 and Quaternion in Rigid.

Compute the laplacian smoothing of a mesh. This class computes the laplacian smooth of a mesh

Engine applying a transformation on 3d points (translation / rotation). This class transforms the positions of one DataFields into new positions after applying a transformation This transformation ca…

Transform position of 3d points. This class transforms the positions of one DataFields into new positions after applying a transformation This transformation can be either : projection on a plane (pl…

Return a rigid position from the vertices, texCoords, normals and facets of any mesh. This class gets as inputs the vertices, texCoords, normals and d_facets of any mesh and returns as output a rigid…

Base class implementing forcefeedback as a force field

Null force feedback for haptic feedback device.

BaseVTKReader is an abstract base class for reading VTK files in the SOFA framework, enabling the loading of geometric data into simulation components.

Load volumetric meshes generated by GID. Some element types are not implemented.

Procedural creation of a two-dimensional mesh. Procedurally creates a triangular grid. The coordinates range from (0,0,0) to (1,1,0). They can be translated, rotated and scaled using the correspond…

Export topology and positions into file.

Specific mesh loader for Gmsh file format.

Specific mesh loader for OBJ file format.

Specific mesh loader for Off file format.

Loader for the STL file format. STL can be used to represent the surface of object using with a triangulation.

Specific mesh loader for trian (only triangulations) file format. Cette classe permet la fabrication d'un visuel pour un fichier de type trian ces fichiers se presentent de la maniere suivante nombre…

Mesh loader for the VTK/VTU file format. Format doc: http://www.vtk.org/VTK/img/file-formats.pdf http://www.cacr.caltech.edu/~slombey/asci/vtk/vtk_formats.simple.html

Specific mesh loader for Xsp file format.

Read and load an .off file at each timestep. This class load a sequence of .off mesh files, ordered by index in their name

Save a topology in file.

Loader for sphere model description files.

Procedural creation of a one-dimensional mesh. Procedurally creates a string. The coordinates range from (0,0,0) to (1,0,0). They can be translated, rotated and scaled using the corresponding attri…

Export the scene under the Wavefront OBJ format.

Voxel loader based on RAW files.

Asynchronous direct Linear Solver using a Sparse LDL^T factorization. This linear solver is based on SparseLDLSolver, a direct linear solver which factorizes the linear system matrix. Its particulari…

Direct linear solver using a Sparse LDL^T factorization.

Linear system solver using the conjugate gradient iterative algorithm

Natural order (no permutation). Corresponding to an identity matrix.

Precomputed matrix system.

Rotation matrix warping the main linear system.

Copy a vector stored in a BaseMechanicalState into a global vector of type BaseVector. The copy location is based on a built MappingGraph.

A component associated to a pair of @BaseMechanicalState able to perform the projection of a matrix from the space of the @BaseMechanicalState's to the main space using the mapping graph. Basically, i…

Component acting like a linear system, but delegates the linear system functionalities to a list of real linear systems.

Linear system taking advantage of the constant sparsity pattern of the global matrix to speed up the matrix assembly. Do not use if sparsity pattern is not constant (topological changes, ...). Assemb…

Matrix mapping computing the matrix projection taking advantage of the constant sparsity pattern. Matrix projection method computing the matrix projection taking advantage of the constant sparsity pa…

Copy the values stored in a global vector to the local vectors stored in teach BaseMechanicalState The copy location is based on a built MappingGraph.

Linear system. Assemble the global matrix using local matrix components Components add their contributions directly to the global matrix, through their local matrices. Local matrices act as a proxy (…

Matrix mapping computing the matrix projection using the Eigen library. The component is a @MatrixMapping computing the matrix projection using the Eigen library.

Component storing a global matrix representing a linear system

Base class for barycentric mapping topology-specific mappers

Class allowing barycentric mapping computation on a BaseMeshTopology with edges

Class allowing barycentric mapping computation on a HexahedronSetTopology

Class allowing barycentric mapping computation on a MeshTopology

Class allowing barycentric mapping computation on a QuadSetTopology

Class allowing barycentric mapping computation on a RegularGridTopology

Class allowing barycentric mapping computation on a SparseGridTopology

Class allowing barycentric mapping computation on a TetrahedronSetTopology

Template class for topology container mappers

Class allowing barycentric mapping computation on a TriangleSetTopology

Set the positions and velocities of points attached to a beam using linear interpolation between DOFs.

This class maps any mesh primitive (point, edge, triangle...) into a point using a relative position from the primitive. This class, called Mesh2PointTopologicalMapping, is a specific implementation …

Special case of mapping where HexahedronSetTopology is converted into a finer HexahedronSetTopology. This class, called SimpleTesselatedTetraTopologicalMapping, is a specific implementation of the in…

Special case of mapping where TetrahedronSetTopology is converted into a finer TetrahedronSetTopology. This class, called SimpleTesselatedTetraTopologicalMapping, is a specific implementation of the …

Template class for barycentric mapping topology-specific mappers.

Mapping point positions from several mechanical states to distances (in distance unit). Maps point positions from several mstates to distances (in distance unit). @tparam TIn parent point positions @…

Set the positions and velocities of points attached to a rigid parent.

Compute a lumped (diagonalized) mass matrix resulting from the space integration of a density over a domain. @class DiagonalMass @brief This component computes the integral of this mass density…

Compute a mass matrix resulting from the space integration of a density over a domain. template <class DataTypes, class TMassType> @class MeshMatrixMass @brief This component computes the integ…

Compute a mass equally spread over the number of nodes.

Outward repulsion applied by a cone geometry.

Constant forces applied to given degrees of freedom. Apply constant forces to given degrees of freedom.

Diagonal velocity damping. Apply damping forces to given degrees of freedom.

Apply a force on edges, distributed on the edge nodes.

Outward / inward repulsion applied by an ellipsoid geometry.

Gravity in world coordinates. Override the default gravity */

Outward / inward repulsion applied by an ellipsoid geometry, which can possibly act on several objects.

Linearly-interpolated force applied to given degrees of freedom. Apply forces changing to given degres of freedom. Some keyTimes are given and the force to be applied is linearly interpolated between…

OscillatingTorsionPressure.

Repulsion along the normal to a plane. @class PlaneForceField A plane is cutting the space in two half spaces. This component generate a force preventing the object to cross the plane. The plane is d…

Pressure applied on a quadrangular geometry. QuadPressureForceField Class Implements a pressure force applied on a quad surface. The force applied to each vertex of a quad is equal to the quad surfac…

Outward repulsion applied by a sphere geometry

Pressure applied on a generic surface (triangular or quadrangular). SurfacePressureForceField Class Implements a pressure force applied on a triangle or quad surface. Each surfel receives a pressure …

\ This component computes the volume enclosed by a surface mesh \ and apply a pressure force following Tait's equation: $P = P_0 - B((V/V_0)^\\gamma - 1)$.\n\ This ForceField can be used to apply :\n\…

Applies a torque to specified degrees of freedom. TorsionForceField This forcefield applies a torque to a set of selected nodes. The force is applied from a specified axis (origin and direction) and …

Pressure applied on a triangular geometry.

Uniform velocity damping. Apply damping forces to given degrees of freedom.

Velocity-based ODE solver using Backward Differentiation Formula (BDF), at any order, supporting variable time step size.

Base class for a linear multistep method Generic class computing a residual based on any coefficients given by a linear multistep method. Derived class just have to define the coefficients. A linear m…

Time integrator using implicit backward Euler scheme. Semi-implicit time integrator using backward Euler scheme for first and second degree ODEs. (default: second) ** 2nd Order *** This is based on […

Implicit time integrator using Newmark scheme. Implicit time integrator using Newmark scheme. This integration scheme is based on the following equations: $x_{t+h} = x_t + h v_t + h^2/2 ( (1-2\beta…

Generic Newton-Raphson algorithm solving nonlinear equations.

Static ODE Solver

Implicit time integrator which conserves linear momentum and mechanical energy. Implicit and Explicit time integrator using the Variational Symplectic Integrator as defined in : Kharevych, L et al. “…

Explicit time integrator using central difference (also known as Verlet of Leap-frog). Explicit time integrator using central difference (also known as Verlet of Leap-frop). @see http://www.dynasuppo…

Reduce the velocities. Velocity damping and thresholding. This is not an ODE solver, but it can be used as a post-process after a real ODE solver.

A simple explicit time integrator. The simplest time integration. Two variants of the Euler solver are available in this component: - forward Euler method, also called explicit Euler method - semi-im…

A popular explicit time integrator. A popular time integration method, much more precise than the EulerSolver */

A popular explicit time integrator. A popular time integration method, much more precise than the EulerSolver */

Compare State vectors from a reference frame to the associated Mechanical State. Compare State vectors from file at each timestep

Compare Topology containers from a reference frame to the associated Topology. Compare Topology vectors from file at each timestep

Read events from file. InputEventReader Class Reads mouse Linux events from file /dev/input/eventX and propagate them as SOFA MouseEvents.

Read State vectors from file at each timestep.

Read topology containers information from file at each timestep. Read Topology containers information from file at each timestep

Write State vectors to file at each timestep. Write State vectors to file at a given set of time instants A period can be established at the last time instant The DoFs to print can be chosen using DO…

Write topology containers information to file at each timestep. Write Topology containers information into a file at a given set of time instants A period can be established at the last time instant.…

Specify the APIVersion of the component used in a scene.

This object retain the info/error message. Despite this component does absolutely nothing... it is very useful as it can be used to retain information scene graph.

This object controls the way Sofa print's A sofa component to add a MessageHandler to the main logger

Abstract class defining how to pause the animation.

This component pauses the simulation when receiving a PauseEvent.

Background setting. Class for the configuration of background settings.

The MouseButtonSetting component configures mouse button settings within a SOFA simulation scene, allowing users to specify which buttons are used for specific interactions or operations.

Default Paths for Sofa Application. Class for the configuration of default path for sofa application.

Stats settings. Class for the configuration of stats settings.

Configuration for the Viewer of your application. Class for the configuration of viewer settings.

The BaseLinearElasticityFEMForceField simulates linear elastic behavior using finite element methods, requiring Young's modulus and Poisson's ratio to define material properties.

Beam finite elements. Compute Finite Element forces based on 6D beam elements.

Fast Corotational Tetrahedral Mesh.

Hexahedral finite elements. Compute Finite Element forces based on hexahedral elements. Corotational hexahedron from @Article{NMPCPF05, author = "Nesme, Matthieu and Marchal, Maud and Promayo…

Hexahedral finite elements with mass Compute Finite Element forces based on hexahedral elements including continuum mass matrices

Hexahedral finite elements. Compute Finite Element forces based on hexahedral elements. Corotational hexahedron from @Article{NMPCPF05, author = "Nesme, Matthieu and Marchal, Maud and Promayo…

Hexahedral finite elements with mass. Compute Finite Element forces based on hexahedral elements including continuum mass matrices

Bending Quad finite elements

Corotational FEM Tetrahedral finite elements Compute Finite Element forces based on tetrahedral elements.

Tetrahedral finite elements. Compute Finite Element forces based on tetrahedral elements. Corotational methods are based on a rotation from world-space to material-space.

Triangular finite elements for static topology. Triangle FEM force field using the QR decomposition of the deformation gradient, inspired from http://www-evasion.imag.fr/Publications/2005/NPF05 , to …

Triangular finite element model using anisotropic material.

Corotational Triangular finite elements for dynamic topology. corotational triangle from @InProceedings{NPF05, author = "Nesme, Matthieu and Payan, Yohan and Faure, Fran\c{c}ois", title …

Corotational Triangular finite elements. corotational triangle from @InProceedings{NPF05, author = "Nesme, Matthieu and Payan, Yohan and Faure, Fran\c{c}ois", title = "Efficient, Phy…

Generic Tetrahedral finite elements. Compute Finite Element forces based on tetrahedral elements.

Generic Hyperelastic Tetrahedral finite elements. Compute Finite Element forces based on tetrahedral elements.

Non uniform Hexahedral finite elements.

Non uniform Hexahedral finite elements. @InProceedings{NPF06, author = "Nesme, Matthieu and Payan, Yohan and Faure, Fran\c{c}ois", title = "Animating Shapes at Arbitrary Resolution with …

Non uniform Hexahedral finite elements. Need a SparseGridTopology with _sparseGrid->d_nbVirtualFinerLevels >= this->d_nbVirtualFinerLevels @InProceedings{NPF06, author = "Nesme, Matthieu and Pa…

Angular springs applied to rotational degrees of freedom of a rigid body or frame. This class describes a simple elastic springs ForceField between DOFs positions and rest positions. Springs are appl…

Springs added to a triangular mesh to prevent bending. Bending elastic force added between vertices of triangles sharing a common edge. Adapted from: P. Volino, N. Magnenat-Thalmann. Simple Linear Be…

Springs for Flexibles. FrameSpringForceField simulates 6D springs between moving frames Use stiffnessTrans vector to specify the directionnal stiffnesses (on each local axis) Use stif…

Gear springs for Rigids. GearSpringForceField simulates 6D springs between Rigid DOFS Use kst vector to specify the directionnal stiffnesses (on each local axe) Use ksr vector to specify the rota…

Springs for Rigids. JointSpringForceField simulates 6D springs between Rigid DOFS Use kst vector to specify the directionnal stiffnesses (on each local axe) Use ksr vector to specify the rotation…

Spring force field acting along the edges of a mesh.

Simple elastic springs applied to given degrees of freedom between their current and rest shape position. This class describes a polynomial elastic springs ForceField between DOFs positions and rest …

Simple elastic springs applied to given degrees of freedom between their current and rest shape position. This class describes a polynomial elastic springs ForceField

Springs added to a quad mesh to prevent bending. Bending springs added between vertices of quads sharing a common edge. The springs connect the vertices not belonging to the common edge. It compresse…

Springs added to a quad mesh to prevent bending. Bending springs added between vertices of quads sharing a common edge. The springs connect the vertices not belonging to the common edge. It compresse…

Spring acting on the edges and faces of a regular grid.

Springs which only repel.

Elastic springs generating forces on degrees of freedom between their current and rest shape position. This class describes a simple elastic springs ForceField between DOFs positions and rest positio…

Springs. Set of simple springs between particles

Springs added to a triangular mesh to prevent bending. Bending springs added between vertices of triangles sharing a common edge. The springs connect the vertices not belonging to the common edge. It…

Springs added to a triangular mesh to prevent bending Bending springs added between vertices of triangles sharing a common edge. The springs connect the vertices not belonging to the common edge. It …

Biquadratic Springs on a Triangular Mesh.

Quadratic Springs on a Triangular Mesh.

Spring force field acting along the edges of a mesh.

Linear Elastic Tetrahedral Mesh

Linear Elastic Membrane on a Triangular Mesh

Mapped state vectors

mechanical state vectors This class can be overridden if needed for additional storage within template specializations.

Surface topology of a cube in 3D (points, edges and quads).

Generic constant topology loaded from a mesh file.

Sphere topology constructed with deformed quads.

Dynamic sparse grid geometry algorithms. A class that provides geometry information on an HexahedronSet.

Dynamic sparse grid geometry container. a class that stores a sparse regular grid of hexahedra and provides a better loading and access to neighbors than HexahedronSetTopologyContainer */

Dynamic sparse grid geometry modifier. A class that modifies the topology by adding and removing hexahedra

Geometry algorithms dedicated to an edge topology. A class that provides geometry information on an EdgeSet.

Topology container for an edge topology. a class that stores a set of edges and provides access to the adjacency between points and edges */

Topology modifier dedicated to an edge topology. A class that can apply basic transformations on a set of edges.

Geometry algorithms dedicated to an hexahedral topology. A class that provides geometry information on an HexahedronSet.

Topology container dedicated to an hexahedral topology. a class that stores a set of hexahedra and provides access with adjacent quads, edges and vertices */

Topology modifier dedicated to an hexahedral topology. A class that modifies the topology by adding and removing hexahedra

Multilevel Hexahedron set topology container.

Geometry algorithms dedicated to a point topology. A class that can perform some geometric computation on a set of points.

Topology container dedicated to a point topology. The container class that stores a set of points and provides access to each point. This set of point may be a subset of the DOF of the mechanical mod…

Topology modifier dedicated to a point topology. A class that can apply basic topology transformations on a set of points.

Geometry algorithms dedicated to a quad topology. A class that provides geometry information on an QuadSet.

Topology container dedicated to a quad topology. Object that stores a set of quads and provides access to each quad and its edges and vertices */

Topology modifier dedicated to a quad topology. A class that modifies the topology by adding and removing quads

Geometry algorithms dedicated to a tetrahedral topology. A class that provides geometry information on an TetrahedronSet.

Topology container dedicated to a tetrahedral topology. a class that stores a set of tetrahedra and provides access with adjacent triangles, edges and vertices */

Topology modifier dedicated to a tetrahedral topology. A class that modifies the topology by adding and removing tetrahedra

Geometry algorithms dedicated to a triangular topology. A class that provides geometry information on an TriangleSet.

Topology container dedicated to a triangular topology. \class TriangleSetTopologyContainer \brief: Object that stores a set of triangles and provides access to each triangle and its edges and vertice…

Topology modifier dedicated to a triangular topology. A class that modifies the topology by adding and removing triangles

Cylinder grid in 3D. Define a cylinder grid topology Parameters are its @sa d_radius and @sa d_length . Position and direction are set by @sa d_center and @sa d_axis nz discretisation is along the cy…

Base class fo a regular grid in 3D. Define a regular grid topology, with no spatial information.

Regular grid in 3D. Regular grid in space. In c++, resolution is set in the constructor or using method setSize of the parent class, while the spatial extent is set using method setPos. In xml, s…

Sparse grid in 3D. Build a SparseGridTopology for several given Triangular meshes. A stiffness coefficient has to be assigned for each mesh. The last found stiffness coefficient is used for an elemen…

Sparse grid in 3D (modified). a SparseGridTopology where each resulting cube contains only one independent connexe component (nodes can be multiplied by using virtual nodes)

Sparse grid in 3D. A sparse grid topology. Like a sparse FFD building from the bounding box of the object. Starting from a RegularGrid, only valid cells containing matter (ie intersecting the origina…

Sphere grid in 3D. Define a sphere grid topology Parameters are its @sa d_radius and discretisation . Position and direction are set by @sa d_center and @sa d_axis nz discretisation is along the sphe…

Topological mapping where each primitive in the input topology will be mapped to a point in the output topology. This class, called CenterPointTopologicalMapping, is a specific implementation of the …

Topological mapping where EdgeSetTopology is converted to QuadSetTopology. This class, called Edge2QuadTopologicalMapping, is a specific implementation of the interface TopologicalMapping where : INP…

Topological mapping where HexahedronSetTopology is converted to QuadSetTopology This class, called Hexa2QuadTopologicalMapping, is a specific implementation of the interface TopologicalMapping where …

Topological mapping where HexahedronSetTopology is converted to TetrahedronSetTopology This class, called Hexa2TetraTopologicalMapping, is a specific implementation of the interface TopologicalMappin…

TopologicalMapping where the destination topology should be kept identical to the source topology. The implementation currently assumes that both topology have been initialized identically. This clas…

Topological mapping where QuadSetTopology is converted to TriangleSetTopology This class, called Quad2TriangleTopologicalMapping, is a specific implementation of the interface TopologicalMapping wher…

TopologicalMapping where the destination topology is a subset of the source topology. The implementation currently assumes that both topologies have been initialized correctly. This class is a specif…

Topological mapping where TetrahedronSetTopology is converted to TriangleSetTopology This class, called Tetra2TriangleTopologicalMapping, is a specific implementation of the interface TopologicalMapp…

Topological mapping where TriangleSetTopology is converted to EdgeSetTopology This class, called Triangle2EdgeTopologicalMapping, is a specific implementation of the interface TopologicalMapping wher…

Read topological changes and process them. Read file containing topological modification. Or apply input modifications A timestep has to be established for each modification. SIMPLE METHOD FOR THE MO…

Component removing all elements going outside from the given bounding box. Read file containing topological modification. Or apply input modifications A timestep has to be established for each modifi…

Read topological Changes and process them. The class TopologyChecker represents a SOFA component which can be added in a scene graph to test a given Topology. The topology component to be tested need…

The `BaseCamera` component defines fundamental camera properties such as position, orientation, field of view, and clipping planes in the SOFA framework.

A Camera that render the scene from a given location & orientation.

Visualize a set of cylinders.

Camera with mouse and keyboard controls.

Display scene axis

A camera that is moving along a predetermined path.

Render a trail behind particles. Render a trail behind particles It can be used to draw the trajectory of a dof. This component does not support topological changes (point removal or point addition) …

Display 3D camera-oriented text. Draw camera-oriented (billboard) 3D text

Display an Axis Aligned Bounding Box (AABB).

Display a simple grid.

Generic visual model. If a viewer is active it will replace the VisualModel alias, otherwise nothing will be displayed. Abstract class which implements partially VisualModel. This class implemented …

Render a point cloud.

Visually apply a (translation,rotation) transformation to visual elements rendering within a node or a sub-graph. Visually apply a (translation,rotation) transformation to visual elements rendering w…

Render a vector field.

AbstractDataLink is the base class for every link between two data fields The targeted BaseData is called the "target", The base object owning the current "child" object is the "owner" it is possible …

Base class for everything This class contains all functionality shared by every objects in SOFA. Most importantly it defines how to retrieve information about an object (name, type, data fields). A…

Component responsible for main animation algorithms, managing how and when mechanical computation happens in one animation step. This class can optionally replace the default computation scheme of c…

Component computing constraint forces within a simulated body using the compliance method.

`BaseConstraintSet` is an abstract class in SOFA that manages constraints within a simulation, providing methods for resetting constraints, setting constraint IDs, processing geometrical data, buildin…

Base class for Context classes, storing shared variables and parameters. A Context contains values or pointers to variables and parameters shared by a group of objects, typically referring to the sa…

Abstract base class for Data.

Component computing forces within simulated bodies. This class define the abstract API common to all force fields. A force field computes forces applied to one or more simulated body given its curr…

BaseInteractionForceField is a force field linking several bodies (MechanicalState) together. An interaction force field computes forces applied to several simulated bodies given their current posit…

Component computing constraints within a simulated body. This class defines the abstract API common to all constraints. A BaseConstraint computes constraints applied to one or more simulated body g…

Abstract base class (as type identifier) for linear system solvers without any API

`BaseLoader` is an abstract base class providing a standardized interface for file loading operations in SOFA simulations.

An interface to convert a model state to an other model state. The model states are positions and velocities or generalizations of these (class sofa::core::BaseState). The source is denoted using vari…

Component responsible for mass-related computations (gravity, acceleration). Mass can be defined either as a scalar, vector, or a full mass-matrix. It is responsible for converting forces to acceler…

Matrix accumulator which is also a BaseObject. It is designed to be associated with another component.

Base class for components storing and assembling a linear system represented as a matrix. The matrix data structure is defined in derived classes.

Component storing all state vectors of a simulated body (position, velocity, etc). This class only contains the data of the body and not any of its <i>active</i> computations, which are handled by t…

`BaseMeshTopology` represents the topological structure of 3D geometric meshes in SOFA, providing methods for adding and querying points, edges, triangles, quads, tetrahedra, and hexahedra.

Base class for simulation nodes. A Node is a class defining the main scene data structure of a simulation. It defined hierarchical relations between elements. Each node can have parent and child no…

Base class for simulation components. An object defines a part of the functionality in the simulation (stores state data, specify topology, compute forces, etc). Each simulation object is related t…

Base Interface for classes containing the description of an object, used to construct it. This class defines what information are used as input (read from a file for instance) to create an object. T…

Abstract base class for ordering methods in sparse linear solvers A permutation is computed and applied on a sparse matrix to improve the computation time when solving a linear system.

Component computing projective constraints within a simulated body. This class define the abstract API common to all projective constraints. A BaseConstraint computes constraints applied to one or m…

Component storing position and velocity vectors. This class define the interface of components used as source and destination of regular (non mechanical) mapping. It is then specialized as Mechanic…

`BaseTopologyObject` manages topological data structures within the SOFA scene graph, enabling dynamic insertion and removal of topology objects from nodes.

Abstract Interface of components defining the behavior of a simulated object. This Interface is used by "black-box" objects (such as some fluid algorithms) that are present in a SOFA simulation but …

given a set of root collision models, computes potentially colliding pairs.

Abstract CollisionModel interface. A CollisionModel contains a list of same-type elements. It can be part of a list of CollisionModels, each describing a level in a bounding-volume hierarchy. Each…

Base class for all the configuration settings of SOFA

Component computing constraint forces within a simulated body using the compliance method.

Class gathering parameters use by constraint components methods, and transmitted by visitors read the velocity and position and where the

Component responsible for the expression and solution of system of equations related to constraints. The main method is solveConstraint(const ConstraintParams *, MultiVecId , MultiVecId ); The defau…

contact response component handling the response between a pair of models - Dynamically created by the ContactManager -# Persistent between iterations -# New id data in DetectionOutput allow to ke…

Implementation of BaseContext, storing all shared parameters in Datas.

Base class for simulation objects that modify the shared context (such as gravity, local coordinate system, ...).

A DDGNode is a vertex in the data dependencies graph. The data dependency graph is used to update the data when some of other changes and it is at the root of the implementation of the data update mec…

Container that holds a variable for a component. This is a fundamental class template in Sofa. Data are used to encapsulated member variables of Sofa components (i.e. classes that somehow inherit fro…

Associate to a set of data a set of callback The callbacks are called when one of the input is changed. Example of use: Data<int> a; Data<int> b; DataCallback cb; In constructor: cb.addCallb…

from a set of Data inputs computes a set of Data outputs Implementation good rules: void init() { addInput // indicate all inputs addOutput // indicate all outputs } // optional (called each tim…

DataLink stores a connection between two object of type Data<XXX> The class is templated by the Data type to connect. The class implements the AbstractDataLink interface.

`DefaultMultiMatrixAccessor` manages the global matrix setup in SOFA simulations by aggregating contributions from multiple mechanical states without mappings. It ensures accurate representation of ph…

Event indicating that a child node is being detached from the scene. Any reference to one of its descendant (such as active contacts) should be removed.

Base class for all events received by the objects. When created, the status is initialized as not handled. It is then propagated along the objects until it is handled. @author Francois Faure

Class gathering parameters use by most components methods, and transmitted by all visitors

Component computing forces within a simulated body. This class defines the abstract API common to force fields using a given type of DOFs. A force field computes forces applied to one simulated bod…

This event notifies about GUI interaction.

This event notifies about haptic device interaction.

@author Damien Marchal @brief This event is propagated along the objects hierarchy at regular interval.

Given 2 collision elements, test if an intersection is possible (for bounding volumes), or compute intersection points if any

The `IntrusiveObject` class implements an internal reference counting mechanism to manage its lifetime. It is intended to work with intrusive smart pointers like `boost::intrusive_ptr`.

JoystickEvent Class

@author Francois Faure @brief This event is propagated along the objects when a key on the keyboard is pressed.

@author Juan Pablo de la Plata @brief This event is propagated along the objects when a key on the keyboard is released.

Component computing constraints within a simulated body. This class defines the abstract API common to constraints using a given type of DOFs. A LagrangianConstraint computes constraints applied to…

Abstract interface for linear system solvers

Base class for components requiring access to a linear solver

Specialized interface to convert a model state of type TIn to a model state of type TOut. This is basically a sofa::core::BaseMapping with given input and output types.

Component responsible for mass-related computations (gravity, acceleration). Mass can be defined either as a scalar, vector, or a full mass-matrix. It is responsible for converting forces to acceler…

Class gathering parameters use by mechanical components methods, and transmitted by mechanical visitors

Component storing all state vectors of a simulated body (position, velocity, etc), using the datatype specified in the template. The given DataTypes class should define the following internal types:…

The `MeshLoader` loads geometric meshes into SOFA simulations, managing elements such as points, edges, triangles, quads, tetrahedra, hexahedra, prisms, and pyramids. It supports transformations and m…

Component computing forces between a pair of simulated body. This class define the abstract API common to interaction force fields between a pair of bodies using a given type of DOFs.

MouseEvent Class Implements an Event that notifies about a Mouse Interaction.

Specialized interface to describe many to many mapping. The inputs can be of two different types, while all the outputs must be of the same type.

Specialized interface to describe many to many mapping. All the input must have the same type, and all the output must have the same type. See also class Multi2Mapping.

Abstract class allowing to find the part of the mechanical matrix associated with a given MechanicalState or pair of MechanicalState (for interaction forces and mappings).

Given a set of potentially colliding pairs of models, compute set of contact points

Component responsible for timestep integration, i.e. advancing the state from time t to t+dt. This class currently control both the integration scheme (explicit, implicit, static, etc). While all c…

Component computing constraints between a pair of simulated body. This class define the abstract API common to interaction constraints between a pair of bodies using a given type of DOFs.

Component computing forces between a pair of simulated body. This class define the abstract API common to interaction force fields between a pair of bodies using a given type of DOFs.

Component computing constraints between a pair of simulated body. This class define the abstract API common to interaction constraints between a pair of bodies using a given type of DOFs.

Pipeline component gather list of collision models and control the sequence of computations

Component computing constraints within a simulated body. This class define the abstract API common to constraints using a given type of DOFs. A ProjectiveConstraintSet computes constraints applied …

The RichConsoleStyleMessageFormatter class The class implement a message formatter dedicated to console pretty printing on a console Among other thing it feature formatting using a markdown like syn…

`SceneLoader` loads and parses scene descriptions into the SOFA simulation environment, facilitating the initialization of simulations based on external configurations.

Generic Event class to send a message through the simulation graph.

A basic interface to define a Shader for different system (OpenGL, DirectX, ...).

Special case to access a single square matrix.

Base class for components having access to one mechanical state with a specific template parameter, in order to read and/or write state variables.

Component storing position and velocity vectors. This class define the interface of components used as source and destination of regular (non mechanical) mapping. It is then specialized as Mechanic…

This Interface is a new kind of Mapping, called TopologicalMapping, which converts an INPUT TOPOLOGY to an OUTPUT TOPOLOGY (both topologies are of type BaseTopology) It first initializes the mesh of t…

The `Topology` class manages mesh topology in SOFA simulations by defining geometric elements and their connectivity, facilitating insertion/removal of topology information from nodes.

A class for storing topology related data. Automatically manages topology changes. This class is a wrapper of class type::vector that is made to take care transparently of all topology changes that mi…

A class that will interact on a topological Data */

A class for storing element related data. Automatically manages topology changes. This class is a wrapper of class type::vector that is made to take care transparently of all topology changes that mig…

`VisualLoop` manages visualization steps in SOFA simulations, including initialization, updates, context updates, rendering, and bounding box computation.

The `VisualManager` component manages visual aspects of simulation scenes in the SOFA framework by handling rendering operations and integrating with the scene graph structure.

An interface which all VisualModel inherit. This Interface is used for the VisualModel, which all visible objects must implement. VisualModels are drawn by calling their draw method. The method upd…

Class gathering parameters used by visual components and by the draw method of each component. Transmitted by visitors

Manages visual state data including vertex coordinates, rest positions, and normals for graphical rendering in SOFA simulations.

The `VoxelLoader` loads and manages voxel-based geometric data within the SOFA simulation framework, providing methods to add hexahedra and retrieve voxel-related information such as size and segmenta…

`BaseFileAccess` provides a unified interface for file access operations in SOFA simulations, supporting opening, closing, reading, and writing files through abstract methods.

The `ClangStyleMessageFormatter` formats log messages in a style similar to Clang compiler output, providing consistent logging for debugging and monitoring.

Format the message using a very simple sofa style. For more advanced formatting style have a look at RichStyleMessageFormatter. Example: [ERROR] ClassName(instanceName): this is a message pr…

Utility class to perform debug drawing. Class which contains a set of methods to perform minimal debug drawing regardless of the graphics API used. Components receive a pointer to the DrawTool throu…

The `Factory` component manages dynamic object instantiation in SOFA by registering creators with specific keys and providing methods to create objects based on these keys.

The `FileAccess` component provides file input/output operations within the SOFA framework, enabling reading from and writing to files for data management in simulations.

The `Image` class in SOFA manages image data, providing methods for loading, saving, and accessing dimensions and pixel information at different mipmap levels.

`ImageDDS` loads and saves DDS (DirectDraw Surface) image files, serving as an input/output utility in the SOFA framework.

`ImageRAW` manages the loading and saving of RAW format images by initializing headers and reading/writing pixel values directly.

The `Mesh` component manages mesh data by providing methods to access vertices, edges, triangles, quads, tetrahedra, hexahedra, texture coordinates, normals, and high-order elements, essential for spa…

`MeshGmsh` reads and processes Gmsh mesh files to extract vertex coordinates and element connectivity data, preparing them for subsequent finite element analysis in SOFA simulations.

`MeshOBJ` loads and parses OBJ files to provide geometric and material information for use in SOFA simulations.

The `MessageFormatter` class formats log messages according to their severity levels by defining methods for setting color codes and prefix texts based on message types.

`STBImage` provides an interface for loading and saving images using the STB library, facilitating image handling in SOFA simulations or visualizations.

The `Transformation` class manages geometric transformations (translation, rotation, scaling) for visual objects within SOFA simulations. It provides methods to apply these transformations and invert …

Simple BTD matrix container

Generic matrix API, allowing to fill and use a matrix independently of the linear algebra library in use. Note that accessing values using this class is rather slow and should only be used in codes wh…

Generic vector API, allowing to fill and use a vector independently of the linear algebra library in use. Note that accessing values using this class is rather slow and should only be used in codes wh…

Simple full matrix container

Simple block full matrix container (used for InvMatrixType)

`BlockVector` organizes vector data into fixed-size blocks, providing efficient block-based access methods (`sub`, `asub`). It extends the functionality of standard vectors by enabling structured mani…

The `CompressedRowSparseMatrixConstraint` manages constraints using compressed row storage for efficient memory usage and fast access to non-zero elements, supporting various vector types. It is used …

The `CompressedRowSparseMatrixGeneric` implements a compressed row sparse (CSR) matrix for efficient storage and manipulation of large sparse matrices in SOFA simulations. It supports various data typ…

The `CompressedRowSparseMatrixMechanical` implements the Compressed Row Storage (CRS) format tailored for mechanical systems in SOFA, supporting various block sizes and symmetric operations. It effici…

Container of a vector of the Eigen library. Not an eigenvector of a matrix.

Simple full matrix container

`FullVector` provides dense vector operations for linear algebra tasks within the SOFA framework, supporting resizing, element access, arithmetic operations, and memory management.

3x3 block-diagonal matrix where each block is considered as a rotation. \tparam TReal Type of scalar One of the feature of this class is to rotate another matrix: if M is a matrix and R is a rotation …

`BaseElement` manages hierarchical relationships, attribute handling, and initialization of nodes within the SOFA scene graph.

`BaseMultiMappingElement` is an abstract class that manages multi-mapping operations between different state contexts in SOFA simulations, facilitating the initialization of nodes and updating the sce…

`ObjectElement` initializes and configures SOFA components from XML descriptions, managing attribute replacement and error messaging for unused attributes or failed initializations.

The `SceneLoaderPHP` loads simulation scenes defined by PHP scripts or `.pscn` files into the SOFA framework, enabling users to leverage PHP for defining complex simulation scenarios.

`SceneLoaderXML` loads and writes SOFA simulation scenes from/to XML files with extensions `.xml` or `.scn`, parsing the content into a simulation graph structure.

The `TransformationVisitor` applies geometric transformations (translation, rotation, scaling) to visual models and mechanical states within the SOFA simulation scene graph.

Event fired by Simulation::animate() before computing a new animation step. @author Jeremie Allard

Event fired by Simulation::animate() after computing a new animation step. @author Jeremie Allard

`AnimateVisitor` manages the temporal progression of the physical system within SOFA by processing nodes, collision pipelines, interaction force fields, and mechanical integration steps.

Base class for easily creating new actions for mechanical simulation. During the first traversal (top-down), method processNodeTopDown(simulation::Node*) is applied to each simulation::Node. Each comp…

Component that export something from the scene could inherit from this class as it implement an uniform handling of the different data attributes.

Update the position of a new simulation step

The `BuildConstraintSystemEndEvent` signals the completion of the process for building constraint systems within a simulation involving constraints and their resolutions.

`CleanupVisitor` traverses the scene graph of a simulation to clean up objects, ensuring proper resource deallocation and preventing memory leaks.

Component responsible for main simulation algorithms, managing how and when collisions and integrations computations happen. This class can optionally replace the default computation scheme of compu…

Event fired by CollisionVisitor before performing the collision detection step.

Event fired by CollisionVisitor after performing the collision detection step.

Base class to implement a CPU task all the tasks running on the CPU should inherits from this class

Simulation loop, created by default when the user does not define one in the scene. This loop first computes the collision detection and then solves the physics. Default Animation Loop to be created …

The `DefaultTaskScheduler` manages worker threads for parallel processing in SOFA simulations, enhancing performance by distributing tasks across multiple cores or processors.

Manager of the visual loop, created by default when the user does not define one in the scene. Default VisualManager Loop to be created when no VisualManager found on simulation::node.

The `DeleteVisitor` is responsible for deleting nodes within the SOFA simulation scene graph by removing all child nodes and associated objects.

Write the graph, starting from a root Node, into a std::ostream. The format is the DOT language from Graphviz (https://graphviz.org/)

The `ExportGnuplotVisitor` traverses nodes in the scene graph to export simulation data related to forces, mechanical states, and masses into Gnuplot-compatible files for external visualization.

The `ExportVisualModelOBJVisitor` exports visual models in OBJ format by traversing the scene graph and processing each node's visual model.

Initialize a newly created (or modified) scene graph. Forward: simulation::Node::initialize() This method puts the OdeSolver, if any, first in the list of components. Then BaseObject::init() for a…

Event fired by IntegrateVisitor before performing the integrate detection step.

Event fired by IntegrateVisitor after performing the integrate detection step.

Compute accelerations generated by given forces

This class define a visitor which will go through the scene graph in reverse order and call the method applyJT of each mechanical mapping (@sa sofa::core::BaseMapping)

Accumulate Jacobian matrices through the mappings up to the independent DOFs

Accumulate the entries of a mechanical matrix (mass or stiffness) of the whole scene */

Accumulate the product of the system matrix by a given vector. Typically used in implicit integration solved by a Conjugate Gradient algorithm. The current value of the dx vector is used. This action …

Accumulate the product of the mass matrix by a given vector. Typically used in implicit integration solved by a Conjugate Gradient algorithm. Note that if a dx vector is given, it is used and propagat…

Add dt*mass*Gravity to the velocity This is called if the mass wants to be added separately to the mm from the other forces

Apply the constraints as filters to the given vector. This works for simple independent constraints, like maintaining a fixed point.

Apply projective constraints of the whole scene */

Visitor used to prepare a time integration step. Typically, does nothing.

Call each BaseConstraintSet to build the Jacobian matrices

Accumulate only the contact forces computed in applyContactForce. This action is typically called after a MechanicalResetForceVisitor.

Compute the variation of force corresponding to a variation of position. This action is typically called after a MechanicalPropagateDxVisitor.

Compute the amount of mechanical energy @author Francois Faure

Accumulate the forces (internal and interactions). This action is typically called after a MechanicalResetForceVisitor.

Compute the mapping geometric stiffness matrices. This action must be call before BaseMapping::getK()

Visitor applied after a time step has been applied. Does typically nothing.

The `MechanicalGetConstraintInfoVisitor` collects constraint information from mechanical systems during simulation, facilitating the enforcement of constraints in Lagrangian mechanics formulations.

The `MechanicalGetConstraintJacobianVisitor` retrieves the Jacobian matrix associated with constraints from mechanical states within a simulation, facilitating the handling of constrained systems in t…

Compute the size of a mechanical matrix (mass or stiffness) of the whole scene */

Compute the linear and angular momenta @author Matthieu Nesme, 2015

Count the number of masses which are not diagonal */

The `MechanicalIdentityBlocksInJacobianVisitor` identifies and constructs identity blocks in the Jacobian matrix for degrees of freedom (DOFs) without children mappings during mechanical simulations.

Visitor used to do a time integration step using OdeSolvers

The `MechanicalMultiVectorFromBaseVectorVisitor` copies data from a base vector into multiple vectors during mechanical state traversal in SOFA simulations.

The `MechanicalMultiVectorPeqBaseVectorVisitor` facilitates the addition of values from a source vector into a destination multi-vector at specified offsets derived from a global matrix accessor. It p…

The `MechanicalMultiVectorToBaseVectorVisitor` transfers data from multi-vector structures to base vectors, ensuring consistency between different representations of physical quantities during simulat…

Find mechanical particles hit by the given ray. A mechanical particle is defined as a 2D or 3D, position or rigid DOF which is linked to the free mechanical DOFs by mechanical mappings

Find mechanical particles hit by the given ray on dof containing one tag or all provided by a tag list A mechanical particle is defined as a 2D or 3D, position or rigid DOF which is linked to the fr…

The `MechanicalProjectJacobianMatrixVisitor` updates Jacobian matrices associated with projective constraints in SOFA simulations, ensuring proper constraint handling during the assembly phase.

The `MechanicalProjectPositionAndVelocityVisitor` projects positions and velocities through constraint sets to maintain consistency across simulation components.

The `MechanicalProjectPositionVisitor` projects positions according to defined projective constraints and mappings within SOFA simulations, ensuring accurate constraint enforcement during the simulati…

The `MechanicalProjectVelocityVisitor` handles velocity projection within mechanical simulations by enforcing consistency with constraints and mappings, ensuring physical realism in dynamic scenarios.

Same as MechanicalPropagateDxVisitor followed by MechanicalResetForceVisitor

Apply a hypothetical displacement. This action does not modify the state (i.e. positions and velocities) of the objects. It is typically applied before a MechanicalComputeDfVisitor, in order to comput…

Same as MechanicalPropagateOnlyPositionVisitor followed by MechanicalResetForceVisitor Note that this visitor only propagate through the mappings, and does not apply projective constraints as was prev…

Propagate positions and velocities to all the levels of the hierarchy. At each level, the mappings form the parent to the child is applied. After the execution of this action, all the (mapped) degrees…

Propagate positions to all the levels of the hierarchy. At each level, the mappings form the parent to the child is applied. Note that this visitor only propagate through the mappings, and does not a…

Propagate velocities to all the levels of the hierarchy. At each level, the mappings form the parent to the child is applied. After the execution of this action, all the (mapped) degrees of freedom ar…

Resets constraints for mechanical states during simulation steps to maintain consistent physical state updates.

Reset the force in all the MechanicalModel This action is typically applied before accumulating all the forces.

Visitor class used to set positions and velocities of the top level MechanicalStates of the hierarchy.

Reserve an auxiliary vector identified by a symbolic constant.

Find the first available index for a VecId

Compute the dot product of two vectors */

Free an auxiliary vector identified by a symbolic constant */

Initialize unset MState destVecId vectors with srcVecId vectors value.

Perform a sequence of linear vector accumulation operation $r_i = sum_j (v_j*f_{ij}) This is used to compute in on steps operations such as $v = v + a*dt, x = x + v*dt$. Note that if the result vect…

Compute the norm of a vector. The type of norm is set by parameter @a l. Use 0 for the infinite norm. Note that the 2-norm is more efficiently computed using the square root of the dot product. @autho…

Perform a vector operation v=a+b*f

Print a vector */

Reserve an auxiliary vector identified by a symbolic constant.

Get vector size */

`MechanicalVisitor` facilitates traversal and processing of mechanical properties across the SOFA scene graph, ensuring consistent propagation of forces, constraints, and parameters during simulation …

Generic API to handle mutations of the graph

Implements the object (component) management of the core::Context. Contains objects in lists and provides accessors. The other nodes are not visible (unknown scene graph). @author The SOFA te…

Event fired when needed to stop the animation.

`PipelineImpl` manages collision processing stages in SOFA simulations, including initialization, reset, detection, and response.

Event modify the position of model

`PrintVisitor` traverses and prints details about nodes, objects, and their properties within the SOFA simulation graph for debugging or visualization purposes.

Visitor used to propagate an event in the data structure. Propagation is done top-down until the event is handled. @author The SOFA team </www.sofa-framework.org>

Load the SOFA modules and/or plugins required to run a simulation.

`ResetVisitor` resets objects in the SOFA scene graph to their initial state during a simulation run by traversing nodes top-down.

`SceneCheck` is an abstract base class for performing validations on SOFA's scene graph nodes to ensure configuration integrity before simulations.

Main controller of the scene. Defines how the scene is inited at the beginning, and updated at each time step. Derives from Base in order to use smart pointers and model the parameters as Data…

Event fired when needed to stop the animation.

Event fired when needed to stop the animation.

Event fired when sofa::simulation::Simulation::initTextures has been called.

Event fired when needed to stop the animation.

Event fired when needed to stop the animation.

`SolveConstraintSystemEndEvent` marks the completion of constraint resolution in SOFA simulations, coordinating various components within the FEM pipeline.

Used by the animation loop: send the solve signal to the others solvers This visitor is able to run the solvers sequentially or concurrently.

The `StateChangeVisitor` propagates state changes through the SOFA simulation graph, ensuring consistency in mechanical states and mappings after topological or other modifications.

Task class interface */

Base class for a task scheduler The API allows to: - initialize the scheduler with a number of dedicated threads - add a task to the scheduler - wait until all tasks are done etc.

`TaskSchedulerUser` manages task schedulers in SOFA by initializing, reinitializing, and stopping them based on specified thread counts. It controls parallel execution to ensure efficient task schedul…

The `TopologyChangeVisitor` manages and propagates topological structure changes within a SOFA simulation by traversing nodes and objects to ensure consistency across dependent components.

The `UpdateBoundingBoxVisitor` computes and updates bounding boxes for simulation nodes by aggregating child object and sub-node bounding boxes in a top-down and bottom-up manner.

The `UpdateContextVisitor` traverses the SOFA scene graph to update contexts for each node, ensuring consistency across different parts of the simulation.

Triggers the updateInternal() function to update method called when variables (used to compute other internal variables) are modified

The `UpdateLinksVisitor` updates links between objects within simulation nodes to ensure proper setup and maintenance of constraints and mappings.

Event fired by Simulation::animate() after computing a new animation step. @author Jeremie Allard

propagating position and velocity through non-mechanical mappings (while MechanicalPropagateOnlyPositionAndVelocityVisitor is propagating mechanical mappings)

The `VelocityThresholdVisitor` processes nodes in a top-down manner within the SOFA simulation graph, applying velocity thresholding by setting all velocity entries below a specified threshold to zero…

Base class for visitors propagated recursively through the scenegraph

`VisualVisitor` processes visual models within the SOFA simulation scene graph for operations such as drawing, updating visuals, initializing visual components, and computing bounding boxes.

The `WriteStateVisitor` traverses and writes out the mechanical state information from nodes in the SOFA simulation hierarchy.

The `XMLPrintVisitor` traverses and prints a SOFA scene graph in XML format, facilitating debugging, visualization, and exporting of simulation data structures.

Main controller of the scene. Defines how the scene is inited at the beginning, and updated at each time step. Derives from BaseObject in order to model the parameters as Datas, which makes their edit…

`BaseSimulationTest` facilitates simulation tests within the SOFA framework by managing test scenes and advancing simulations, ensuring correct behavior under various conditions.

Base class for Sofa test fixtures.

Helper functions to compare scalars, vectors, matrices, etc.

`Element` represents geometric elements in SOFA simulations by storing node indices and providing methods to access them.

The `Point` component defines individual vertices or nodes in the simulation's geometry, essential for forming topological structures such as edges, triangles, and tetrahedra within SOFA simulations.

Same as type::vector, + delimiters on serialization

Regular vector Using CPUMemoryManager, it has the same behavior as std::vector with extra conveniences: - string serialization (making it usable in Data) - operator[] is checking if the index is wit…

`DrawToolGL` is responsible for rendering geometric shapes and text within the OpenGL context in SOFA simulations, providing methods to handle transformations, lighting, depth testing, and pixel readi…

`TransformationGL` applies graphical transformations such as rotation, translation, and scaling in the SOFA simulation environment for visual elements.

Create texture coordinate for a given field. This class give texture coordinate in 1D according to an input state vector.

Provides color palette and support for conversion of numbers to colors.

Display 2D text in the viewport.

Set an additional viewport into the main one.

Define arbitrary clipping plane into OpenGL.

Color rendering of data associated with a mesh.

Merge several visual models. This class merges several visual models.

Generic visual model for OpenGL display. Main class for rendering 3D model in SOFA. This class implements VisuelModelImpl with rendering functions using OpenGL.

Display a frame at the corner of the scene view.

Visualization for a cloud of points using splatting.

Sliced visualization for a volumetric model defined with hexahedra.

Visual loop enabling multipass rendering. Needs multiple fbo data and a compositing shader. \Compositing visual loop: render multiple passes and composite them into one single rendered frame

A directional light illuminating the scene with parallel rays of light (can cast shadows). Utility to cast Light into a Opengl scene. This class must be used in a scene with one LightManager object.…

Manage a set of lights that can cast hard and soft shadows.Soft Shadows is done using Variance Shadow Mapping Utility to manage lights into an Opengl scene This class must be used with the Light cla…

OglFloatAttribute

Shader implementating Order Independent Transparency.

Set the current visual context framebuffer with SRGB. The utility to enable/disable sRGB rendering

Set custom shader for the current visual context. Utility to use shader for a visual model in OpenGL. This class is used to implement shader into Sofa, for visual rendering or for special treatment…

Visual model for OpenGL display using a custom shader.

This component sets the shader system responsible of the shadowing.

Load a texture to be used in a shader. Defines an uniform sampler (texture) for a OglShader. This is an abstract class which passes a texture id to an uniform sampler variable defined into the shad…

Pointer to a OglTexture, useful for sharing a texture between multiple shaders. Defines an uniform sampler (texture) for a OglShader. This is an abstract class which passes a texture id to an unifor…

OglIntVariable Defines an uniform variable for a OglShader. This is an abstract class which pass a value to an uniform variable defined into the shader. At the moment, following types are supporte…

Order Independent Transparency Manager (to be used with OglOITShader). Utility to manage transparency (translucency) into an Opengl scene \note Reference: http://jcgt.org/published/0002/02/09/paper.…

Add a post process pass to the actual rendering.

Render pass element: render the relevant tagged objects in a FBO.

Chain different rendering pass, for compositing. Render pass element: render the relevant tagged objects in a FBO

`BatchGUI` enables non-interactive batch processing of SOFA simulations by setting up scenes, executing iterations, and managing timers and JSON exports.

`BaseGUI` provides an abstract interface for implementing graphical user interfaces in SOFA, managing viewer configurations, background settings, and mouse interactions.

`BaseViewer` is an abstract base class defining the interface for GUI viewers in SOFA, providing methods for scene management, camera control, and rendering.

The `ColourPickingVisitor` facilitates colour-based picking by rendering collision models with unique RGB codes to identify objects in the GUI.

The `FilesRecentlyOpenedManager` manages a list of recently opened files in the SOFA GUI, ensuring the list does not exceed a predefined maximum number of entries.

The `PickHandler` manages mouse interactions for picking and manipulating objects within the SOFA simulation scene by handling ray-casting, selection buffer methods, and collision detection.

Button setting adding a frame to a skinned model.

Save Camera's View Point Button configuration.

The `AddRecordedCameraPerformer` records the current camera's position and orientation into a `RecordedCamera` object for later playback or navigation during simulation runs.

Attach Body Button configuration.

Attach an object to the mouse using lagrangian multiplier. This component modifies the mouse picking behavior in the GUI and set it at the beginning to Lagrangian-based constraints It doesn't have an…

Fix a picked particle in space.

The `InciseAlongPathPerformer` manages topological cuts along user-defined paths in SOFA simulations, handling both incremental incisions and complete cuts when the performer is frozen.

The `InteractionPerformer` class in SOFA is an abstract base for mouse-based user interactions within the GUI, defining methods to configure, start, execute, handle events, draw visuals, and freeze in…

The `StartNavigationPerformer` initiates camera navigation actions within the SOFA GUI by saving the current camera's position and orientation when navigation starts.

InspectorDock provides an interactive dock widget for inspecting and modifying properties of simulation components in the SOFA framework.

The `GLPickHandler` facilitates picking operations in OpenGL contexts by allocating selection buffers and identifying objects using color coding techniques.

The `GraphDataWidget` provides graphical visualization capabilities for displaying data in graph form within the SOFA framework's Qt-based interface.

`GraphListenerQListView` connects the SOFA scene graph with a Qt QTreeView widget, enabling dynamic visualization and interaction with the hierarchy of nodes and objects within a simulation.

`QEnergyStatWidget` displays energy-related statistics during SOFA simulations, providing visual insights into energy dynamics within the simulation environment.

Base class to make graphes in the stat tab of the node widget TODO add gnuplot export

The `QMenuFilesRecentlyOpened` class manages recently opened files through a graphical menu system in SOFA's GUI, inheriting from `FilesRecentlyOpenedManager`. It provides methods for creating, updati…

The `QMomentumStatWidget` is a visualization tool that displays momentum-related statistical information during SOFA simulations, inheriting from `QGraphStatWidget` to provide real-time feedback on si…

QSofaListView is a Qt-based widget providing a list view to visualize and manage nodes in the SOFA scene graph.

`RealGUI` provides graphical user interface functionalities in the SOFA framework, enabling visualization and control of simulation environments.

This class manages the GUI of a BaseData, using the corresponding instance of data_widget_container

The `SofaSceneGraphWidget` provides an interface for visualizing and interacting with scene graph structures within the SOFA framework. It supports state management through locking and dirty status up…

The `TableDataWidget` extends `SimpleDataWidget` to display tabular data interactively within the SOFA framework's Qt module.

`OglModelPolicy` manages loading and unloading of visual model data for OpenGL-based graphical representations in SOFA's Qt viewer extension.

`SofaViewer` provides visualization capabilities for SOFA simulations, handling user interface interactions such as key events, mouse events, and wheel events.

The `VisualModelPolicy` defines policies for visual model loading and unloading in the SOFA Qt viewer, ensuring consistent behavior for different types of visual models.

`BaseVTKLoader` is an abstract base class in SOFA's VTK module for loading VTK data files into the simulation framework, inheriting from `MeshLoader`. It provides a method to be implemented by derived…

Mesh loader

Mesh loader for unstructured grids

Components that calls the elec model with a finer time step

Bidirectional explicit electrical coupling between the 3D ElecPMJCouplingForceField ------------------------- Explicit, bidirectional electrical coupling between: - the 3D myocardium monodomain Mit…

MS model Monodomain reaction–diffusion model with Mitchell–Schaeffer ionic kinetics. This ForceField extends TetrahedronDiffusionFEMForceField to provide: - diffusion of the transmembrane potential…

Purkinje diffusion force field on a 1D Purkinje network (edge topology) PurkinjeDiffusionForceField ---------------------------- Electrical ForceField for a Purkinje network defined on an edge topolo…

The scene loader for python3 scene files

Surf Constraint This component implements a Lagrange constraint problem resolution with integrated volume computation (dV as constraint Jacobian row). Topology is found automatically from the context…

General ForceField for tetrahedral meshes

Applies contraction force along fiber directions in tetrahedral meshes, coupling with a MS model

Surf Constraint

Example Engine Template Engine as example

Surf Constraint

Surf Constraint

Compute tetrahedral mesh volume by sum of element volumes

Applies functional contraction (stress is computed from a function of strain) force along fiber directions in tetrahedral meshes

Implement the Huxley model ODE to compute active stress along fiber

Applies constant contraction force along fiber directions in tetrahedral meshes

Compute open surface volume and volume derivative with respect to DOFs