diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeCollisionModel.cpp b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeCollisionModel.cpp
index 0e756637900..13a2959bba3 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeCollisionModel.cpp
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeCollisionModel.cpp
@@ -43,7 +43,7 @@ CubeCollisionModel::CubeCollisionModel()
     enum_type = AABB_TYPE;
 }
 
-void CubeCollisionModel::resize(sofa::Size size)
+void CubeCollisionModel::doResize(sofa::Size size)
 {
     const auto size0 = this->size;
     if (size == size0) return;
@@ -54,7 +54,7 @@ void CubeCollisionModel::resize(sofa::Size size)
         parent->resize(0);
         parent = parent->getPrevious();
     }
-    this->core::CollisionModel::resize(size);
+    this->core::CollisionModel::doResize(size);
     this->elems.resize(size);
     this->parentOf.resize(size);
     // set additional indices
@@ -104,7 +104,7 @@ Index CubeCollisionModel::addCube(Cube subcellsBegin, Cube subcellsEnd)
 {
     const sofa::Index index = size;
 
-    this->core::CollisionModel::resize(index + 1);
+    this->core::CollisionModel::doResize(index + 1);
     elems.resize(index + 1);
     
     elems[index].subcells.first = subcellsBegin;
@@ -226,7 +226,7 @@ bool CubeCollisionModel::isLeaf(sofa::Index index ) const
     return elems[index].children.first.valid();
 }
 
-void CubeCollisionModel::computeBoundingTree(int maxDepth)
+void CubeCollisionModel::doComputeBoundingTree(int maxDepth)
 {
 
     dmsg_info() << ">CubeCollisionModel::computeBoundingTree(" << maxDepth << ")";
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeCollisionModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeCollisionModel.h
index 511aad2d24d..9794922c20b 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeCollisionModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CubeCollisionModel.h
@@ -90,8 +90,22 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API CubeCollisionModel : public core::Co
     CubeCollisionModel();
 
     void drawCollisionModel(const core::visual::VisualParams* vparams) override;
+    void doResize(sofa::Size size) override;
+
+    // -- CollisionModel interface
+
+    /**
+      *Here we make up the hierarchy (a tree) of bounding boxes which contain final CollisionElements like Spheres or Triangles.
+      *The leafs of the tree contain final CollisionElements. This hierarchy is made up from the top to the bottom, i.e., we begin
+      *to compute a bounding box containing all CollisionElements, then we divide this big bounding box into two boxes.
+      *These new two boxes inherit from the root box and have depth 1. Then we can do the same operation for the new boxes.
+      *The division is done only if the box contains more than 4 final CollisionElements and if the depth doesn't exceed
+      *the max depth. The division is made along an axis. This axis corresponds to the biggest dimension of the current bounding box.
+      *Note : a bounding box is a Cube here.
+      */
+    void doComputeBoundingTree(int maxDepth=0) override;
+
 public:
-    void resize(sofa::Size size) override;
 
     void setParentOf(sofa::Index childIndex, const sofa::type::Vec3& min, const sofa::type::Vec3& max);
     void setParentOf(sofa::Index childIndex, const sofa::type::Vec3& min, const sofa::type::Vec3& max, const sofa::type::Vec3& normal, const SReal angle=0);
@@ -121,19 +135,6 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API CubeCollisionModel : public core::Co
 
     const CubeData & getCubeData(sofa::Index index)const{return elems[index];}
 
-    // -- CollisionModel interface
-
-    /**
-      *Here we make up the hierarchy (a tree) of bounding boxes which contain final CollisionElements like Spheres or Triangles.
-      *The leafs of the tree contain final CollisionElements. This hierarchy is made up from the top to the bottom, i.e., we begin
-      *to compute a bounding box containing all CollisionElements, then we divide this big bounding box into two boxes.
-      *These new two boxes inherit from the root box and have depth 1. Then we can do the same operation for the new boxes.
-      *The division is done only if the box contains more than 4 final CollisionElements and if the depth doesn't exceed
-      *the max depth. The division is made along an axis. This axis corresponds to the biggest dimension of the current bounding box.
-      *Note : a bounding box is a Cube here.
-      */
-    void computeBoundingTree(int maxDepth=0) override;
-
     std::pair<core::CollisionElementIterator,core::CollisionElementIterator> getInternalChildren(sofa::Index index) const override;
 
     std::pair<core::CollisionElementIterator,core::CollisionElementIterator> getExternalChildren(sofa::Index index) const override;
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderCollisionModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderCollisionModel.h
index ed1fbd88f95..15f4bdfa21c 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderCollisionModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderCollisionModel.h
@@ -101,13 +101,13 @@ class CylinderCollisionModel : public core::CollisionModel
     CylinderCollisionModel();
     CylinderCollisionModel(core::behavior::MechanicalState<DataTypes>* mstate );
 
-public:
-    void init() override;
-
     // -- CollisionModel interface
-    void resize(sofa::Size size) override;
+    void doResize(sofa::Size size) override;
 
-    void computeBoundingTree(int maxDepth=0) override;
+    void doComputeBoundingTree(int maxDepth=0) override;
+
+public:
+    void init() override;
 
     void draw(const core::visual::VisualParams* vparams,sofa::Index index) override;
 
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderCollisionModel.inl b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderCollisionModel.inl
index b73b1a0641e..1568538a060 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderCollisionModel.inl
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/CylinderCollisionModel.inl
@@ -55,9 +55,9 @@ CylinderCollisionModel<DataTypes>::CylinderCollisionModel(core::behavior::Mechan
 }
 
 template<class DataTypes>
-void CylinderCollisionModel<DataTypes>::resize(sofa::Size size)
+void CylinderCollisionModel<DataTypes>::doResize(sofa::Size size)
 {
-    this->core::CollisionModel::resize(size);
+    this->core::CollisionModel::doResize(size);
 
     VecReal & Cylinder_radii = *d_cylinder_radii.beginEdit();
     VecReal & Cylinder_heights = *d_cylinder_heights.beginEdit();
@@ -115,7 +115,7 @@ void CylinderCollisionModel<DataTypes>::init()
 
 
 template<class DataTypes>
-void CylinderCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
+void CylinderCollisionModel<DataTypes>::doComputeBoundingTree(int maxDepth)
 {
     using namespace sofa::type;
     using namespace sofa::defaulttype;
@@ -125,6 +125,7 @@ void CylinderCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
     bool updated = false;
     if (ncyl != size)
     {
+        // TODO (SPRINT SED 2025 SUGGESTION): maybe we should use doResize (because of double state check)
         resize(ncyl);
         updated = true;
         cubeModel->resize(0);
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineCollisionModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineCollisionModel.h
index 374569733fa..41221a72bbf 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineCollisionModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineCollisionModel.h
@@ -104,6 +104,21 @@ public :
 
     void drawCollisionModel(const core::visual::VisualParams* vparams) override;
 
+    // -- CollisionModel interface
+
+    void doResize(sofa::Size size) override;
+
+    void doComputeBoundingTree(int maxDepth=0) override;
+
+    void doComputeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag, int maxDepth=0) override;
+
+    bool doCanCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;
+
+    sofa::core::topology::BaseMeshTopology* doGetCollisionTopology() override
+    {
+        return l_topology.get();
+    }
+    
 public:
     typedef TDataTypes DataTypes;
     typedef DataTypes InDataTypes;
@@ -118,18 +133,8 @@ public :
 
     void init() override;
 
-    // -- CollisionModel interface
-
-    void resize(sofa::Size size) override;
-
-    void computeBoundingTree(int maxDepth=0) override;
-
-    void computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia, int maxDepth=0) override;
-
     void handleTopologyChange() override;
 
-    bool canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;
-
     core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return mstate; }
 
     Deriv velocity(sofa::Index index)const;
@@ -154,11 +159,6 @@ public :
         return sofa::core::objectmodel::BaseComponent::canCreate(obj, context, arg);
     }
 
-    sofa::core::topology::BaseMeshTopology* getCollisionTopology() override
-    {
-        return l_topology.get();
-    }
-
     void computeBBox(const core::ExecParams* params, bool onlyVisible) override;
 
     Data<bool> d_displayFreePosition; ///< Display Collision Model Points free position(in green)
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineCollisionModel.inl b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineCollisionModel.inl
index dd485591a07..9f5959d0938 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineCollisionModel.inl
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/LineCollisionModel.inl
@@ -47,9 +47,9 @@ LineCollisionModel<DataTypes>::LineCollisionModel()
 
 
 template<class DataTypes>
-void LineCollisionModel<DataTypes>::resize(sofa::Size size)
+void LineCollisionModel<DataTypes>::doResize(sofa::Size size)
 {
-    this->core::CollisionModel::resize(size);
+    this->core::CollisionModel::doResize(size);
     elems.resize(size);
 }
 
@@ -354,7 +354,7 @@ void LineCollisionModel<DataTypes>::drawCollisionModel(const core::visual::Visua
 }
 
 template<class DataTypes>
-bool LineCollisionModel<DataTypes>::canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2)
+bool LineCollisionModel<DataTypes>::doCanCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2)
 {
     if (!this->bSelfCollision.getValue()) return true;
     if (this->getContext() != model2->getContext()) return true;
@@ -458,7 +458,7 @@ bool LineCollisionModel<DataTypes>::canCollideWithElement(sofa::Index index, Col
 }
 
 template<class DataTypes>
-void LineCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
+void LineCollisionModel<DataTypes>::doComputeBoundingTree(int maxDepth)
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();
     updateFromTopology();
@@ -495,7 +495,7 @@ void LineCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
 }
 
 template<class DataTypes>
-void LineCollisionModel<DataTypes>::computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag, int maxDepth)
+void LineCollisionModel<DataTypes>::doComputeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag, int maxDepth)
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();
     updateFromTopology();
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointCollisionModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointCollisionModel.h
index e5ebbec02ba..53f16464340 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointCollisionModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointCollisionModel.h
@@ -84,19 +84,9 @@ class PointCollisionModel : public core::CollisionModel
 
 public:
     void init() override;
-
-    // -- CollisionModel interface
-
-    void resize(sofa::Size size) override;
-
-    void computeBoundingTree(int maxDepth=0) override;
-
-    void computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia, int maxDepth=0) override;
-
+    
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
 
-    bool canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;
-
     core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return mstate; }
 
     Deriv getNormal(sofa::Index index){ return (normals.size()) ? normals[index] : Deriv();}
@@ -122,11 +112,6 @@ class PointCollisionModel : public core::CollisionModel
     void computeBBox(const core::ExecParams* params, bool onlyVisible) override;
     void updateNormals();
 
-    sofa::core::topology::BaseMeshTopology* getCollisionTopology() override
-    {
-        return l_topology.get();
-    }
-
 protected:
 
     core::behavior::MechanicalState<DataTypes>* mstate;
@@ -139,6 +124,18 @@ class PointCollisionModel : public core::CollisionModel
     /// Link to be set to the topology container in the component graph.
     SingleLink<PointCollisionModel<DataTypes>, sofa::core::topology::BaseMeshTopology, BaseLink::FLAG_STOREPATH | BaseLink::FLAG_STRONGLINK> l_topology;
 
+    // -- CollisionModel interface
+
+    void doComputeBoundingTree(int maxDepth=0) override;
+
+    void doComputeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia, int maxDepth=0) override;
+
+    bool doCanCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;
+
+    sofa::core::topology::BaseMeshTopology* doGetCollisionTopology() override
+    {
+        return l_topology.get();
+    }
 };
 
 
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointCollisionModel.inl b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointCollisionModel.inl
index 8a10d5227df..72d95d13a7a 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointCollisionModel.inl
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/PointCollisionModel.inl
@@ -43,12 +43,6 @@ PointCollisionModel<DataTypes>::PointCollisionModel()
     enum_type = POINT_TYPE;
 }
 
-template<class DataTypes>
-void PointCollisionModel<DataTypes>::resize(sofa::Size size)
-{
-    this->core::CollisionModel::resize(size);
-}
-
 template<class DataTypes>
 void PointCollisionModel<DataTypes>::init()
 {
@@ -74,7 +68,7 @@ void PointCollisionModel<DataTypes>::init()
 
 
 template<class DataTypes>
-bool PointCollisionModel<DataTypes>::canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2)
+bool PointCollisionModel<DataTypes>::doCanCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2)
 {
 
     if (!this->bSelfCollision.getValue()) return true; // we need to perform this verification process only for the selfcollision case.
@@ -112,13 +106,14 @@ bool PointCollisionModel<DataTypes>::canCollideWithElement(sofa::Index index, Co
 }
 
 template<class DataTypes>
-void PointCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
+void PointCollisionModel<DataTypes>::doComputeBoundingTree(int maxDepth)
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();
     const auto npoints = mstate->getSize();
     bool updated = false;
     if (npoints != size)
     {
+        // TODO (SPRINT SED 2025 SUGGESTION): maybe we should use doResize (because of double state check)
         resize(npoints);
         updated = true;
     }
@@ -143,13 +138,14 @@ void PointCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
 }
 
 template<class DataTypes>
-void PointCollisionModel<DataTypes>::computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag , int maxDepth)
+void PointCollisionModel<DataTypes>::doComputeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag, int maxDepth)
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();
     const auto npoints = mstate->getSize();
     bool updated = false;
     if (npoints != size)
     {
+        // TODO (SPRINT SED 2025 SUGGESTION): maybe we should use doResize (because of double state check)
         resize(npoints);
         updated = true;
     }
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayCollisionModel.cpp b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayCollisionModel.cpp
index 08ec23ec121..d6267f4af4f 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayCollisionModel.cpp
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayCollisionModel.cpp
@@ -44,9 +44,9 @@ RayCollisionModel::RayCollisionModel(SReal length)
     this->contactResponse.setValue("RayContact"); // use RayContact response class
 }
 
-void RayCollisionModel::resize(sofa::Size size)
+void RayCollisionModel::doResize(sofa::Size size)
 {
-    this->core::CollisionModel::resize(size);
+    this->core::CollisionModel::doResize(size);
 
     if (length.size() < size)
     {
@@ -110,7 +110,7 @@ void RayCollisionModel::draw(const core::visual::VisualParams* vparams, sofa::In
 
 }
 
-void RayCollisionModel::computeBoundingTree(int maxDepth)
+void RayCollisionModel::doComputeBoundingTree(int maxDepth)
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();
 
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayCollisionModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayCollisionModel.h
index 5e492069de7..a48b3e23119 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayCollisionModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/RayCollisionModel.h
@@ -63,13 +63,14 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API RayCollisionModel : public core::Col
     friend class Ray;
 protected:
     RayCollisionModel(SReal defaultLength=1);
-public:
-    void init() override;
 
     // -- CollisionModel interface
-    void resize(sofa::Size size) override;
+    void doResize(sofa::Size size) override;
+
+    void doComputeBoundingTree(int maxDepth) override;
 
-    void computeBoundingTree(int maxDepth) override;
+public:
+    void init() override;
 
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
 
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereCollisionModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereCollisionModel.h
index 6ba48175cde..9a810379d7b 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereCollisionModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereCollisionModel.h
@@ -104,13 +104,14 @@ class SphereCollisionModel : public core::CollisionModel
 public:
     void init() override;
 
+
     // -- CollisionModel interface
 
-    void resize(sofa::Size size) override;
+    void doResize(sofa::Size size) override;
 
-    void computeBoundingTree(int maxDepth=0) override;
+    void doComputeBoundingTree(int maxDepth=0) override;
 
-    void computeContinuousBoundingTree(SReal dt,  ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia,  int maxDepth=0) override;
+    void doComputeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia,  int maxDepth=0) override;
 
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
 
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereCollisionModel.inl b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereCollisionModel.inl
index f1c9370aba8..76db9d25781 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereCollisionModel.inl
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/SphereCollisionModel.inl
@@ -54,9 +54,9 @@ SphereCollisionModel<DataTypes>::SphereCollisionModel(core::behavior::Mechanical
 
 
 template<class DataTypes>
-void SphereCollisionModel<DataTypes>::resize(sofa::Size size)
+void SphereCollisionModel<DataTypes>::doResize(sofa::Size size)
 {
-    this->core::CollisionModel::resize(size);
+    this->core::CollisionModel::doResize(size);
 
     helper::WriteAccessor< Data<VecReal> > r = d_radius;
 
@@ -156,7 +156,7 @@ void SphereCollisionModel<DataTypes>::drawCollisionModel(const core::visual::Vis
 }
 
 template <class DataTypes>
-void SphereCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
+void SphereCollisionModel<DataTypes>::doComputeBoundingTree(int maxDepth)
 {
     if(d_componentState.getValue() != ComponentState::Valid)
         return ;
@@ -166,6 +166,7 @@ void SphereCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
     bool updated = false;
     if (npoints != size)
     {
+        // TODO (SPRINT SED 2025 SUGGESTION): maybe we should use doResize (because of double state check)
         resize(npoints);
         updated = true;
         cubeModel->resize(0);
@@ -194,7 +195,7 @@ void SphereCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
 
 
 template <class DataTypes>
-void SphereCollisionModel<DataTypes>::computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag  continuousIntersectionFlag, int maxDepth)
+void SphereCollisionModel<DataTypes>::doComputeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag  continuousIntersectionFlag, int maxDepth)
 {
     using sofa::type::Vec3 ;
 
@@ -206,6 +207,7 @@ void SphereCollisionModel<DataTypes>::computeContinuousBoundingTree(SReal dt, Co
     bool updated = false;
     if (npoints != size)
     {
+        // TODO (SPRINT SED 2025 SUGGESTION): maybe we should use doResize (because of double state check)
         resize(npoints);
         updated = true;
         cubeModel->resize(0);
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronCollisionModel.cpp b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronCollisionModel.cpp
index ca88ef0f133..e9327cedef8 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronCollisionModel.cpp
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronCollisionModel.cpp
@@ -50,9 +50,9 @@ TetrahedronCollisionModel::TetrahedronCollisionModel()
     enum_type = TETRAHEDRON_TYPE;
 }
 
-void TetrahedronCollisionModel::resize(sofa::Size size)
+void TetrahedronCollisionModel::doResize(sofa::Size size)
 {
-    this->core::CollisionModel::resize(size);
+    this->core::CollisionModel::doResize(size);
     elems.resize(size);
     if (getPrevious() != nullptr) getPrevious()->resize(0); // force recomputation of bounding tree
 }
@@ -193,7 +193,7 @@ void TetrahedronCollisionModel::drawCollisionModel(const core::visual::VisualPar
     }
 }
 
-void TetrahedronCollisionModel::computeBoundingTree(int maxDepth)
+void TetrahedronCollisionModel::doComputeBoundingTree(int maxDepth)
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();
     if (!mstate || !m_topology) return;
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronCollisionModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronCollisionModel.h
index 5c93d0fb484..efed38917c7 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronCollisionModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TetrahedronCollisionModel.h
@@ -111,13 +111,14 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API TetrahedronCollisionModel : public c
 public:
     void init() override;
 
+
     // -- CollisionModel interface
 
-    void resize(sofa::Size size) override;
+    void doResize(sofa::Size size) override;
 
-    void computeBoundingTree(int maxDepth=0) override;
+    void doComputeBoundingTree(int maxDepth=0) override;
 
-    //virtual void computeContinuousBoundingTree(double dt, int maxDepth=0);
+    //virtual void doComputeContinuousBoundingTree(double dt, int maxDepth=0);
 
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
 
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleCollisionModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleCollisionModel.h
index 712c6db49f6..358332e082f 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleCollisionModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleCollisionModel.h
@@ -170,20 +170,26 @@ class TriangleCollisionModel : public core::CollisionModel
     virtual void updateNormals();
     void drawCollisionModel(const core::visual::VisualParams* vparams) override;
 
-public:
-    void init() override;
-
     // -- CollisionModel interface
 
-    void resize(sofa::Size size) override;
+    void doResize(sofa::Size size) override;
 
-    void computeBoundingTree(int maxDepth=0) override;
+    void doComputeBoundingTree(int maxDepth=0) override;
 
-    void computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia, int maxDepth=0) override;
+    void doComputeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia, int maxDepth=0) override;
 
-    void draw(const core::visual::VisualParams*, sofa::Index index) override;
 
-    bool canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;
+    bool doCanCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;
+
+    sofa::core::topology::BaseMeshTopology* doGetCollisionTopology() override
+    {
+        return l_topology.get();
+    }
+    
+public:
+    void init() override;
+
+    void draw(const core::visual::VisualParams*, sofa::Index index) override;
 
     core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return m_mstate; }
     const core::behavior::MechanicalState<DataTypes>* getMechanicalState() const { return m_mstate; }
@@ -212,10 +218,6 @@ class TriangleCollisionModel : public core::CollisionModel
 
     void computeBBox(const core::ExecParams* params, bool onlyVisible=false) override;
 
-    sofa::core::topology::BaseMeshTopology* getCollisionTopology() override
-    {
-        return l_topology.get();
-    }
 };
 
 template<class DataTypes>
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleCollisionModel.inl b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleCollisionModel.inl
index f2bc2b681ef..fbe193b777d 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleCollisionModel.inl
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleCollisionModel.inl
@@ -50,9 +50,9 @@ TriangleCollisionModel<DataTypes>::TriangleCollisionModel()
 }
 
 template<class DataTypes>
-void TriangleCollisionModel<DataTypes>::resize(sofa::Size size)
+void TriangleCollisionModel<DataTypes>::doResize(sofa::Size size)
 {
-    this->core::CollisionModel::resize(size);
+    this->core::CollisionModel::doResize(size);
     m_normals.resize(size);
 }
 
@@ -194,7 +194,7 @@ void TriangleCollisionModel<DataTypes>::updateFromTopology()
 
 
 template<class DataTypes>
-bool TriangleCollisionModel<DataTypes>::canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2)
+bool TriangleCollisionModel<DataTypes>::doCanCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2)
 {
     if (!this->bSelfCollision.getValue()) return true; // we need to perform this verification process only for the selfcollision case.
     if (this->getContext() != model2->getContext()) return true;
@@ -214,7 +214,7 @@ bool TriangleCollisionModel<DataTypes>::canCollideWithElement(sofa::Index index,
 }
 
 template<class DataTypes>
-void TriangleCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
+void TriangleCollisionModel<DataTypes>::doComputeBoundingTree(int maxDepth)
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();
 
@@ -276,7 +276,7 @@ void TriangleCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
 }
 
 template<class DataTypes>
-void TriangleCollisionModel<DataTypes>::computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag, int maxDepth)
+void TriangleCollisionModel<DataTypes>::doComputeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag, int maxDepth)
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();
 
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModelInRegularGrid.cpp b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModelInRegularGrid.cpp
index 31912c20506..75d9eddef96 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModelInRegularGrid.cpp
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModelInRegularGrid.cpp
@@ -101,7 +101,7 @@ void TriangleModelInRegularGrid::init()
     }
 }
 
-void TriangleModelInRegularGrid::computeBoundingTree ( int )
+void TriangleModelInRegularGrid::doComputeBoundingTree ( int )
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();
     updateFromTopology();
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModelInRegularGrid.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModelInRegularGrid.h
index 74319ab7d37..cb106163f28 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModelInRegularGrid.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleModelInRegularGrid.h
@@ -35,15 +35,17 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API TriangleModelInRegularGrid : public
     SOFA_CLASS(TriangleModelInRegularGrid, TriangleCollisionModel<sofa::defaulttype::Vec3Types>);
 
     void init() override;
-    void computeBoundingTree ( int maxDepth=0 ) override;
 
     sofa::core::topology::BaseMeshTopology* _topology;
     sofa::core::topology::BaseMeshTopology* _higher_topo;
     core::behavior::MechanicalState<defaulttype::Vec3Types>* _higher_mstate;
+    
 
 protected:
     TriangleModelInRegularGrid();
     ~TriangleModelInRegularGrid();
+
+    void doComputeBoundingTree ( int maxDepth=0 ) override;
 };
 
 }  // namespace sofa::component::collision::geometry
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeCollisionModel.cpp b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeCollisionModel.cpp
index 62abb5bdc39..00432e41875 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeCollisionModel.cpp
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeCollisionModel.cpp
@@ -71,7 +71,7 @@ void TriangleOctreeCollisionModel::drawCollisionModel (const core::visual::Visua
     }
 }
 
-void TriangleOctreeCollisionModel::computeBoundingTree(int maxDepth)
+void TriangleOctreeModel::doComputeBoundingTree(int maxDepth)
 {
     const type::vector<topology::Triangle>& tri = *m_triangles;
     if(octreeRoot)
@@ -129,9 +129,10 @@ void TriangleOctreeCollisionModel::computeBoundingTree(int maxDepth)
     }
 }
 
-void TriangleOctreeCollisionModel::computeContinuousBoundingTree(SReal/* dt*/, ContinuousIntersectionTypeFlag continuousIntersectionFlag, int maxDepth)
+
+void TriangleOctreeModel::doComputeContinuousBoundingTree(SReal/* dt*/, ContinuousIntersectionTypeFlag continuousIntersectionFlag, int maxDepth)
 {
-    computeBoundingTree(maxDepth);
+    doComputeBoundingTree(maxDepth);
 }
 
 void TriangleOctreeCollisionModel::buildOctree()
diff --git a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeCollisionModel.h b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeCollisionModel.h
index 1a36dfb96c9..00a171292ea 100644
--- a/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeCollisionModel.h
+++ b/Sofa/Component/Collision/Geometry/src/sofa/component/collision/geometry/TriangleOctreeCollisionModel.h
@@ -40,13 +40,15 @@ class SOFA_COMPONENT_COLLISION_GEOMETRY_API TriangleOctreeCollisionModel : publi
 protected:
     TriangleOctreeCollisionModel();
     void drawCollisionModel(const core::visual::VisualParams* vparams) override;
+
+
+    void doComputeBoundingTree(int maxDepth=0) override;
+    void doComputeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia, int maxDepth=0) override;
 public:
     Data<bool> d_drawOctree;  ///< draw the octree
 
     /// the normals for each point
     type::vector<type::Vec3> pNorms;
-    void computeBoundingTree(int maxDepth=0) override;
-    void computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia, int maxDepth=0) override;
     /// init the octree creation
     void buildOctree ();
 };
diff --git a/Sofa/framework/Core/src/sofa/core/CollisionModel.cpp b/Sofa/framework/Core/src/sofa/core/CollisionModel.cpp
index 0bf883450e9..da281b5217f 100644
--- a/Sofa/framework/Core/src/sofa/core/CollisionModel.cpp
+++ b/Sofa/framework/Core/src/sofa/core/CollisionModel.cpp
@@ -145,7 +145,7 @@ void CollisionModel::setPrevious(CollisionModel::SPtr val)
         val->next.set(this);
 }
 
-void CollisionModel::computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag, int maxDepth)
+void CollisionModel::doComputeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag, int maxDepth)
 {
     SOFA_UNUSED(dt);
     SOFA_UNUSED(continuousIntersectionFlag);
diff --git a/Sofa/framework/Core/src/sofa/core/CollisionModel.h b/Sofa/framework/Core/src/sofa/core/CollisionModel.h
index 1fcce798dc4..f2d1aac0aba 100644
--- a/Sofa/framework/Core/src/sofa/core/CollisionModel.h
+++ b/Sofa/framework/Core/src/sofa/core/CollisionModel.h
@@ -113,6 +113,33 @@ class SOFA_CORE_API CollisionModel : public virtual objectmodel::BaseComponent
     /// Destructor
     ~CollisionModel() override {}
 
+    /// Set the number of elements.
+    virtual void doResize(Size s)
+    {
+        size = s;
+    }
+
+    /// Create or update the bounding volume hierarchy.
+    virtual void doComputeBoundingTree(int maxDepth=0) = 0;
+
+    /// \brief Create or update the bounding volume hierarchy, accounting for motions
+    /// within the given timestep.
+    ///
+    /// Default to computeBoundingTree().
+    virtual void doComputeContinuousBoundingTree(SReal /*dt*/, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia, int maxDepth=0);
+
+    /// \brief Test if two elements can collide with each other.
+    ///
+    /// This method should be implemented by models supporting
+    /// self-collisions to prune tests between adjacent elements.
+    ///
+    /// Default to true. Note that this method assumes that canCollideWith(model2)
+    /// was already used to test if the collision models can collide.
+    virtual bool doCanCollideWithElement(Index /*index*/, CollisionModel* /*model2*/, Index /*index2*/) { return true; }
+
+    /// BaseMeshTopology associated to the collision model. TODO: epernod remove virtual pure method by l_topology.get as soons as new link will be available
+    virtual sofa::core::topology::BaseMeshTopology* doGetCollisionTopology() { return nullptr; }
+
 public:
     void bwdInit() override;
 
@@ -152,10 +179,19 @@ class SOFA_CORE_API CollisionModel : public virtual objectmodel::BaseComponent
         d_numberOfContacts.setValue(i);
     }
 
+    /**
+     * !!! WARNING since v25.12 !!! 
+     * 
+     * The template method pattern has been applied to this part of the API. 
+     * This method calls the newly introduced method "doResize" internally,
+     * which is the method to override from now on.
+     * 
+     **/  
     /// Set the number of elements.
-    virtual void resize(Size s)
+    virtual void resize(Size s) final
     {
-        size = s;
+        //TODO (SPRINT SED 2025): Component state mechamism
+        this->doResize(s); 
     }
 
     /// Return an iterator to the first element.
@@ -213,14 +249,38 @@ class SOFA_CORE_API CollisionModel : public virtual objectmodel::BaseComponent
     /// \brief Set true if this CollisionModel is attached to a simulation.
     virtual void setSimulated(bool val=true) { bSimulated.setValue(val); }
 
+    /**
+     * !!! WARNING since v25.12 !!! 
+     * 
+     * The template method pattern has been applied to this part of the API. 
+     * This method calls the newly introduced method "doFunctionName" internally,
+     * which is the method to override from now on.
+     * 
+     **/  
     /// Create or update the bounding volume hierarchy.
-    virtual void computeBoundingTree(int maxDepth=0) = 0;
+    virtual void computeBoundingTree(int maxDepth=0) final {
+        //TODO (SPRINT SED 2025): Component state mechamism
+        this->doComputeBoundingTree(maxDepth);
+    }
 
+    /**
+     * !!! WARNING since v25.12 !!! 
+     * 
+     * The template method pattern has been applied to this part of the API. 
+     * This method calls the newly introduced method "doFunctionName" internally,
+     * which is the method to override from now on.
+     * 
+     **/  
     /// \brief Create or update the bounding volume hierarchy, accounting for motions
     /// within the given timestep.
     ///
     /// Default to computeBoundingTree().
-    virtual void computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia, int maxDepth=0);
+
+
+    virtual void computeContinuousBoundingTree(SReal dt, ContinuousIntersectionTypeFlag continuousIntersectionFlag = ContinuousIntersectionTypeFlag::Inertia, int maxDepth=0) final {
+        //TODO (SPRINT SED 2025): Component state mechamism
+        this->doComputeContinuousBoundingTree(dt, continuousIntersectionFlag, maxDepth);
+    }
 
     /// \brief Return the list (as a pair of iterators) of <i>internal children</i> of
     /// an element.
@@ -271,6 +331,14 @@ class SOFA_CORE_API CollisionModel : public virtual objectmodel::BaseComponent
     /// If both models are included in a common "group", they won't collide
     virtual bool canCollideWith(CollisionModel* model) ;
 
+    /**
+     * !!! WARNING since v25.12 !!! 
+     * 
+     * The template method pattern has been applied to this part of the API. 
+     * This method calls the newly introduced method "doFunctionName" internally,
+     * which is the method to override from now on.
+     * 
+     **/  
     /// \brief Test if two elements can collide with each other.
     ///
     /// This method should be implemented by models supporting
@@ -278,7 +346,10 @@ class SOFA_CORE_API CollisionModel : public virtual objectmodel::BaseComponent
     ///
     /// Default to true. Note that this method assumes that canCollideWith(model2)
     /// was already used to test if the collision models can collide.
-    virtual bool canCollideWithElement(Index /*index*/, CollisionModel* /*model2*/, Index /*index2*/) { return true; }
+    virtual bool canCollideWithElement(Index index, CollisionModel* model2, Index index2) final {
+        //TODO (SPRINT SED 2025): Component state mechamism
+        return this->doCanCollideWithElement(index, model2, index2);
+    }
 
     /// Render an collision element.
     virtual void draw(const core::visual::VisualParams* /*vparams*/, Index /*index*/) {}
@@ -365,8 +436,19 @@ class SOFA_CORE_API CollisionModel : public virtual objectmodel::BaseComponent
     void setGroups(const std::set<int>& ids) { group.setValue(ids); }
     /// @}
 
+    /**
+     * !!! WARNING since v25.12 !!!
+     *
+     * The template method pattern has been applied to this part of the API.
+     * This method calls the newly introduced method "doGetCollisionTopology" internally,
+     * which is the method to override from now on.
+     *
+     **/
     /// BaseMeshTopology associated to the collision model. TODO: epernod remove virtual pure method by l_topology.get as soons as new link will be available
-    virtual sofa::core::topology::BaseMeshTopology* getCollisionTopology() { return nullptr; }
+    virtual sofa::core::topology::BaseMeshTopology* getCollisionTopology() final {
+        // TODO (SPRINT SED 2025): Component state mechamism
+        return this->doGetCollisionTopology();
+    }
 
     /// Get a color that can be used to display this CollisionModel
     const float* getColor4f();
diff --git a/Sofa/framework/Core/test/collision/NarrowPhaseDetection_test.cpp b/Sofa/framework/Core/test/collision/NarrowPhaseDetection_test.cpp
index 4e7693d6065..d7e817c9269 100644
--- a/Sofa/framework/Core/test/collision/NarrowPhaseDetection_test.cpp
+++ b/Sofa/framework/Core/test/collision/NarrowPhaseDetection_test.cpp
@@ -82,7 +82,7 @@ namespace sofa::core
 class DummyCollisionModel : public CollisionModel
 {
 public:
-    void computeBoundingTree(int /*maxDepth*/) override {}
+    void doComputeBoundingTree(int /*maxDepth*/) override {}
 };
 } //namespace sofa::collision
 
diff --git a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletCapsuleModel.h b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletCapsuleModel.h
index 9e45c64e564..45616469610 100644
--- a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletCapsuleModel.h
+++ b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletCapsuleModel.h
@@ -55,10 +55,6 @@ class TBulletCapsuleModel : public collisionobbcapsule::geometry::CapsuleCollisi
     virtual void initBullet();
     virtual void updateBullet();
 
-    inline virtual void computeBoundingTree(int/* maxDepth*/){
-        _bt_cshape->recalculateLocalAabb();
-    }
-
     inline virtual ~TBulletCapsuleModel();
 
     virtual void init();
@@ -79,6 +75,10 @@ class TBulletCapsuleModel : public collisionobbcapsule::geometry::CapsuleCollisi
     void cleanGarbage();
 
     static void makeBtQuat(const Coord & dir,btQuaternion & quat);
+
+    inline virtual void doComputeBoundingTree(int/* maxDepth*/) override {
+        _bt_cshape->recalculateLocalAabb();
+    }
 };
 
 typedef TBulletCapsuleModel<defaulttype::Vec3Types> BulletCapsuleModel;
diff --git a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletConvexHullModel.h b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletConvexHullModel.h
index 32e014742e0..d1265931e5d 100644
--- a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletConvexHullModel.h
+++ b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletConvexHullModel.h
@@ -82,25 +82,10 @@ class TBulletConvexHullModel : public sofa::core::CollisionModel ,public BulletC
 
     virtual void reinit();
 
-    // -- CollisionModel interface
-
-    virtual void resize(int size);
-
     //void draw(const core::visual::VisualParams*,int index);
 
     void draw(const core::visual::VisualParams* vparams);    
 
-    inline virtual void computeBoundingTree(int/* maxDepth*/){
-        _bt_cshape.recalculateLocalAabb();
-    }
-
-    virtual bool canCollideWithElement(int index, CollisionModel* model2, int index2){
-        if(this == model2)
-            return false;
-
-        return CollisionModel::canCollideWithElement(index,model2,index2);
-    }
-
     core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return _mstate; }
     const core::behavior::MechanicalState<DataTypes>* getMechanicalState() const { return _mstate; }
 
@@ -148,6 +133,21 @@ class TBulletConvexHullModel : public sofa::core::CollisionModel ,public BulletC
     void draw_without_decomposition(const core::visual::VisualParams* vparams);
     void draw_decomposition(const core::visual::VisualParams* vparams);
 
+    // -- CollisionModel interface
+
+    // virtual void doResize(int size) override;
+
+    inline virtual void doComputeBoundingTree(int/* maxDepth*/) override {
+        _bt_cshape.recalculateLocalAabb();
+    }
+
+    virtual bool doCanCollideWithElement(int index, CollisionModel* model2, int index2) override {
+        if(this == model2)
+            return false;
+
+        return CollisionModel::doCanCollideWithElement(index,model2,index2);
+    }
+
     Coord _bary;
     btTransform _bt_trans;
     core::behavior::MechanicalState<DataTypes>* _mstate;
diff --git a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletConvexHullModel.inl b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletConvexHullModel.inl
index cae6ed3906b..3cd321cb564 100644
--- a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletConvexHullModel.inl
+++ b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletConvexHullModel.inl
@@ -30,13 +30,6 @@ TBulletConvexHullModel<DataTypes>::TBulletConvexHullModel()
 }
 
 
-template <class DataTypes>
-void TBulletConvexHullModel<DataTypes>::resize(int size)
-{
-    this->core::CollisionModel::resize(size);
-}
-
-
 template <class DataTypes>
 void TBulletConvexHullModel<DataTypes>::init(){
     this->CollisionModel::init();
diff --git a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletCylinderModel.h b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletCylinderModel.h
index 9d21fd9804f..988b44ea814 100644
--- a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletCylinderModel.h
+++ b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletCylinderModel.h
@@ -48,9 +48,7 @@ class TBulletCylinderModel : public sofa::component::collision::geometry::Cylind
     virtual void initBullet();
     virtual void updateBullet();
 
-    inline virtual void computeBoundingTree(int/* maxDepth*/){
-        _bt_cshape->recalculateLocalAabb();
-    }
+
 
     inline virtual ~TBulletCylinderModel();
 
@@ -70,6 +68,10 @@ class TBulletCylinderModel : public sofa::component::collision::geometry::Cylind
     btCompoundShape * _bt_cshape;//or maybe something else ?
 
     void cleanGarbage();
+
+    inline virtual void doComputeBoundingTree(int/* maxDepth*/) override {
+        _bt_cshape->recalculateLocalAabb();
+    }
 };
 
 typedef TBulletCylinderModel<defaulttype::RigidTypes> BulletCylinderModel;
diff --git a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletOBBModel.h b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletOBBModel.h
index 0a10de66ec6..0f03652075c 100644
--- a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletOBBModel.h
+++ b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletOBBModel.h
@@ -48,9 +48,7 @@ class TBulletOBBModel : public collisionobbcapsule::geometry::OBBCollisionModel<
     virtual void initBullet();
     virtual void updateBullet();
 
-    inline virtual void computeBoundingTree(int/* maxDepth*/){
-        _bt_cshape->recalculateLocalAabb();
-    }
+
 
     inline virtual ~TBulletOBBModel();
 
@@ -69,6 +67,10 @@ class TBulletOBBModel : public collisionobbcapsule::geometry::OBBCollisionModel<
     std::stack<btCollisionShape*> _garbage;
     btCompoundShape * _bt_cshape;
 
+    inline virtual void doComputeBoundingTree(int/* maxDepth*/) override {
+        _bt_cshape->recalculateLocalAabb();
+    }
+
     void cleanGarbage();
 };
 
diff --git a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletSphereModel.h b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletSphereModel.h
index a06fb6a839d..fd4397d2b19 100644
--- a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletSphereModel.h
+++ b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletSphereModel.h
@@ -39,10 +39,6 @@ class TBulletSphereModel : public sofa::component::collision::geometry::SphereCo
     virtual void initBullet();
     virtual void updateBullet();
 
-    inline virtual void computeBoundingTree(int/* maxDepth*/){
-        _bt_cshape->recalculateLocalAabb();
-    }
-
     inline virtual ~TBulletSphereModel();
 
     virtual void init();
@@ -60,6 +56,10 @@ class TBulletSphereModel : public sofa::component::collision::geometry::SphereCo
     std::stack<btCollisionShape*> _garbage;
     btCompoundShape * _bt_cshape;
 
+    inline virtual void doComputeBoundingTree(int/* maxDepth*/) override {
+        _bt_cshape->recalculateLocalAabb();
+    }
+
     void cleanGarbage();
 };
 
diff --git a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletTriangleModel.h b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletTriangleModel.h
index 5c7d2c80806..9fe28fa492f 100644
--- a/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletTriangleModel.h
+++ b/applications/plugins/BulletCollisionDetection/src/BulletCollisionDetection/BulletTriangleModel.h
@@ -38,14 +38,33 @@ class TBulletTriangleModel : public sofa::component::collision::geometry::Triang
     virtual void initBullet();
     virtual void updateBullet();
 
-    inline virtual void computeBoundingTree(int/* maxDepth*/){
+    inline virtual ~TBulletTriangleModel(){
+        delete _bt_mesh;
+        delete _bt_gmesh;
+    }
+
+    virtual void init();
+
+    virtual void reinit();
+
+    void handleEvent(sofa::core::objectmodel::Event * ev);
+
+ 	inline virtual void setMargin(SReal m){ *margin.beginEdit() = m; margin.endEdit(); }
+
+    bool goodSofaBulletLink()const;
+
+protected:
+    template <class MyReal,class ToRead,class ToFill>
+    void myFillFunc(const ToRead & pos,int numverts,ToFill vertexbase,int vertexStride);
+
+    inline virtual void doComputeBoundingTree(int/* maxDepth*/) override {
         //_bt_collision_object
         _bt_gmesh->updateBound();
         //_bt_gmesh->refitTree();
         //_bt_gmesh->postUpdate();
     }
 
-//    inline virtual void computeBoundingTree(int/* maxDepth*/){
+//    inline virtual void doComputeBoundingTree(int/* maxDepth*/){
 //        //_bt_collision_object
 //        //_bt_gmesh->updateBound();
 //        const Vector3 & min = this->mstate->f_bbox.getValue().minBBox();
@@ -61,27 +80,7 @@ class TBulletTriangleModel : public sofa::component::collision::geometry::Triang
 //        //_bt_gmesh->postUpdate();
 //    }
 
-    //virtual void computeBoundingTree(int maxDepth=0);
-
-    inline virtual ~TBulletTriangleModel(){
-        delete _bt_mesh;
-        delete _bt_gmesh;
-    }
-
-    virtual void init();
-
-    virtual void reinit();
-
-    void handleEvent(sofa::core::objectmodel::Event * ev);
-
- 	inline virtual void setMargin(SReal m){ *margin.beginEdit() = m; margin.endEdit(); }
-
-    bool goodSofaBulletLink()const;
-
-protected:
-    template <class MyReal,class ToRead,class ToFill>
-    void myFillFunc(const ToRead & pos,int numverts,ToFill vertexbase,int vertexStride);
-
+    //virtual void doComputeBoundingTree(int maxDepth=0);
 
     btTriangleMesh * _bt_mesh;
     btGImpactMeshShape * _bt_gmesh;
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.h b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.h
index 41d2553e9d7..d7ce2b7f109 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.h
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.h
@@ -111,13 +111,6 @@ class CapsuleCollisionModel : public core::CollisionModel
 public:
     void init() override;
 
-    // -- CollisionModel interface
-
-    void resize(sofa::Size size) override;
-
-    void computeBoundingTree(int maxDepth=0) override;
-
-    //virtual void computeContinuousBoundingTree(SReal dt, int maxDepth=0);
 
     void draw(const core::visual::VisualParams* vparams, Index index) override;
 
@@ -168,11 +161,6 @@ class CapsuleCollisionModel : public core::CollisionModel
         return sofa::core::objectmodel::BaseComponent::canCreate(obj, context, arg);
     }
 
-    sofa::core::topology::BaseMeshTopology* getCollisionTopology() override
-    {
-        return l_topology.get();
-    }
-
     /**
       *Returns true if capsules at indexes i1 and i2 share the same vertex.
       */
@@ -185,6 +173,20 @@ class CapsuleCollisionModel : public core::CollisionModel
 
 protected:
     core::behavior::MechanicalState<DataTypes>* _mstate;
+
+    // -- CollisionModel interface
+
+    void doResize(sofa::Size size) override;
+
+    void doComputeBoundingTree(int maxDepth=0) override;
+
+    //virtual void doComputeContinuousBoundingTree(SReal dt, int maxDepth=0);
+
+    sofa::core::topology::BaseMeshTopology* doGetCollisionTopology() override
+    {
+        return l_topology.get();
+    }
+    
 };
 
 template<class DataTypes>
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.inl b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.inl
index 3d018ecb681..14f5dccd91e 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.inl
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/CapsuleModel.inl
@@ -52,9 +52,9 @@ CapsuleCollisionModel<TDataTypes>::~CapsuleCollisionModel()
 {}
 
 template<class DataTypes>
-void CapsuleCollisionModel<DataTypes>::resize(sofa::Size size)
+void CapsuleCollisionModel<DataTypes>::doResize(sofa::Size size)
 {
-    this->core::CollisionModel::resize(size);
+    this->core::CollisionModel::doResize(size);
     _capsule_points.resize(size);
 
     VecReal & capsule_radii = *_capsule_radii.beginEdit();
@@ -117,7 +117,7 @@ Size CapsuleCollisionModel<DataTypes>::nbCap()const
 }
 
 template <class DataTypes>
-void CapsuleCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
+void CapsuleCollisionModel<DataTypes>::doComputeBoundingTree(int maxDepth)
 {
     using namespace sofa::type;
     using namespace sofa::defaulttype;
@@ -126,6 +126,7 @@ void CapsuleCollisionModel<DataTypes>::computeBoundingTree(int maxDepth)
     bool updated = false;
     if (ncap != size)
     {
+        // TODO (SPRINT SED 2025 SUGGESTION): maybe we should use doResize (because of double state check)
         resize(ncap);
         updated = true;
         cubeModel->resize(0);
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.h b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.h
index 1432c07738f..23c405d53f4 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.h
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.h
@@ -151,14 +151,6 @@ class OBBCollisionModel : public core::CollisionModel
 public:
     void init() override;
 
-    // -- CollisionModel interface
-
-    void resize(sofa::Size size) override;
-
-    void computeBoundingTree(int maxDepth=0) override;
-
-    //virtual void computeContinuousBoundingTree(SReal dt, int maxDepth=0);
-
     void draw(const sofa::core::visual::VisualParams* vparams, sofa::Index index) override;
 
     sofa::core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return _mstate; }
@@ -255,6 +247,14 @@ class OBBCollisionModel : public core::CollisionModel
 
 protected:
     sofa::core::behavior::MechanicalState<DataTypes>* _mstate;
+
+    // -- CollisionModel interface
+
+    void doResize(sofa::Size size) override;
+
+    void doComputeBoundingTree(int maxDepth=0) override;
+
+    //virtual void doComputeContinuousBoundingTree(SReal dt, int maxDepth=0);
 };
 
 template<class DataTypes>
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.inl b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.inl
index d2d9fcc1b39..c7df5c34c97 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.inl
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/OBBModel.inl
@@ -65,8 +65,8 @@ void OBBCollisionModel<DataTypes>::init()
 
 
 template<class DataTypes>
-void OBBCollisionModel<DataTypes>::resize(sofa::Size size){
-    this->core::CollisionModel::resize(size);
+void OBBCollisionModel<DataTypes>::doResize(sofa::Size size){
+    this->core::CollisionModel::doResize(size);
 
     VecCoord & vext = *(ext.beginEdit());
 
@@ -85,12 +85,13 @@ void OBBCollisionModel<DataTypes>::resize(sofa::Size size){
 
 
 template<class DataTypes>
-void OBBCollisionModel<DataTypes>::computeBoundingTree(int maxDepth){
+void OBBCollisionModel<DataTypes>::doComputeBoundingTree(int maxDepth){
     sofa::component::collision::geometry::CubeCollisionModel* cubeModel = createPrevious<sofa::component::collision::geometry::CubeCollisionModel>();
     const auto npoints = _mstate->getSize();
     bool updated = false;
     if (npoints != size)
     {
+        // TODO (SPRINT SED 2025 SUGGESTION): maybe we should use doResize (because of double state check)
         resize(npoints);
         updated = true;
         cubeModel->resize(0);
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.h b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.h
index 46bfdd8e0c1..0625bc63107 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.h
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.h
@@ -118,14 +118,6 @@ class CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> > : publi
 public:
     void init() override;
 
-    // -- CollisionModel interface
-
-    void resize(sofa::Size size) override;
-
-    void computeBoundingTree(int maxDepth=0) override;
-
-    //virtual void computeContinuousBoundingTree(SReal dt, int maxDepth=0);
-
     void draw(const core::visual::VisualParams* vparams, sofa::Index index) override;
 
     core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return _mstate; }
@@ -169,6 +161,14 @@ class CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> > : publi
     Data<VecReal > & writeRadii();
 protected:
     core::behavior::MechanicalState<DataTypes>* _mstate;
+
+    // -- CollisionModel interface
+
+    void doResize(sofa::Size size) override;
+
+    void doComputeBoundingTree(int maxDepth=0) override;
+
+    //virtual void doComputeContinuousBoundingTree(SReal dt, int maxDepth=0);
 };
 
 
diff --git a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.inl b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.inl
index 50e2101e7bc..43c127ea8cc 100644
--- a/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.inl
+++ b/applications/plugins/CollisionOBBCapsule/src/CollisionOBBCapsule/geometry/RigidCapsuleModel.inl
@@ -50,9 +50,9 @@ CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> >::CapsuleColli
 }
 
 template<class MyReal>
-void CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> >::resize(sofa::Size size)
+void CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> >::doResize(sofa::Size size)
 {
-    this->core::CollisionModel::resize(size);
+    this->core::CollisionModel::doResize(size);
 
     VecReal & capsule_radii = *d_capsule_radii.beginEdit();
     VecReal & capsule_heights = *d_capsule_heights.beginEdit();
@@ -103,7 +103,7 @@ Size CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> >::nbCap()
 }
 
 template <class MyReal>
-void CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> >::computeBoundingTree(int maxDepth)
+void CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> >::doComputeBoundingTree(int maxDepth)
 {
     sofa::component::collision::geometry::CubeCollisionModel* cubeModel = createPrevious<sofa::component::collision::geometry::CubeCollisionModel>();
     const auto ncap = _mstate->getSize();
@@ -111,6 +111,7 @@ void CapsuleCollisionModel<sofa::defaulttype::StdRigidTypes<3,MyReal> >::compute
     bool updated = false;
     if (ncap != size)
     {
+        // TODO (SPRINT SED 2025 SUGGESTION): maybe we should use doResize (because of double state check)
         resize(ncap);
         updated = true;
         cubeModel->resize(0);
diff --git a/applications/plugins/SofaCUDA/Component/src/SofaCUDA/component/collision/geometry/CudaPointModel.cpp b/applications/plugins/SofaCUDA/Component/src/SofaCUDA/component/collision/geometry/CudaPointModel.cpp
index 63471bb74ce..8a0ebb1ac52 100644
--- a/applications/plugins/SofaCUDA/Component/src/SofaCUDA/component/collision/geometry/CudaPointModel.cpp
+++ b/applications/plugins/SofaCUDA/Component/src/SofaCUDA/component/collision/geometry/CudaPointModel.cpp
@@ -42,9 +42,9 @@ CudaPointCollisionModel::CudaPointCollisionModel()
 {
 }
 
-void CudaPointCollisionModel::resize(Size size)
+void CudaPointCollisionModel::doResize(Size size)
 {
-    this->core::CollisionModel::resize(size);
+    this->core::CollisionModel::doResize(size);
 }
 
 void CudaPointCollisionModel::init()
@@ -105,7 +105,7 @@ void CudaPointCollisionModel::drawCollisionModel(const core::visual::VisualParam
 
 using sofa::component::collision::geometry::CubeCollisionModel;
 
-void CudaPointCollisionModel::computeBoundingTree(int maxDepth)
+void CudaPointCollisionModel::doComputeBoundingTree(int maxDepth)
 {
     CubeCollisionModel* cubeModel = createPrevious<CubeCollisionModel>();
     const int npoints = mstate->getSize();
@@ -114,6 +114,7 @@ void CudaPointCollisionModel::computeBoundingTree(int maxDepth)
     bool updated = false;
     if (nelems != size)
     {
+        // TODO (SPRINT SED 2025 SUGGESTION): maybe we should use doResize (because of double state check)
         resize(nelems);
         updated = true;
     }
diff --git a/applications/plugins/SofaCUDA/Component/src/SofaCUDA/component/collision/geometry/CudaPointModel.h b/applications/plugins/SofaCUDA/Component/src/SofaCUDA/component/collision/geometry/CudaPointModel.h
index 5694402231a..d4a4f7f3b56 100644
--- a/applications/plugins/SofaCUDA/Component/src/SofaCUDA/component/collision/geometry/CudaPointModel.h
+++ b/applications/plugins/SofaCUDA/Component/src/SofaCUDA/component/collision/geometry/CudaPointModel.h
@@ -68,14 +68,6 @@ class SOFACUDA_COMPONENT_API CudaPointCollisionModel : public core::CollisionMod
 
     virtual void init() override;
 
-    // -- CollisionModel interface
-
-    virtual void resize(Size size) override;
-
-    virtual void computeBoundingTree(int maxDepth=0) override;
-
-    //virtual void computeContinuousBoundingTree(double dt, int maxDepth=0);
-
     void draw(const core::visual::VisualParams*,Index index) override;
 
     core::behavior::MechanicalState<InDataTypes>* getMechanicalState() { return mstate; }
@@ -84,6 +76,14 @@ class SOFACUDA_COMPONENT_API CudaPointCollisionModel : public core::CollisionMod
 
     void drawCollisionModel(const core::visual::VisualParams*) override;
     core::behavior::MechanicalState<InDataTypes>* mstate;
+
+    // -- CollisionModel interface
+
+    virtual void doResize(Size size) override;
+
+    virtual void doComputeBoundingTree(int maxDepth=0) override;
+
+    //virtual void doComputeContinuousBoundingTree(double dt, int maxDepth=0);
 };
 
 inline CudaPoint::CudaPoint(CudaPointCollisionModel* model, Index index)
diff --git a/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.cpp b/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.cpp
index 15b26d9b60e..bb6bc9e6c88 100644
--- a/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.cpp
+++ b/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.cpp
@@ -561,9 +561,9 @@ void CudaRigidDistanceGridCollisionModel::init()
     std::cout << "< CudaRigidDistanceGridCollisionModel::init()"<<std::endl;
 }
 
-void CudaRigidDistanceGridCollisionModel::resize(Size s)
+void CudaRigidDistanceGridCollisionModel::doResize(Size s)
 {
-    this->core::CollisionModel::resize(s);
+    this->core::CollisionModel::doResize(s);
     elems.resize(s);
 }
 
@@ -599,7 +599,7 @@ void CudaRigidDistanceGridCollisionModel::setNewState(Index index, double dt, Cu
 using sofa::component::collision::geometry::CubeCollisionModel;
 
 /// Create or update the bounding volume hierarchy.
-void CudaRigidDistanceGridCollisionModel::computeBoundingTree(int maxDepth)
+void CudaRigidDistanceGridCollisionModel::doComputeBoundingTree(int maxDepth)
 {
     CubeCollisionModel* cubeModel = this->createPrevious<CubeCollisionModel>();
 
diff --git a/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.h b/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.h
index 8da7b24b5d6..89f43f66405 100644
--- a/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.h
+++ b/applications/plugins/SofaDistanceGrid/extensions/CUDA/src/SofaDistanceGrid/CUDA/CudaDistanceGridCollisionModel.h
@@ -475,6 +475,11 @@ class CudaRigidDistanceGridCollisionModel : public core::CollisionModel
     void updateGrid();
 
     void drawCollisionModel(const core::visual::VisualParams*) override;
+    // -- CollisionModel interface
+    void doResize(Size size) override;
+
+    /// Create or update the bounding volume hierarchy.
+    void doComputeBoundingTree(int maxDepth=0) override;
 
 public:
     // Input data parameters
@@ -546,13 +551,6 @@ class CudaRigidDistanceGridCollisionModel : public core::CollisionModel
     /// Set new grid and transform, keeping the old state to estimate velocity
     void setNewState(double dt, CudaDistanceGrid* grid, const Matrix3& rotation, const Vec3& translation);
 
-    // -- CollisionModel interface
-
-    void resize(Size size) override;
-
-    /// Create or update the bounding volume hierarchy.
-    void computeBoundingTree(int maxDepth=0) override;
-
     void draw(const core::visual::VisualParams*, Index index) override;
 };
 
diff --git a/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.cpp b/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.cpp
index f10b376ac7c..c0e1932df0f 100644
--- a/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.cpp
+++ b/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.cpp
@@ -137,9 +137,9 @@ void RigidDistanceGridCollisionModel::init()
     msg_info() << "Initialisation done.";
 }
 
-void RigidDistanceGridCollisionModel::resize(sofa::Size s)
+void RigidDistanceGridCollisionModel::doResize(sofa::Size s)
 {
-    this->core::CollisionModel::resize(s);
+    this->core::CollisionModel::doResize(s);
     elems.resize(s);
 }
 
@@ -199,7 +199,7 @@ void RigidDistanceGridCollisionModel::updateState()
 }
 
 /// Create or update the bounding volume hierarchy.
-void RigidDistanceGridCollisionModel::computeBoundingTree(int maxDepth)
+void RigidDistanceGridCollisionModel::doComputeBoundingTree(int maxDepth)
 {
     CubeCollisionModel* cubeModel = this->createPrevious<CubeCollisionModel>();
 
@@ -549,13 +549,13 @@ void FFDDistanceGridCollisionModel::init()
     msg_info() << c <<" active cubes.";
 }
 
-void FFDDistanceGridCollisionModel::resize(sofa::Size s)
+void FFDDistanceGridCollisionModel::doResize(sofa::Size s)
 {
-    this->core::CollisionModel::resize(s);
+    this->core::CollisionModel::doResize(s);
     elems.resize(s);
 }
 
-bool FFDDistanceGridCollisionModel::canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2)
+bool FFDDistanceGridCollisionModel::doCanCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2)
 {
     if (model2 != this) return true;
     if (!this->bSelfCollision.getValue()) return true;
@@ -566,7 +566,7 @@ bool FFDDistanceGridCollisionModel::canCollideWithElement(sofa::Index index, Col
 }
 
 /// Create or update the bounding volume hierarchy.
-void FFDDistanceGridCollisionModel::computeBoundingTree(int maxDepth)
+void FFDDistanceGridCollisionModel::doComputeBoundingTree(int maxDepth)
 {
     CubeCollisionModel* cubeModel = this->createPrevious<CubeCollisionModel>();
 
diff --git a/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.h b/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.h
index 675094f8922..ce08eba0135 100644
--- a/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.h
+++ b/applications/plugins/SofaDistanceGrid/src/SofaDistanceGrid/components/collision/DistanceGridCollisionModel.h
@@ -145,6 +145,11 @@ class SOFA_SOFADISTANCEGRID_API RigidDistanceGridCollisionModel : public core::C
     ~RigidDistanceGridCollisionModel() override;
 
     void drawCollisionModel(const core::visual::VisualParams* vparams) override;
+    void doResize(sofa::Size size) override;
+
+    /// Create or update the bounding volume hierarchy.
+    void doComputeBoundingTree(int maxDepth=0) override;
+
 public:
     core::behavior::MechanicalState<InDataTypes>* getRigidModel() { return this->mstate ; }
     core::behavior::MechanicalState<InDataTypes>* getMechanicalState() { return this->mstate ; }
@@ -217,11 +222,6 @@ class SOFA_SOFADISTANCEGRID_API RigidDistanceGridCollisionModel : public core::C
     /// Update transformation matrices from current rigid state
     void updateState();
 
-    void resize(sofa::Size size) override;
-
-    /// Create or update the bounding volume hierarchy.
-    void computeBoundingTree(int maxDepth=0) override;
-
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
 
 };
@@ -450,13 +450,23 @@ class SOFA_SOFADISTANCEGRID_API FFDDistanceGridCollisionModel : public core::Col
     ~FFDDistanceGridCollisionModel() override;
 
     void drawCollisionModel(const core::visual::VisualParams* vparams) override;
+    /// CollisionModel interface
+    void doResize(sofa::Size size) override;
+
+    /// Create or update the bounding volume hierarchy.
+    void doComputeBoundingTree(int maxDepth=0) override;
+
+    bool doCanCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;
+
+    core::topology::BaseMeshTopology* doGetCollisionTopology() override { return l_ffdMesh; }
+
 public:
     core::behavior::MechanicalState<DataTypes>* getDeformModel() { return this->mstate; }
     core::topology::BaseMeshTopology* getDeformGrid() { return l_ffdMesh; }
 
     /// alias used by ContactMapper
     core::behavior::MechanicalState<DataTypes>* getMechanicalState() { return this->mstate; }
-    core::topology::BaseMeshTopology* getCollisionTopology() override { return l_ffdMesh; }
+
 
     void init() override;
 
@@ -470,14 +480,6 @@ class SOFA_SOFADISTANCEGRID_API FFDDistanceGridCollisionModel : public core::Col
         return elems[index];
     }
 
-    /// CollisionModel interface
-    void resize(sofa::Size size) override;
-
-    /// Create or update the bounding volume hierarchy.
-    void computeBoundingTree(int maxDepth=0) override;
-
-    bool canCollideWithElement(sofa::Index index, CollisionModel* model2, sofa::Index index2) override;
-
     void draw(const core::visual::VisualParams*, sofa::Index index) override;
 };