Back

MechanicalParams

sofa::core::MechanicalParams
ExecParams
Doc (from source)

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

Abstract (AI generated)

`MechanicalParams` manages key parameters for mechanical computations in SOFA simulations, including time step size, mass matrix contributions factor, damping matrix contributions factor, stiffness matrix contributions factor, and implicit integration flags.

Metadata
module
Sofa.framework.Core
namespace
sofa::core
include
sofa/core/MechanicalParams.h
inherits
  • ExecParams
description

The MechanicalParams class in the SOFA framework serves as an essential container for parameters related to mechanical computations, particularly those used by mechanical components and methods during simulations. This class is crucial for storing and managing key variables that influence the dynamics of deformable bodies and other physical systems simulated within SOFA.

Governing Equations and Operators

The MechanicalParams class does not directly implement or contribute to specific governing equations such as the mass matrix $M$, stiffness matrix $K$, internal force vector $f_{int}$, or nonlinear residual $R$. Instead, it provides parameters that are used in these computations. For instance:

  • Time Step (dt): The time step size $ riangle t$ is a fundamental parameter for time integration schemes such as the implicit Backward Euler method.

  • Mass Matrix Contributions Factor (mFactor): This factor, denoted by $m_{factor}$, scales contributions to the mass matrix in implicit schemes. It is used in equations like:

$$ R(x_{n+1}) = M rac{x_{n+1}-x_n}{ riangle t} - riangle t f_{int}(x_{n+1}) - riangle t f_{ext} = 0 $$
  • Damping Matrix Contributions Factor (bFactor): The damping matrix contributions factor, denoted by $b_{factor}$, is used in the Rayleigh Damping model where the damping matrix $D$ is defined as:
$$ D = b_{factor} imes K - b_{factor} imes M $$
  • Stiffness Matrix Contributions Factor (kFactor): The stiffness matrix contributions factor, denoted by $k_{factor}$, scales the stiffness matrix contributions in implicit schemes. It is used in equations like:
$$ R(x_{n+1}) = M rac{x_{n+1}-x_n}{ riangle t} - riangle t k_{factor} K(x_{n+1}) - riangle t f_{ext} = 0 $$

Constitutive and Kinematic Laws

The MechanicalParams class does not implement or contribute to specific constitutive laws (e.g., strain measures, stress tensors, hyperelastic potentials) directly. However, it provides parameters that are used in these calculations. For example:

  • Rayleigh Damping: The Rayleigh damping coefficients $eta$ and $eta_m$, which are computed using kFactorIncludingRayleighDamping and mFactorIncludingRayleighDamping, respectively.

Role in the Global FEM Pipeline

The MechanicalParams class plays a critical role in several stages of the FEM simulation pipeline:

  • Assembly Phase: The factors (e.g., $m_{factor}$, $k_{factor}$) are used to scale contributions during assembly.

  • Time Integration: Parameters like time step size $ riangle t$ and implicit integration flags determine how the system evolves over time.

  • Nonlinear Solution: The factors contribute to the nonlinear residual equations and are crucial for solving the nonlinear dynamics of deformable systems.

Numerical Methods and Discretization Choices

The MechanicalParams class encodes several numerical methods and discretization choices, such as:

  • Implicit Integration Scheme Flag (implicit): Indicates whether the time integration scheme is implicit or not. This affects the structure of equations like Newton-Raphson iterations.

Variational / Lagrangian Mechanics Framework

The MechanicalParams class fits into the broader variational and Lagrangian mechanics framework by providing necessary parameters that are used in assembling the weak form, time integration schemes, and nonlinear solvers. These parameters ensure consistency with the underlying physics while enabling numerical stability and extensibility.

Summary

In summary, MechanicalParams is a critical component for managing simulation parameters that influence various aspects of mechanical simulations within SOFA, including time integration, assembly of equations, and handling implicit schemes. While it does not directly implement specific physical laws or governing equations, its role in parameter management is essential for the accurate and efficient execution of FEM simulations.

Methods
SReal dt ()
bool implicit ()
SReal mFactor ()
SReal bFactor ()
SReal kFactor ()
SReal kFactorIncludingRayleighDamping (SReal rayleighStiffness)
SReal mFactorIncludingRayleighDamping (SReal rayleighMass)
bool supportOnlySymmetricMatrix ()
bool energy ()
const Data<typename S::VecCoord> * readX (const S * state)
const Data<typename S::VecDeriv> * readV (const S * state)
const Data<typename S::VecDeriv> * readF (const S * state)
const Data<typename S::VecDeriv> * readDx (const S * state)
const Data<typename S::VecDeriv> * readDf (const S * state)
MechanicalParams & setDt (SReal v)
MechanicalParams & setImplicit (bool v)
MechanicalParams & setMFactor (SReal v)
MechanicalParams & setBFactor (SReal v)
MechanicalParams & setKFactor (SReal v)
MechanicalParams & setSupportOnlySymmetricMatrix (bool b)
void setKFactorUsed (bool )
MechanicalParams & setEnergy (bool v)
const ConstMultiVecCoordId & x ()
const ConstMultiVecDerivId & v ()
const ConstMultiVecDerivId & f ()
const ConstMultiVecDerivId & dx ()
const ConstMultiVecDerivId & df ()
MechanicalParams & setX (ConstVecCoordId v)
MechanicalParams & setX (ConstMultiVecCoordId v)
MechanicalParams & setX (const StateSet & g, ConstVecCoordId v)
MechanicalParams & setV (ConstVecDerivId v)
MechanicalParams & setV (ConstMultiVecDerivId v)
MechanicalParams & setV (const StateSet & g, ConstVecDerivId v)
MechanicalParams & setF (ConstVecDerivId v)
MechanicalParams & setF (ConstMultiVecDerivId v)
MechanicalParams & setF (const StateSet & g, ConstVecDerivId v)
MechanicalParams & setDx (ConstVecDerivId v)
MechanicalParams & setDx (ConstMultiVecDerivId v)
MechanicalParams & setDx (const StateSet & g, ConstVecDerivId v)
MechanicalParams & setDf (ConstVecDerivId v)
MechanicalParams & setDf (ConstMultiVecDerivId v)
MechanicalParams & setDf (const StateSet & g, ConstVecDerivId v)
const MechanicalParams * defaultInstance ()
MechanicalParams * setExecParams (const core::ExecParams * params)
MechanicalParams * operator= (const MechanicalParams & mparams)
void setImplicitVelocity (SReal i)
const SReal & implicitVelocity ()
void setImplicitPosition (SReal i)
const SReal & implicitPosition () 
{
  "name": "MechanicalParams",
  "namespace": "sofa::core",
  "module": "Sofa.framework.Core",
  "include": "sofa/core/MechanicalParams.h",
  "doc": "Class gathering parameters use by mechanical components methods, and transmitted by mechanical visitors",
  "inherits": [
    "ExecParams"
  ],
  "templates": [],
  "data_fields": [],
  "links": [],
  "methods": [
    {
      "name": "dt",
      "return_type": "SReal",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "implicit",
      "return_type": "bool",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "mFactor",
      "return_type": "SReal",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "bFactor",
      "return_type": "SReal",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "kFactor",
      "return_type": "SReal",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "kFactorIncludingRayleighDamping",
      "return_type": "SReal",
      "params": [
        {
          "name": "rayleighStiffness",
          "type": "SReal"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "mFactorIncludingRayleighDamping",
      "return_type": "SReal",
      "params": [
        {
          "name": "rayleighMass",
          "type": "SReal"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "supportOnlySymmetricMatrix",
      "return_type": "bool",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "energy",
      "return_type": "bool",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "readX",
      "return_type": "const Data<typename S::VecCoord> *",
      "params": [
        {
          "name": "state",
          "type": "const S *"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "readV",
      "return_type": "const Data<typename S::VecDeriv> *",
      "params": [
        {
          "name": "state",
          "type": "const S *"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "readF",
      "return_type": "const Data<typename S::VecDeriv> *",
      "params": [
        {
          "name": "state",
          "type": "const S *"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "readDx",
      "return_type": "const Data<typename S::VecDeriv> *",
      "params": [
        {
          "name": "state",
          "type": "const S *"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "readDf",
      "return_type": "const Data<typename S::VecDeriv> *",
      "params": [
        {
          "name": "state",
          "type": "const S *"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setDt",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "SReal"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setImplicit",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "bool"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setMFactor",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "SReal"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setBFactor",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "SReal"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setKFactor",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "SReal"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setSupportOnlySymmetricMatrix",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "b",
          "type": "bool"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setKFactorUsed",
      "return_type": "void",
      "params": [
        {
          "name": "",
          "type": "bool"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setEnergy",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "bool"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "x",
      "return_type": "const ConstMultiVecCoordId &",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "v",
      "return_type": "const ConstMultiVecDerivId &",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "f",
      "return_type": "const ConstMultiVecDerivId &",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "dx",
      "return_type": "const ConstMultiVecDerivId &",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "df",
      "return_type": "const ConstMultiVecDerivId &",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setX",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "ConstVecCoordId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setX",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "ConstMultiVecCoordId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setX",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "g",
          "type": "const StateSet &"
        },
        {
          "name": "v",
          "type": "ConstVecCoordId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setV",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "ConstVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setV",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "ConstMultiVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setV",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "g",
          "type": "const StateSet &"
        },
        {
          "name": "v",
          "type": "ConstVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setF",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "ConstVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setF",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "ConstMultiVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setF",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "g",
          "type": "const StateSet &"
        },
        {
          "name": "v",
          "type": "ConstVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setDx",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "ConstVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setDx",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "ConstMultiVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setDx",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "g",
          "type": "const StateSet &"
        },
        {
          "name": "v",
          "type": "ConstVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setDf",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "ConstVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setDf",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "v",
          "type": "ConstMultiVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setDf",
      "return_type": "MechanicalParams &",
      "params": [
        {
          "name": "g",
          "type": "const StateSet &"
        },
        {
          "name": "v",
          "type": "ConstVecDerivId"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "defaultInstance",
      "return_type": "const MechanicalParams *",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": true,
      "access": "public"
    },
    {
      "name": "setExecParams",
      "return_type": "MechanicalParams *",
      "params": [
        {
          "name": "params",
          "type": "const core::ExecParams *"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "operator=",
      "return_type": "MechanicalParams *",
      "params": [
        {
          "name": "mparams",
          "type": "const MechanicalParams &"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setImplicitVelocity",
      "return_type": "void",
      "params": [
        {
          "name": "i",
          "type": "SReal"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "implicitVelocity",
      "return_type": "const SReal &",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "setImplicitPosition",
      "return_type": "void",
      "params": [
        {
          "name": "i",
          "type": "SReal"
        }
      ],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    },
    {
      "name": "implicitPosition",
      "return_type": "const SReal &",
      "params": [],
      "is_virtual": false,
      "is_pure_virtual": false,
      "is_static": false,
      "access": "public"
    }
  ],
  "description": "The `MechanicalParams` class in SOFA (Simulation Open-Framework Architecture) is an essential part of the simulation framework, specifically designed to store and manage parameters related to mechanical computations.",
  "inheritsFrom": [
    "sofa::core::ExecParams"
  ],
  "purpose": "It encapsulates various properties required for the computation of physical systems within simulations, such as time step values, flags indicating whether integration is implicit or explicit, and factors for matrix contributions in the system dynamics. This class provides a way to consistently pass these parameters across different parts of the simulation engine.",
  "keyMethods": {
    "setX(const VecCoordId v)": "Sets the ID of position vector.",
    "setV(const VecDerivId v)": "Sets the ID of velocity vector.",
    "setF(const VecDerivId v)": "Sets the ID of force vector.",
    "setDx(const VecDerivId v)": "Sets the ID of dx (displacement) vector, used in implicit schemes.",
    "setDf(const VecDerivId v)": "Sets the ID of df (force increment) vector, also used in implicit schemes.",
    "defaultInstance()": "Returns a default instance of MechanicalParams which serves as a fallback for methods requiring default values.",
    "operator=(const MechanicalParams& mparams)": "Overloaded assignment operator to copy another `MechanicalParams` object.",
    "setExecParams(const core::ExecParams* params)": "Sets the execution parameters used in simulations."
  },
  "experimentalFeatures": {
    "m_implicitVelocity": "A compliance parameter indicating the ratio of future and current force used for velocity update. A value of 1 indicates fully implicit, while 0 means fully explicit.",
    "m_implicitPosition": "Another compliance parameter showing the ratio of future and current velocity used for position updates. Similarly, a value of 1 is fully implicit, and 0 is fully explicit."
  },
  "usageScenario": "The `MechanicalParams` object can be utilized in simulation components that require mechanical settings, such as integrators or solvers, to ensure consistent handling of the physical properties across different modules.",
  "examplesOfUse": [
    "Example: Initializing Mechanical Parameters for an Integrator",
    "```cpp\n// Create a default instance and modify it according to needs\nsofa::core::MechanicalParams params = *sofa::core::MechanicalParams::defaultInstance();\nparams.dt(0.01); // set time step to 0.01 seconds\nparams.setImplicit(true); // enable implicit integration\n// Pass the parameters to an integrator\nmyIntegrator->init(params);\n```"
  ],
  "note": "The `MechanicalParams` class is thread-safe due to its use of a thread-local default instance.",
  "maths": "The `MechanicalParams` class in the SOFA framework serves as an essential container for parameters related to mechanical computations, particularly those used by mechanical components and methods during simulations. This class is crucial for storing and managing key variables that influence the dynamics of deformable bodies and other physical systems simulated within SOFA.\n\n### Governing Equations and Operators\n\nThe `MechanicalParams` class does not directly implement or contribute to specific governing equations such as the mass matrix \\(M\\), stiffness matrix \\(K\\), internal force vector \\(f_{int}\\), or nonlinear residual \\(R\\). Instead, it provides parameters that are used in these computations. For instance:\n\n- **Time Step** (dt): The time step size \\(\triangle t\\) is a fundamental parameter for time integration schemes such as the implicit Backward Euler method.\n  \n- **Mass Matrix Contributions Factor** (mFactor): This factor, denoted by \\(m_{factor}\\), scales contributions to the mass matrix in implicit schemes. It is used in equations like:\n  \n\\[ R(x_{n+1}) = M\frac{x_{n+1}-x_n}{\triangle t} - \triangle t f_{int}(x_{n+1}) - \triangle t f_{ext} = 0 \\]\n\n- **Damping Matrix Contributions Factor** (bFactor): The damping matrix contributions factor, denoted by \\(b_{factor}\\), is used in the Rayleigh Damping model where the damping matrix \\(D\\) is defined as:\n\n\\[ D = b_{factor} \times K - b_{factor} \times M \\]\n\n- **Stiffness Matrix Contributions Factor** (kFactor): The stiffness matrix contributions factor, denoted by \\(k_{factor}\\), scales the stiffness matrix contributions in implicit schemes. It is used in equations like:\n  \n\\[ R(x_{n+1}) = M\frac{x_{n+1}-x_n}{\triangle t} - \triangle t k_{factor} K(x_{n+1}) - \triangle t f_{ext} = 0 \\]\n\n### Constitutive and Kinematic Laws\n\nThe `MechanicalParams` class does not implement or contribute to specific constitutive laws (e.g., strain measures, stress tensors, hyperelastic potentials) directly. However, it provides parameters that are used in these calculations. For example:\n\n- **Rayleigh Damping**: The Rayleigh damping coefficients \\(\beta\\) and \\(\beta_m\\), which are computed using `kFactorIncludingRayleighDamping` and `mFactorIncludingRayleighDamping`, respectively.\n  \n### Role in the Global FEM Pipeline\n\nThe `MechanicalParams` class plays a critical role in several stages of the FEM simulation pipeline:\n\n- **Assembly Phase**: The factors (e.g., \\(m_{factor}\\), \\(k_{factor}\\)) are used to scale contributions during assembly.\n\n- **Time Integration**: Parameters like time step size \\(\triangle t\\) and implicit integration flags determine how the system evolves over time.\n\n- **Nonlinear Solution**: The factors contribute to the nonlinear residual equations and are crucial for solving the nonlinear dynamics of deformable systems.\n\n### Numerical Methods and Discretization Choices\n\nThe `MechanicalParams` class encodes several numerical methods and discretization choices, such as:\n\n- **Implicit Integration Scheme Flag** (implicit): Indicates whether the time integration scheme is implicit or not. This affects the structure of equations like Newton-Raphson iterations.\n\n### Variational / Lagrangian Mechanics Framework\n\nThe `MechanicalParams` class fits into the broader variational and Lagrangian mechanics framework by providing necessary parameters that are used in assembling the weak form, time integration schemes, and nonlinear solvers. These parameters ensure consistency with the underlying physics while enabling numerical stability and extensibility.\n\n### Summary\n\nIn summary, `MechanicalParams` is a critical component for managing simulation parameters that influence various aspects of mechanical simulations within SOFA, including time integration, assembly of equations, and handling implicit schemes. While it does not directly implement specific physical laws or governing equations, its role in parameter management is essential for the accurate and efficient execution of FEM simulations.",
  "abstract": "`MechanicalParams` manages key parameters for mechanical computations in SOFA simulations, including time step size, mass matrix contributions factor, damping matrix contributions factor, stiffness matrix contributions factor, and implicit integration flags.",
  "sheet": "# MechanicalParams\n\n## Overview\nThe `MechanicalParams` class is a crucial component in the SOFA framework that manages key parameters used by mechanical components during simulations. It provides essential factors and flags that influence various aspects of mechanical computations, such as time integration schemes and assembly phases.\n\n## Parameters and Data\n- **dt**: Time step size (\triangle t) for time integration schemes.\n- **mFactor**: Mass matrix contributions factor (m_{factor}) used in implicit schemes to scale mass matrix contributions.\n- **bFactor**: Damping matrix contributions factor (b_{factor}) used in Rayleigh damping models.\n- **kFactor**: Stiffness matrix contributions factor (k_{factor}) used to scale stiffness matrix contributions in implicit schemes.\n- **implicit**: Flag indicating whether the time integration scheme is implicit or not.\n\n## Practical Notes\nThe `MechanicalParams` class does not directly implement governing equations but provides parameters that are critical for numerical stability and consistency with underlying physics. Proper configuration of these parameters ensures accurate and efficient execution of FEM simulations."
}