Salome HOME
PR: merged from V5_1_4rc1
[modules/smesh.git] / src / SMDS / SMDS_Mesh.hxx
index 8a68e9a1e87794a13e29c02984d64adf79a6b4da..d827ab18e8ea31720e77631f154c77a35c9e8320 100644 (file)
@@ -1,4 +1,4 @@
-//  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
+//  Copyright (C) 2007-2010  CEA/DEN, EDF R&D, OPEN CASCADE
 //
 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
 //
 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
 //
+
 //  SMESH SMDS : implementaion of Salome mesh data structure
 //  File   : SMDS_Mesh.hxx
 //  Module : SMESH
-
+//
 #ifndef _SMDS_Mesh_HeaderFile
 #define _SMDS_Mesh_HeaderFile
 
 #include "SMESH_SMDS.hxx"
 
 #include "SMDS_MeshNode.hxx"
+#include "SMDS_MeshCell.hxx"
 #include "SMDS_Mesh0DElement.hxx"
 #include "SMDS_MeshEdge.hxx"
 #include "SMDS_MeshFace.hxx"
 #include "SMDS_MeshElementIDFactory.hxx"
 #include "SMDS_MeshInfo.hxx"
 #include "SMDS_ElemIterator.hxx"
+#include "SMDS_VolumeOfNodes.hxx"
+#include "SMDS_VtkEdge.hxx"
+#include "SMDS_VtkFace.hxx"
+#include "SMDS_VtkVolume.hxx"
+#include "ObjectPool.hxx"
+#include "SMDS_UnstructuredGrid.hxx"
 
 #include <boost/shared_ptr.hpp>
 #include <set>
 #include <vector>
 #include <vtkSystemIncludes.h>
 
-class vtkUnstructuredGrid;
+#include "Utils_SALOME_Exception.hxx"
+#define MYASSERT(val) if (!(val)) throw SALOME_Exception(LOCALIZED("assertion not verified"));
 
 class SMDS_EXPORT SMDS_Mesh:public SMDS_MeshObject{
 public:
-
-  static std::vector<SMDS_Mesh*> _meshList;    // --- to find the SMDS_mesh from its elements
+  friend class SMDS_MeshElementIDFactory;
+  friend class SMDS_MeshVolumeVtkNodes;
 
   SMDS_Mesh();
+  
+  //! to retreive this SMDS_Mesh instance from its elements (index stored in SMDS_Elements)
+  static std::vector<SMDS_Mesh*> _meshList;
 
+  //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
   inline vtkUnstructuredGrid* getGrid() {return myGrid; };
+  inline int getMeshId() {return myMeshId; };
 
-  SMDS_NodeIteratorPtr nodesIterator() const;
+  SMDS_NodeIteratorPtr nodesIterator(bool idInceasingOrder=false) const;
   SMDS_0DElementIteratorPtr elements0dIterator() const;
   SMDS_EdgeIteratorPtr edgesIterator() const;
   SMDS_FaceIteratorPtr facesIterator() const;
@@ -75,40 +89,40 @@ public:
 
   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int ID);
   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
-                                      const SMDS_MeshNode * n2,
-                                      int ID);
+                                       const SMDS_MeshNode * n2,
+                                       int ID);
   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
-                                const SMDS_MeshNode * n2);
+                                 const SMDS_MeshNode * n2);
 
   // 2d order edge with 3 nodes: n12 - node between n1 and n2
   virtual SMDS_MeshEdge* AddEdgeWithID(int n1, int n2, int n12, int ID);
   virtual SMDS_MeshEdge* AddEdgeWithID(const SMDS_MeshNode * n1,
-                                      const SMDS_MeshNode * n2,
-                                      const SMDS_MeshNode * n12,
-                                      int ID);
+                                       const SMDS_MeshNode * n2,
+                                       const SMDS_MeshNode * n12,
+                                       int ID);
   virtual SMDS_MeshEdge* AddEdge(const SMDS_MeshNode * n1,
                                  const SMDS_MeshNode * n2,
                                  const SMDS_MeshNode * n12);
 
   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
-                                      const SMDS_MeshNode * n2,
-                                      const SMDS_MeshNode * n3,
-                                      int ID);
+                                       const SMDS_MeshNode * n2,
+                                       const SMDS_MeshNode * n3,
+                                       int ID);
   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
-                                const SMDS_MeshNode * n2,
-                                const SMDS_MeshNode * n3);
+                                 const SMDS_MeshNode * n2,
+                                 const SMDS_MeshNode * n3);
 
   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4, int ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
-                                      const SMDS_MeshNode * n2,
-                                      const SMDS_MeshNode * n3,
-                                      const SMDS_MeshNode * n4,
-                                      int ID);
+                                       const SMDS_MeshNode * n2,
+                                       const SMDS_MeshNode * n3,
+                                       const SMDS_MeshNode * n4,
+                                       int ID);
   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
-                                const SMDS_MeshNode * n2,
-                                const SMDS_MeshNode * n3,
-                                const SMDS_MeshNode * n4);
+                                 const SMDS_MeshNode * n2,
+                                 const SMDS_MeshNode * n3,
+                                 const SMDS_MeshNode * n4);
 
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshEdge * e1,
                                        const SMDS_MeshEdge * e2,
@@ -130,100 +144,100 @@ public:
   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3,
                                        int n12,int n23,int n31, int ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
-                                      const SMDS_MeshNode * n2,
-                                      const SMDS_MeshNode * n3,
-                                      const SMDS_MeshNode * n12,
-                                      const SMDS_MeshNode * n23,
-                                      const SMDS_MeshNode * n31,
-                                      int ID);
+                                       const SMDS_MeshNode * n2,
+                                       const SMDS_MeshNode * n3,
+                                       const SMDS_MeshNode * n12,
+                                       const SMDS_MeshNode * n23,
+                                       const SMDS_MeshNode * n31,
+                                       int ID);
   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
-                                const SMDS_MeshNode * n2,
-                                const SMDS_MeshNode * n3,
+                                 const SMDS_MeshNode * n2,
+                                 const SMDS_MeshNode * n3,
                                  const SMDS_MeshNode * n12,
-                                const SMDS_MeshNode * n23,
-                                const SMDS_MeshNode * n31);
+                                 const SMDS_MeshNode * n23,
+                                 const SMDS_MeshNode * n31);
 
   // 2d order quadrangle
   virtual SMDS_MeshFace* AddFaceWithID(int n1, int n2, int n3, int n4,
                                        int n12,int n23,int n34,int n41, int ID);
   virtual SMDS_MeshFace* AddFaceWithID(const SMDS_MeshNode * n1,
-                                      const SMDS_MeshNode * n2,
-                                      const SMDS_MeshNode * n3,
-                                      const SMDS_MeshNode * n4,
-                                      const SMDS_MeshNode * n12,
-                                      const SMDS_MeshNode * n23,
-                                      const SMDS_MeshNode * n34,
-                                      const SMDS_MeshNode * n41,
-                                      int ID);
+                                       const SMDS_MeshNode * n2,
+                                       const SMDS_MeshNode * n3,
+                                       const SMDS_MeshNode * n4,
+                                       const SMDS_MeshNode * n12,
+                                       const SMDS_MeshNode * n23,
+                                       const SMDS_MeshNode * n34,
+                                       const SMDS_MeshNode * n41,
+                                       int ID);
   virtual SMDS_MeshFace* AddFace(const SMDS_MeshNode * n1,
-                                const SMDS_MeshNode * n2,
-                                const SMDS_MeshNode * n3,
-                                const SMDS_MeshNode * n4,
+                                 const SMDS_MeshNode * n2,
+                                 const SMDS_MeshNode * n3,
+                                 const SMDS_MeshNode * n4,
                                  const SMDS_MeshNode * n12,
-                                const SMDS_MeshNode * n23,
-                                const SMDS_MeshNode * n34,
-                                const SMDS_MeshNode * n41);
+                                 const SMDS_MeshNode * n23,
+                                 const SMDS_MeshNode * n34,
+                                 const SMDS_MeshNode * n41);
 
   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4, int ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
-                                          const SMDS_MeshNode * n2,
-                                          const SMDS_MeshNode * n3,
-                                          const SMDS_MeshNode * n4,
-                                          int ID);
+                                           const SMDS_MeshNode * n2,
+                                           const SMDS_MeshNode * n3,
+                                           const SMDS_MeshNode * n4,
+                                           int ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
-                                    const SMDS_MeshNode * n2,
-                                    const SMDS_MeshNode * n3,
-                                    const SMDS_MeshNode * n4);
+                                     const SMDS_MeshNode * n2,
+                                     const SMDS_MeshNode * n3,
+                                     const SMDS_MeshNode * n4);
 
   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
                                            int n5, int ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
-                                          const SMDS_MeshNode * n2,
-                                          const SMDS_MeshNode * n3,
-                                          const SMDS_MeshNode * n4,
-                                          const SMDS_MeshNode * n5,
-                                          int ID);
+                                           const SMDS_MeshNode * n2,
+                                           const SMDS_MeshNode * n3,
+                                           const SMDS_MeshNode * n4,
+                                           const SMDS_MeshNode * n5,
+                                           int ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
-                                    const SMDS_MeshNode * n2,
-                                    const SMDS_MeshNode * n3,
-                                    const SMDS_MeshNode * n4,
-                                    const SMDS_MeshNode * n5);
+                                     const SMDS_MeshNode * n2,
+                                     const SMDS_MeshNode * n3,
+                                     const SMDS_MeshNode * n4,
+                                     const SMDS_MeshNode * n5);
 
   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
                                            int n5, int n6, int ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
-                                          const SMDS_MeshNode * n2,
-                                          const SMDS_MeshNode * n3,
-                                          const SMDS_MeshNode * n4,
-                                          const SMDS_MeshNode * n5,
-                                          const SMDS_MeshNode * n6,
-                                          int ID);
+                                           const SMDS_MeshNode * n2,
+                                           const SMDS_MeshNode * n3,
+                                           const SMDS_MeshNode * n4,
+                                           const SMDS_MeshNode * n5,
+                                           const SMDS_MeshNode * n6,
+                                           int ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
-                                    const SMDS_MeshNode * n2,
-                                    const SMDS_MeshNode * n3,
-                                    const SMDS_MeshNode * n4,
-                                    const SMDS_MeshNode * n5,
-                                    const SMDS_MeshNode * n6);
+                                     const SMDS_MeshNode * n2,
+                                     const SMDS_MeshNode * n3,
+                                     const SMDS_MeshNode * n4,
+                                     const SMDS_MeshNode * n5,
+                                     const SMDS_MeshNode * n6);
 
   virtual SMDS_MeshVolume* AddVolumeWithID(int n1, int n2, int n3, int n4,
                                            int n5, int n6, int n7, int n8, int ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
-                                          const SMDS_MeshNode * n2,
-                                          const SMDS_MeshNode * n3,
-                                          const SMDS_MeshNode * n4,
-                                          const SMDS_MeshNode * n5,
-                                          const SMDS_MeshNode * n6,
-                                          const SMDS_MeshNode * n7,
-                                          const SMDS_MeshNode * n8,
-                                          int ID);
+                                           const SMDS_MeshNode * n2,
+                                           const SMDS_MeshNode * n3,
+                                           const SMDS_MeshNode * n4,
+                                           const SMDS_MeshNode * n5,
+                                           const SMDS_MeshNode * n6,
+                                           const SMDS_MeshNode * n7,
+                                           const SMDS_MeshNode * n8,
+                                           int ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
-                                    const SMDS_MeshNode * n2,
-                                    const SMDS_MeshNode * n3,
-                                    const SMDS_MeshNode * n4,
-                                    const SMDS_MeshNode * n5,
-                                    const SMDS_MeshNode * n6,
-                                    const SMDS_MeshNode * n7,
-                                    const SMDS_MeshNode * n8);
+                                     const SMDS_MeshNode * n2,
+                                     const SMDS_MeshNode * n3,
+                                     const SMDS_MeshNode * n4,
+                                     const SMDS_MeshNode * n5,
+                                     const SMDS_MeshNode * n6,
+                                     const SMDS_MeshNode * n7,
+                                     const SMDS_MeshNode * n8);
 
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshFace * f1,
                                            const SMDS_MeshFace * f2,
@@ -263,20 +277,20 @@ public:
                                            int n12,int n23,int n31,
                                            int n14,int n24,int n34, int ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
-                                          const SMDS_MeshNode * n2,
-                                          const SMDS_MeshNode * n3,
-                                          const SMDS_MeshNode * n4,
-                                          const SMDS_MeshNode * n12,
-                                          const SMDS_MeshNode * n23,
-                                          const SMDS_MeshNode * n31,
-                                          const SMDS_MeshNode * n14,
-                                          const SMDS_MeshNode * n24,
-                                          const SMDS_MeshNode * n34,
-                                          int ID);
+                                           const SMDS_MeshNode * n2,
+                                           const SMDS_MeshNode * n3,
+                                           const SMDS_MeshNode * n4,
+                                           const SMDS_MeshNode * n12,
+                                           const SMDS_MeshNode * n23,
+                                           const SMDS_MeshNode * n31,
+                                           const SMDS_MeshNode * n14,
+                                           const SMDS_MeshNode * n24,
+                                           const SMDS_MeshNode * n34,
+                                           int ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
-                                    const SMDS_MeshNode * n2,
-                                    const SMDS_MeshNode * n3,
-                                    const SMDS_MeshNode * n4,
+                                     const SMDS_MeshNode * n2,
+                                     const SMDS_MeshNode * n3,
+                                     const SMDS_MeshNode * n4,
                                      const SMDS_MeshNode * n12,
                                      const SMDS_MeshNode * n23,
                                      const SMDS_MeshNode * n31,
@@ -290,24 +304,24 @@ public:
                                            int n15,int n25,int n35,int n45,
                                            int ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
-                                          const SMDS_MeshNode * n2,
-                                          const SMDS_MeshNode * n3,
-                                          const SMDS_MeshNode * n4,
-                                          const SMDS_MeshNode * n5,
-                                          const SMDS_MeshNode * n12,
-                                          const SMDS_MeshNode * n23,
-                                          const SMDS_MeshNode * n34,
-                                          const SMDS_MeshNode * n41,
-                                          const SMDS_MeshNode * n15,
-                                          const SMDS_MeshNode * n25,
-                                          const SMDS_MeshNode * n35,
-                                          const SMDS_MeshNode * n45,
-                                          int ID);
+                                           const SMDS_MeshNode * n2,
+                                           const SMDS_MeshNode * n3,
+                                           const SMDS_MeshNode * n4,
+                                           const SMDS_MeshNode * n5,
+                                           const SMDS_MeshNode * n12,
+                                           const SMDS_MeshNode * n23,
+                                           const SMDS_MeshNode * n34,
+                                           const SMDS_MeshNode * n41,
+                                           const SMDS_MeshNode * n15,
+                                           const SMDS_MeshNode * n25,
+                                           const SMDS_MeshNode * n35,
+                                           const SMDS_MeshNode * n45,
+                                           int ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
-                                    const SMDS_MeshNode * n2,
-                                    const SMDS_MeshNode * n3,
-                                    const SMDS_MeshNode * n4,
-                                    const SMDS_MeshNode * n5,
+                                     const SMDS_MeshNode * n2,
+                                     const SMDS_MeshNode * n3,
+                                     const SMDS_MeshNode * n4,
+                                     const SMDS_MeshNode * n5,
                                      const SMDS_MeshNode * n12,
                                      const SMDS_MeshNode * n23,
                                      const SMDS_MeshNode * n34,
@@ -325,27 +339,27 @@ public:
                                            int n14,int n25,int n36,
                                            int ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
-                                          const SMDS_MeshNode * n2,
-                                          const SMDS_MeshNode * n3,
-                                          const SMDS_MeshNode * n4,
-                                          const SMDS_MeshNode * n5,
-                                          const SMDS_MeshNode * n6,
-                                          const SMDS_MeshNode * n12,
-                                          const SMDS_MeshNode * n23,
-                                          const SMDS_MeshNode * n31,
-                                          const SMDS_MeshNode * n45,
-                                          const SMDS_MeshNode * n56,
-                                          const SMDS_MeshNode * n64,
-                                          const SMDS_MeshNode * n14,
-                                          const SMDS_MeshNode * n25,
-                                          const SMDS_MeshNode * n36,
-                                          int ID);
+                                           const SMDS_MeshNode * n2,
+                                           const SMDS_MeshNode * n3,
+                                           const SMDS_MeshNode * n4,
+                                           const SMDS_MeshNode * n5,
+                                           const SMDS_MeshNode * n6,
+                                           const SMDS_MeshNode * n12,
+                                           const SMDS_MeshNode * n23,
+                                           const SMDS_MeshNode * n31,
+                                           const SMDS_MeshNode * n45,
+                                           const SMDS_MeshNode * n56,
+                                           const SMDS_MeshNode * n64,
+                                           const SMDS_MeshNode * n14,
+                                           const SMDS_MeshNode * n25,
+                                           const SMDS_MeshNode * n36,
+                                           int ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
-                                    const SMDS_MeshNode * n2,
-                                    const SMDS_MeshNode * n3,
-                                    const SMDS_MeshNode * n4,
-                                    const SMDS_MeshNode * n5,
-                                    const SMDS_MeshNode * n6,
+                                     const SMDS_MeshNode * n2,
+                                     const SMDS_MeshNode * n3,
+                                     const SMDS_MeshNode * n4,
+                                     const SMDS_MeshNode * n5,
+                                     const SMDS_MeshNode * n6,
                                      const SMDS_MeshNode * n12,
                                      const SMDS_MeshNode * n23,
                                      const SMDS_MeshNode * n31,
@@ -364,34 +378,34 @@ public:
                                            int n15,int n26,int n37,int n48,
                                            int ID);
   virtual SMDS_MeshVolume* AddVolumeWithID(const SMDS_MeshNode * n1,
-                                          const SMDS_MeshNode * n2,
-                                          const SMDS_MeshNode * n3,
-                                          const SMDS_MeshNode * n4,
-                                          const SMDS_MeshNode * n5,
-                                          const SMDS_MeshNode * n6,
-                                          const SMDS_MeshNode * n7,
-                                          const SMDS_MeshNode * n8,
-                                          const SMDS_MeshNode * n12,
-                                          const SMDS_MeshNode * n23,
-                                          const SMDS_MeshNode * n34,
-                                          const SMDS_MeshNode * n41,
-                                          const SMDS_MeshNode * n56,
-                                          const SMDS_MeshNode * n67,
-                                          const SMDS_MeshNode * n78,
-                                          const SMDS_MeshNode * n85,
-                                          const SMDS_MeshNode * n15,
-                                          const SMDS_MeshNode * n26,
-                                          const SMDS_MeshNode * n37,
-                                          const SMDS_MeshNode * n48,
-                                          int ID);
+                                           const SMDS_MeshNode * n2,
+                                           const SMDS_MeshNode * n3,
+                                           const SMDS_MeshNode * n4,
+                                           const SMDS_MeshNode * n5,
+                                           const SMDS_MeshNode * n6,
+                                           const SMDS_MeshNode * n7,
+                                           const SMDS_MeshNode * n8,
+                                           const SMDS_MeshNode * n12,
+                                           const SMDS_MeshNode * n23,
+                                           const SMDS_MeshNode * n34,
+                                           const SMDS_MeshNode * n41,
+                                           const SMDS_MeshNode * n56,
+                                           const SMDS_MeshNode * n67,
+                                           const SMDS_MeshNode * n78,
+                                           const SMDS_MeshNode * n85,
+                                           const SMDS_MeshNode * n15,
+                                           const SMDS_MeshNode * n26,
+                                           const SMDS_MeshNode * n37,
+                                           const SMDS_MeshNode * n48,
+                                           int ID);
   virtual SMDS_MeshVolume* AddVolume(const SMDS_MeshNode * n1,
-                                    const SMDS_MeshNode * n2,
-                                    const SMDS_MeshNode * n3,
-                                    const SMDS_MeshNode * n4,
-                                    const SMDS_MeshNode * n5,
-                                    const SMDS_MeshNode * n6,
-                                    const SMDS_MeshNode * n7,
-                                    const SMDS_MeshNode * n8,
+                                     const SMDS_MeshNode * n2,
+                                     const SMDS_MeshNode * n3,
+                                     const SMDS_MeshNode * n4,
+                                     const SMDS_MeshNode * n5,
+                                     const SMDS_MeshNode * n6,
+                                     const SMDS_MeshNode * n7,
+                                     const SMDS_MeshNode * n8,
                                      const SMDS_MeshNode * n12,
                                      const SMDS_MeshNode * n23,
                                      const SMDS_MeshNode * n34,
@@ -498,8 +512,11 @@ public:
                                        const SMDS_MeshNode *n7,
                                        const SMDS_MeshNode *n8);
 
-  const SMDS_MeshFace *FindFace(std::vector<int> nodes_ids) const;
-  static const SMDS_MeshFace* FindFace(std::vector<const SMDS_MeshNode *> nodes);
+  const SMDS_MeshFace *FindFace(const std::vector<int>& nodes_ids) const;
+  static const SMDS_MeshFace* FindFace(const std::vector<const SMDS_MeshNode *>& nodes);
+  static const SMDS_MeshElement* FindElement(const std::vector<const SMDS_MeshNode *>& nodes,
+                                             const SMDSAbs_ElementType                 type=SMDSAbs_All,
+                                             const bool                                noMedium=true);
 
   /*!
    * \brief Raise an exception if free memory (ram+swap) too low
@@ -549,39 +566,44 @@ public:
   typedef std::vector<SMDS_MeshCell *> SetOfCells;
 
   void updateNodeMinMax();
-  int fromVtkToSmds(int vtkid) { return myElementIDFactory->fromVtkToSmds(vtkid); };
+  inline int fromVtkToSmds(int vtkid) { MYASSERT(vtkid>=0); return myVtkIndex[vtkid]; };
+  inline int fromSmdsToVtk(int smdsid) { MYASSERT(smdsid>=0); return myIDElements[smdsid]; };
 
-  int myCellLinksSize;
+  void incrementNodesCapacity(int nbNodes);
+  void incrementCellsCapacity(int nbCells);
+  void adjustStructure();
+  void dumpGrid(string ficdump="dumpGrid");
 
   static int chunkSize;
 
-private:
+protected:
   SMDS_Mesh(SMDS_Mesh * parent);
 
   SMDS_MeshFace * createTriangle(const SMDS_MeshNode * node1,
-                                const SMDS_MeshNode * node2,
-                                const SMDS_MeshNode * node3);
+                                 const SMDS_MeshNode * node2,
+                                 const SMDS_MeshNode * node3,
+                                 int ID);
   SMDS_MeshFace * createQuadrangle(const SMDS_MeshNode * node1,
-                                  const SMDS_MeshNode * node2,
-                                  const SMDS_MeshNode * node3,
-                                  const SMDS_MeshNode * node4,
+                                   const SMDS_MeshNode * node2,
+                                   const SMDS_MeshNode * node3,
+                                   const SMDS_MeshNode * node4,
                                    int ID);
 //  SMDS_Mesh0DElement* Find0DElementOrCreate(const SMDS_MeshNode * n);
   SMDS_MeshEdge* FindEdgeOrCreate(const SMDS_MeshNode * n1,
-                                 const SMDS_MeshNode * n2);
+                                  const SMDS_MeshNode * n2);
   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
-                                 const SMDS_MeshNode *n2,
-                                 const SMDS_MeshNode *n3);
+                                  const SMDS_MeshNode *n2,
+                                  const SMDS_MeshNode *n3);
   SMDS_MeshFace* FindFaceOrCreate(const SMDS_MeshNode *n1,
-                                 const SMDS_MeshNode *n2,
-                                 const SMDS_MeshNode *n3,
-                                 const SMDS_MeshNode *n4);
+                                  const SMDS_MeshNode *n2,
+                                  const SMDS_MeshNode *n3,
+                                  const SMDS_MeshNode *n4);
 
   bool registerElement(int ID, SMDS_MeshElement * element);
 
   void addChildrenWithNodes(std::set<const SMDS_MeshElement*>& setOfChildren,
-                           const SMDS_MeshElement * element,
-                           std::set<const SMDS_MeshElement*>& nodes);
+                            const SMDS_MeshElement * element,
+                            std::set<const SMDS_MeshElement*>& nodes);
 
   inline void adjustmyCellsCapacity(int ID)
   {
@@ -592,17 +614,31 @@ private:
 
   // Fields PRIVATE
 
-  int myMeshId;                           // --- index for this mesh in the vector
-  vtkUnstructuredGrid*      myGrid;
+  //! index of this SMDS_mesh in the static vector<SMDS_Mesh*> _meshList
+  int myMeshId;
+
+  //! actual nodes coordinates, cells definition and reverse connectivity are stored in a vtkUnstructuredGrid
+  SMDS_UnstructuredGrid*      myGrid;
 
+  //! Small objects like SMDS_MeshNode are allocated by chunks to limit memory costs of new
+  ObjectPool<SMDS_MeshNode>* myNodePool;
 
+  //! Small objects like SMDS_VtkVolume are allocated by chunks to limit memory costs of new
+  ObjectPool<SMDS_VtkVolume>* myVolumePool;
+  ObjectPool<SMDS_VtkFace>* myFacePool;
+  ObjectPool<SMDS_VtkEdge>* myEdgePool;
+
+  //! SMDS_MeshNodes refer to vtk nodes (vtk id = index in myNodes),store reference to this mesh, and subshape
   SetOfNodes             myNodes;
+
+  //! SMDS_MeshCells refer to vtk cells (vtk id != index in myCells),store reference to this mesh, and subshape
   SetOfCells             myCells;
 
-//   SetOf0DElements        my0DElements;
-//   SetOfEdges             myEdges;
-//   SetOfFaces             myFaces;
-//   SetOfVolumes           myVolumes;
+  //! for cells only: index = ID for SMDS users, value = ID in vtkUnstructuredGrid
+  std::vector<int>       myIDElements;
+
+  //! for cells only: index = ID in vtkUnstructuredGrid, value = ID for SMDS users
+  std::vector<int>       myVtkIndex;
 
   SMDS_Mesh *            myParent;
   std::list<SMDS_Mesh *> myChildren;