Merge branch 'master' into consolemessagehandler

Author: bakpaul

CONTRIBUTING.md

@@ -73,6 +73,7 @@ For newcomers in the community, we regularly identify issues easy to tackle and
 
 ### Rules
 
+- While **artificial intelligence** tools may assist in drafting code contributions, such contributions must address a real issue encountered by a human developer or a feature needed by end users for their specific use case. The contributor must actively participate in the development process from start to finish, ensuring no contribution is fully automated.
 - Description must explain the **issue solved** or the **feature added**, and this must be reported in the **[CHANGELOG.md](https://github.com/sofa-framework/sofa/blob/master/CHANGELOG.md)** file.
 - Code must follow **[our guidelines](https://github.com/sofa-framework/sofa/blob/master/GUIDELINES.md)**.
 - Commit must build **successfully** on Jenkins for all steps (compilation + tests + examples).
@@ -159,4 +160,4 @@ By making a contribution to this project, I certify that:
 
 # Annual development cycle
 
-<center><figure><img src="https://www.sofa-framework.org/wp-content/uploads/2023/04/SOFA-contribution-process.png" alt="Annual dev cycle" style="width:75%"><figcaption align = "center"><b>A year of development within the SOFA community: dev meeting and events</b></figcaption></figure></center>
+<center><figure><img src="https://www.sofa-framework.org/wp-content/uploads/2023/04/SOFA-contribution-process.png" alt="Annual dev cycle" style="width:75%"><figcaption align = "center"><b>A year of development within the SOFA community: dev meeting and events</b></figcaption></figure></center>

Sofa/Component/AnimationLoop/src/sofa/component/animationloop/FreeMotionAnimationLoop.cpp

@@ -132,19 +132,10 @@ void FreeMotionAnimationLoop::init()
         }
     }
 
-    auto* taskScheduler = sofa::simulation::MainTaskSchedulerFactory::createInRegistry();
-    assert(taskScheduler != nullptr);
+
     if (d_parallelCollisionDetectionAndFreeMotion.getValue() || d_parallelODESolving.getValue())
     {
-        if (taskScheduler->getThreadCount() < 1)
-        {
-            taskScheduler->init(0);
-            msg_info() << "Task scheduler initialized on " << taskScheduler->getThreadCount() << " threads";
-        }
-        else
-        {
-            msg_info() << "Task scheduler already initialized on " << taskScheduler->getThreadCount() << " threads";
-        }
+        initTaskScheduler();
     }
 
     this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Valid);
@@ -348,9 +339,6 @@ void FreeMotionAnimationLoop::computeFreeMotionAndCollisionDetection(const sofa:
     {
         SCOPED_TIMER("FreeMotion+CollisionDetection");
 
-        auto* taskScheduler = sofa::simulation::MainTaskSchedulerFactory::createInRegistry();
-        assert(taskScheduler != nullptr);
-
         preCollisionComputation(params);
 
         {
@@ -368,7 +356,7 @@ void FreeMotionAnimationLoop::computeFreeMotionAndCollisionDetection(const sofa:
         }
 
         sofa::simulation::CpuTask::Status freeMotionTaskStatus;
-        taskScheduler->addTask(freeMotionTaskStatus, [&]() { computeFreeMotion(params, cparams, dt, pos, freePos, freeVel, mop); });
+        m_taskScheduler->addTask(freeMotionTaskStatus, [&]() { computeFreeMotion(params, cparams, dt, pos, freePos, freeVel, mop); });
 
         {
             SCOPED_TIMER("CollisionDetection");
@@ -379,7 +367,7 @@ void FreeMotionAnimationLoop::computeFreeMotionAndCollisionDetection(const sofa:
 
         {
             SCOPED_TIMER("WaitFreeMotion");
-            taskScheduler->workUntilDone(&freeMotionTaskStatus);
+            m_taskScheduler->workUntilDone(&freeMotionTaskStatus);
         }
 
         {

Sofa/Component/AnimationLoop/src/sofa/component/animationloop/FreeMotionAnimationLoop.h

@@ -24,6 +24,7 @@
 
 #include <sofa/simulation/CollisionAnimationLoop.h>
 #include <sofa/core/MultiVecId.h>
+#include <sofa/simulation/task/TaskSchedulerUser.h>
 
 namespace sofa::core::behavior
 {
@@ -33,7 +34,8 @@ namespace sofa::core::behavior
 namespace sofa::component::animationloop
 {
 
-class SOFA_COMPONENT_ANIMATIONLOOP_API FreeMotionAnimationLoop : public sofa::simulation::CollisionAnimationLoop
+class SOFA_COMPONENT_ANIMATIONLOOP_API FreeMotionAnimationLoop : public sofa::simulation::CollisionAnimationLoop,
+                                                                 public sofa::simulation::TaskSchedulerUser
 {
 public:
     SOFA_CLASS(FreeMotionAnimationLoop, sofa::simulation::CollisionAnimationLoop);

Sofa/Component/Constraint/Lagrangian/Model/src/sofa/component/constraint/lagrangian/model/StopperLagrangianConstraint.h

@@ -109,7 +109,6 @@ class StopperLagrangianConstraint : public core::behavior::LagrangianConstraint<
 
 
 public:
-    void init() override;
     void buildConstraintMatrix(const core::ConstraintParams* cParams, DataMatrixDeriv &c_d, unsigned int &cIndex, const DataVecCoord &x) override;
     void getConstraintViolation(const core::ConstraintParams* cParams, linearalgebra::BaseVector *resV, const DataVecCoord &x, const DataVecDeriv &v) override;
 

Sofa/Component/Constraint/Lagrangian/Model/src/sofa/component/constraint/lagrangian/model/StopperLagrangianConstraint.inl

@@ -37,19 +37,6 @@ StopperLagrangianConstraint<DataTypes>::StopperLagrangianConstraint(MechanicalSt
 {
 }
 
-template<class DataTypes>
-void StopperLagrangianConstraint<DataTypes>::init()
-{
-    this->mstate = dynamic_cast<MechanicalState*>(this->getContext()->getMechanicalState());
-
-    helper::WriteAccessor<Data<VecCoord> > xData = *this->mstate->write(core::vec_id::write_access::position);
-    VecCoord& x = xData.wref();
-    if (x[d_index.getValue()].x() < d_min.getValue())
-        x[d_index.getValue()].x() = (Real) d_min.getValue();
-    if (x[d_index.getValue()].x() > d_max.getValue())
-        x[d_index.getValue()].x() = (Real) d_max.getValue();
-}
-
 template<class DataTypes>
 void StopperLagrangianConstraint<DataTypes>::buildConstraintMatrix(const core::ConstraintParams* /*cParams*/, DataMatrixDeriv &c_d, unsigned int &cIndex, const DataVecCoord &/*x*/)
 {

Sofa/Component/Constraint/Lagrangian/Solver/src/sofa/component/constraint/lagrangian/solver/BuiltConstraintSolver.cpp

@@ -42,7 +42,7 @@ void BuiltConstraintSolver::init()
     Inherit1::init();
     if(d_multithreading.getValue())
     {
-        simulation::MainTaskSchedulerFactory::createInRegistry()->init();
+        initTaskScheduler();
     }
 }
 

Sofa/Component/Constraint/Lagrangian/Solver/src/sofa/component/constraint/lagrangian/solver/BuiltConstraintSolver.h

@@ -22,6 +22,7 @@
 #pragma once
 
 #include <sofa/component/constraint/lagrangian/solver/GenericConstraintSolver.h>
+#include <sofa/simulation/task/TaskSchedulerUser.h>
 
 namespace sofa::component::constraint::lagrangian::solver
 {
@@ -32,7 +33,8 @@ namespace sofa::component::constraint::lagrangian::solver
  *  This component is purely virtual because doSolve is not defined and needs to be defined in the
  *  inherited class
  */
-class SOFA_COMPONENT_CONSTRAINT_LAGRANGIAN_SOLVER_API BuiltConstraintSolver : public GenericConstraintSolver
+class SOFA_COMPONENT_CONSTRAINT_LAGRANGIAN_SOLVER_API BuiltConstraintSolver : public GenericConstraintSolver,
+                                                                              public sofa::simulation::TaskSchedulerUser
 {
 
 public:

Sofa/Component/LinearSolver/Iterative/src/sofa/component/linearsolver/iterative/MatrixLinearSolver.h

@@ -25,6 +25,7 @@
 #include <sofa/simulation/MechanicalVisitor.h>
 #include <sofa/simulation/MechanicalOperations.h>
 #include <sofa/simulation/VectorOperations.h>
+#include <sofa/simulation/task/TaskSchedulerUser.h>
 #include <sofa/core/behavior/LinearSolver.h>
 #include <sofa/component/linearsolver/iterative/GraphScatteredTypes.h>
 #include <sofa/linearalgebra/FullVector.h>
@@ -44,6 +45,7 @@
 #include <sofa/core/behavior/DefaultMultiMatrixAccessor.h>
 #endif // SOFA_CORE_ENABLE_CRSMULTIMATRIXACCESSOR
 
+
 namespace sofa::component::linearsolver
 {
 
@@ -174,7 +176,8 @@ template<class Matrix, class Vector, class ThreadManager = NoThreadManager>
 class MatrixLinearSolver;
 
 template<class Matrix, class Vector>
-class MatrixLinearSolver<Matrix,Vector,NoThreadManager> : public BaseMatrixLinearSolver<Matrix, Vector>
+class MatrixLinearSolver<Matrix,Vector,NoThreadManager> : public BaseMatrixLinearSolver<Matrix, Vector>,
+                                                          public simulation::TaskSchedulerUser
 {
 public:
     SOFA_ABSTRACT_CLASS(SOFA_TEMPLATE3(MatrixLinearSolver,Matrix,Vector,NoThreadManager), SOFA_TEMPLATE2(BaseMatrixLinearSolver,Matrix,Vector));

Sofa/Component/LinearSolver/Iterative/src/sofa/component/linearsolver/iterative/MatrixLinearSolver.inl

@@ -62,18 +62,7 @@ MatrixLinearSolver<Matrix,Vector>::MatrixLinearSolver()
         SOFA_UNUSED(tracker);
         if (d_parallelInverseProduct.getValue())
         {
-            simulation::TaskScheduler* taskScheduler = simulation::MainTaskSchedulerFactory::createInRegistry();
-            assert(taskScheduler);
-
-            if (taskScheduler->getThreadCount() < 1)
-            {
-                taskScheduler->init(0);
-                msg_info() << "Task scheduler initialized on " << taskScheduler->getThreadCount() << " threads";
-            }
-            else
-            {
-                msg_info() << "Task scheduler already initialized on " << taskScheduler->getThreadCount() << " threads";
-            }
+            initTaskScheduler();
         }
         return this->d_componentState.getValue();
     },

Sofa/Component/Topology/Container/Constant/src/sofa/component/topology/container/constant/MeshTopology.cpp

@@ -518,6 +518,8 @@ void MeshTopology::init()
 
     const auto hexahedra = sofa::helper::getReadAccessor(d_seqHexahedra);
     const auto tetrahedra = sofa::helper::getReadAccessor(d_seqTetrahedra);
+    const auto prisms = sofa::helper::getReadAccessor(d_seqPrisms);
+    const auto pyramids = sofa::helper::getReadAccessor(d_seqPyramids);
     const auto quads = sofa::helper::getReadAccessor(d_seqQuads);
     const auto triangles = sofa::helper::getReadAccessor(d_seqTriangles);
     const auto edges = sofa::helper::getReadAccessor(d_seqEdges);
@@ -527,6 +529,10 @@ void MeshTopology::init()
         m_upperElementType = geometry::ElementType::HEXAHEDRON;
     else if (!tetrahedra.empty())
         m_upperElementType = sofa::geometry::ElementType::TETRAHEDRON;
+    else if (!prisms.empty())
+        m_upperElementType = sofa::geometry::ElementType::PRISM;
+    else if (!pyramids.empty())
+        m_upperElementType = sofa::geometry::ElementType::PYRAMID;
     else if (!quads.empty())
         m_upperElementType = sofa::geometry::ElementType::QUAD;
     else if (!triangles.empty())
@@ -545,28 +551,13 @@ void MeshTopology::init()
     // compute the number of points, if the topology is charged from the scene or if it was loaded from a MeshLoader without any points data.
     if (nbPoints==0)
     {
-        unsigned int n = 0;
-        const auto countPoints = [&n](const auto& seqElements)
-        {
-            for (const auto& element : seqElements)
-            {
-                for (const auto pointId : element)
-                {
-                    if (n <= pointId)
-                    {
-                        n = 1 + pointId;
-                    }
-                }
-            }
-        };
-
-        countPoints(edges);
-        countPoints(triangles);
-        countPoints(quads);
-        countPoints(tetrahedra);
-        countPoints(hexahedra);
-
-        nbPoints = n;
+        nbPoints = std::max(nbPoints, countPoints(edges));
+        nbPoints = std::max(nbPoints, countPoints(triangles));
+        nbPoints = std::max(nbPoints, countPoints(quads));
+        nbPoints = std::max(nbPoints, countPoints(tetrahedra));
+        nbPoints = std::max(nbPoints, countPoints(hexahedra));
+        nbPoints = std::max(nbPoints, countPoints(prisms));
+        nbPoints = std::max(nbPoints, countPoints(pyramids));
     }
 
 
@@ -694,55 +685,58 @@ void MeshTopology::addPoint(SReal px, SReal py, SReal pz)
 
 void MeshTopology::addEdge( Index a, Index b )
 {
-    d_seqEdges.beginEdit()->push_back(Edge(a, b));
-    d_seqEdges.endEdit();
-    if (a >= nbPoints) nbPoints = a+1;
-    if (b >= nbPoints) nbPoints = b+1;
+    const Edge addedElement { a, b };
+    auto seqElements = helper::getWriteOnlyAccessor(d_seqEdges);
+    seqElements.push_back(addedElement);
+    nbPoints = std::max(nbPoints, countPoints(std::array{addedElement}));
 }
 
 void MeshTopology::addTriangle( Index a, Index b, Index c )
 {
-    d_seqTriangles.beginEdit()->push_back(Triangle(a, b, c) );
-    d_seqTriangles.endEdit();
-    if (a >= nbPoints) nbPoints = a+1;
-    if (b >= nbPoints) nbPoints = b+1;
-    if (c >= nbPoints) nbPoints = c+1;
+    const Triangle addedElement { a, b, c };
+    auto seqElements = helper::getWriteOnlyAccessor(d_seqTriangles);
+    seqElements.push_back(addedElement);
+    nbPoints = std::max(nbPoints, countPoints(std::array{addedElement}));
 }
 
 void MeshTopology::addQuad(Index a, Index b, Index c, Index d)
 {
-    d_seqQuads.beginEdit()->push_back(Quad(a, b, c, d));
-    d_seqQuads.endEdit();
-    if (a >= nbPoints) nbPoints = a+1;
-    if (b >= nbPoints) nbPoints = b+1;
-    if (c >= nbPoints) nbPoints = c+1;
-    if (d >= nbPoints) nbPoints = d+1;
+    const Quad addedElement { a, b, c, d };
+    auto seqElements = helper::getWriteOnlyAccessor(d_seqQuads);
+    seqElements.push_back(addedElement);
+    nbPoints = std::max(nbPoints, countPoints(std::array{addedElement}));
 }
 
 void MeshTopology::addTetra( Index a, Index b, Index c, Index d )
 {
-    d_seqTetrahedra.beginEdit()->push_back(Tetra(a, b, c, d) );
-    d_seqTetrahedra.endEdit();
-    if (a >= nbPoints) nbPoints = a+1;
-    if (b >= nbPoints) nbPoints = b+1;
-    if (c >= nbPoints) nbPoints = c+1;
-    if (d >= nbPoints) nbPoints = d+1;
+    const Tetrahedron addedElement { a, b, c, d };
+    auto seqElements = helper::getWriteOnlyAccessor(d_seqTetrahedra);
+    seqElements.push_back(addedElement);
+    nbPoints = std::max(nbPoints, countPoints(std::array{addedElement}));
 }
 
 void MeshTopology::addHexa(Index p1, Index p2, Index p3, Index p4, Index p5, Index p6, Index p7, Index p8)
 {
+    const Hexahedron addedElement { p1, p2, p3, p4, p5, p6, p7, p8 };
+    auto seqElements = helper::getWriteOnlyAccessor(d_seqHexahedra);
+    seqElements.push_back(addedElement);
+    nbPoints = std::max(nbPoints, countPoints(std::array{addedElement}));
+}
 
-    d_seqHexahedra.beginEdit()->push_back(Hexa(p1, p2, p3, p4, p5, p6, p7, p8));
+void MeshTopology::addPrism(Index a, Index b, Index c, Index d, Index e, Index f)
+{
+    const Prism addedElement { a, b, c, d, e, f };
+    auto seqElements = helper::getWriteOnlyAccessor(d_seqPrisms);
+    seqElements.push_back(addedElement);
+    nbPoints = std::max(nbPoints, countPoints(std::array{addedElement}));
+}
 
-    d_seqHexahedra.endEdit();
-    if (p1 >= nbPoints) nbPoints = p1+1;
-    if (p2 >= nbPoints) nbPoints = p2+1;
-    if (p3 >= nbPoints) nbPoints = p3+1;
-    if (p4 >= nbPoints) nbPoints = p4+1;
-    if (p5 >= nbPoints) nbPoints = p5+1;
-    if (p6 >= nbPoints) nbPoints = p6+1;
-    if (p7 >= nbPoints) nbPoints = p7+1;
-    if (p8 >= nbPoints) nbPoints = p8+1;
+void MeshTopology::addPyramid(Index a, Index b, Index c, Index d, Index e)
+{
+    const Pyramid addedElement { a, b, c, d, e };
+    auto seqElements = helper::getWriteOnlyAccessor(d_seqPyramids);
+    seqElements.push_back(addedElement);
+    nbPoints = std::max(nbPoints, countPoints(std::array{addedElement}));
 }
 
 void MeshTopology::addUV(SReal u, SReal v)