SOFA API  56988ca1
Open source framework for multi-physics simuation
sofa::component::mass Namespace Reference

Classes

struct  AddMToMatrixFunctor
 
struct  AddMToMatrixFunctor< defaulttype::RigidDeriv< N, Real >, defaulttype::RigidMass< N, Real >, MatrixType >
 
class  DiagonalMassInternalData
 
class  DiagonalMass
 This component computes the integral of this mass density over the volume of the object geometry but it supposes that the Mass matrix is diagonal. More...
 
struct  MassType
 
class  MeshMatrixMassInternalData
 
class  MeshMatrixMass
 This component computes the integral of this mass density over the volume of the object geometry. More...
 
struct  MassType< sofa::defaulttype::StdRigidTypes< N, real > >
 
class  UniformMass
 
struct  MassType< defaulttype::StdVectorTypes< TCoord, TDeriv, TReal > >
 

Functions

SOFA_EXPORT_DYNAMIC_LIBRARY void initExternalModule ()
 
SOFA_EXPORT_DYNAMIC_LIBRARY const chargetModuleName ()
 
SOFA_EXPORT_DYNAMIC_LIBRARY const chargetModuleVersion ()
 
SOFA_EXPORT_DYNAMIC_LIBRARY const chargetModuleComponentList ()
 
void init ()
 
template<class MassType >
void parseMassTemplate (sofa::core::objectmodel::BaseObjectDescription *arg, const core::behavior::BaseMass *mass)
 
Mat3x3d MatrixFromEulerXYZ (double thetaX, double thetaY, double thetaZ)
 

Variables

int DiagonalMassClass
 
template class SOFA_COMPONENT_MASS_API DiagonalMass< Vec3Types >
 
template class SOFA_COMPONENT_MASS_API DiagonalMass< Vec2Types >
 
template class SOFA_COMPONENT_MASS_API DiagonalMass< Vec2Types, Vec3Types >
 
template class SOFA_COMPONENT_MASS_API DiagonalMass< Vec1Types >
 
template class SOFA_COMPONENT_MASS_API DiagonalMass< Vec1Types, Vec2Types >
 
template class SOFA_COMPONENT_MASS_API DiagonalMass< Vec1Types, Vec3Types >
 
template class SOFA_COMPONENT_MASS_API DiagonalMass< Rigid3Types >
 
template class SOFA_COMPONENT_MASS_API DiagonalMass< Rigid2Types >
 
template class SOFA_COMPONENT_MASS_API DiagonalMass< Rigid2Types, Rigid3Types >
 
int MeshMatrixMassClass
 
int UniformMassClass
 
template class SOFA_COMPONENT_MASS_API UniformMass< Vec3Types >
 
template class SOFA_COMPONENT_MASS_API UniformMass< Vec2Types >
 
template class SOFA_COMPONENT_MASS_API UniformMass< Vec1Types >
 
template class SOFA_COMPONENT_MASS_API UniformMass< Vec6Types >
 
template class SOFA_COMPONENT_MASS_API UniformMass< Rigid3Types >
 
template class SOFA_COMPONENT_MASS_API UniformMass< Rigid2Types >
 

Function Documentation

◆ getModuleComponentList()

const char * sofa::component::mass::getModuleComponentList ( )

◆ getModuleName()

const char * sofa::component::mass::getModuleName ( )

◆ getModuleVersion()

const char * sofa::component::mass::getModuleVersion ( )

◆ init()

SOFA_COMPONENT_MASS_API void sofa::component::mass::init ( )

◆ initExternalModule()

void sofa::component::mass::initExternalModule ( )

◆ MatrixFromEulerXYZ()

Mat3x3d sofa::component::mass::MatrixFromEulerXYZ ( double  thetaX,
double  thetaY,
double  thetaZ 
)

◆ parseMassTemplate()

template<class MassType >
void sofa::component::mass::parseMassTemplate ( sofa::core::objectmodel::BaseObjectDescription arg,
const core::behavior::BaseMass mass 
)

Function used in parsing some classes derived from BaseMass to warn the user how the template attributes have changed since #2644

Variable Documentation

◆ DiagonalMass< Rigid2Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::DiagonalMass< Rigid2Types >

◆ DiagonalMass< Rigid2Types, Rigid3Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::DiagonalMass< Rigid2Types, Rigid3Types >

◆ DiagonalMass< Rigid3Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::DiagonalMass< Rigid3Types >

◆ DiagonalMass< Vec1Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::DiagonalMass< Vec1Types >

◆ DiagonalMass< Vec1Types, Vec2Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::DiagonalMass< Vec1Types, Vec2Types >

◆ DiagonalMass< Vec1Types, Vec3Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::DiagonalMass< Vec1Types, Vec3Types >

◆ DiagonalMass< Vec2Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::DiagonalMass< Vec2Types >

◆ DiagonalMass< Vec2Types, Vec3Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::DiagonalMass< Vec2Types, Vec3Types >

◆ DiagonalMass< Vec3Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::DiagonalMass< Vec3Types >

◆ DiagonalMassClass

int sofa::component::mass::DiagonalMassClass
Initial value:
= core::RegisterObject("Define a specific mass for each particle")
.add< DiagonalMass<Vec3Types> >()
.add< DiagonalMass<Vec2Types, Vec3Types> >()
.add< DiagonalMass<Vec1Types> >()
.add< DiagonalMass<Vec1Types, Vec2Types> >()
.add< DiagonalMass<Vec1Types, Vec3Types> >()
.add< DiagonalMass<Rigid3Types> >()
.add< DiagonalMass<Rigid2Types> >()
.add< DiagonalMass<Rigid2Types, Rigid3Types> >()

◆ MeshMatrixMassClass

int sofa::component::mass::MeshMatrixMassClass
Initial value:
= core::RegisterObject("Define a specific mass for each particle")
.add< MeshMatrixMass<Vec3Types> >()
.add< MeshMatrixMass<Vec2Types> >()
.add< MeshMatrixMass<Vec2Types, Vec3Types> >()
.add< MeshMatrixMass<Vec1Types> >()
.add< MeshMatrixMass<Vec1Types, Vec2Types> >()
.add< MeshMatrixMass<Vec1Types, Vec3Types> >()

◆ UniformMass< Rigid2Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::UniformMass< Rigid2Types >

◆ UniformMass< Rigid3Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::UniformMass< Rigid3Types >

◆ UniformMass< Vec1Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::UniformMass< Vec1Types >

◆ UniformMass< Vec2Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::UniformMass< Vec2Types >

◆ UniformMass< Vec3Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::UniformMass< Vec3Types >

TEMPLATE INITIALIZATION ///////////////////////////////////////////////// Force template specialization for the most common sofa type. This goes with the extern template declaration in the .h. Declaring extern template avoid the code generation of the template for each compilation unit. see: http://www.stroustrup.com/C++11FAQ.html#extern-templates

◆ UniformMass< Vec6Types >

template class SOFA_COMPONENT_MASS_API sofa::component::mass::UniformMass< Vec6Types >

◆ UniformMassClass

int sofa::component::mass::UniformMassClass
Initial value:
= core::RegisterObject("Define the same mass for all the particles")
.add< UniformMass<Vec3Types> >()
.add< UniformMass<Vec2Types> >()
.add< UniformMass<Vec1Types> >()
.add< UniformMass<Vec6Types> >()
.add< UniformMass<Rigid3Types> >()
.add< UniformMass<Rigid2Types> >()

REGISTERING TO FACTORY ///////////////////////////////////////// Registering the component see: https://www.sofa-framework.org/community/doc/programming-with-sofa/components-api/the-objectfactory/ 1-SOFA_DECL_CLASS(componentName) : Set the class name of the component 2-RegisterObject("description") + .add<> : Register the component 3-.add<>(true) : Set default template