StaticSolver

This component belongs to the category of integration schemes or ODE Solver.

In the field of mechanics, statics consists in finding the equilibrium taking into account the loads (internal forces, external forces and torques) acting on the physical system, that do not experience an acceleration ( ). Finding a static equilibrium means finding a solution to: where is the sum of all loads, one of which might be unknown.

In a static analysis, the inertia and damping effects are ignored, i.e. the dynamic effect of the mass is ignored. It can thus be written: . In the same way, when running a static simulation, time is not elapsing and time steps should rather be considered as convergence steps.

In a static simulation involving elasticity, the linear system that we solve corresponds to where is the stiffness matrix (derivative of elastic forces), is a vector describing the total increment of displacement and are all explicit forces. We realize here that the static solver is in fact an implicit scheme, since the matrix is present in the left-hand side of the equation. The solution is obtained iteratively. At each iteration i, the displacement is incremented , thus resulting in the following system to solve: .

In case of non-linear elasticity, is a linearization which must be updated with regards to the increment of displacement . In such cases, several iterations of Newton Raphson are required to find an appropriate approximate solution. In one step of the StaticSolver, the number of Newton Raphson iterations is ruled by the data field newton_iterations.

Reminder: the Newton Raphson method is an iterative algorithm aiming at finding the solution of the system where is non-linear. At each iteration of Newton Raphson algorithm, we find a new approximate solution:

where

In our elasticity case, the system to solve is . At each iteration of Newton Raphson algorithm at simulation step , we therefore find:

Sequence diagram

Data

The solver is ruled by several breaking (converging or diverging) conditions:

• correction_tolerance_threshold is the value of under which the Newton Raphson stops and considers the iteration as having converged. This data is homogeneous to the DOFs of the simulation.
• residual_tolerance_threshold is the value of under which the Newton Raphson stops and considers the iteration as having converged. This data is homogeneous to loads/forces. Note that this residual tolerance threshold must be strictly positive.

Two other data fields are availabe:

• should_diverge_when_residual_is_growing is an option (bool) stopping the simulation – considered as diverging – as soon as the residual is growing
• newton_iterations limits the number of Newton Raphson iterations, as stated above.

Usage

At each simulation step and each Newton Raphson iteration, the StaticSolver requires:

• a LinearSolver to solve the linear system
• and a MechanicalObject to store the state vectors.

A StaticSolver must be used in simulations where the dynamics has no or a negligible effect on the system. A StaticSolver would also be relevant for systems with low mass. In such case, we fall into the quasi-static analysis.

In some loading configuration, applying the full forces and torques might not lead to any converging simulation. It is then relevant to go for an incremental loading, i.e. loads are applied incrementally at each simulation step . This incremental loading has to be done in the associated ForceField. If you want to use this solver with Newton Raphson iterations, it is in the user’s hand to make sure the external forces used in the scene (pressure, traction, etc.) only get incremented at each time step, and not at each calls to addForce (which is currently the case for most force fields).

Example

This component is used as follows in XML format:

<StaticSolver newton_iterations="10" correction_tolerance_threshold="1e-4" residual_tolerance_threshold="1e-2" should_diverge_when_residual_is_growing="0" />  

or using SofaPython3:

node.addObject('StaticSolver', newton_iterations='10', correction_tolerance_threshold='1e-4', residual_tolerance_threshold='1e-2', should_diverge_when_residual_is_growing='0')  

An example scene involving a StaticSolver is available in examples/Component/ODESolver/Backward/StaticSolver.scn