SOFA is an open-source framework primarily targeted at real-time simulation, with an emphasis on medical simulation. Its design encourages the development newer models and algorithms. SOFA is currently developed by 4 INRIA teams: Mimesis, Imagine, Defrost and Asclepios.
Based on C++, the SOFA engine is build using a flexible architecture. The base mechanisms of SOFA are implemented in a public core. Around this public core, several public modules and plugins are available. These additional packages can be activated at will using CMake in order to build your own configuration of SOFA. With its high level of modularity, SOFA appears to be an efficient tools for benchmarking and developing new training medical technologies.
Additional private plugins are implemented around SOFA. However, the access to these plugins is restricted and specific licences may apply. Do not hesitate to contact us for any further information.
The development of SOFA follows a continuous integration. This development effort is performed on the three platforms: Windows, MacOS and Linux.
Scene graph: a simulation in SOFA is described as a Direct Acyclic Graph (DAG), i.e. a generalized hierarchy. The simulation is therefore composed of nodes containing the components used for the computation (solvers, models, visualization, etc.). The properties of a specific component are called “Data” and these “Data” can be linked each other.
State vectors: originally designed for soft mechanics, the degrees of freedom and all other state vectors (velocity, forces, etc.) are store in a key component: the MechanicalObject. This component stores everything about the simulated object. Depending on its template, the degrees of freedom can be 1D, 2D, 3D, 6D or rigid (3D + orientation).
Algorithms & models: the SOFA engine provides many algorithms and physiological models. Here is a short list of the available codes in SOFA. First, SOFA includes different integration schemes and linear system solvers:
- Integration schemes: Euler explicit, Euler implicit, RK2, RK4, static solver,
- Linear system solvers: iterative solver (Conjugate Gradient), direct solvers.
Different physical models are also available in SOFA:
- Rigid models: articulated bodies based on penalties or reduced coordinates,
- Deformable models: mass spring, FEM (triangles, tetrahedra, hexahedra) with many different constitutive laws,
- Fluid models: SPH, Eulerian formulation.
Multi-model representation: the SOFA architecture relies on a multi-model representation which allows to have several representations (e.g. mechanical, thermal and visual) of the same object. Those different representations are connected together through a mechanism called the “Mappings”. With this features, it is also possible to have models of very different nature interacting together, for instance rigid bodies, deformable objects, and fluids.
Topology: all types of topology are available in SOFA (points, edges, triangles, quads, tetrahedra, hexahedra). Loaders implemented in the public version of SOFA allow to load various type of formats (obj, msh, vtk, etc.). Using these loaders, your mesh is directly uploaded in the simulation. Finally, SOFA proposes algorithms handling topological changes.
Collision: different methods are at your disposal in SOFA to build a simulation involving collision:
- Collision models: spheres, triangular meshes, distance fields; with AABB-tree or octree bounding volume hierarchies,
- Collision detection methods: BVH, discrete intersection (proximity method), LDI (Layer Depth Image), Distance maps,
- Collision response methods: penalty method, LCP-based constraints.
Interactions: with its emphasis to real-time simulation, SOFA makes possible to include user interaction in the simulation, such as probing, cutting, suturing, etc. In this scope, SOFA is compatible with VR / simulation devices: Geomagic®, ARTTrack™, Novint® Falcon™, etc.
Parallelization methods: the flexibility of SOFA also resides in the fact that the scene graph describes the simulation while allowing a possible parallel scheduling. Two different parallelization approaches are available in two separate plugins:
- GPU computing using the CUDA API: the CUDA version of a code can very easily be activated based on a template mechanism,
- and Multithreading.
Python scripting: the usual description of a SOFA simulation is performed using an XML syntax. For even more flexibility, a Python plugin now allows to script your simulation using the Python language, thus making the benchmarking of your algorithms easier and increasing the level of interactivity in the simulation.
SOFA appears to be an ideal tool to reuse and easily compare a variety of methods. Using SOFA, you will also be able to create complex simulations by combining new algorithms with existing ones. To create your own application based on SOFA, your C++ components can be implemented within a private plugin. To share your contribution with the SOFA community or access any information, please do not hesitate to contact us.
If you want to read more about SOFA and its architecture, you can visit the Online Documentation of SOFA.
Find more information about the previous work and projects using SOFA: