[Core,Lagrangian] Add some useful comments (#5500)

alxbilger · bakpaul · web-flow · commit 3db7d742672c · 2025-05-27T17:37:30.000+02:00
* [Core,Lagrangian] Add some useful comments

* more comments

---------

Co-authored-by: Paul Baksic &lt;30337881+bakpaul@users.noreply.github.com&gt;
diff --git a/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/GenericConstraintCorrection.cpp b/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/GenericConstraintCorrection.cpp
@@ -166,9 +166,10 @@ void GenericConstraintCorrection::addComplianceInConstraintSpace(const Constrain
     }
 
     factor *= complianceFactor;
-    // use the Linear solver to compute J*inv(M)*Jt, where M is the mechanical linear system matrix
-    l_linearSolver.get()->buildComplianceMatrix(cparams, W, factor, d_regularizationTerm.getValue());
 
+    // use the Linear solver to compute J*A^-1*J^T, where A is the mechanical linear system matrix
+    // the linear solver will also be in charge to assemble J
+    l_linearSolver.get()->buildComplianceMatrix(cparams, W, factor, d_regularizationTerm.getValue());
 }
 
 void GenericConstraintCorrection::computeMotionCorrectionFromLambda(const ConstraintParams* cparams, MultiVecDerivId dx, const linearalgebra::BaseVector * lambda)
@@ -189,9 +190,9 @@ void GenericConstraintCorrection::applyMotionCorrection(const ConstraintParams*
 }
 
 void GenericConstraintCorrection::applyMotionCorrection(const ConstraintParams * cparams,
-                                                        MultiVecCoordId xId,
-                                                        MultiVecDerivId vId,
-                                                        MultiVecDerivId dxId,
+                                                        MultiVecCoordId x,
+                                                        MultiVecDerivId v,
+                                                        MultiVecDerivId dx,
                                                         ConstMultiVecDerivId correction)
 {
     if (!l_ODESolver.get()) return;
@@ -200,7 +201,7 @@ void GenericConstraintCorrection::applyMotionCorrection(const ConstraintParams *
     const SReal positionFactor = l_ODESolver.get()->getPositionIntegrationFactor() * complianceFactor;
     const SReal velocityFactor = l_ODESolver.get()->getVelocityIntegrationFactor() * complianceFactor;
 
-    applyMotionCorrection(cparams, xId, vId, dxId, correction, positionFactor, velocityFactor);
+    applyMotionCorrection(cparams, x, v, dx, correction, positionFactor, velocityFactor);
 }
 
 void GenericConstraintCorrection::applyPositionCorrection(const ConstraintParams * cparams,
@@ -234,9 +235,19 @@ void GenericConstraintCorrection::applyContactForce(const BaseVector *f)
 
     ConstraintParams cparams(*sofa::core::execparams::defaultInstance());
 
+    MultiVecDerivId dx = cparams.dx();
+
+    // force = J^T * f
+    // dx = A^-1 * force
+    computeMotionCorrectionFromLambda(&cparams, dx, f);
+
+    //cparams.lambda() is an implicit output of computeMotionCorrectionFromLambda
+    const MultiVecDerivId& force = cparams.lambda();
 
-    computeMotionCorrectionFromLambda(&cparams, cparams.dx(), f);
-    applyMotionCorrection(&cparams, core::vec_id::write_access::position, core::vec_id::write_access::velocity, cparams.dx(), cparams.lambda());
+    // x = x_free + force * positionFactor
+    // v = v_free + force * velocityFactor
+    // dx *= correctionFactor
+    applyMotionCorrection(&cparams, core::vec_id::write_access::position, core::vec_id::write_access::velocity, dx, force);
 }
 
 void GenericConstraintCorrection::computeResidual(const ExecParams* params, linearalgebra::BaseVector *lambda)
@@ -267,7 +278,7 @@ void GenericConstraintCorrection::resetContactForce(){}
 
 void registerGenericConstraintCorrection(sofa::core::ObjectFactory* factory)
 {
-    factory->registerObjects(core::ObjectRegistrationData("Generic Constraint Correction.")
+    factory->registerObjects(core::ObjectRegistrationData("Component computing constraint forces within a simulated body using the compliance method.")
         .add< GenericConstraintCorrection >());
 }
 
diff --git a/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/GenericConstraintCorrection.h b/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/GenericConstraintCorrection.h
@@ -27,7 +27,8 @@
 namespace sofa::component::constraint::lagrangian::correction
 {
 
-class SOFA_COMPONENT_CONSTRAINT_LAGRANGIAN_CORRECTION_API GenericConstraintCorrection : public core::behavior::BaseConstraintCorrection
+class SOFA_COMPONENT_CONSTRAINT_LAGRANGIAN_CORRECTION_API GenericConstraintCorrection
+    : public core::behavior::BaseConstraintCorrection
 {
 public:
     SOFA_CLASS(GenericConstraintCorrection, core::behavior::BaseConstraintCorrection);
@@ -37,16 +38,70 @@ class SOFA_COMPONENT_CONSTRAINT_LAGRANGIAN_CORRECTION_API GenericConstraintCorre
     void addConstraintSolver(core::behavior::ConstraintSolver *s) override;
     void removeConstraintSolver(core::behavior::ConstraintSolver *s) override;
 
-    void computeMotionCorrectionFromLambda(const core::ConstraintParams* cparams, core::MultiVecDerivId dx, const linearalgebra::BaseVector * lambda) override;
-
+    /**
+     * \brief \copybrief BaseConstraintCorrection::computeMotionCorrectionFromLambda
+     *
+     * \details Calls the linear solver to perform the computations:
+     * f = J^T * lambda
+     * dx = A^-1 * f
+     *
+     * f is implicitly stored in cparams->lambda()
+     */
+    void computeMotionCorrectionFromLambda(
+        const core::ConstraintParams* cparams,
+        core::MultiVecDerivId dx,
+        const linearalgebra::BaseVector * lambda) override;
+
+    /**
+     * \brief \copybrief BaseConstraintCorrection::addComplianceInConstraintSpace
+     *
+     * \details Calls the linear solver to perform the computation W += J A^-1 J^T
+     */
     void addComplianceInConstraintSpace(const core::ConstraintParams *cparams, linearalgebra::BaseMatrix* W) override;
 
     void getComplianceMatrix(linearalgebra::BaseMatrix* ) const override;
 
-    void applyMotionCorrection(const core::ConstraintParams *cparams, core::MultiVecCoordId x, core::MultiVecDerivId v, core::MultiVecDerivId dx, core::ConstMultiVecDerivId correction) override;
-
+    /**
+     * Compute:
+     * x = x_free + correction * positionFactor
+     * v = v_free + correction * velocityFactor
+     * dx *= correctionFactor
+     *
+     * x_free and v_free correspond to the position and velocity of the free motion. Both vectors
+     * are referred in \p cparams.
+     *
+     * positionFactor and velocityFactor are factors provided by the ODE solver.
+     *
+     * correctionFactor is either positionFactor or velocityFactor depending on
+     * cparams->constOrder()
+     */
+    void applyMotionCorrection(
+        const core::ConstraintParams *cparams,
+        core::MultiVecCoordId x,
+        core::MultiVecDerivId v,
+        core::MultiVecDerivId dx,
+        core::ConstMultiVecDerivId correction) override;
+
+    /**
+     * Compute:
+     * x = x_free + correction * positionFactor
+     * dx *= correctionFactor
+     *
+     * x_free corresponds to the position of the free motion. x_free is referred in \p cparams.
+     *
+     * positionFactor is a factor provided by the ODE solver.
+     */
     void applyPositionCorrection(const core::ConstraintParams *cparams, core::MultiVecCoordId x, core::MultiVecDerivId dx, core::ConstMultiVecDerivId correction) override;
 
+    /**
+     * Compute:
+     * v = v_free + correction * velocityFactor
+     * dx *= correctionFactor
+     *
+     * v_free corresponds to the velocity of the free motion. v_free is referred in \p cparams.
+     *
+     * velocityFactor is a factor provided by the ODE solver.
+     */
     void applyVelocityCorrection(const core::ConstraintParams *cparams, core::MultiVecDerivId v, core::MultiVecDerivId dv, core::ConstMultiVecDerivId correction) override;
 
     void applyPredictiveConstraintForce(const core::ConstraintParams *cparams, core::MultiVecDerivId f, const linearalgebra::BaseVector *lambda) override;
diff --git a/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/LinearSolverConstraintCorrection.cpp b/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/LinearSolverConstraintCorrection.cpp
@@ -32,7 +32,7 @@ using namespace sofa::defaulttype;
 
 void registerLinearSolverConstraintCorrection(sofa::core::ObjectFactory* factory)
 {
-    factory->registerObjects(core::ObjectRegistrationData("Constraint Correction for Linear Solvers.")
+    factory->registerObjects(core::ObjectRegistrationData("Component computing constraint forces within a simulated body using the compliance method.")
         .add< LinearSolverConstraintCorrection<Vec3Types> >()
         .add< LinearSolverConstraintCorrection<Vec2Types> >()
         .add< LinearSolverConstraintCorrection<Vec1Types> >()
diff --git a/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/LinearSolverConstraintCorrection.inl b/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/LinearSolverConstraintCorrection.inl
@@ -211,13 +211,14 @@ void LinearSolverConstraintCorrection<DataTypes>::addComplianceInConstraintSpace
         break;
     }
 
+    // J is read from the mechanical state and converted to m_constraintJacobian
     {
         helper::ReadAccessor inputConstraintMatrix ( *cparams->readJ(this->mstate.get()) );
         const sofa::SignedIndex numberOfConstraints = W->rowSize();
         convertConstraintMatrix(numberOfConstraints, inputConstraintMatrix.ref());
     }
 
-    // use the Linear solver to compute J*inv(M)*Jt, where M is the mechanical linear system matrix
+    // use the Linear solver to compute J*A^-1*J^T, where A is the mechanical linear system matrix
     l_linearSolver->setSystemLHVector(sofa::core::MultiVecDerivId::null());
     l_linearSolver->addJMInvJt(W, &m_constraintJacobian, factor);
 
diff --git a/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/PrecomputedConstraintCorrection.cpp b/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/PrecomputedConstraintCorrection.cpp
@@ -125,7 +125,7 @@ using namespace sofa::defaulttype;
 
 void registerPrecomputedConstraintCorrection(sofa::core::ObjectFactory* factory)
 {
-    factory->registerObjects(core::ObjectRegistrationData("Component precomputing constraint forces within a simulated body using the compliance method.")
+    factory->registerObjects(core::ObjectRegistrationData("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 based on the rotation of elements.")
         .add< PrecomputedConstraintCorrection<Vec3Types> >()
         .add< PrecomputedConstraintCorrection<Vec1Types> >()
         .add< PrecomputedConstraintCorrection<Rigid3Types> >());
diff --git a/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/PrecomputedConstraintCorrection.inl b/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/PrecomputedConstraintCorrection.inl
@@ -53,7 +53,7 @@ namespace sofa::component::constraint::lagrangian::correction
 template<class DataTypes>
 PrecomputedConstraintCorrection<DataTypes>::PrecomputedConstraintCorrection(sofa::core::behavior::MechanicalState<DataTypes> *mm)
     : Inherit(mm)
-    , d_rotations(initData(&d_rotations, false, "rotations", ""))
+    , d_rotations(initData(&d_rotations, false, "rotations", "Project the precomputed matrix with a rotation matrix"))
     , d_restRotations(initData(&d_restRotations, false, "restDeformations", ""))
     , d_recompute(initData(&d_recompute, false, "recompute", "if true, always recompute the compliance"))
     , d_regularizationTerm(initData(&d_regularizationTerm, 0.0_sreal, "regularizationTerm", "Add regularization factor times the identity matrix to the compliance W when solving constraints"))
diff --git a/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/UncoupledConstraintCorrection.cpp b/Sofa/Component/Constraint/Lagrangian/Correction/src/sofa/component/constraint/lagrangian/correction/UncoupledConstraintCorrection.cpp
@@ -157,7 +157,7 @@ SOFA_COMPONENT_CONSTRAINT_LAGRANGIAN_CORRECTION_API void UncoupledConstraintCorr
 
 void registerUncoupledConstraintCorrection(sofa::core::ObjectFactory* factory)
 {
-    factory->registerObjects(core::ObjectRegistrationData("Component computing constraint forces within a simulated body using the compliance method.")
+    factory->registerObjects(core::ObjectRegistrationData("Component computing constraint forces within a simulated body using the compliance method, approximating the compliance matrix by a diagonal matrix.")
         .add< UncoupledConstraintCorrection< Vec1Types > >()
         .add< UncoupledConstraintCorrection< Vec2Types > >()
         .add< UncoupledConstraintCorrection< Vec3Types > >()
diff --git a/Sofa/Component/Constraint/Lagrangian/Solver/src/sofa/component/constraint/lagrangian/solver/ConstraintSolverImpl.h b/Sofa/Component/Constraint/Lagrangian/Solver/src/sofa/component/constraint/lagrangian/solver/ConstraintSolverImpl.h
@@ -38,8 +38,16 @@ namespace sofa::component::constraint::lagrangian::solver
 class SOFA_COMPONENT_CONSTRAINT_LAGRANGIAN_SOLVER_API ConstraintProblem
 {
 public:
+    // The compliance matrix projected in the constraint space
+    // If J is the jacobian matrix of the constraints and A is the mechanical matrix of the system,
+    // then W = J A^{-1} J^T
     sofa::linearalgebra::LPtrFullMatrix<SReal> W;
-    sofa::linearalgebra::FullVector<SReal> dFree, f;
+
+    // The constraint values of the "free motion" state
+    sofa::linearalgebra::FullVector<SReal> dFree;
+
+    // The lambda values from the Lagrange multipliers
+    sofa::linearalgebra::FullVector<SReal> f;
 
     ConstraintProblem();
     virtual ~ConstraintProblem();
@@ -48,10 +56,13 @@ class SOFA_COMPONENT_CONSTRAINT_LAGRANGIAN_SOLVER_API ConstraintProblem
     int maxIterations;
 
     virtual void clear(int nbConstraints);
-    int getDimension()	{ return dimension; }
-    SReal** getW()		{ return W.lptr(); }
-    SReal* getDfree()	{ return dFree.ptr(); }
-    SReal* getF()		{ return f.ptr(); }
+
+    // Returns the number of scalar constraints, or equivalently the number of Lagrange multipliers
+    int getDimension() const { return dimension; }
+
+    SReal** getW() { return W.lptr(); }
+    SReal* getDfree() { return dFree.ptr(); }
+    SReal* getF() { return f.ptr(); }
 
     virtual void solveTimed(SReal tolerance, int maxIt, SReal timeout) = 0;
 
diff --git a/Sofa/Component/Constraint/Lagrangian/Solver/src/sofa/component/constraint/lagrangian/solver/GenericConstraintSolver.cpp b/Sofa/Component/Constraint/Lagrangian/Solver/src/sofa/component/constraint/lagrangian/solver/GenericConstraintSolver.cpp
@@ -197,6 +197,7 @@ bool GenericConstraintSolver::buildSystem(const core::ConstraintParams *cParams,
     // suppress the constraints that are on DOFS currently concerned by projective constraint
     applyProjectiveConstraintOnConstraintMatrix(cParams);
 
+    //clear and/or resize based on the number of constraints
     current_cp->clear(numConstraints);
 
     getConstraintViolation(cParams, &current_cp->dFree);
diff --git a/Sofa/Component/Constraint/Lagrangian/Solver/src/sofa/component/constraint/lagrangian/solver/GenericConstraintSolver.h b/Sofa/Component/Constraint/Lagrangian/Solver/src/sofa/component/constraint/lagrangian/solver/GenericConstraintSolver.h
@@ -138,6 +138,9 @@ class SOFA_COMPONENT_CONSTRAINT_LAGRANGIAN_SOLVER_API GenericConstraintSolver :
         const core::ConstraintParams* cParams,
         MultiVecId res1, MultiVecId res2,
         core::behavior::BaseConstraintCorrection* constraintCorrection) const;
+
+    // Accumulate the lambda values projected in the motion space in the states
+    // f += J^T * lambda
     void storeConstraintLambdas(const core::ConstraintParams* cParams);
 
 };
diff --git a/Sofa/Component/LinearSolver/Iterative/src/sofa/component/linearsolver/iterative/MatrixLinearSolver.inl b/Sofa/Component/LinearSolver/Iterative/src/sofa/component/linearsolver/iterative/MatrixLinearSolver.inl
@@ -622,15 +622,18 @@ void MatrixLinearSolver<Matrix,Vector>::applyConstraintForce(const sofa::core::C
 }
 
 template<class Matrix, class Vector>
-void MatrixLinearSolver<Matrix,Vector>::computeResidual(const core::ExecParams* params,linearalgebra::BaseVector* f) {
+void MatrixLinearSolver<Matrix,Vector>::computeResidual(const core::ExecParams* params,linearalgebra::BaseVector* f)
+{
     getSystemRHVector()->clear();
     getSystemRHVector()->resize(getSystemMatrix()->colSize());
 
+    /// rhs = J^t * f
     internalData.projectForceInConstraintSpace(getSystemRHVector(), f);
 
     sofa::simulation::common::VectorOperations vop( params, this->getContext() );
     sofa::core::behavior::MultiVecDeriv force(&vop, core::vec_id::write_access::force );
 
+    // force += rhs
     executeVisitor( MechanicalMultiVectorPeqBaseVectorVisitor(core::execparams::defaultInstance(), force, getSystemRHVector(), &(linearSystem.matrixAccessor)) );
 }
 
diff --git a/Sofa/framework/Core/src/sofa/core/ConstraintOrder.h b/Sofa/framework/Core/src/sofa/core/ConstraintOrder.h
@@ -24,12 +24,16 @@
 namespace sofa::core
 {
 
-/// Description of the order of the constraint
+/// Description of the constraint order.
+///
+/// The order corresponds to the derivative order of the constraint function. This information
+/// tells which derivative is solved by the constraint solver. For example, solving only the
+/// velocity-level will authorize constraint violation but will prevent further violation.
 enum class ConstraintOrder
 {
-    POS = 0,
-    VEL,
-    ACC,
+    POS = 0, //corresponds to the constraint function itself
+    VEL, //corresponds to the first derivative of the constraint function
+    ACC, //corresponds to the second derivative of the constraint function
     POS_AND_VEL
 };
 
diff --git a/Sofa/framework/Core/src/sofa/core/ConstraintParams.h b/Sofa/framework/Core/src/sofa/core/ConstraintParams.h
@@ -41,8 +41,8 @@ class SOFA_CORE_API ConstraintParams : public sofa::core::ExecParams
 
     ConstraintParams& setOrder(ConstraintOrder o) { m_constOrder = o;   return *this; }
 
-	/// Smooth contribution factor (for smooth constraints resolution)
-    double smoothFactor() const { return m_smoothFactor; }
+    /// Smooth contribution factor (for smooth constraints resolution)
+    SReal smoothFactor() const { return m_smoothFactor; }
 
     /// @}
 
@@ -92,8 +92,8 @@ class SOFA_CORE_API ConstraintParams : public sofa::core::ExecParams
 
     /// @{
 
-	/// Set smooth contribution factor (for smooth constraints resolution)
-    ConstraintParams& setSmoothFactor(double v) { m_smoothFactor = v; return *this; }
+    /// Set smooth contribution factor (for smooth constraints resolution)
+    ConstraintParams& setSmoothFactor(SReal v) { m_smoothFactor = v; return *this; }
 
     /// Returns ids of the position vectors
     const ConstMultiVecCoordId& x() const { return m_x; }
@@ -180,8 +180,8 @@ class SOFA_CORE_API ConstraintParams : public sofa::core::ExecParams
     /// Description of the order of the constraint
     ConstraintOrder m_constOrder;
 
-	/// Smooth contribution factor (for smooth constraints resolution)
-    double m_smoothFactor;
+    /// Smooth contribution factor (for smooth constraints resolution)
+    SReal m_smoothFactor;
 };
 
 } // namespace sofa::core
diff --git a/Sofa/framework/Core/src/sofa/core/behavior/BaseConstraintCorrection.h b/Sofa/framework/Core/src/sofa/core/behavior/BaseConstraintCorrection.h
@@ -43,6 +43,10 @@ class SOFA_CORE_API BaseConstraintCorrection : public virtual objectmodel::BaseO
     /// @name Compliance Matrix API
     /// @{
 
+    /// Compute the compliance matrix projected in the constraint space and accumulate it into \p W
+    ///
+    /// The computation is W += J A^-1 J^T where J is the constraint Jacobian matrix and A is the
+    /// mechanical matrix
     virtual void addComplianceInConstraintSpace(const ConstraintParams *, linearalgebra::BaseMatrix* W) = 0;
 
     /// Fill the matrix m with the full Compliance Matrix
@@ -117,6 +121,8 @@ class SOFA_CORE_API BaseConstraintCorrection : public virtual objectmodel::BaseO
 
     /// @name Unbuilt constraint system during resolution
     /// @{
+
+    /// Is the constraint managed by this constraint correction?
     virtual bool hasConstraintNumber(int /*index*/);
     virtual void resetForUnbuiltResolution(SReal* /*f*/, std::list<unsigned int>& /*renumbering*/);
     virtual void addConstraintDisplacement(SReal* /*d*/, int /*begin*/, int /*end*/);
diff --git a/Sofa/framework/Core/src/sofa/core/behavior/ConstraintCorrection.inl b/Sofa/framework/Core/src/sofa/core/behavior/ConstraintCorrection.inl
@@ -136,7 +136,7 @@ void ConstraintCorrection< DataTypes >::applyPredictiveConstraintForce(const cor
     if (mstate)
     {
         addConstraintForceInMotionSpace(cparams, f, cparams->j(), lambda);
-        }
+    }
 }
 
 template< class DataTypes >
diff --git a/Sofa/framework/Simulation/Core/src/sofa/simulation/mechanicalvisitor/MechanicalGetConstraintJacobianVisitor.h b/Sofa/framework/Simulation/Core/src/sofa/simulation/mechanicalvisitor/MechanicalGetConstraintJacobianVisitor.h
@@ -26,7 +26,6 @@
 namespace sofa::simulation::mechanicalvisitor
 {
 
-/** Compute the size of a mechanical matrix (mass or stiffness) of the whole scene */
 class SOFA_SIMULATION_CORE_API MechanicalGetConstraintJacobianVisitor : public BaseMechanicalVisitor
 {
 public:

Original file line number	Diff line number	Diff line change
`@@ -32,7 +32,7 @@ using namespace sofa::defaulttype;`
`32`	`32`
`33`	`33`	`void registerLinearSolverConstraintCorrection(sofa::core::ObjectFactory* factory)`
`34`	`34`	`{`
`35`		`- factory->registerObjects(core::ObjectRegistrationData("Constraint Correction for Linear Solvers.")`
	`35`	`+ factory->registerObjects(core::ObjectRegistrationData("Component computing constraint forces within a simulated body using the compliance method.")`
`36`	`36`	`.add< LinearSolverConstraintCorrection<Vec3Types> >()`
`37`	`37`	`.add< LinearSolverConstraintCorrection<Vec2Types> >()`
`38`	`38`	`.add< LinearSolverConstraintCorrection<Vec1Types> >()`
Original file line number	Diff line number	Diff line change
`@@ -211,13 +211,14 @@ void LinearSolverConstraintCorrection<DataTypes>::addComplianceInConstraintSpace`
`211`	`211`	`break;`
`212`	`212`	`}`
`213`	`213`
	`214`	`+ // J is read from the mechanical state and converted to m_constraintJacobian`
`214`	`215`	`{`
`215`	`216`	`helper::ReadAccessor inputConstraintMatrix ( *cparams->readJ(this->mstate.get()) );`
`216`	`217`	`const sofa::SignedIndex numberOfConstraints = W->rowSize();`
`217`	`218`	`convertConstraintMatrix(numberOfConstraints, inputConstraintMatrix.ref());`
`218`	`219`	`}`
`219`	`220`
`220`		`- // use the Linear solver to compute Jinv(M)Jt, where M is the mechanical linear system matrix`
	`221`	`+ // use the Linear solver to compute JA^-1J^T, where A is the mechanical linear system matrix`
`221`	`222`	`l_linearSolver->setSystemLHVector(sofa::core::MultiVecDerivId::null());`
`222`	`223`	`l_linearSolver->addJMInvJt(W, &m_constraintJacobian, factor);`
`223`	`224`
Original file line number	Diff line number	Diff line change
`@@ -125,7 +125,7 @@ using namespace sofa::defaulttype;`
`125`	`125`
`126`	`126`	`void registerPrecomputedConstraintCorrection(sofa::core::ObjectFactory* factory)`
`127`	`127`	`{`
`128`		`- factory->registerObjects(core::ObjectRegistrationData("Component precomputing constraint forces within a simulated body using the compliance method.")`
	`128`	`+ factory->registerObjects(core::ObjectRegistrationData("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 based on the rotation of elements.")`
`129`	`129`	`.add< PrecomputedConstraintCorrection<Vec3Types> >()`
`130`	`130`	`.add< PrecomputedConstraintCorrection<Vec1Types> >()`
`131`	`131`	`.add< PrecomputedConstraintCorrection<Rigid3Types> >());`
Original file line number	Diff line number	Diff line change
`@@ -157,7 +157,7 @@ SOFA_COMPONENT_CONSTRAINT_LAGRANGIAN_CORRECTION_API void UncoupledConstraintCorr`
`157`	`157`
`158`	`158`	`void registerUncoupledConstraintCorrection(sofa::core::ObjectFactory* factory)`
`159`	`159`	`{`
`160`		`- factory->registerObjects(core::ObjectRegistrationData("Component computing constraint forces within a simulated body using the compliance method.")`
	`160`	`+ factory->registerObjects(core::ObjectRegistrationData("Component computing constraint forces within a simulated body using the compliance method, approximating the compliance matrix by a diagonal matrix.")`
`161`	`161`	`.add< UncoupledConstraintCorrection< Vec1Types > >()`
`162`	`162`	`.add< UncoupledConstraintCorrection< Vec2Types > >()`
`163`	`163`	`.add< UncoupledConstraintCorrection< Vec3Types > >()`