diff --git a/Sofa/Component/Mapping/Linear/src/sofa/component/mapping/linear/SimpleTesselatedHexaTopologicalMapping.cpp b/Sofa/Component/Mapping/Linear/src/sofa/component/mapping/linear/SimpleTesselatedHexaTopologicalMapping.cpp
index eda72c1227d..522f948e21e 100644
--- a/Sofa/Component/Mapping/Linear/src/sofa/component/mapping/linear/SimpleTesselatedHexaTopologicalMapping.cpp
+++ b/Sofa/Component/Mapping/Linear/src/sofa/component/mapping/linear/SimpleTesselatedHexaTopologicalMapping.cpp
@@ -48,285 +48,289 @@ int SimpleTesselatedHexaTopologicalMappingClass = core::RegisterObject ( "Specia
 
 // Implementation
 SimpleTesselatedHexaTopologicalMapping::SimpleTesselatedHexaTopologicalMapping()
+    : sofa::core::topology::TopologicalMapping()
 {
+    m_inputType = TopologyElementType::HEXAHEDRON;
+    m_outputType = TopologyElementType::HEXAHEDRON;
 }
 
 void SimpleTesselatedHexaTopologicalMapping::init()
 {
-    if(fromModel)
+    // Check input/output topology
+    if (!this->checkTopologyInputTypes()) // method will display error message if false
     {
-        if(toModel)
+        this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
+        return;
+    }
+
+    toModel->clear();
+
+    for (std::size_t i=0; i<fromModel->getNbPoints(); ++i)
+    {
+        // points mapped from points
+        pointMappedFromPoint.push_back(i);
+        toModel->addPoint(fromModel->getPX(i), fromModel->getPY(i), fromModel->getPZ(i));
+    }
+
+    size_t pointIndex = pointMappedFromPoint.size();
+    Vec3 p;
+
+    for (std::size_t i=0; i<fromModel->getNbHexahedra(); ++i)
+    {
+        core::topology::BaseMeshTopology::Hexa h = fromModel->getHexahedron(i);
+
+        Vec3 p0(fromModel->getPX(h[0]), fromModel->getPY(h[0]), fromModel->getPZ(h[0]));
+        Vec3 p1(fromModel->getPX(h[1]), fromModel->getPY(h[1]), fromModel->getPZ(h[1]));
+        Vec3 p2(fromModel->getPX(h[2]), fromModel->getPY(h[2]), fromModel->getPZ(h[2]));
+        Vec3 p3(fromModel->getPX(h[3]), fromModel->getPY(h[3]), fromModel->getPZ(h[3]));
+        Vec3 p4(fromModel->getPX(h[4]), fromModel->getPY(h[4]), fromModel->getPZ(h[4]));
+        Vec3 p5(fromModel->getPX(h[5]), fromModel->getPY(h[5]), fromModel->getPZ(h[5]));
+        Vec3 p6(fromModel->getPX(h[6]), fromModel->getPY(h[6]), fromModel->getPZ(h[6]));
+        Vec3 p7(fromModel->getPX(h[7]), fromModel->getPY(h[7]), fromModel->getPZ(h[7]));
+
+        // points mapped from edges
+        std::pair<std::map<fixed_array<int,2>, int>::iterator, bool> insert_result;
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[0],h[1]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p0+p1)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[1],h[(2)]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p1+p2)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[3],h[2]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p3+p2)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[0],h[3]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p0+p3)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[0],h[4]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p0+p4)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[1],h[5]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p1+p5)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[2],h[6]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p2+p6)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[3],h[7]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p3+p7)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[4],h[5]),pointIndex));
+        if(insert_result.second)
         {
-            toModel->clear();
-
-            for (std::size_t i=0; i<fromModel->getNbPoints(); ++i)
-            {
-                // points mapped from points
-                pointMappedFromPoint.push_back(i);
-                toModel->addPoint(fromModel->getPX(i), fromModel->getPY(i), fromModel->getPZ(i));
-            }
-
-            size_t pointIndex = pointMappedFromPoint.size();
-            Vec3 p;
-
-            for (std::size_t i=0; i<fromModel->getNbHexahedra(); ++i)
-            {
-                core::topology::BaseMeshTopology::Hexa h = fromModel->getHexahedron(i);
-
-                Vec3 p0(fromModel->getPX(h[0]), fromModel->getPY(h[0]), fromModel->getPZ(h[0]));
-                Vec3 p1(fromModel->getPX(h[1]), fromModel->getPY(h[1]), fromModel->getPZ(h[1]));
-                Vec3 p2(fromModel->getPX(h[2]), fromModel->getPY(h[2]), fromModel->getPZ(h[2]));
-                Vec3 p3(fromModel->getPX(h[3]), fromModel->getPY(h[3]), fromModel->getPZ(h[3]));
-                Vec3 p4(fromModel->getPX(h[4]), fromModel->getPY(h[4]), fromModel->getPZ(h[4]));
-                Vec3 p5(fromModel->getPX(h[5]), fromModel->getPY(h[5]), fromModel->getPZ(h[5]));
-                Vec3 p6(fromModel->getPX(h[6]), fromModel->getPY(h[6]), fromModel->getPZ(h[6]));
-                Vec3 p7(fromModel->getPX(h[7]), fromModel->getPY(h[7]), fromModel->getPZ(h[7]));
-
-                // points mapped from edges
-                std::pair<std::map<fixed_array<int,2>, int>::iterator, bool> insert_result;
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[0],h[1]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p0+p1)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[1],h[(2)]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p1+p2)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[3],h[2]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p3+p2)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[0],h[3]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p0+p3)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[0],h[4]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p0+p4)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[1],h[5]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p1+p5)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[2],h[6]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p2+p6)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[3],h[7]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p3+p7)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[4],h[5]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p4+p5)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[5],h[6]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p5+p6)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[7],h[6]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p7+p6)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[4],h[7]),pointIndex));
-                if(insert_result.second)
-                {
-                    p = (p4+p7)/2;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                // points mapped from facets
-                std::pair<std::map<fixed_array<int,4>, int>::iterator, bool> insert_facets_result;
-                insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[0], h[1], h[2], h[3]), pointIndex));
-                if (insert_facets_result.second)
-                {
-                    p = (p0+p1+p2+p3)/4;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[0], h[1], h[5], h[4]), pointIndex));
-                if (insert_facets_result.second)
-                {
-                    p = (p0+p1+p5+p4)/4;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[1], h[2], h[6], h[5]), pointIndex));
-                if (insert_facets_result.second)
-                {
-                    p = (p1+p2+p6+p5)/4;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[3], h[2], h[6], h[7]), pointIndex));
-                if (insert_facets_result.second)
-                {
-                    p = (p3+p2+p6+p7)/4;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[0], h[3], h[7], h[4]), pointIndex));
-                if (insert_facets_result.second)
-                {
-                    p = (p0+p4+p7+p3)/4;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[4], h[5], h[6], h[7]), pointIndex));
-                if (insert_facets_result.second)
-                {
-                    p = (p4+p5+p6+p7)/4;
-                    toModel->addPoint(p[0], p[1], p[2]);
-                    pointIndex++;
-                }
-
-                // points mapped from hexahedra
-                pointMappedFromHexa.push_back((int)pointIndex);
-                p = (p0+p1+p2+p3+p4+p5+p6+p7)/8;
-                toModel->addPoint(p[0], p[1], p[2]);
-                pointIndex++;
-            }
-
-            for (unsigned int i=0; i<fromModel->getNbHexahedra(); ++i)
-            {
-                core::topology::BaseMeshTopology::Hexa h = fromModel->getHexahedron(i);
-
-                Vec3d p0(fromModel->getPX(h[0]), fromModel->getPY(h[0]), fromModel->getPZ(h[0]));
-                Vec3d p1(fromModel->getPX(h[1]), fromModel->getPY(h[1]), fromModel->getPZ(h[1]));
-                Vec3d p2(fromModel->getPX(h[2]), fromModel->getPY(h[2]), fromModel->getPZ(h[2]));
-                Vec3d p3(fromModel->getPX(h[3]), fromModel->getPY(h[3]), fromModel->getPZ(h[3]));
-                Vec3d p4(fromModel->getPX(h[4]), fromModel->getPY(h[4]), fromModel->getPZ(h[4]));
-                Vec3d p5(fromModel->getPX(h[5]), fromModel->getPY(h[5]), fromModel->getPZ(h[5]));
-                Vec3d p6(fromModel->getPX(h[6]), fromModel->getPY(h[6]), fromModel->getPZ(h[6]));
-                Vec3d p7(fromModel->getPX(h[7]), fromModel->getPY(h[7]), fromModel->getPZ(h[7]));
-
-                toModel->addHexa(h[0],
-                        pointMappedFromEdge[fixed_array<int,2>(h[0],h[1])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[2],h[3])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[0],h[3])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[0],h[4])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[5],h[4])],
-                        pointMappedFromHexa[i],
-                        pointMappedFromFacet[fixed_array<int,4>(h[0],h[3],h[7],h[4])]);
-
-                toModel->addHexa(pointMappedFromEdge[fixed_array<int,2>(h[0],h[1])],
-                        h[1],
-                        pointMappedFromEdge[fixed_array<int,2>(h[1],h[2])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[2],h[3])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[5],h[4])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[1],h[5])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[1],h[2],h[6],h[5])],
-                        pointMappedFromHexa[i]);
-
-                toModel->addHexa(pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[2],h[3])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[1],h[2])],
-                        h[2],
-                        pointMappedFromEdge[fixed_array<int,2>(h[3],h[2])],
-                        pointMappedFromHexa[i],
-                        pointMappedFromFacet[fixed_array<int,4>(h[1],h[2],h[6],h[5])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[2],h[6])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[3],h[2],h[6],h[7])]);
-
-                toModel->addHexa(pointMappedFromEdge[fixed_array<int,2>(h[0],h[3])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[2],h[3])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[3],h[2])],
-                        h[3],
-                        pointMappedFromFacet[fixed_array<int,4>(h[0],h[3],h[7],h[4])],
-                        pointMappedFromHexa[i],
-                        pointMappedFromFacet[fixed_array<int,4>(h[3],h[2],h[6],h[7])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[3],h[7])]);
-
-                toModel->addHexa(pointMappedFromEdge[fixed_array<int,2>(h[0],h[4])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[5],h[4])],
-                        pointMappedFromHexa[i],
-                        pointMappedFromFacet[fixed_array<int,4>(h[0],h[3],h[7],h[4])],
-                        h[4],
-                        pointMappedFromEdge[fixed_array<int,2>(h[4],h[5])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[4],h[5],h[6],h[7])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[4],h[7])]);
-
-                toModel->addHexa(pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[5],h[4])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[1],h[5])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[1],h[2],h[6],h[5])],
-                        pointMappedFromHexa[i],
-                        pointMappedFromEdge[fixed_array<int,2>(h[4],h[5])],
-                        h[5],
-                        pointMappedFromEdge[fixed_array<int,2>(h[5],h[6])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[4],h[5],h[6],h[7])]);
-
-                toModel->addHexa(pointMappedFromHexa[i],
-                        pointMappedFromFacet[fixed_array<int,4>(h[1],h[2],h[6],h[5])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[2],h[6])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[3],h[2],h[6],h[7])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[4],h[5],h[6],h[7])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[5],h[6])],
-                        h[6],
-                        pointMappedFromEdge[fixed_array<int,2>(h[7],h[6])]);
-
-                toModel->addHexa(pointMappedFromFacet[fixed_array<int,4>(h[0],h[3],h[7],h[4])],
-                        pointMappedFromHexa[i],
-                        pointMappedFromFacet[fixed_array<int,4>(h[3],h[2],h[6],h[7])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[3],h[7])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[4],h[7])],
-                        pointMappedFromFacet[fixed_array<int,4>(h[4],h[5],h[6],h[7])],
-                        pointMappedFromEdge[fixed_array<int,2>(h[7],h[6])],
-                        h[7]);
-            }
-
-            // Need to fully init the target topology
-            toModel->init();
+            p = (p4+p5)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
         }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[5],h[6]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p5+p6)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[7],h[6]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p7+p6)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_result = pointMappedFromEdge.insert(std::make_pair(fixed_array<int,2>(h[4],h[7]),pointIndex));
+        if(insert_result.second)
+        {
+            p = (p4+p7)/2;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        // points mapped from facets
+        std::pair<std::map<fixed_array<int,4>, int>::iterator, bool> insert_facets_result;
+        insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[0], h[1], h[2], h[3]), pointIndex));
+        if (insert_facets_result.second)
+        {
+            p = (p0+p1+p2+p3)/4;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[0], h[1], h[5], h[4]), pointIndex));
+        if (insert_facets_result.second)
+        {
+            p = (p0+p1+p5+p4)/4;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[1], h[2], h[6], h[5]), pointIndex));
+        if (insert_facets_result.second)
+        {
+            p = (p1+p2+p6+p5)/4;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[3], h[2], h[6], h[7]), pointIndex));
+        if (insert_facets_result.second)
+        {
+            p = (p3+p2+p6+p7)/4;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[0], h[3], h[7], h[4]), pointIndex));
+        if (insert_facets_result.second)
+        {
+            p = (p0+p4+p7+p3)/4;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        insert_facets_result = pointMappedFromFacet.insert(std::make_pair(fixed_array<int,4>(h[4], h[5], h[6], h[7]), pointIndex));
+        if (insert_facets_result.second)
+        {
+            p = (p4+p5+p6+p7)/4;
+            toModel->addPoint(p[0], p[1], p[2]);
+            pointIndex++;
+        }
+
+        // points mapped from hexahedra
+        pointMappedFromHexa.push_back((int)pointIndex);
+        p = (p0+p1+p2+p3+p4+p5+p6+p7)/8;
+        toModel->addPoint(p[0], p[1], p[2]);
+        pointIndex++;
     }
+
+    for (unsigned int i=0; i<fromModel->getNbHexahedra(); ++i)
+    {
+        core::topology::BaseMeshTopology::Hexa h = fromModel->getHexahedron(i);
+
+        Vec3d p0(fromModel->getPX(h[0]), fromModel->getPY(h[0]), fromModel->getPZ(h[0]));
+        Vec3d p1(fromModel->getPX(h[1]), fromModel->getPY(h[1]), fromModel->getPZ(h[1]));
+        Vec3d p2(fromModel->getPX(h[2]), fromModel->getPY(h[2]), fromModel->getPZ(h[2]));
+        Vec3d p3(fromModel->getPX(h[3]), fromModel->getPY(h[3]), fromModel->getPZ(h[3]));
+        Vec3d p4(fromModel->getPX(h[4]), fromModel->getPY(h[4]), fromModel->getPZ(h[4]));
+        Vec3d p5(fromModel->getPX(h[5]), fromModel->getPY(h[5]), fromModel->getPZ(h[5]));
+        Vec3d p6(fromModel->getPX(h[6]), fromModel->getPY(h[6]), fromModel->getPZ(h[6]));
+        Vec3d p7(fromModel->getPX(h[7]), fromModel->getPY(h[7]), fromModel->getPZ(h[7]));
+
+        toModel->addHexa(h[0],
+                pointMappedFromEdge[fixed_array<int,2>(h[0],h[1])],
+                pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[2],h[3])],
+                pointMappedFromEdge[fixed_array<int,2>(h[0],h[3])],
+                pointMappedFromEdge[fixed_array<int,2>(h[0],h[4])],
+                pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[5],h[4])],
+                pointMappedFromHexa[i],
+                pointMappedFromFacet[fixed_array<int,4>(h[0],h[3],h[7],h[4])]);
+
+        toModel->addHexa(pointMappedFromEdge[fixed_array<int,2>(h[0],h[1])],
+                h[1],
+                pointMappedFromEdge[fixed_array<int,2>(h[1],h[2])],
+                pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[2],h[3])],
+                pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[5],h[4])],
+                pointMappedFromEdge[fixed_array<int,2>(h[1],h[5])],
+                pointMappedFromFacet[fixed_array<int,4>(h[1],h[2],h[6],h[5])],
+                pointMappedFromHexa[i]);
+
+        toModel->addHexa(pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[2],h[3])],
+                pointMappedFromEdge[fixed_array<int,2>(h[1],h[2])],
+                h[2],
+                pointMappedFromEdge[fixed_array<int,2>(h[3],h[2])],
+                pointMappedFromHexa[i],
+                pointMappedFromFacet[fixed_array<int,4>(h[1],h[2],h[6],h[5])],
+                pointMappedFromEdge[fixed_array<int,2>(h[2],h[6])],
+                pointMappedFromFacet[fixed_array<int,4>(h[3],h[2],h[6],h[7])]);
+
+        toModel->addHexa(pointMappedFromEdge[fixed_array<int,2>(h[0],h[3])],
+                pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[2],h[3])],
+                pointMappedFromEdge[fixed_array<int,2>(h[3],h[2])],
+                h[3],
+                pointMappedFromFacet[fixed_array<int,4>(h[0],h[3],h[7],h[4])],
+                pointMappedFromHexa[i],
+                pointMappedFromFacet[fixed_array<int,4>(h[3],h[2],h[6],h[7])],
+                pointMappedFromEdge[fixed_array<int,2>(h[3],h[7])]);
+
+        toModel->addHexa(pointMappedFromEdge[fixed_array<int,2>(h[0],h[4])],
+                pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[5],h[4])],
+                pointMappedFromHexa[i],
+                pointMappedFromFacet[fixed_array<int,4>(h[0],h[3],h[7],h[4])],
+                h[4],
+                pointMappedFromEdge[fixed_array<int,2>(h[4],h[5])],
+                pointMappedFromFacet[fixed_array<int,4>(h[4],h[5],h[6],h[7])],
+                pointMappedFromEdge[fixed_array<int,2>(h[4],h[7])]);
+
+        toModel->addHexa(pointMappedFromFacet[fixed_array<int,4>(h[0],h[1],h[5],h[4])],
+                pointMappedFromEdge[fixed_array<int,2>(h[1],h[5])],
+                pointMappedFromFacet[fixed_array<int,4>(h[1],h[2],h[6],h[5])],
+                pointMappedFromHexa[i],
+                pointMappedFromEdge[fixed_array<int,2>(h[4],h[5])],
+                h[5],
+                pointMappedFromEdge[fixed_array<int,2>(h[5],h[6])],
+                pointMappedFromFacet[fixed_array<int,4>(h[4],h[5],h[6],h[7])]);
+
+        toModel->addHexa(pointMappedFromHexa[i],
+                pointMappedFromFacet[fixed_array<int,4>(h[1],h[2],h[6],h[5])],
+                pointMappedFromEdge[fixed_array<int,2>(h[2],h[6])],
+                pointMappedFromFacet[fixed_array<int,4>(h[3],h[2],h[6],h[7])],
+                pointMappedFromFacet[fixed_array<int,4>(h[4],h[5],h[6],h[7])],
+                pointMappedFromEdge[fixed_array<int,2>(h[5],h[6])],
+                h[6],
+                pointMappedFromEdge[fixed_array<int,2>(h[7],h[6])]);
+
+        toModel->addHexa(pointMappedFromFacet[fixed_array<int,4>(h[0],h[3],h[7],h[4])],
+                pointMappedFromHexa[i],
+                pointMappedFromFacet[fixed_array<int,4>(h[3],h[2],h[6],h[7])],
+                pointMappedFromEdge[fixed_array<int,2>(h[3],h[7])],
+                pointMappedFromEdge[fixed_array<int,2>(h[4],h[7])],
+                pointMappedFromFacet[fixed_array<int,4>(h[4],h[5],h[6],h[7])],
+                pointMappedFromEdge[fixed_array<int,2>(h[7],h[6])],
+                h[7]);
+    }
+
+    // Need to fully init the target topology
+    toModel->init();
 }
 
 } //namespace sofa::component::mapping::linear
diff --git a/Sofa/Component/Mapping/Linear/src/sofa/component/mapping/linear/SimpleTesselatedTetraTopologicalMapping.cpp b/Sofa/Component/Mapping/Linear/src/sofa/component/mapping/linear/SimpleTesselatedTetraTopologicalMapping.cpp
index 4b44fca6acd..35948dbfcb4 100644
--- a/Sofa/Component/Mapping/Linear/src/sofa/component/mapping/linear/SimpleTesselatedTetraTopologicalMapping.cpp
+++ b/Sofa/Component/Mapping/Linear/src/sofa/component/mapping/linear/SimpleTesselatedTetraTopologicalMapping.cpp
@@ -49,107 +49,112 @@ int SimpleTesselatedTetraTopologicalMappingClass = core::RegisterObject ( "Speci
 
 // Implementation
 SimpleTesselatedTetraTopologicalMapping::SimpleTesselatedTetraTopologicalMapping ()
-    : tetrahedraMappedFromTetra( initData ( &tetrahedraMappedFromTetra, "tetrahedraMappedFromTetra", "Each Tetrahedron of the input topology is mapped to the 8 tetrahedrons in which it can be divided")),
-      tetraSource( initData ( &tetraSource, "tetraSource", "Which tetra from the input topology map to a given tetra in the output topology (sofa::InvalidID if none)")),
-      d_pointMappedFromPoint( initData ( &d_pointMappedFromPoint, "pointMappedFromPoint", "Each point of the input topology is mapped to the same point")),
-      d_pointMappedFromEdge( initData ( &d_pointMappedFromEdge, "pointMappedFromEdge", "Each edge of the input topology is mapped to his midpoint")),
-      d_pointSource( initData ( &d_pointSource, "pointSource", "Which input topology element map to a given point in the output topology : 0 -> none, > 0 -> point index + 1, < 0 , - edge index -1"))
+    : sofa::core::topology::TopologicalMapping()
+    , tetrahedraMappedFromTetra( initData ( &tetrahedraMappedFromTetra, "tetrahedraMappedFromTetra", "Each Tetrahedron of the input topology is mapped to the 8 tetrahedrons in which it can be divided"))
+    , tetraSource( initData ( &tetraSource, "tetraSource", "Which tetra from the input topology map to a given tetra in the output topology (sofa::InvalidID if none)"))
+    , d_pointMappedFromPoint( initData ( &d_pointMappedFromPoint, "pointMappedFromPoint", "Each point of the input topology is mapped to the same point"))
+    , d_pointMappedFromEdge( initData ( &d_pointMappedFromEdge, "pointMappedFromEdge", "Each edge of the input topology is mapped to his midpoint"))
+    , d_pointSource( initData ( &d_pointSource, "pointSource", "Which input topology element map to a given point in the output topology : 0 -> none, > 0 -> point index + 1, < 0 , - edge index -1"))
 {
+    m_inputType = TopologyElementType::TETRAHEDRON;
+    m_outputType = TopologyElementType::TETRAHEDRON;
 }
 
 void SimpleTesselatedTetraTopologicalMapping::init()
 {
-    if(fromModel)
+    // Check input/output topology
+    if (!this->checkTopologyInputTypes()) // method will display error message if false
     {
-        TetrahedronSetTopologyContainer *from_tstc;
-        fromModel->getContext()->get(from_tstc);
-        if(toModel)
-        {
+        this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
+        return;
+    }
 
-            helper::WriteAccessor< Data< sofa::type::vector<Index> > > pointSourceData = d_pointSource;
-            helper::WriteAccessor< Data< sofa::type::vector<Index> > > pointMappedFromPointData = d_pointMappedFromPoint;
-            helper::WriteAccessor< Data< sofa::type::vector<Index> > > pointMappedFromEdgeData = d_pointMappedFromEdge;
 
-            sofa::type::vector<type::fixed_array<Index, 8> >& tetrahedraMappedFromTetraData = *(tetrahedraMappedFromTetra.beginEdit());
-            type::vector<Index>& tetraSourceData = *(tetraSource.beginEdit());
+    TetrahedronSetTopologyContainer *from_tstc;
+    fromModel->getContext()->get(from_tstc);
 
-            TetrahedronSetTopologyContainer *to_tstc;
-            toModel->getContext()->get(to_tstc);
-            to_tstc->clear();
-            if(!from_tstc->hasPos())
-            {
+    helper::WriteAccessor< Data< sofa::type::vector<Index> > > pointSourceData = d_pointSource;
+    helper::WriteAccessor< Data< sofa::type::vector<Index> > > pointMappedFromPointData = d_pointMappedFromPoint;
+    helper::WriteAccessor< Data< sofa::type::vector<Index> > > pointMappedFromEdgeData = d_pointMappedFromEdge;
+
+    sofa::type::vector<type::fixed_array<Index, 8> >& tetrahedraMappedFromTetraData = *(tetrahedraMappedFromTetra.beginEdit());
+    type::vector<Index>& tetraSourceData = *(tetraSource.beginEdit());
+
+    TetrahedronSetTopologyContainer *to_tstc;
+    toModel->getContext()->get(to_tstc);
+    to_tstc->clear();
+    if(!from_tstc->hasPos())
+    {
 //				MeshLoader *mshLoader;
 //				fromModel->getContext()->get(mshLoader);
 //				from_tstc->loadFromMeshLoader(mshLoader);
-            }
+    }
 
-            pointSourceData.resize(from_tstc->getNbPoints()+from_tstc->getNbEdges());
+    pointSourceData.resize(from_tstc->getNbPoints()+from_tstc->getNbEdges());
 
 
-            for (std::size_t i=0; i<from_tstc->getNbPoints(); i++)
-            {
-                to_tstc->addPoint(from_tstc->getPX(i), from_tstc->getPY(i), from_tstc->getPZ(i));
+    for (std::size_t i=0; i<from_tstc->getNbPoints(); i++)
+    {
+        to_tstc->addPoint(from_tstc->getPX(i), from_tstc->getPY(i), from_tstc->getPZ(i));
 
-                pointMappedFromPointData.push_back(i);
-                pointSourceData[i] = i+1;
-            }
+        pointMappedFromPointData.push_back(i);
+        pointSourceData[i] = i+1;
+    }
 
-            Index newPointIndex = to_tstc->getNbPoints();
+    Index newPointIndex = to_tstc->getNbPoints();
 
-            for (unsigned int i=0; i<from_tstc->getNbEdges(); i++)
-            {
-                Edge e = from_tstc->getEdge(i);
+    for (unsigned int i=0; i<from_tstc->getNbEdges(); i++)
+    {
+        Edge e = from_tstc->getEdge(i);
 
-                to_tstc->addPoint(
-                    (from_tstc->getPX(e[0]) + from_tstc->getPX(e[1]))/2,
-                    (from_tstc->getPY(e[0]) + from_tstc->getPY(e[1]))/2,
-                    (from_tstc->getPZ(e[0]) + from_tstc->getPZ(e[1]))/2
-                );
+        to_tstc->addPoint(
+            (from_tstc->getPX(e[0]) + from_tstc->getPX(e[1]))/2,
+            (from_tstc->getPY(e[0]) + from_tstc->getPY(e[1]))/2,
+            (from_tstc->getPZ(e[0]) + from_tstc->getPZ(e[1]))/2
+        );
 
-                pointMappedFromEdgeData.push_back(newPointIndex);
-                pointSourceData[newPointIndex] = -(i+1);
-                newPointIndex++;
-            }
+        pointMappedFromEdgeData.push_back(newPointIndex);
+        pointSourceData[newPointIndex] = -(i+1);
+        newPointIndex++;
+    }
 
-            fixed_array <Index, 8> newTetrahedraIndices;
-            unsigned int newTetraIndex = (unsigned int)to_tstc->getNbTetrahedra();
+    fixed_array <Index, 8> newTetrahedraIndices;
+    unsigned int newTetraIndex = (unsigned int)to_tstc->getNbTetrahedra();
 
-            tetraSourceData.resize(8*from_tstc->getNbTetrahedra());
+    tetraSourceData.resize(8*from_tstc->getNbTetrahedra());
 
-            for (unsigned int i=0; i<from_tstc->getNbTetrahedra(); i++)
-            {
-                core::topology::BaseMeshTopology::Tetra t = from_tstc->getTetrahedron(i);
-                core::topology::BaseMeshTopology::EdgesInTetrahedron e = from_tstc->getEdgesInTetrahedron(i);
-                to_tstc->addTetra(t[0],	pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[1]], pointMappedFromEdgeData[e[2]]);
-                newTetrahedraIndices[0] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
+    for (unsigned int i=0; i<from_tstc->getNbTetrahedra(); i++)
+    {
+        core::topology::BaseMeshTopology::Tetra t = from_tstc->getTetrahedron(i);
+        core::topology::BaseMeshTopology::EdgesInTetrahedron e = from_tstc->getEdgesInTetrahedron(i);
+        to_tstc->addTetra(t[0],	pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[1]], pointMappedFromEdgeData[e[2]]);
+        newTetrahedraIndices[0] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
 
-                to_tstc->addTetra(t[1],	pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[4]], pointMappedFromEdgeData[e[3]]);
-                newTetrahedraIndices[1] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
+        to_tstc->addTetra(t[1],	pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[4]], pointMappedFromEdgeData[e[3]]);
+        newTetrahedraIndices[1] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
 
-                to_tstc->addTetra(t[2],	pointMappedFromEdgeData[e[1]], pointMappedFromEdgeData[e[3]], pointMappedFromEdgeData[e[5]]);
-                newTetrahedraIndices[2] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
+        to_tstc->addTetra(t[2],	pointMappedFromEdgeData[e[1]], pointMappedFromEdgeData[e[3]], pointMappedFromEdgeData[e[5]]);
+        newTetrahedraIndices[2] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
 
-                to_tstc->addTetra(t[3],	pointMappedFromEdgeData[e[2]], pointMappedFromEdgeData[e[5]], pointMappedFromEdgeData[e[4]]);
-                newTetrahedraIndices[3] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
+        to_tstc->addTetra(t[3],	pointMappedFromEdgeData[e[2]], pointMappedFromEdgeData[e[5]], pointMappedFromEdgeData[e[4]]);
+        newTetrahedraIndices[3] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
 
-                to_tstc->addTetra(pointMappedFromEdgeData[e[1]], pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[3]], pointMappedFromEdgeData[e[5]]);
-                newTetrahedraIndices[4] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
+        to_tstc->addTetra(pointMappedFromEdgeData[e[1]], pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[3]], pointMappedFromEdgeData[e[5]]);
+        newTetrahedraIndices[4] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
 
-                to_tstc->addTetra(pointMappedFromEdgeData[e[1]], pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[5]], pointMappedFromEdgeData[e[2]]);
-                newTetrahedraIndices[5] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
+        to_tstc->addTetra(pointMappedFromEdgeData[e[1]], pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[5]], pointMappedFromEdgeData[e[2]]);
+        newTetrahedraIndices[5] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
 
-                to_tstc->addTetra(pointMappedFromEdgeData[e[4]], pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[5]], pointMappedFromEdgeData[e[3]]);
-                newTetrahedraIndices[6] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
+        to_tstc->addTetra(pointMappedFromEdgeData[e[4]], pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[5]], pointMappedFromEdgeData[e[3]]);
+        newTetrahedraIndices[6] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
 
-                to_tstc->addTetra(pointMappedFromEdgeData[e[4]], pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[2]], pointMappedFromEdgeData[e[5]]);
-                newTetrahedraIndices[7] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
+        to_tstc->addTetra(pointMappedFromEdgeData[e[4]], pointMappedFromEdgeData[e[0]], pointMappedFromEdgeData[e[2]], pointMappedFromEdgeData[e[5]]);
+        newTetrahedraIndices[7] = newTetraIndex; tetraSourceData[newTetraIndex] = i; newTetraIndex++;
 
-                tetrahedraMappedFromTetraData.push_back(newTetrahedraIndices);
-            }
-            toModel->init();
-            tetrahedraMappedFromTetra.endEdit();
-        }
+        tetrahedraMappedFromTetraData.push_back(newTetrahedraIndices);
     }
+    toModel->init();
+    tetrahedraMappedFromTetra.endEdit();
 }
 
 void SimpleTesselatedTetraTopologicalMapping::updateTopologicalMappingBottomUp()
diff --git a/Sofa/Component/Topology/Container/Constant/src/sofa/component/topology/container/constant/MeshTopology.cpp b/Sofa/Component/Topology/Container/Constant/src/sofa/component/topology/container/constant/MeshTopology.cpp
index 1c1259cd1ce..fa763f85a3c 100644
--- a/Sofa/Component/Topology/Container/Constant/src/sofa/component/topology/container/constant/MeshTopology.cpp
+++ b/Sofa/Component/Topology/Container/Constant/src/sofa/component/topology/container/constant/MeshTopology.cpp
@@ -540,20 +540,21 @@ void MeshTopology::init()
     const auto triangles = sofa::helper::getReadAccessor(seqTriangles);
     const auto edges = sofa::helper::getReadAccessor(seqEdges);
 
-    if (nbPoints==0)
-    {
-        // looking for upper topology
-        if (!hexahedra.empty())
-            m_upperElementType = core::topology::TopologyElementType::HEXAHEDRON;
-        else if (!tetrahedra.empty())
-            m_upperElementType = sofa::core::topology::TopologyElementType::TETRAHEDRON;
-        else if (!quads.empty())
-            m_upperElementType = sofa::core::topology::TopologyElementType::QUAD;
-        else if (!triangles.empty())
-            m_upperElementType = sofa::core::topology::TopologyElementType::TRIANGLE;
-        else
-            m_upperElementType = sofa::core::topology::TopologyElementType::EDGE;
-    }
+
+    // looking for upper topology
+    if (!hexahedra.empty())
+        m_upperElementType = core::topology::TopologyElementType::HEXAHEDRON;
+    else if (!tetrahedra.empty())
+        m_upperElementType = sofa::core::topology::TopologyElementType::TETRAHEDRON;
+    else if (!quads.empty())
+        m_upperElementType = sofa::core::topology::TopologyElementType::QUAD;
+    else if (!triangles.empty())
+        m_upperElementType = sofa::core::topology::TopologyElementType::TRIANGLE;
+    else if (!edges.empty())
+        m_upperElementType = sofa::core::topology::TopologyElementType::EDGE;
+    else
+        m_upperElementType = sofa::core::topology::TopologyElementType::POINT;
+
 
     // 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)
diff --git a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Edge2QuadTopologicalMapping.cpp b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Edge2QuadTopologicalMapping.cpp
index 0ca39914d40..e19e009c57a 100644
--- a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Edge2QuadTopologicalMapping.cpp
+++ b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Edge2QuadTopologicalMapping.cpp
@@ -64,6 +64,8 @@ Edge2QuadTopologicalMapping::Edge2QuadTopologicalMapping()
     , d_edgeList(initData(&d_edgeList, "edgeList", "list of input edges for the topological mapping: by default, all considered"))
     , d_flipNormals(initData(&d_flipNormals, bool(false), "flipNormals", "Flip Normal ? (Inverse point order when creating quad)"))
 {
+    m_inputType = TopologyElementType::EDGE;
+    m_outputType = TopologyElementType::QUAD;
 }
 
 void Edge2QuadTopologicalMapping::init()
@@ -98,6 +100,14 @@ void Edge2QuadTopologicalMapping::init()
 
     unsigned int N = d_nbPointsOnEachCircle.getValue();
 
+    // Check input/output topology
+    if (!this->checkTopologyInputTypes()) // method will display error message if false
+    {
+        this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
+        return;
+    }
+
+    
     // INITIALISATION of QUADULAR mesh from EDGE mesh :
     core::behavior::MechanicalState<Rigid3Types>* from_mstate = dynamic_cast<core::behavior::MechanicalState<Rigid3Types>*>(fromModel->getContext()->getMechanicalState());
     core::behavior::MechanicalState<Vec3Types>* to_mstate = dynamic_cast<core::behavior::MechanicalState<Vec3Types>*>(toModel->getContext()->getMechanicalState());
@@ -266,6 +276,12 @@ void Edge2QuadTopologicalMapping::init()
         }
 
     }
+    else
+    {
+        // Check type Rigid3 of input mechanical object (required)
+        msg_error() << "Mechanical object associated with the input is not of type Rigid. Edge2QuadTopologicalMapping only supports Rigid3Types to Vec3Types";
+        d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
+    }
 }
 
 
diff --git a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Hexa2QuadTopologicalMapping.cpp b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Hexa2QuadTopologicalMapping.cpp
index 4b2e6d59f46..54f2f0f34f3 100644
--- a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Hexa2QuadTopologicalMapping.cpp
+++ b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Hexa2QuadTopologicalMapping.cpp
@@ -54,50 +54,29 @@ int Hexa2QuadTopologicalMappingClass = core::RegisterObject("Special case of map
 // Implementation
 
 Hexa2QuadTopologicalMapping::Hexa2QuadTopologicalMapping()
-    : flipNormals(initData(&flipNormals, bool(false), "flipNormals", "Flip Normal ? (Inverse point order when creating triangle)"))
+    : sofa::core::topology::TopologicalMapping()
+    , flipNormals(initData(&flipNormals, bool(false), "flipNormals", "Flip Normal ? (Inverse point order when creating triangle)"))
 {
+    m_inputType = TopologyElementType::HEXAHEDRON;
+    m_outputType = TopologyElementType::QUAD;
 }
 
 void Hexa2QuadTopologicalMapping::init()
 {
     using namespace container::dynamic;
 
-    bool modelsOk = true;
-    if (!fromModel)
+    if (!this->checkTopologyInputTypes()) // method will display error message if false
     {
-        // If the input topology link isn't set by the user, the TopologicalMapping::create method tries to find it.
-        // If it is null at this point, it means no input mesh topology could be found.
-        msg_error() << "No input mesh topology found. Consider setting the '" << fromModel.getName() << "' data attribute.";
-        modelsOk = false;
-    }
-
-    if (!toModel)
-    {
-        // If the output topology link isn't set by the user, the TopologicalMapping::create method tries to find it.
-        // If it is null at this point, it means no output mesh topology could be found.
-        msg_error() << "No output mesh topology found. Consider setting the '" << toModel.getName() << "' data attribute.";
-        modelsOk = false;
-    }
-
-    // Making sure the output topology is derived from the quad topology container
-    if (!dynamic_cast<QuadSetTopologyContainer *>(toModel.get())) {
-        msg_error() << "The output topology '" << toModel.getPath() << "' is not a derived class of QuadSetTopologyContainer. "
-                    << "Consider setting the '" << toModel.getName() << "' data attribute to a valid"
-                                                                        " QuadSetTopologyContainer derived object.";
-        modelsOk = false;
-    } else {
-        // Making sure a topology modifier exists at the same level as the output topology
-        QuadSetTopologyModifier *to_tstm;
-        toModel->getContext()->get(to_tstm);
-        if (!to_tstm) {
-            msg_error() << "No QuadSetTopologyModifier found in the output topology node '"
-                        << toModel->getContext()->getName() << "'.";
-            modelsOk = false;
-        }
+        this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
+        return;
     }
 
-    if (!modelsOk)
-    {
+    // Making sure a topology modifier exists at the same level as the output topology
+    QuadSetTopologyModifier *to_tstm;
+    toModel->getContext()->get(to_tstm);
+    if (!to_tstm) {
+        msg_error() << "No QuadSetTopologyModifier found in the output topology node '"
+                    << toModel->getContext()->getName() << "'.";
         this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
         return;
     }
diff --git a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Hexa2TetraTopologicalMapping.cpp b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Hexa2TetraTopologicalMapping.cpp
index 0332a1efd59..9dad4a7d720 100644
--- a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Hexa2TetraTopologicalMapping.cpp
+++ b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Hexa2TetraTopologicalMapping.cpp
@@ -55,8 +55,11 @@ int Hexa2TetraTopologicalMappingClass = core::RegisterObject("Special case of ma
 // Implementation
 
 Hexa2TetraTopologicalMapping::Hexa2TetraTopologicalMapping()
-    : swapping(initData(&swapping, false, "swapping","Boolean enabling to swapp hexa-edges\n in order to avoid bias effect"))
+    : sofa::core::topology::TopologicalMapping()
+    , swapping(initData(&swapping, false, "swapping","Boolean enabling to swapp hexa-edges\n in order to avoid bias effect"))
 {
+    m_inputType = TopologyElementType::HEXAHEDRON;
+    m_outputType = TopologyElementType::TETRAHEDRON;
 }
 
 Hexa2TetraTopologicalMapping::~Hexa2TetraTopologicalMapping()
@@ -67,38 +70,23 @@ void Hexa2TetraTopologicalMapping::init()
 {
     using namespace container::dynamic;
 
-    // INITIALISATION of TETRAHEDRAL mesh from HEXAHEDRAL mesh :
-
-    // recheck models
-    bool modelsOk = true;
-    if (!fromModel)
-    {
-        msg_error() << "Pointer to input topology is invalid.";
-        modelsOk = false;
-    }
-
-    if (!toModel)
-    {
-        msg_error() << "Pointer to output topology is invalid.";
-        modelsOk = false;
-    }
-    else
+    if (!this->checkTopologyInputTypes()) // method will display error message if false
     {
-        TetrahedronSetTopologyModifier *to_tstm;
-        toModel->getContext()->get(to_tstm);
-        if (!to_tstm)
-        {
-            msg_error() << "No TetrahedronSetTopologyModifier found in the Tetrahedron topology Node.";
-            modelsOk = false;
-        }
+        this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
+        return;
     }
 
-    if (!modelsOk)
+    TetrahedronSetTopologyModifier* to_tstm;
+    toModel->getContext()->get(to_tstm);
+    if (!to_tstm)
     {
+        msg_error() << "No TetrahedronSetTopologyModifier found in the Tetrahedron topology Node.";
         this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
         return;
     }
 
+    // INITIALISATION of TETRAHEDRAL mesh from HEXAHEDRAL mesh :
+
     TetrahedronSetTopologyContainer *to_tstc;
     toModel->getContext()->get(to_tstc);
     // Clear output topology
diff --git a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Quad2TriangleTopologicalMapping.cpp b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Quad2TriangleTopologicalMapping.cpp
index d26c7f397b5..29c2c133c7e 100644
--- a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Quad2TriangleTopologicalMapping.cpp
+++ b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Quad2TriangleTopologicalMapping.cpp
@@ -60,7 +60,10 @@ int Quad2TriangleTopologicalMappingClass = core::RegisterObject("Special case of
 // Implementation
 
 Quad2TriangleTopologicalMapping::Quad2TriangleTopologicalMapping()
+    : sofa::core::topology::TopologicalMapping()
 {
+    m_inputType = TopologyElementType::QUAD;
+    m_outputType = TopologyElementType::TRIANGLE;
 }
 
 
@@ -72,48 +75,24 @@ void Quad2TriangleTopologicalMapping::init()
 {
     using namespace container::dynamic;
 
-    bool modelsOk = true;
-    if (!fromModel)
+    if (!this->checkTopologyInputTypes()) // method will display error message if false
     {
-        // If the input topology link isn't set by the user, the TopologicalMapping::create method tries to find it.
-        // If it is null at this point, it means no input mesh topology could be found.
-        msg_error() << "No input mesh topology found. Consider setting the '" << fromModel.getName() << "' data attribute.";
-        modelsOk = false;
-    }
-
-    if (!toModel)
-    {
-        // If the output topology link isn't set by the user, the TopologicalMapping::create method tries to find it.
-        // If it is null at this point, it means no output mesh topology could be found.
-        msg_error() << "No output mesh topology found. Consider setting the '" << toModel.getName() << "' data attribute.";
-        modelsOk = false;
-    }
-
-    // Making sure the output topology is derived from the triangle topology container
-    if (!dynamic_cast<TriangleSetTopologyContainer *>(toModel.get())) {
-        msg_error() << "The output topology '" << toModel.getPath() << "' is not a derived class of TriangleSetTopologyContainer. "
-                    << "Consider setting the '" << toModel.getName() << "' data attribute to a valid"
-                                                                        " TriangleSetTopologyContainer derived object.";
-        modelsOk = false;
-    } else {
-        // Making sure a topology modifier exists at the same level as the output topology
-        TriangleSetTopologyModifier *to_tstm;
-        toModel->getContext()->get(to_tstm);
-        if (!to_tstm)
-        {
-            msg_error() << "No TriangleSetTopologyModifier found in the output topology node '"
-                        << toModel->getContext()->getName() << "'.";
-            modelsOk = false;
-        }
+        this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
+        return;
     }
 
-    if (!modelsOk)
+        
+    // Making sure a topology modifier exists at the same level as the output topology
+    TriangleSetTopologyModifier *to_tstm;
+    toModel->getContext()->get(to_tstm);
+    if (!to_tstm)
     {
+        msg_error() << "No TriangleSetTopologyModifier found in the output topology node '"
+                    << toModel->getContext()->getName() << "'.";
         this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
         return;
     }
 
-
     // Clear output topology
     toModel->clear();
 
diff --git a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Tetra2TriangleTopologicalMapping.cpp b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Tetra2TriangleTopologicalMapping.cpp
index 75591f810eb..8593032d8d8 100644
--- a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Tetra2TriangleTopologicalMapping.cpp
+++ b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Tetra2TriangleTopologicalMapping.cpp
@@ -60,52 +60,31 @@ Tetra2TriangleTopologicalMapping::Tetra2TriangleTopologicalMapping()
     , noInitialTriangles(initData(&noInitialTriangles, bool(false), "noInitialTriangles", "If true the list of initial triangles is initially empty. Only additional triangles will be added in the list"))
     , m_outTopoModifier(nullptr)
 {
+    m_inputType = TopologyElementType::TETRAHEDRON;
+    m_outputType = TopologyElementType::TRIANGLE;
 }
 
 void Tetra2TriangleTopologicalMapping::init()
 {
-    bool modelsOk = true;
-    if (!fromModel)
+    if (!this->checkTopologyInputTypes()) // method will display error message if false
     {
-        // If the input topology link isn't set by the user, the TopologicalMapping::create method tries to find it.
-        // If it is null at this point, it means no input mesh topology could be found.
-        msg_error() << "No input mesh topology found. Consider setting the '" << fromModel.getName() << "' data attribute.";
-        modelsOk = false;
-    }
-
-    if (!toModel)
-    {
-        // If the output topology link isn't set by the user, the TopologicalMapping::create method tries to find it.
-        // If it is null at this point, it means no output mesh topology could be found.
-        msg_error() << "No output mesh topology found. Consider setting the '" << toModel.getName() << "' data attribute.";
-        modelsOk = false;
-    }
-
-    // Making sure the output topology is derived from the triangle topology container
-    if (!dynamic_cast<container::dynamic::TriangleSetTopologyContainer *>(toModel.get())) {
-        msg_error() << "The output topology '" << toModel.getPath() << "' is not a derived class of TriangleSetTopologyContainer. "
-                    << "Consider setting the '" << toModel.getName() << "' data attribute to a valid"
-                                                                        " TriangleSetTopologyContainer derived object.";
-        modelsOk = false;
-    } else {
-        // Making sure a topology modifier exists at the same level as the output topology
-        container::dynamic::TriangleSetTopologyModifier *to_tstm;
-        toModel->getContext()->get(to_tstm);
-        if (!to_tstm) {
-            msg_error() << "No TriangleSetTopologyModifier found in the output topology node '"
-                        << toModel->getContext()->getName() << "'.";
-            modelsOk = false;
-        } else {
-            m_outTopoModifier = to_tstm;
-        }
+        this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
+        return;
     }
 
-    if (!modelsOk)
+    container::dynamic::TriangleSetTopologyModifier* to_tstm;
+    toModel->getContext()->get(to_tstm);
+    if (!to_tstm) 
     {
+        msg_error() << "No TriangleSetTopologyModifier found in the output topology node '"
+            << toModel->getContext()->getName() << "'.";
         this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
         return;
     }
-
+    else {
+        m_outTopoModifier = to_tstm;
+    }
+    
 
     // INITIALISATION of Triangle mesh from Tetrahedral mesh :
     // Clear output topology
diff --git a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Triangle2EdgeTopologicalMapping.cpp b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Triangle2EdgeTopologicalMapping.cpp
index 241196a2e9c..3177e403fa5 100644
--- a/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Triangle2EdgeTopologicalMapping.cpp
+++ b/Sofa/Component/Topology/Mapping/src/sofa/component/topology/mapping/Triangle2EdgeTopologicalMapping.cpp
@@ -52,6 +52,8 @@ Triangle2EdgeTopologicalMapping::Triangle2EdgeTopologicalMapping()
     : sofa::core::topology::TopologicalMapping()
     , m_outTopoModifier(nullptr)
 {
+    m_inputType = TopologyElementType::TRIANGLE;
+    m_outputType = TopologyElementType::EDGE;
 }
 
 
@@ -65,29 +67,17 @@ Triangle2EdgeTopologicalMapping::~Triangle2EdgeTopologicalMapping()
 
 void Triangle2EdgeTopologicalMapping::init()
 {
-    // recheck models
-    bool modelsOk = true;
-    if (!fromModel)
+    if (!this->checkTopologyInputTypes()) // method will display error message if false
     {
-        msg_error() << "Pointer to input topology is invalid.";
-        modelsOk = false;
+        this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
+        return; 
     }
 
-    if (!toModel)
-    {
-        msg_error() << "Pointer to output topology is invalid.";
-        modelsOk = false;
-    }
 
     toModel->getContext()->get(m_outTopoModifier);
     if (!m_outTopoModifier)
     {
         msg_error() << "No EdgeSetTopologyModifier found in the Edge topology Node.";
-        modelsOk = false;
-    }
-
-    if (!modelsOk)
-    {
         this->d_componentState.setValue(sofa::core::objectmodel::ComponentState::Invalid);
         return;
     }
diff --git a/examples/Components/constraint/BilateralInteractionConstraint.scn.view b/examples/Components/constraint/BilateralInteractionConstraint.scn.view
deleted file mode 100644
index 33267fe946d..00000000000
--- a/examples/Components/constraint/BilateralInteractionConstraint.scn.view
+++ /dev/null
@@ -1,2 +0,0 @@
-0.0290281 1.52398 -35.4868
--0.0102872 -0.693185 -0.011295 -0.720598