X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMDS%2FSMDS_Mesh.cxx;h=ffb2926b9016757bfdf694052d5c2c00f21899bf;hp=da6ecd8a30806db6660e9c689a800b0f95157053;hb=21af9b3a2c317f5693f228cd8ed55c2bb44b0a07;hpb=05ee6999b7acbf3d5fac0054fe38751b2200f73d

diff --git a/src/SMDS/SMDS_Mesh.cxx b/src/SMDS/SMDS_Mesh.cxx
index da6ecd8a3..ffb2926b9 100644
--- a/src/SMDS/SMDS_Mesh.cxx
+++ b/src/SMDS/SMDS_Mesh.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2013  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2016  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
@@ -6,7 +6,7 @@
 // This library is free software; you can redistribute it and/or
 // modify it under the terms of the GNU Lesser General Public
 // License as published by the Free Software Foundation; either
-// version 2.1 of the License.
+// version 2.1 of the License, or (at your option) any later version.
 //
 // This library is distributed in the hope that it will be useful,
 // but WITHOUT ANY WARRANTY; without even the implied warranty of
@@ -56,7 +56,7 @@
 #include <iterator>
 using namespace std;
 
-#ifndef WIN32
+#if !defined WIN32 && !defined __APPLE__
 #include <sys/sysinfo.h>
 #endif
 
@@ -77,7 +77,7 @@ int SMDS_Mesh::chunkSize = 1024;
 
 int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc)
 {
-#ifndef WIN32
+#if !defined WIN32 && !defined __APPLE__
   struct sysinfo si;
   int err = sysinfo( &si );
   if ( err )
@@ -124,25 +124,17 @@ int SMDS_Mesh::CheckMemory(const bool doNotRaise) throw (std::bad_alloc)
 ///////////////////////////////////////////////////////////////////////////////
 /// Create a new mesh object
 ///////////////////////////////////////////////////////////////////////////////
-SMDS_Mesh::SMDS_Mesh()
-        :myParent(NULL),
-         myNodeIDFactory(new SMDS_MeshNodeIDFactory()),
-         myElementIDFactory(new SMDS_MeshElementIDFactory()),
-         myHasConstructionEdges(false), myHasConstructionFaces(false),
-         myHasInverseElements(true),
-         myNodeMin(0), myNodeMax(0),
-         myNodePool(0), myEdgePool(0), myFacePool(0), myVolumePool(0),myBallPool(0),
-         myModified(false), myModifTime(0), myCompactTime(0),
-         xmin(0), xmax(0), ymin(0), ymax(0), zmin(0), zmax(0)
+SMDS_Mesh::SMDS_Mesh():
+  myNodePool(0), myVolumePool(0), myFacePool(0), myEdgePool(0), myBallPool(0),
+  myParent(NULL),
+  myNodeIDFactory(new SMDS_MeshNodeIDFactory()),
+  myElementIDFactory(new SMDS_MeshElementIDFactory()),
+  myModified(false), myModifTime(0), myCompactTime(0),
+  myHasConstructionEdges(false), myHasConstructionFaces(false),
+  myHasInverseElements(true),
+  xmin(0), xmax(0), ymin(0), ymax(0), zmin(0), zmax(0)
 {
   myMeshId = _meshList.size();         // --- index of the mesh to push back in the vector
-  MESSAGE("myMeshId=" << myMeshId);
-  MESSAGE("sizeof(SMDS_MeshElement) " << sizeof(SMDS_MeshElement) );
-  MESSAGE("sizeof(SMDS_MeshNode) " << sizeof(SMDS_MeshNode) );
-  MESSAGE("sizeof(SMDS_MeshCell) " << sizeof(SMDS_MeshCell) );
-  MESSAGE("sizeof(SMDS_VtkVolume) " << sizeof(SMDS_VtkVolume) );
-  MESSAGE("sizeof(SMDS_Position) " << sizeof(SMDS_Position) );
-  MESSAGE("sizeof(SMDS_SpacePosition) " << sizeof(SMDS_SpacePosition) );
   myNodeIDFactory->SetMesh(this);
   myElementIDFactory->SetMesh(this);
   _meshList.push_back(this);
@@ -167,8 +159,19 @@ SMDS_Mesh::SMDS_Mesh()
   points->SetNumberOfPoints(0 /*SMDS_Mesh::chunkSize*/);
   myGrid->SetPoints( points );
   points->Delete();
-  myGrid->BuildLinks();
+  //myGrid->BuildLinks();
   this->Modified();
+
+  // initialize static maps in SMDS_MeshCell, to be thread-safe
+  if ( myMeshId == 0 )
+  {
+    SMDS_MeshCell::toVtkType( SMDSEntity_Node );
+    SMDS_MeshCell::toVtkOrder( SMDSEntity_Node );
+    SMDS_MeshCell::reverseSmdsOrder( SMDSEntity_Node );
+    SMDS_MeshCell::interlacedSmdsOrder( SMDSEntity_Node );
+    SMDS_MeshCell::toSmdsType( VTK_VERTEX );
+    SMDS_MeshCell::fromVtkOrder( SMDSEntity_Node );
+  }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -176,16 +179,16 @@ SMDS_Mesh::SMDS_Mesh()
 /// Note that the tree structure of SMDS_Mesh seems to be unused in this version
 /// (2003-09-08) of SMESH
 ///////////////////////////////////////////////////////////////////////////////
-SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent)
-        :myParent(parent), myNodeIDFactory(parent->myNodeIDFactory),
-         myElementIDFactory(parent->myElementIDFactory),
-         myHasConstructionEdges(false), myHasConstructionFaces(false),
-         myHasInverseElements(true),
-         myNodePool(parent->myNodePool),
-         myEdgePool(parent->myEdgePool),
-         myFacePool(parent->myFacePool),
-         myVolumePool(parent->myVolumePool),
-         myBallPool(parent->myBallPool)
+SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent):
+  myNodePool(parent->myNodePool),
+  myVolumePool(parent->myVolumePool),
+  myFacePool(parent->myFacePool),
+  myEdgePool(parent->myEdgePool),
+  myBallPool(parent->myBallPool),
+  myParent(parent), myNodeIDFactory(parent->myNodeIDFactory),
+  myElementIDFactory(parent->myElementIDFactory),
+  myHasConstructionEdges(false), myHasConstructionFaces(false),
+  myHasInverseElements(true)
 {
 }
 
@@ -195,9 +198,9 @@ SMDS_Mesh::SMDS_Mesh(SMDS_Mesh * parent)
 
 SMDS_Mesh *SMDS_Mesh::AddSubMesh()
 {
-        SMDS_Mesh *submesh = new SMDS_Mesh(this);
-        myChildren.insert(myChildren.end(), submesh);
-        return submesh;
+  SMDS_Mesh *submesh = new SMDS_Mesh(this);
+  myChildren.insert(myChildren.end(), submesh);
+  return submesh;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -230,7 +233,7 @@ SMDS_MeshNode * SMDS_Mesh::AddNodeWithID(double x, double y, double z, int ID)
     SMDS_MeshNode * node = myNodePool->getNew();
     node->init(ID, myMeshId, 0, x, y, z);
 
-    if (ID >= myNodes.size())
+    if (ID >= (int)myNodes.size())
     {
         myNodes.resize(ID+SMDS_Mesh::chunkSize, 0);
 //         MESSAGE(" ------------------ myNodes resize " << ID << " --> " << ID+SMDS_Mesh::chunkSize);
@@ -329,11 +332,11 @@ SMDS_BallElement* SMDS_Mesh::AddBallWithID(const SMDS_MeshNode * n, double diame
   SMDS_BallElement *ball = myBallPool->getNew();
   ball->init(n->getVtkId(), diameter, this);
   if (!this->registerElement(ID,ball))
-    {
-      this->myGrid->GetCellTypesArray()->SetValue(ball->getVtkId(), VTK_EMPTY_CELL);
-      myBallPool->destroy(ball);
-      return 0;
-    }
+  {
+    this->myGrid->GetCellTypesArray()->SetValue(ball->getVtkId(), VTK_EMPTY_CELL);
+    myBallPool->destroy(ball);
+    return 0;
+  }
   adjustmyCellsCapacity(ID);
   myCells[ID] = ball;
   myInfo.myNbBalls++;
@@ -532,7 +535,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1,
   if ( !e1 || !e2 || !e3 ) return 0;
 
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
-  MESSAGE("AddFaceWithID" << ID);
 
   SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3);
   adjustmyCellsCapacity(ID);
@@ -559,7 +561,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshEdge * e1,
 {
   if (!hasConstructionEdges())
     return NULL;
-     //MESSAGE("AddFaceWithID" );
  return AddFaceWithID(e1,e2,e3,e4, myElementIDFactory->GetFreeID());
 }
 
@@ -575,7 +576,6 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshEdge * e1,
 {
   if (!hasConstructionEdges())
     return NULL;
-  MESSAGE("AddFaceWithID" << ID);
   if ( !e1 || !e2 || !e3 || !e4 ) return 0;
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   SMDS_MeshFace * face = new SMDS_FaceOfEdges(e1,e2,e3,e4);
@@ -603,7 +603,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                       const SMDS_MeshNode * n4)
 {
   int ID = myElementIDFactory->GetFreeID();
-    //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
   if(v==NULL) myElementIDFactory->ReleaseID(ID);
   return v;
@@ -622,7 +621,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
                                              int idnode4,
                                              int ID)
 {
-    //MESSAGE("AddVolumeWithID" << ID);
   SMDS_MeshNode *node1, *node2, *node3, *node4;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
@@ -644,7 +642,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n4,
                                             int ID)
 {
-    //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@@ -659,36 +656,34 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     myInfo.myNbTetras++;
   }
   else if(hasConstructionEdges()) {
-    MESSAGE("Error : Not implemented");
     return NULL;
   }
   else {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(n1->getVtkId());
-    nodeIds.push_back(n3->getVtkId()); // order SMDS-->VTK
-    nodeIds.push_back(n2->getVtkId());
-    nodeIds.push_back(n4->getVtkId());
+    myNodeIds.resize(4);
+    myNodeIds[0] = n1->getVtkId();
+    myNodeIds[1] = n3->getVtkId(); // order SMDS-->VTK
+    myNodeIds[2] = n2->getVtkId();
+    myNodeIds[3] = n4->getVtkId();
 
     SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-    volvtk->init(nodeIds, this);
+    volvtk->init(myNodeIds, this);
     if (!this->registerElement(ID,volvtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-        myVolumePool->destroy(volvtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+      myVolumePool->destroy(volvtk);
+      return 0;
+    }
     volume = volvtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = volume;
     myInfo.myNbTetras++;
   }
 
-//  if (!registerElement(ID, volume)) {
-//    RemoveElement(volume, false);
-//    volume = NULL;
-//  }
+  //  if (!registerElement(ID, volume)) {
+  //    RemoveElement(volume, false);
+  //    volume = NULL;
+  //  }
   return volume;
 }
 
@@ -705,7 +700,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                       const SMDS_MeshNode * n5)
 {
   int ID = myElementIDFactory->GetFreeID();
-    //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
   if(v==NULL) myElementIDFactory->ReleaseID(ID);
   return v;
@@ -726,7 +720,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
                                              int idnode5,
                                              int ID)
 {
-    //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshNode *node1, *node2, *node3, *node4, *node5;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
@@ -751,7 +744,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n5,
                                             int ID)
 {
-    //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@@ -766,37 +758,35 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     myInfo.myNbPyramids++;
   }
   else if(hasConstructionEdges()) {
-    MESSAGE("Error : Not implemented");
     return NULL;
   }
   else {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(n1->getVtkId());
-    nodeIds.push_back(n4->getVtkId());
-    nodeIds.push_back(n3->getVtkId());
-    nodeIds.push_back(n2->getVtkId());
-    nodeIds.push_back(n5->getVtkId());
+    myNodeIds.resize(5);
+    myNodeIds[0] = n1->getVtkId();
+    myNodeIds[1] = n4->getVtkId();
+    myNodeIds[2] = n3->getVtkId();
+    myNodeIds[3] = n2->getVtkId();
+    myNodeIds[4] = n5->getVtkId();
 
     SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-    volvtk->init(nodeIds, this);
+    volvtk->init(myNodeIds, this);
     if (!this->registerElement(ID,volvtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-        myVolumePool->destroy(volvtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+      myVolumePool->destroy(volvtk);
+      return 0;
+    }
     volume = volvtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = volume;
     myInfo.myNbPyramids++;
   }
 
-//  if (!registerElement(ID, volume)) {
-//    RemoveElement(volume, false);
-//    volume = NULL;
-//  }
+  //  if (!registerElement(ID, volume)) {
+  //    RemoveElement(volume, false);
+  //    volume = NULL;
+  //  }
   return volume;
 }
 
@@ -814,7 +804,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                       const SMDS_MeshNode * n6)
 {
   int ID = myElementIDFactory->GetFreeID();
-    //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshVolume * v = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
   if(v==NULL) myElementIDFactory->ReleaseID(ID);
   return v;
@@ -836,7 +825,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
                                              int idnode6,
                                              int ID)
 {
-    //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
@@ -863,7 +851,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n6,
                                             int ID)
 {
-    //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@@ -879,38 +866,36 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     myInfo.myNbPrisms++;
   }
   else if(hasConstructionEdges()) {
-    MESSAGE("Error : Not implemented");
     return NULL;
   }
   else {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(n1->getVtkId());
-    nodeIds.push_back(n2->getVtkId());
-    nodeIds.push_back(n3->getVtkId());
-    nodeIds.push_back(n4->getVtkId());
-    nodeIds.push_back(n5->getVtkId());
-    nodeIds.push_back(n6->getVtkId());
+    myNodeIds.resize(6);
+    myNodeIds[0] = n1->getVtkId();
+    myNodeIds[1] = n2->getVtkId();
+    myNodeIds[2] = n3->getVtkId();
+    myNodeIds[3] = n4->getVtkId();
+    myNodeIds[4] = n5->getVtkId();
+    myNodeIds[5] = n6->getVtkId();
 
     SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-    volvtk->init(nodeIds, this);
+    volvtk->init(myNodeIds, this);
     if (!this->registerElement(ID,volvtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-        myVolumePool->destroy(volvtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+      myVolumePool->destroy(volvtk);
+      return 0;
+    }
     volume = volvtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = volume;
     myInfo.myNbPrisms++;
   }
 
-//  if (!registerElement(ID, volume)) {
-//    RemoveElement(volume, false);
-//    volume = NULL;
-//  }
+  //  if (!registerElement(ID, volume)) {
+  //    RemoveElement(volume, false);
+  //    volume = NULL;
+  //  }
   return volume;
 }
 
@@ -1004,38 +989,36 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if(hasConstructionFaces()) {
-    MESSAGE("Error : Not implemented");
     return NULL;
   }
   else if(hasConstructionEdges()) {
-    MESSAGE("Error : Not implemented");
     return NULL;
   }
   else {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.push_back(n1->getVtkId());
-    nodeIds.push_back(n6->getVtkId());
-    nodeIds.push_back(n5->getVtkId());
-    nodeIds.push_back(n4->getVtkId());
-    nodeIds.push_back(n3->getVtkId());
-    nodeIds.push_back(n2->getVtkId());
-
-    nodeIds.push_back(n7->getVtkId());
-    nodeIds.push_back(n12->getVtkId());
-    nodeIds.push_back(n11->getVtkId());
-    nodeIds.push_back(n10->getVtkId());
-    nodeIds.push_back(n9->getVtkId());
-    nodeIds.push_back(n8->getVtkId());
+    myNodeIds.resize(12);
+    myNodeIds[0] = n1->getVtkId();
+    myNodeIds[1] = n6->getVtkId();
+    myNodeIds[2] = n5->getVtkId();
+    myNodeIds[3] = n4->getVtkId();
+    myNodeIds[4] = n3->getVtkId();
+    myNodeIds[5] = n2->getVtkId();
+
+    myNodeIds[6] = n7->getVtkId();
+    myNodeIds[7] = n12->getVtkId();
+    myNodeIds[8] = n11->getVtkId();
+    myNodeIds[9] = n10->getVtkId();
+    myNodeIds[10] = n9->getVtkId();
+    myNodeIds[11] = n8->getVtkId();
 
     SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-    volvtk->init(nodeIds, this);
+    volvtk->init(myNodeIds, this);
     if (!this->registerElement(ID,volvtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-        myVolumePool->destroy(volvtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+      myVolumePool->destroy(volvtk);
+      return 0;
+    }
     volume = volvtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = volume;
@@ -1084,7 +1067,6 @@ SMDS_MeshVolume * SMDS_Mesh::AddVolumeWithID(int idnode1,
                                              int idnode8,
                                              int ID)
 {
-    //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshNode *node1, *node2, *node3, *node4, *node5, *node6, *node7, *node8;
   node1 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode1);
   node2 = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(idnode2);
@@ -1118,7 +1100,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n8,
                                             int ID)
 {
-    //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6 || !n7 || !n8) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@@ -1135,40 +1116,38 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     myInfo.myNbHexas++;
   }
   else if(hasConstructionEdges()) {
-    MESSAGE("Error : Not implemented");
     return NULL;
   }
   else {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(n1->getVtkId());
-    nodeIds.push_back(n4->getVtkId());
-    nodeIds.push_back(n3->getVtkId());
-    nodeIds.push_back(n2->getVtkId());
-    nodeIds.push_back(n5->getVtkId());
-    nodeIds.push_back(n8->getVtkId());
-    nodeIds.push_back(n7->getVtkId());
-    nodeIds.push_back(n6->getVtkId());
+    myNodeIds.resize(8);
+    myNodeIds[0] = n1->getVtkId();
+    myNodeIds[1] = n4->getVtkId();
+    myNodeIds[2] = n3->getVtkId();
+    myNodeIds[3] = n2->getVtkId();
+    myNodeIds[4] = n5->getVtkId();
+    myNodeIds[5] = n8->getVtkId();
+    myNodeIds[6] = n7->getVtkId();
+    myNodeIds[7] = n6->getVtkId();
 
     SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-    volvtk->init(nodeIds, this);
+    volvtk->init(myNodeIds, this);
     if (!this->registerElement(ID,volvtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-        myVolumePool->destroy(volvtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+      myVolumePool->destroy(volvtk);
+      return 0;
+    }
     volume = volvtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = volume;
     myInfo.myNbHexas++;
   }
- 
-//  if (!registerElement(ID, volume)) {
-//    RemoveElement(volume, false);
-//    volume = NULL;
-//  }
+
+  //  if (!registerElement(ID, volume)) {
+  //    RemoveElement(volume, false);
+  //    volume = NULL;
+  //  }
   return volume;
 }
 
@@ -1182,7 +1161,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
                                       const SMDS_MeshFace * f3,
                                       const SMDS_MeshFace * f4)
 {
-    //MESSAGE("AddVolumeWithID");
   if (!hasConstructionFaces())
     return NULL;
   return AddVolumeWithID(f1,f2,f3,f4, myElementIDFactory->GetFreeID());
@@ -1200,7 +1178,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
                                             const SMDS_MeshFace * f4,
                                             int ID)
 {
-  MESSAGE("AddVolumeWithID" << ID);
   if (!hasConstructionFaces())
     return NULL;
   if ( !f1 || !f2 || !f3 || !f4) return 0;
@@ -1229,7 +1206,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
                                       const SMDS_MeshFace * f4,
                                       const SMDS_MeshFace * f5)
 {
-     //MESSAGE("AddVolumeWithID");
  if (!hasConstructionFaces())
     return NULL;
   return AddVolumeWithID(f1,f2,f3,f4,f5, myElementIDFactory->GetFreeID());
@@ -1248,7 +1224,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
                                             const SMDS_MeshFace * f5,
                                             int ID)
 {
-  MESSAGE("AddVolumeWithID" << ID);
   if (!hasConstructionFaces())
     return NULL;
   if ( !f1 || !f2 || !f3 || !f4 || !f5) return 0;
@@ -1278,7 +1253,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolume(const SMDS_MeshFace * f1,
                                       const SMDS_MeshFace * f5,
                                       const SMDS_MeshFace * f6)
 {
-     //MESSAGE("AddVolumeWithID" );
  if (!hasConstructionFaces())
     return NULL;
   return AddVolumeWithID(f1,f2,f3,f4,f5,f6, myElementIDFactory->GetFreeID());
@@ -1298,7 +1272,6 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshFace * f1,
                                             const SMDS_MeshFace * f6,
                                             int ID)
 {
-  MESSAGE("AddVolumeWithID" << ID);
   if (!hasConstructionFaces())
     return NULL;
   if ( !f1 || !f2 || !f3 || !f4 || !f5 || !f6) return 0;
@@ -1336,57 +1309,39 @@ SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID (const vector<int> & nodes_ids,
 /// Add a polygon defined by its nodes
 ///////////////////////////////////////////////////////////////////////////////
 
-SMDS_MeshFace* SMDS_Mesh::AddPolygonalFaceWithID
-                          (const vector<const SMDS_MeshNode*> & nodes,
-                           const int                            ID)
+SMDS_MeshFace*
+SMDS_Mesh::AddPolygonalFaceWithID (const vector<const SMDS_MeshNode*> & nodes,
+                                   const int                            ID)
 {
   SMDS_MeshFace * face;
 
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if (hasConstructionEdges())
-    {
-      MESSAGE("Error : Not implemented");
-      return NULL;
-    }
+  {
+    return NULL;
+  }
   else
-    {
-//#ifdef VTK_HAVE_POLYHEDRON
-    //MESSAGE("AddPolygonalFaceWithID vtk " << ID);
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    vector<const SMDS_MeshNode*>::const_iterator it = nodes.begin();
-    for ( ; it != nodes.end(); ++it)
-      nodeIds.push_back((*it)->getVtkId());
+  {
+    myNodeIds.resize( nodes.size() );
+    for ( size_t i = 0; i < nodes.size(); ++i )
+      myNodeIds[i] = nodes[i]->getVtkId();
 
     SMDS_VtkFace *facevtk = myFacePool->getNew();
-    facevtk->initPoly(nodeIds, this);
+    facevtk->initPoly(myNodeIds, this);
     if (!this->registerElement(ID,facevtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
-        myFacePool->destroy(facevtk);
-        return 0;
-      }
-    face = facevtk;
-//#else
-//    MESSAGE("AddPolygonalFaceWithID smds " << ID);
-//     for ( int i = 0; i < nodes.size(); ++i )
-//      if ( !nodes[ i ] ) return 0;
-//      face = new SMDS_PolygonalFaceOfNodes(nodes);
-//#endif
-      adjustmyCellsCapacity(ID);
-      myCells[ID] = face;
-      myInfo.myNbPolygons++;
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+      myFacePool->destroy(facevtk);
+      return 0;
     }
+    face = facevtk;
 
-//#ifndef VTK_HAVE_POLYHEDRON
-//  if (!registerElement(ID, face))
-//    {
-//      registerElement(myElementIDFactory->GetFreeID(), face);
-//      //RemoveElement(face, false);
-//      //face = NULL;
-//    }
-//#endif
- return face;
+    adjustmyCellsCapacity(ID);
+    myCells[ID] = face;
+    myInfo.myNbPolygons++;
+  }
+
+  return face;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1399,6 +1354,68 @@ SMDS_MeshFace* SMDS_Mesh::AddPolygonalFace (const vector<const SMDS_MeshNode*> &
   return SMDS_Mesh::AddPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID());
 }
 
+///////////////////////////////////////////////////////////////////////////////
+/// Add a quadratic polygon defined by its nodes IDs
+///////////////////////////////////////////////////////////////////////////////
+
+SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector<int> & nodes_ids,
+                                                      const int           ID)
+{
+  vector<const SMDS_MeshNode*> nodes( nodes_ids.size() );
+  for ( size_t i = 0; i < nodes.size(); i++) {
+    nodes[i] = (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nodes_ids[i]);
+    if (!nodes[i]) return NULL;
+  }
+  return SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, ID);
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// Add a quadratic polygon defined by its nodes
+///////////////////////////////////////////////////////////////////////////////
+
+SMDS_MeshFace*
+SMDS_Mesh::AddQuadPolygonalFaceWithID (const vector<const SMDS_MeshNode*> & nodes,
+                                       const int                            ID)
+{
+  SMDS_MeshFace * face;
+
+  if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
+  if (hasConstructionEdges())
+  {
+    return NULL;
+  }
+  else
+  {
+    myNodeIds.resize( nodes.size() );
+    for ( size_t i = 0; i < nodes.size(); ++i )
+      myNodeIds[i] = nodes[i]->getVtkId();
+
+    SMDS_VtkFace *facevtk = myFacePool->getNew();
+    facevtk->initQuadPoly(myNodeIds, this);
+    if (!this->registerElement(ID,facevtk))
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+      myFacePool->destroy(facevtk);
+      return 0;
+    }
+    face = facevtk;
+    adjustmyCellsCapacity(ID);
+    myCells[ID] = face;
+    myInfo.myNbQuadPolygons++;
+  }
+  return face;
+}
+
+///////////////////////////////////////////////////////////////////////////////
+/// Add a quadratic polygon defined by its nodes.
+/// An ID is automatically affected to the created face.
+///////////////////////////////////////////////////////////////////////////////
+
+SMDS_MeshFace* SMDS_Mesh::AddQuadPolygonalFace (const vector<const SMDS_MeshNode*> & nodes)
+{
+  return SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, myElementIDFactory->GetFreeID());
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 /// Create a new polyhedral volume and add it to the mesh.
 /// @param ID The ID of the new volume
@@ -1426,63 +1443,57 @@ SMDS_MeshVolume * SMDS_Mesh::AddPolyhedralVolumeWithID
 /// @return The created  volume
 ///////////////////////////////////////////////////////////////////////////////
 
-SMDS_MeshVolume* SMDS_Mesh::AddPolyhedralVolumeWithID
-                            (const vector<const SMDS_MeshNode*>& nodes,
-                             const vector<int>                 & quantities,
-                             const int                           ID)
+SMDS_MeshVolume*
+SMDS_Mesh::AddPolyhedralVolumeWithID (const vector<const SMDS_MeshNode*>& nodes,
+                                      const vector<int>                 & quantities,
+                                      const int                           ID)
 {
   SMDS_MeshVolume* volume = 0;
   if ( nodes.empty() || quantities.empty() )
     return NULL;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if (hasConstructionFaces())
-    {
-      MESSAGE("Error : Not implemented");
-      return NULL;
-    }
+  {
+    return NULL;
+  }
   else if (hasConstructionEdges())
-    {
-      MESSAGE("Error : Not implemented");
-      return NULL;
-    }
+  {
+    return NULL;
+  }
   else
+  {
+    //#ifdef VTK_HAVE_POLYHEDRON
+    myNodeIds.resize( nodes.size() );
+    for ( size_t i = 0; i < nodes.size(); ++i )
+      myNodeIds[i] = nodes[i]->getVtkId();
+
+    SMDS_VtkVolume *volvtk = myVolumePool->getNew();
+    volvtk->initPoly(myNodeIds, quantities, this);
+    if (!this->registerElement(ID, volvtk))
     {
-//#ifdef VTK_HAVE_POLYHEDRON
-      //MESSAGE("AddPolyhedralVolumeWithID vtk " << ID);
-      vector<vtkIdType> nodeIds;
-      nodeIds.clear();
-      vector<const SMDS_MeshNode*>::const_iterator it = nodes.begin();
-      for (; it != nodes.end(); ++it)
-        nodeIds.push_back((*it)->getVtkId());
-
-      SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-      volvtk->initPoly(nodeIds, quantities, this);
-      if (!this->registerElement(ID, volvtk))
-        {
-          this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-          myVolumePool->destroy(volvtk);
-          return 0;
-        }
-      volume = volvtk;
-//#else
-//      MESSAGE("AddPolyhedralVolumeWithID smds " << ID);
-//      for ( int i = 0; i < nodes.size(); ++i )
-//      if ( !nodes[ i ] ) return 0;
-//      volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities);
-//#endif
-      adjustmyCellsCapacity(ID);
-      myCells[ID] = volume;
-      myInfo.myNbPolyhedrons++;
+      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+      myVolumePool->destroy(volvtk);
+      return 0;
     }
+    volume = volvtk;
+    //#else
+    //      for ( int i = 0; i < nodes.size(); ++i )
+    //      if ( !nodes[ i ] ) return 0;
+    //      volume = new SMDS_PolyhedralVolumeOfNodes(nodes, quantities);
+    //#endif
+    adjustmyCellsCapacity(ID);
+    myCells[ID] = volume;
+    myInfo.myNbPolyhedrons++;
+  }
 
-//#ifndef VTK_HAVE_POLYHEDRON
-//  if (!registerElement(ID, volume))
-//    {
-//      registerElement(myElementIDFactory->GetFreeID(), volume);
-//      //RemoveElement(volume, false);
-//      //volume = NULL;
-//    }
-//#endif
+  //#ifndef VTK_HAVE_POLYHEDRON
+  //  if (!registerElement(ID, volume))
+  //    {
+  //      registerElement(myElementIDFactory->GetFreeID(), volume);
+  //      //RemoveElement(volume, false);
+  //      //volume = NULL;
+  //    }
+  //#endif
   return volume;
 }
 
@@ -1615,8 +1626,7 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceFromVtkIdsWithID(const std::vector<vtkIdType>&
 ///////////////////////////////////////////////////////////////////////////////
 bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
 {
-  //MESSAGE("registerElement " << ID);
-  if ((ID >=0) && (ID < myCells.size()) && myCells[ID]) // --- already bound
+  if ((ID >=0) && (ID < (int)myCells.size()) && myCells[ID]) // --- already bound
   {
     MESSAGE(" ------------------ already bound "<< ID << " " << myCells[ID]->getVtkId());
     return false;
@@ -1631,9 +1641,8 @@ bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
   if (vtkId == -1)
     vtkId = myElementIDFactory->SetInVtkGrid(element);
 
-  if (vtkId >= myCellIdVtkToSmds.size()) // --- resize local vector
+  if (vtkId >= (int)myCellIdVtkToSmds.size()) // --- resize local vector
   {
-//     MESSAGE(" --------------------- resize myCellIdVtkToSmds " << vtkId << " --> " << vtkId + SMDS_Mesh::chunkSize);
     myCellIdVtkToSmds.resize(vtkId + SMDS_Mesh::chunkSize, -1);
   }
   myCellIdVtkToSmds[vtkId] = ID;
@@ -1658,11 +1667,8 @@ void SMDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z)
 ///////////////////////////////////////////////////////////////////////////////
 const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
 {
-  if (ID < 1 || ID >= myNodes.size())
+  if (ID < 1 || ID >= (int)myNodes.size())
   {
-//     MESSAGE("------------------------------------------------------------------------- ");
-//     MESSAGE("----------------------------------- bad ID " << ID << " " << myNodes.size());
-//     MESSAGE("------------------------------------------------------------------------- ");
     return 0;
   }
   return (const SMDS_MeshNode *)myNodes[ID];
@@ -1674,7 +1680,7 @@ const SMDS_MeshNode * SMDS_Mesh::FindNode(int ID) const
 const SMDS_MeshNode * SMDS_Mesh::FindNodeVtk(int vtkId) const
 {
   // TODO if needed use mesh->nodeIdFromVtkToSmds
-  if (vtkId < 0 || vtkId >= (myNodes.size() -1))
+  if ( vtkId < 0 || vtkId+1 >= (int) myNodes.size() )
   {
     MESSAGE("------------------------------------------------------------------------- ");
     MESSAGE("---------------------------- bad VTK ID " << vtkId << " " << myNodes.size());
@@ -1712,25 +1718,23 @@ SMDS_MeshFace * SMDS_Mesh::createTriangle(const SMDS_MeshNode * node1,
   else
   {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(node1->getVtkId());
-    nodeIds.push_back(node2->getVtkId());
-    nodeIds.push_back(node3->getVtkId());
+    myNodeIds.resize(3);
+    myNodeIds[0] = node1->getVtkId();
+    myNodeIds[1] = node2->getVtkId();
+    myNodeIds[2] = node3->getVtkId();
 
     SMDS_MeshFace * face = 0;
     SMDS_VtkFace *facevtk = myFacePool->getNew();
-    facevtk->init(nodeIds, this); // put in vtkUnstructuredGrid
+    facevtk->init(myNodeIds, this); // put in vtkUnstructuredGrid
     if (!this->registerElement(ID,facevtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
-        myFacePool->destroy(facevtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+      myFacePool->destroy(facevtk);
+      return 0;
+    }
     face = facevtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = face;
-    //MESSAGE("createTriangle " << ID << " " << face);
     myInfo.myNbTriangles++;
     return face;
   }
@@ -1750,7 +1754,6 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if(hasConstructionEdges())
   {
-      //MESSAGE("createQuadrangle hasConstructionEdges "<< ID);
     SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
     edge1=FindEdgeOrCreate(node1,node2);
     edge2=FindEdgeOrCreate(node2,node3);
@@ -1766,22 +1769,21 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
   else
   {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(node1->getVtkId());
-    nodeIds.push_back(node2->getVtkId());
-    nodeIds.push_back(node3->getVtkId());
-    nodeIds.push_back(node4->getVtkId());
+    myNodeIds.resize(4);
+    myNodeIds[0] = node1->getVtkId();
+    myNodeIds[1] = node2->getVtkId();
+    myNodeIds[2] = node3->getVtkId();
+    myNodeIds[3] = node4->getVtkId();
 
     SMDS_MeshFace * face = 0;
     SMDS_VtkFace *facevtk = myFacePool->getNew();
-    facevtk->init(nodeIds, this);
+    facevtk->init(myNodeIds, this);
     if (!this->registerElement(ID,facevtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
-        myFacePool->destroy(facevtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+      myFacePool->destroy(facevtk);
+      return 0;
+    }
     face = facevtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = face;
@@ -1796,8 +1798,7 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
 
 void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
 {
-    MESSAGE("RemoveNode");
-        RemoveElement(node, true);
+  RemoveElement(node, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1806,7 +1807,6 @@ void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
 
 void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
 {
-    MESSAGE("Remove0DElement");
   RemoveElement(elem0d,true);
 }
 
@@ -1816,8 +1816,7 @@ void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
 
 void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
 {
-    MESSAGE("RemoveEdge");
-        RemoveElement(edge,true);
+  RemoveElement(edge,true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1826,8 +1825,7 @@ void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
 
 void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
 {
-    MESSAGE("RemoveFace");
-        RemoveElement(face, true);
+  RemoveElement(face, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1836,8 +1834,7 @@ void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
 
 void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
 {
-    MESSAGE("RemoveVolume");
-        RemoveElement(volume, true);
+  RemoveElement(volume, true);
 }
 
 //=======================================================================
@@ -1847,8 +1844,8 @@ void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
 
 bool SMDS_Mesh::RemoveFromParent()
 {
-        if (myParent==NULL) return false;
-        else return (myParent->RemoveSubMesh(this));
+  if (myParent==NULL) return false;
+  else return (myParent->RemoveSubMesh(this));
 }
 
 //=======================================================================
@@ -1858,20 +1855,20 @@ bool SMDS_Mesh::RemoveFromParent()
 
 bool SMDS_Mesh::RemoveSubMesh(const SMDS_Mesh * aMesh)
 {
-        bool found = false;
+  bool found = false;
 
-        list<SMDS_Mesh *>::iterator itmsh=myChildren.begin();
-        for (; itmsh!=myChildren.end() && !found; itmsh++)
-        {
-                SMDS_Mesh * submesh = *itmsh;
-                if (submesh == aMesh)
-                {
-                        found = true;
-                        myChildren.erase(itmsh);
-                }
-        }
+  list<SMDS_Mesh *>::iterator itmsh=myChildren.begin();
+  for (; itmsh!=myChildren.end() && !found; itmsh++)
+  {
+    SMDS_Mesh * submesh = *itmsh;
+    if (submesh == aMesh)
+    {
+      found = true;
+      myChildren.erase(itmsh);
+    }
+  }
 
-        return found;
+  return found;
 }
 
 //=======================================================================
@@ -1883,7 +1880,6 @@ bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element,
                                    const SMDS_MeshNode    * nodes[],
                                    const int                nbnodes)
 {
-  MESSAGE("SMDS_Mesh::ChangeElementNodes");
   // keep current nodes of elem
   set<const SMDS_MeshNode*> oldNodes( element->begin_nodes(), element->end_nodes() );
 
@@ -1891,10 +1887,10 @@ bool SMDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * element,
   bool Ok = false;
   SMDS_MeshCell* cell = dynamic_cast<SMDS_MeshCell*>((SMDS_MeshElement*) element);
   if (cell)
-    {
-      Ok = cell->vtkOrder(nodes, nbnodes);
-      Ok = cell->ChangeNodes(nodes, nbnodes);
-    }
+  {
+    Ok = cell->vtkOrder(nodes, nbnodes);
+    Ok = cell->ChangeNodes(nodes, nbnodes);
+  }
 
   if ( Ok ) { // update InverseElements
 
@@ -2101,19 +2097,18 @@ SMDS_MeshEdge* SMDS_Mesh::FindEdgeOrCreate(const SMDS_MeshNode * node1,
     if ( NbEdges() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
     int ID = myElementIDFactory->GetFreeID(); // -PR- voir si on range cet element
     adjustmyCellsCapacity(ID);
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(node1->getVtkId());
-    nodeIds.push_back(node2->getVtkId());
+    myNodeIds.resize(2);
+    myNodeIds[0] = node1->getVtkId();
+    myNodeIds[1] = node2->getVtkId();
 
     SMDS_VtkEdge *edgevtk = myEdgePool->getNew();
-    edgevtk->init(nodeIds, this);
+    edgevtk->init(myNodeIds, this);
     if (!this->registerElement(ID,edgevtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
-        myEdgePool->destroy(edgevtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
+      myEdgePool->destroy(edgevtk);
+      return 0;
+    }
     toReturn = edgevtk;
     myCells[ID] = toReturn;
     myInfo.myNbEdges++;
@@ -2396,13 +2391,8 @@ const SMDS_MeshFace* SMDS_Mesh::FindFace(const SMDS_MeshNode *node1,
 
 const SMDS_MeshElement* SMDS_Mesh::FindElement(int IDelem) const
 {
-  if ((IDelem <= 0) || IDelem >= myCells.size())
+  if ( IDelem <= 0 || IDelem >= (int)myCells.size() )
   {
-    MESSAGE("--------------------------------------------------------------------------------- ");
-    MESSAGE("----------------------------------- bad IDelem " << IDelem << " " << myCells.size());
-    MESSAGE("--------------------------------------------------------------------------------- ");
-    // TODO raise an exception
-    //assert(0);
     return 0;
   }
   return myCells[IDelem];
@@ -2452,9 +2442,9 @@ const SMDS_MeshElement* SMDS_Mesh::FindElement (const vector<const SMDS_MeshNode
     {
       const SMDS_MeshElement* e = itF->next();
       int nbNodesToCheck = noMedium ? e->NbCornerNodes() : e->NbNodes();
-      if ( nbNodesToCheck == nodes.size() )
+      if ( nbNodesToCheck == (int)nodes.size() )
       {
-        for ( int i = 1; e && i < nodes.size(); ++ i )
+        for ( size_t i = 1; e && i < nodes.size(); ++i )
         {
           int nodeIndex = e->GetNodeIndex( nodes[ i ]);
           if ( nodeIndex < 0 || nodeIndex >= nbNodesToCheck )
@@ -2475,9 +2465,8 @@ const SMDS_MeshElement* SMDS_Mesh::FindElement (const vector<const SMDS_MeshNode
 
 void SMDS_Mesh::DumpNodes() const
 {
-        MESSAGE("dump nodes of mesh : ");
-        SMDS_NodeIteratorPtr itnode=nodesIterator();
-        while(itnode->more()) ; //MESSAGE(itnode->next());
+  SMDS_NodeIteratorPtr itnode=nodesIterator();
+  while(itnode->more()) ; //MESSAGE(itnode->next());
 }
 
 //=======================================================================
@@ -2486,7 +2475,6 @@ void SMDS_Mesh::DumpNodes() const
 //=======================================================================
 void SMDS_Mesh::Dump0DElements() const
 {
-  MESSAGE("dump 0D elements of mesh : ");
   SMDS_ElemIteratorPtr it0d = elementsIterator(SMDSAbs_0DElement);
   while(it0d->more()) ; //MESSAGE(it0d->next());
 }
@@ -2498,9 +2486,8 @@ void SMDS_Mesh::Dump0DElements() const
 
 void SMDS_Mesh::DumpEdges() const
 {
-        MESSAGE("dump edges of mesh : ");
-        SMDS_EdgeIteratorPtr itedge=edgesIterator();
-        while(itedge->more()) ; //MESSAGE(itedge->next());
+  SMDS_EdgeIteratorPtr itedge=edgesIterator();
+  while(itedge->more()) ; //MESSAGE(itedge->next());
 }
 
 //=======================================================================
@@ -2510,9 +2497,8 @@ void SMDS_Mesh::DumpEdges() const
 
 void SMDS_Mesh::DumpFaces() const
 {
-        MESSAGE("dump faces of mesh : ");
-        SMDS_FaceIteratorPtr itface=facesIterator();
-        while(itface->more()) ; //MESSAGE(itface->next());
+  SMDS_FaceIteratorPtr itface=facesIterator();
+  while(itface->more()) ; //MESSAGE(itface->next());
 }
 
 //=======================================================================
@@ -2522,9 +2508,8 @@ void SMDS_Mesh::DumpFaces() const
 
 void SMDS_Mesh::DumpVolumes() const
 {
-        MESSAGE("dump volumes of mesh : ");
-        SMDS_VolumeIteratorPtr itvol=volumesIterator();
-        while(itvol->more()) ; //MESSAGE(itvol->next());
+  SMDS_VolumeIteratorPtr itvol=volumesIterator();
+  while(itvol->more()) ; //MESSAGE(itvol->next());
 }
 
 //=======================================================================
@@ -2582,12 +2567,16 @@ void SMDS_Mesh::DebugStats() const
 ///////////////////////////////////////////////////////////////////////////////
 int SMDS_Mesh::NbNodes() const
 {
-        //MESSAGE(myGrid->GetNumberOfPoints());
-        //MESSAGE(myInfo.NbNodes());
-        //MESSAGE(myNodeMax);
-    return myInfo.NbNodes();
+  return myInfo.NbNodes();
 }
 
+///////////////////////////////////////////////////////////////////////////////
+/// Return the number of elements
+///////////////////////////////////////////////////////////////////////////////
+int SMDS_Mesh::NbElements() const
+{
+  return myInfo.NbElements();
+}
 ///////////////////////////////////////////////////////////////////////////////
 /// Return the number of 0D elements
 ///////////////////////////////////////////////////////////////////////////////
@@ -2688,54 +2677,27 @@ SMDS_Mesh::~SMDS_Mesh()
 
 void SMDS_Mesh::Clear()
 {
-  MESSAGE("SMDS_Mesh::Clear");
   if (myParent!=NULL)
-    {
+  {
     SMDS_ElemIteratorPtr eIt = elementsIterator();
     while ( eIt->more() )
-      {
-        const SMDS_MeshElement *elem = eIt->next();
-        myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
-      }
+    {
+      const SMDS_MeshElement *elem = eIt->next();
+      myElementIDFactory->ReleaseID(elem->GetID(), elem->getVtkId());
+    }
     SMDS_NodeIteratorPtr itn = nodesIterator();
     while (itn->more())
-      {
-        const SMDS_MeshNode *node = itn->next();
-        myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
-      }
+    {
+      const SMDS_MeshNode *node = itn->next();
+      myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
     }
+  }
   else
-    {
+  {
     myNodeIDFactory->Clear();
     myElementIDFactory->Clear();
-    }
+  }
 
-  // SMDS_ElemIteratorPtr itv = elementsIterator();
-  // while (itv->more())
-  //   {
-  //     SMDS_MeshElement* elem = (SMDS_MeshElement*)(itv->next());
-  //     SMDSAbs_ElementType aType = elem->GetType();
-  //     switch (aType)
-  //     {
-  //       case SMDSAbs_0DElement:
-  //         delete elem;
-  //         break;
-  //       case SMDSAbs_Edge:
-  //          myEdgePool->destroy(static_cast<SMDS_VtkEdge*>(elem));
-  //         break;
-  //       case SMDSAbs_Face:
-  //         myFacePool->destroy(static_cast<SMDS_VtkFace*>(elem));
-  //         break;
-  //       case SMDSAbs_Volume:
-  //         myVolumePool->destroy(static_cast<SMDS_VtkVolume*>(elem));
-  //         break;
-  //       case SMDSAbs_Ball:
-  //         myBallPool->destroy(static_cast<SMDS_BallElement*>(elem));
-  //         break;
-  //       default:
-  //         break;
-  //     }
-  //   }
   myVolumePool->clear();
   myFacePool->clear();
   myEdgePool->clear();
@@ -2746,11 +2708,11 @@ void SMDS_Mesh::Clear()
 
   SMDS_NodeIteratorPtr itn = nodesIterator();
   while (itn->more())
-    {
-      SMDS_MeshNode *node = (SMDS_MeshNode*)(itn->next());
-      node->SetPosition(SMDS_SpacePosition::originSpacePosition());
-      //myNodePool->destroy(node);
-    }
+  {
+    SMDS_MeshNode *node = (SMDS_MeshNode*)(itn->next());
+    node->SetPosition(SMDS_SpacePosition::originSpacePosition());
+    //myNodePool->destroy(node);
+  }
   myNodePool->clear();
   clearVector( myNodes );
 
@@ -2772,10 +2734,10 @@ void SMDS_Mesh::Clear()
   // rnv: to fix bug "21125: EDF 1233 SMESH: Degrardation of precision in a test case for quadratic conversion"
   // using double type for storing coordinates of nodes instead float.
   points->SetDataType(VTK_DOUBLE);
-  points->SetNumberOfPoints(0 /*SMDS_Mesh::chunkSize*/);
+  points->SetNumberOfPoints( 0 );
   myGrid->SetPoints( points );
   points->Delete();
-  myGrid->BuildLinks();
+  myGrid->DeleteLinks();
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2785,7 +2747,7 @@ void SMDS_Mesh::Clear()
 ///////////////////////////////////////////////////////////////////////////////
 bool SMDS_Mesh::hasConstructionEdges()
 {
-        return myHasConstructionEdges;
+  return myHasConstructionEdges;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2797,7 +2759,7 @@ bool SMDS_Mesh::hasConstructionEdges()
 ///////////////////////////////////////////////////////////////////////////////
 bool SMDS_Mesh::hasConstructionFaces()
 {
-        return myHasConstructionFaces;
+  return myHasConstructionFaces;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2806,7 +2768,7 @@ bool SMDS_Mesh::hasConstructionFaces()
 ///////////////////////////////////////////////////////////////////////////////
 bool SMDS_Mesh::hasInverseElements()
 {
-        return myHasInverseElements;
+  return myHasInverseElements;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2815,7 +2777,7 @@ bool SMDS_Mesh::hasInverseElements()
 ///////////////////////////////////////////////////////////////////////////////
 void SMDS_Mesh::setConstructionEdges(bool b)
 {
-        myHasConstructionEdges=b;
+  myHasConstructionEdges=b;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2824,7 +2786,7 @@ void SMDS_Mesh::setConstructionEdges(bool b)
 ///////////////////////////////////////////////////////////////////////////////
 void SMDS_Mesh::setConstructionFaces(bool b)
 {
-         myHasConstructionFaces=b;
+  myHasConstructionFaces=b;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -2857,7 +2819,7 @@ namespace {
     IdSortedIterator(const SMDS_MeshElementIDFactory& fact,
                      const SMDSAbs_ElementType        type, // SMDSAbs_All NOT allowed!!! 
                      const int                        totalNb)
-      :myIDFact( fact ),
+      :myIDFact( const_cast<SMDS_MeshElementIDFactory&>(fact) ),
        myID(1), myMaxID( myIDFact.GetMaxID() ),myNbFound(0), myTotalNb( totalNb ),
        myType( type ),
        myElem(0)
@@ -2944,6 +2906,11 @@ SMDS_ElemIteratorPtr SMDS_Mesh::elementGeomIterator(SMDSAbs_GeometryType type) c
 
 SMDS_ElemIteratorPtr SMDS_Mesh::elementEntityIterator(SMDSAbs_EntityType type) const
 {
+  if ( type == SMDSEntity_Node )
+  {
+    typedef ElemVecIterator<const SMDS_MeshElement*, SMDS_MeshNode*> TIterator;
+    return SMDS_ElemIteratorPtr( new TIterator(myNodes));
+  }
   // naturally always sorted by ID
   typedef ElemVecIterator
     < const SMDS_MeshElement*, SMDS_MeshCell*, SMDS_MeshElement::EntityFilter > TIterator;
@@ -3042,61 +3009,57 @@ static set<const SMDS_MeshElement*> * intersectionOfSets(
 ///////////////////////////////////////////////////////////////////////////////
 static set<const SMDS_MeshElement*> * getFinitElements(const SMDS_MeshElement * element)
 {
-        int numberOfSets=element->NbNodes();
-        set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];
-
-        SMDS_ElemIteratorPtr itNodes=element->nodesIterator();
+  int numberOfSets=element->NbNodes();
+  set<const SMDS_MeshElement*> *initSet = new set<const SMDS_MeshElement*>[numberOfSets];
 
-        int i=0;
-        while(itNodes->more())
-        {
-          const SMDS_MeshElement* node = itNodes->next();
-          MYASSERT(node);
-                const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(node);
-                SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
+  SMDS_ElemIteratorPtr itNodes=element->nodesIterator();
 
-                //initSet[i]=set<const SMDS_MeshElement*>();
-                while(itFe->more())
-                {
-                  const SMDS_MeshElement* elem = itFe->next();
-                  MYASSERT(elem);
-                  initSet[i].insert(elem);
+  int i = 0;
+  while ( itNodes->more() )
+  {
+    const SMDS_MeshElement* node = itNodes->next();
+    MYASSERT(node);
+    const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(node);
+    SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
 
-                }
+    while ( itFe->more() )
+    {
+      const SMDS_MeshElement* elem = itFe->next();
+      MYASSERT(elem);
+      initSet[i].insert(elem);
+    }
 
-                i++;
-        }
-        set<const SMDS_MeshElement*> *retSet=intersectionOfSets(initSet, numberOfSets);
-//         MESSAGE("nb elems " << i << " intersection " << retSet->size());
-        delete [] initSet;
-        return retSet;
+    i++;
+  }
+  set<const SMDS_MeshElement*> *retSet = intersectionOfSets( initSet, numberOfSets );
+  delete [] initSet;
+  return retSet;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
 /// Return the list of nodes used only by the given elements
 ///////////////////////////////////////////////////////////////////////////////
-static set<const SMDS_MeshElement*> * getExclusiveNodes(
-        set<const SMDS_MeshElement*>& elements)
+static set<const SMDS_MeshElement*> * getExclusiveNodes(set<const SMDS_MeshElement*>& elements)
 {
-        set<const SMDS_MeshElement*> * toReturn=new set<const SMDS_MeshElement*>();
-        set<const SMDS_MeshElement*>::iterator itElements=elements.begin();
+  set<const SMDS_MeshElement*> * toReturn=new set<const SMDS_MeshElement*>();
+  set<const SMDS_MeshElement*>::iterator itElements=elements.begin();
 
-        while(itElements!=elements.end())
-        {
-                SMDS_ElemIteratorPtr itNodes = (*itElements)->nodesIterator();
-                itElements++;
-
-                while(itNodes->more())
-                {
-                        const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(itNodes->next());
-                        SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
-                        set<const SMDS_MeshElement*> s;
-                        while(itFe->more())
-                          s.insert(itFe->next());
-                        if(s==elements) toReturn->insert(n);
-                }
-        }
-        return toReturn;
+  while(itElements!=elements.end())
+  {
+    SMDS_ElemIteratorPtr itNodes = (*itElements)->nodesIterator();
+    itElements++;
+
+    while(itNodes->more())
+    {
+      const SMDS_MeshNode * n=static_cast<const SMDS_MeshNode*>(itNodes->next());
+      SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
+      set<const SMDS_MeshElement*> s;
+      while(itFe->more())
+        s.insert(itFe->next());
+      if(s==elements) toReturn->insert(n);
+    }
+  }
+  return toReturn;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -3110,62 +3073,65 @@ void SMDS_Mesh::addChildrenWithNodes(set<const SMDS_MeshElement*>& setOfChildren
                                      set<const SMDS_MeshElement*>& nodes)
 {
   switch(element->GetType())
+  {
+  case SMDSAbs_Node:
+    MESSAGE("Internal Error: This should not happen");
+    break;
+  case SMDSAbs_0DElement:
+  case SMDSAbs_Ball:
+  {
+  }
+  break;
+  case SMDSAbs_Edge:
+  {
+    SMDS_ElemIteratorPtr itn=element->nodesIterator();
+    while(itn->more())
     {
-    case SMDSAbs_Node:
-      MESSAGE("Internal Error: This should not happen");
-      break;
-    case SMDSAbs_0DElement:
+      const SMDS_MeshElement * e=itn->next();
+      if(nodes.find(e)!=nodes.end())
       {
+        setOfChildren.insert(element);
+        break;
       }
-      break;
-    case SMDSAbs_Edge:
-        {
-                SMDS_ElemIteratorPtr itn=element->nodesIterator();
-                while(itn->more())
-                {
-                        const SMDS_MeshElement * e=itn->next();
-                        if(nodes.find(e)!=nodes.end())
-                        {
-                          setOfChildren.insert(element);
-                          break;
-                        }
-                }
-        } break;
-    case SMDSAbs_Face:
-        {
-                SMDS_ElemIteratorPtr itn=element->nodesIterator();
-                while(itn->more())
-                {
-                        const SMDS_MeshElement * e=itn->next();
-                        if(nodes.find(e)!=nodes.end())
-                        {
-                          setOfChildren.insert(element);
-                          break;
-                        }
-                }
-                if(hasConstructionEdges())
-                {
-                        SMDS_ElemIteratorPtr ite=element->edgesIterator();
-                        while(ite->more())
-                                addChildrenWithNodes(setOfChildren, ite->next(), nodes);
-                }
-        } break;
-    case SMDSAbs_Volume:
-        {
-                if(hasConstructionFaces())
-                {
-                        SMDS_ElemIteratorPtr ite=element->facesIterator();
-                        while(ite->more())
-                                addChildrenWithNodes(setOfChildren, ite->next(), nodes);
-                }
-                else if(hasConstructionEdges())
-                {
-                        SMDS_ElemIteratorPtr ite=element->edgesIterator();
-                        while(ite->more())
-                                addChildrenWithNodes(setOfChildren, ite->next(), nodes);
-                }
-        }
     }
+  } break;
+  case SMDSAbs_Face:
+  {
+    SMDS_ElemIteratorPtr itn=element->nodesIterator();
+    while(itn->more())
+    {
+      const SMDS_MeshElement * e=itn->next();
+      if(nodes.find(e)!=nodes.end())
+      {
+        setOfChildren.insert(element);
+        break;
+      }
+    }
+    if(hasConstructionEdges())
+    {
+      SMDS_ElemIteratorPtr ite=element->edgesIterator();
+      while(ite->more())
+        addChildrenWithNodes(setOfChildren, ite->next(), nodes);
+    }
+  } break;
+  case SMDSAbs_Volume:
+  {
+    if(hasConstructionFaces())
+    {
+      SMDS_ElemIteratorPtr ite=element->facesIterator();
+      while(ite->more())
+        addChildrenWithNodes(setOfChildren, ite->next(), nodes);
+    }
+    else if(hasConstructionEdges())
+    {
+      SMDS_ElemIteratorPtr ite=element->edgesIterator();
+      while(ite->more())
+        addChildrenWithNodes(setOfChildren, ite->next(), nodes);
+    }
+  }
+  case SMDSAbs_NbElementTypes:
+  case SMDSAbs_All: break;
+  }
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -3191,7 +3157,6 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement *        elem,
                               list<const SMDS_MeshElement *>& removedNodes,
                               bool                            removenodes)
 {
-  //MESSAGE("SMDS_Mesh::RemoveElement " << elem->getVtkId() << " " << removenodes);
   // get finite elements built on elem
   set<const SMDS_MeshElement*> * s1;
   if (    (elem->GetType() == SMDSAbs_0DElement)
@@ -3236,19 +3201,16 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement *        elem,
       // Remove element from <InverseElements> of its nodes
       SMDS_ElemIteratorPtr itn = (*it)->nodesIterator();
       while (itn->more())
-        {
-          SMDS_MeshNode * n = static_cast<SMDS_MeshNode *> (const_cast<SMDS_MeshElement *> (itn->next()));
-          n->RemoveInverseElement((*it));
-        }
+      {
+        SMDS_MeshNode * n = static_cast<SMDS_MeshNode *> (const_cast<SMDS_MeshElement *> (itn->next()));
+        n->RemoveInverseElement((*it));
+      }
       int IdToRemove = (*it)->GetID();
       int vtkid = (*it)->getVtkId();
-      //MESSAGE("elem Id to remove " << IdToRemove << " vtkid " << vtkid <<
-      //        " vtktype " << (*it)->GetVtkType() << " type " << (*it)->GetType());
       switch ((*it)->GetType())
       {
         case SMDSAbs_Node:
-          MYASSERT("Internal Error: This should not happen")
-          ;
+          MYASSERT("Internal Error: This should not happen");
           break;
         case SMDSAbs_0DElement:
           if (IdToRemove >= 0)
@@ -3270,8 +3232,10 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement *        elem,
           myElementIDFactory->ReleaseID(IdToRemove, vtkid);
           if (const SMDS_VtkEdge* vtkElem = dynamic_cast<const SMDS_VtkEdge*>(*it))
             myEdgePool->destroy((SMDS_VtkEdge*) vtkElem);
-          else
+          else {
+            ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse
             delete (*it);
+          }
           break;
         case SMDSAbs_Face:
           if (IdToRemove >= 0)
@@ -3283,8 +3247,10 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement *        elem,
           myElementIDFactory->ReleaseID(IdToRemove, vtkid);
           if (const SMDS_VtkFace* vtkElem = dynamic_cast<const SMDS_VtkFace*>(*it))
             myFacePool->destroy((SMDS_VtkFace*) vtkElem);
-          else
+          else {
+            ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse
             delete (*it);
+          }
           break;
         case SMDSAbs_Volume:
           if (IdToRemove >= 0)
@@ -3296,8 +3262,10 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement *        elem,
           myElementIDFactory->ReleaseID(IdToRemove, vtkid);
           if (const SMDS_VtkVolume* vtkElem = dynamic_cast<const SMDS_VtkVolume*>(*it))
             myVolumePool->destroy((SMDS_VtkVolume*) vtkElem);
-          else
+          else {
+            ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse
             delete (*it);
+          }
           break;
         case SMDSAbs_Ball:
           if (IdToRemove >= 0)
@@ -3309,43 +3277,46 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement *        elem,
           myElementIDFactory->ReleaseID(IdToRemove, vtkid);
           if (const SMDS_BallElement* vtkElem = dynamic_cast<const SMDS_BallElement*>(*it))
             myBallPool->destroy(const_cast<SMDS_BallElement*>( vtkElem ));
-          else
+          else {
+            ((SMDS_MeshElement*) *it)->init( -1, -1, -1 ); // avoid reuse
             delete (*it);
+          }
           break;
+
+        case SMDSAbs_All: // avoid compilation warning
+        case SMDSAbs_NbElementTypes: break;
       }
       if (vtkid >= 0)
-        {
-          //MESSAGE("VTK_EMPTY_CELL in " << vtkid);
-          this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL);
-        }
+      {
+        this->myGrid->GetCellTypesArray()->SetValue(vtkid, VTK_EMPTY_CELL);
+      }
       it++;
     }
 
   // remove exclusive (free) nodes
   if (removenodes)
+  {
+    it = s2->begin();
+    while (it != s2->end())
     {
-      it = s2->begin();
-      while (it != s2->end())
-        {
-          int IdToRemove = (*it)->GetID();
-          //MESSAGE( "SMDS: RM node " << IdToRemove);
-          if (IdToRemove >= 0)
-            {
-              myNodes[IdToRemove] = 0;
-              myInfo.myNbNodes--;
-            }
-          myNodeIDFactory->ReleaseID((*it)->GetID(), (*it)->getVtkId());
-          removedNodes.push_back((*it));
-          if (const SMDS_MeshNode* vtkElem = dynamic_cast<const SMDS_MeshNode*>(*it))
-          {
-            ((SMDS_MeshNode*)vtkElem)->SetPosition(SMDS_SpacePosition::originSpacePosition());
-            myNodePool->destroy((SMDS_MeshNode*) vtkElem);
-          }
-          else
-            delete (*it);
-          it++;
-        }
+      int IdToRemove = (*it)->GetID();
+      if (IdToRemove >= 0)
+      {
+        myNodes[IdToRemove] = 0;
+        myInfo.myNbNodes--;
+      }
+      myNodeIDFactory->ReleaseID((*it)->GetID(), (*it)->getVtkId());
+      removedNodes.push_back((*it));
+      if (const SMDS_MeshNode* vtkElem = dynamic_cast<const SMDS_MeshNode*>(*it))
+      {
+        ((SMDS_MeshNode*)vtkElem)->SetPosition(SMDS_SpacePosition::originSpacePosition());
+        myNodePool->destroy((SMDS_MeshNode*) vtkElem);
+      }
+      else
+        delete (*it);
+      it++;
     }
+  }
 
   delete s2;
   delete s1;
@@ -3358,16 +3329,14 @@ void SMDS_Mesh::RemoveElement(const SMDS_MeshElement *        elem,
 void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
 {
   int elemId = elem->GetID();
-  int vtkId = elem->getVtkId();
-  //MESSAGE("RemoveFreeElement " << elemId);
+  int  vtkId = elem->getVtkId();
   SMDSAbs_ElementType aType = elem->GetType();
-  SMDS_MeshElement* todest = (SMDS_MeshElement*)(elem);
-  if (aType == SMDSAbs_Node) {
-    //MESSAGE("Remove free node " << elemId);
+  SMDS_MeshElement*  todest = (SMDS_MeshElement*)(elem);
+  if ( aType == SMDSAbs_Node )
+  {
     // only free node can be removed by this method
     const SMDS_MeshNode* n = static_cast<SMDS_MeshNode*>(todest);
-    SMDS_ElemIteratorPtr itFe = n->GetInverseElementIterator();
-    if (!itFe->more()) { // free node
+    if ( n->NbInverseElements() == 0 ) { // free node
       myNodes[elemId] = 0;
       myInfo.myNbNodes--;
       ((SMDS_MeshNode*) n)->SetPosition(SMDS_SpacePosition::originSpacePosition());
@@ -3375,12 +3344,13 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
       myNodePool->destroy(static_cast<SMDS_MeshNode*>(todest));
       myNodeIDFactory->ReleaseID(elemId, vtkId);
     }
-  } else {
+  }
+  else
+  {
     if (hasConstructionEdges() || hasConstructionFaces())
       // this methods is only for meshes without descendants
       return;
 
-    //MESSAGE("Remove free element " << elemId);
     // Remove element from <InverseElements> of its nodes
     SMDS_ElemIteratorPtr itn = elem->nodesIterator();
     while (itn->more()) {
@@ -3390,11 +3360,12 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
     }
 
     // in meshes without descendants elements are always free
-     switch (aType) {
+    switch (aType) {
     case SMDSAbs_0DElement:
       myCells[elemId] = 0;
       myInfo.remove(elem);
       delete elem;
+      elem = 0;
       break;
     case SMDSAbs_Edge:
       myCells[elemId] = 0;
@@ -3423,6 +3394,9 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
 
     this->myGrid->GetCellTypesArray()->SetValue(vtkId, VTK_EMPTY_CELL);
     // --- to do: keep vtkid in a list of reusable cells
+
+    if ( elem )
+      ((SMDS_MeshElement*) elem)->init( -1, -1, -1 ); // avoid reuse
   }
 }
 
@@ -3432,7 +3406,7 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
  */
 bool SMDS_Mesh::Contains (const SMDS_MeshElement* elem) const
 {
-  // we should not imply on validity of *elem, so iterate on containers
+  // we should not rely on validity of *elem, so iterate on containers
   // of all types in the hope of finding <elem> somewhere there
   SMDS_NodeIteratorPtr itn = nodesIterator();
   while (itn->more())
@@ -3452,7 +3426,7 @@ bool SMDS_Mesh::Contains (const SMDS_MeshElement* elem) const
 
 int SMDS_Mesh::MaxNodeID() const
 {
-  return myNodeMax;
+  return myNodeIDFactory->GetMaxID();
 }
 
 //=======================================================================
@@ -3462,7 +3436,7 @@ int SMDS_Mesh::MaxNodeID() const
 
 int SMDS_Mesh::MinNodeID() const
 {
-  return myNodeMin;
+  return myNodeIDFactory->GetMinID();
 }
 
 //=======================================================================
@@ -3492,7 +3466,6 @@ int SMDS_Mesh::MinElementID() const
 
 void SMDS_Mesh::Renumber (const bool isNodes, const int  startID, const int  deltaID)
 {
-    MESSAGE("Renumber");
   if ( deltaID == 0 )
     return;
 
@@ -3593,30 +3566,29 @@ SMDS_MeshEdge* SMDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
   if ( !n1 || !n2 || !n12 ) return 0;
 
   // --- retrieve nodes ID
-  vector<vtkIdType> nodeIds;
-  nodeIds.clear();
-  nodeIds.push_back(n1->getVtkId());
-  nodeIds.push_back(n2->getVtkId());
-  nodeIds.push_back(n12->getVtkId());
+  myNodeIds.resize(3);
+  myNodeIds[0] = n1->getVtkId();
+  myNodeIds[1] = n2->getVtkId();
+  myNodeIds[2] = n12->getVtkId();
 
   SMDS_MeshEdge * edge = 0;
   SMDS_VtkEdge *edgevtk = myEdgePool->getNew();
-  edgevtk->init(nodeIds, this);
+  edgevtk->init(myNodeIds, this);
   if (!this->registerElement(ID,edgevtk))
-    {
-      this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
-      myEdgePool->destroy(edgevtk);
-      return 0;
-    }
+  {
+    this->myGrid->GetCellTypesArray()->SetValue(edgevtk->getVtkId(), VTK_EMPTY_CELL);
+    myEdgePool->destroy(edgevtk);
+    return 0;
+  }
   edge = edgevtk;
   adjustmyCellsCapacity(ID);
   myCells[ID] = edge;
   myInfo.myNbQuadEdges++;
 
-//  if (!registerElement(ID, edge)) {
-//        RemoveElement(edge, false);
-//        edge = NULL;
-//  }
+  //  if (!registerElement(ID, edge)) {
+  //        RemoveElement(edge, false);
+  //        edge = NULL;
+  //  }
   return edge;
 
 }
@@ -3674,33 +3646,32 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
   else
   {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(n1->getVtkId());
-    nodeIds.push_back(n2->getVtkId());
-    nodeIds.push_back(n3->getVtkId());
-    nodeIds.push_back(n12->getVtkId());
-    nodeIds.push_back(n23->getVtkId());
-    nodeIds.push_back(n31->getVtkId());
+    myNodeIds.resize(6);
+    myNodeIds[0] = n1->getVtkId();
+    myNodeIds[1] = n2->getVtkId();
+    myNodeIds[2] = n3->getVtkId();
+    myNodeIds[3] = n12->getVtkId();
+    myNodeIds[4] = n23->getVtkId();
+    myNodeIds[5] = n31->getVtkId();
 
     SMDS_MeshFace * face = 0;
     SMDS_VtkFace *facevtk = myFacePool->getNew();
-    facevtk->init(nodeIds, this);
+    facevtk->init(myNodeIds, this);
     if (!this->registerElement(ID,facevtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
-        myFacePool->destroy(facevtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+      myFacePool->destroy(facevtk);
+      return 0;
+    }
     face = facevtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = face;
     myInfo.myNbQuadTriangles++;
 
-//    if (!registerElement(ID, face)) {
-//      RemoveElement(face, false);
-//      face = NULL;
-//    }
+    //    if (!registerElement(ID, face)) {
+    //      RemoveElement(face, false);
+    //      face = NULL;
+    //    }
     return face;
   }
 }
@@ -3761,34 +3732,33 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
   else
   {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(n1->getVtkId());
-    nodeIds.push_back(n2->getVtkId());
-    nodeIds.push_back(n3->getVtkId());
-    nodeIds.push_back(n12->getVtkId());
-    nodeIds.push_back(n23->getVtkId());
-    nodeIds.push_back(n31->getVtkId());
-    nodeIds.push_back(nCenter->getVtkId());
+    myNodeIds.resize(7);
+    myNodeIds[0] = n1->getVtkId();
+    myNodeIds[1] = n2->getVtkId();
+    myNodeIds[2] = n3->getVtkId();
+    myNodeIds[3] = n12->getVtkId();
+    myNodeIds[4] = n23->getVtkId();
+    myNodeIds[5] = n31->getVtkId();
+    myNodeIds[6] = nCenter->getVtkId();
 
     SMDS_MeshFace * face = 0;
     SMDS_VtkFace *facevtk = myFacePool->getNew();
-    facevtk->init(nodeIds, this);
+    facevtk->init(myNodeIds, this);
     if (!this->registerElement(ID,facevtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
-        myFacePool->destroy(facevtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+      myFacePool->destroy(facevtk);
+      return 0;
+    }
     face = facevtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = face;
     myInfo.myNbBiQuadTriangles++;
 
-//    if (!registerElement(ID, face)) {
-//      RemoveElement(face, false);
-//      face = NULL;
-//    }
+    //    if (!registerElement(ID, face)) {
+    //      RemoveElement(face, false);
+    //      face = NULL;
+    //    }
     return face;
   }
 }
@@ -3847,40 +3817,39 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
   if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41) return 0;
   if(hasConstructionEdges()) {
     // creation quadratic edges - not implemented
-        return 0;
+    return 0;
   }
   else
   {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(n1->getVtkId());
-    nodeIds.push_back(n2->getVtkId());
-    nodeIds.push_back(n3->getVtkId());
-    nodeIds.push_back(n4->getVtkId());
-    nodeIds.push_back(n12->getVtkId());
-    nodeIds.push_back(n23->getVtkId());
-    nodeIds.push_back(n34->getVtkId());
-    nodeIds.push_back(n41->getVtkId());
+    myNodeIds.resize(8);
+    myNodeIds[0] = n1->getVtkId();
+    myNodeIds[1] = n2->getVtkId();
+    myNodeIds[2] = n3->getVtkId();
+    myNodeIds[3] = n4->getVtkId();
+    myNodeIds[4] = n12->getVtkId();
+    myNodeIds[5] = n23->getVtkId();
+    myNodeIds[6] = n34->getVtkId();
+    myNodeIds[7] = n41->getVtkId();
 
     SMDS_MeshFace * face = 0;
     SMDS_VtkFace *facevtk = myFacePool->getNew();
-    facevtk->init(nodeIds, this);
+    facevtk->init(myNodeIds, this);
     if (!this->registerElement(ID,facevtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
-        myFacePool->destroy(facevtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+      myFacePool->destroy(facevtk);
+      return 0;
+    }
     face = facevtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = face;
     myInfo.myNbQuadQuadrangles++;
 
-//    if (!registerElement(ID, face)) {
-//      RemoveElement(face, false);
-//      face = NULL;
-//    }
+    //    if (!registerElement(ID, face)) {
+    //      RemoveElement(face, false);
+    //      face = NULL;
+    //    }
     return face;
   }
 }
@@ -3941,41 +3910,40 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
   if ( !n1 || !n2 || !n3 || !n4 || !n12 || !n23 || !n34 || !n41 || !nCenter) return 0;
   if(hasConstructionEdges()) {
     // creation quadratic edges - not implemented
-        return 0;
+    return 0;
   }
   else
   {
     // --- retrieve nodes ID
-    vector<vtkIdType> nodeIds;
-    nodeIds.clear();
-    nodeIds.push_back(n1->getVtkId());
-    nodeIds.push_back(n2->getVtkId());
-    nodeIds.push_back(n3->getVtkId());
-    nodeIds.push_back(n4->getVtkId());
-    nodeIds.push_back(n12->getVtkId());
-    nodeIds.push_back(n23->getVtkId());
-    nodeIds.push_back(n34->getVtkId());
-    nodeIds.push_back(n41->getVtkId());
-    nodeIds.push_back(nCenter->getVtkId());
+    myNodeIds.resize(9);
+    myNodeIds[0] = n1->getVtkId();
+    myNodeIds[1] = n2->getVtkId();
+    myNodeIds[2] = n3->getVtkId();
+    myNodeIds[3] = n4->getVtkId();
+    myNodeIds[4] = n12->getVtkId();
+    myNodeIds[5] = n23->getVtkId();
+    myNodeIds[6] = n34->getVtkId();
+    myNodeIds[7] = n41->getVtkId();
+    myNodeIds[8] = nCenter->getVtkId();
 
     SMDS_MeshFace * face = 0;
     SMDS_VtkFace *facevtk = myFacePool->getNew();
-    facevtk->init(nodeIds, this);
+    facevtk->init(myNodeIds, this);
     if (!this->registerElement(ID,facevtk))
-      {
-        this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
-        myFacePool->destroy(facevtk);
-        return 0;
-      }
+    {
+      this->myGrid->GetCellTypesArray()->SetValue(facevtk->getVtkId(), VTK_EMPTY_CELL);
+      myFacePool->destroy(facevtk);
+      return 0;
+    }
     face = facevtk;
     adjustmyCellsCapacity(ID);
     myCells[ID] = face;
     myInfo.myNbBiQuadQuadrangles++;
 
-//    if (!registerElement(ID, face)) {
-//      RemoveElement(face, false);
-//      face = NULL;
-//    }
+    //    if (!registerElement(ID, face)) {
+    //      RemoveElement(face, false);
+    //      face = NULL;
+    //    }
     return face;
   }
 }
@@ -4048,37 +4016,36 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     return 0;
   }
   // --- retrieve nodes ID
-  vector<vtkIdType> nodeIds;
-  nodeIds.clear();
-  nodeIds.push_back(n1->getVtkId());
-  nodeIds.push_back(n3->getVtkId());
-  nodeIds.push_back(n2->getVtkId());
-  nodeIds.push_back(n4->getVtkId());
+  myNodeIds.resize(10);
+  myNodeIds[0] = n1->getVtkId();
+  myNodeIds[1] = n3->getVtkId();
+  myNodeIds[2] = n2->getVtkId();
+  myNodeIds[3] = n4->getVtkId();
 
-  nodeIds.push_back(n31->getVtkId());
-  nodeIds.push_back(n23->getVtkId());
-  nodeIds.push_back(n12->getVtkId());
+  myNodeIds[4] = n31->getVtkId();
+  myNodeIds[5] = n23->getVtkId();
+  myNodeIds[6] = n12->getVtkId();
 
-  nodeIds.push_back(n14->getVtkId());
-  nodeIds.push_back(n34->getVtkId());
-  nodeIds.push_back(n24->getVtkId());
+  myNodeIds[7] = n14->getVtkId();
+  myNodeIds[8] = n34->getVtkId();
+  myNodeIds[9] = n24->getVtkId();
 
   SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-  volvtk->init(nodeIds, this);
+  volvtk->init(myNodeIds, this);
   if (!this->registerElement(ID,volvtk))
-    {
-      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-      myVolumePool->destroy(volvtk);
-      return 0;
-    }
+  {
+    this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+    myVolumePool->destroy(volvtk);
+    return 0;
+  }
   adjustmyCellsCapacity(ID);
   myCells[ID] = volvtk;
   myInfo.myNbQuadTetras++;
 
-//  if (!registerElement(ID, volvtk)) {
-//    RemoveElement(volvtk, false);
-//    volvtk = NULL;
-//  }
+  //  if (!registerElement(ID, volvtk)) {
+  //    RemoveElement(volvtk, false);
+  //    volvtk = NULL;
+  //  }
   return volvtk;
 }
 
@@ -4161,40 +4128,39 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     return 0;
   }
   // --- retrieve nodes ID
-  vector<vtkIdType> nodeIds;
-  nodeIds.clear();
-  nodeIds.push_back(n1->getVtkId());
-  nodeIds.push_back(n4->getVtkId());
-  nodeIds.push_back(n3->getVtkId());
-  nodeIds.push_back(n2->getVtkId());
-  nodeIds.push_back(n5->getVtkId());
-
-  nodeIds.push_back(n41->getVtkId());
-  nodeIds.push_back(n34->getVtkId());
-  nodeIds.push_back(n23->getVtkId());
-  nodeIds.push_back(n12->getVtkId());
-
-  nodeIds.push_back(n15->getVtkId());
-  nodeIds.push_back(n45->getVtkId());
-  nodeIds.push_back(n35->getVtkId());
-  nodeIds.push_back(n25->getVtkId());
+  myNodeIds.resize(13);
+  myNodeIds[0] = n1->getVtkId();
+  myNodeIds[1] = n4->getVtkId();
+  myNodeIds[2] = n3->getVtkId();
+  myNodeIds[3] = n2->getVtkId();
+  myNodeIds[4] = n5->getVtkId();
+
+  myNodeIds[5] = n41->getVtkId();
+  myNodeIds[6] = n34->getVtkId();
+  myNodeIds[7] = n23->getVtkId();
+  myNodeIds[8] = n12->getVtkId();
+
+  myNodeIds[9] = n15->getVtkId();
+  myNodeIds[10] = n45->getVtkId();
+  myNodeIds[11] = n35->getVtkId();
+  myNodeIds[12] = n25->getVtkId();
 
   SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-  volvtk->init(nodeIds, this);
+  volvtk->init(myNodeIds, this);
   if (!this->registerElement(ID,volvtk))
-    {
-      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-      myVolumePool->destroy(volvtk);
-      return 0;
-    }
+  {
+    this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+    myVolumePool->destroy(volvtk);
+    return 0;
+  }
   adjustmyCellsCapacity(ID);
   myCells[ID] = volvtk;
   myInfo.myNbQuadPyramids++;
 
-//  if (!registerElement(ID, volvtk)) {
-//    RemoveElement(volvtk, false);
-//    volvtk = NULL;
-//  }
+  //  if (!registerElement(ID, volvtk)) {
+  //    RemoveElement(volvtk, false);
+  //    volvtk = NULL;
+  //  }
   return volvtk;
 }
 
@@ -4285,44 +4251,43 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     return 0;
   }
   // --- retrieve nodes ID
-  vector<vtkIdType> nodeIds;
-  nodeIds.clear();
-  nodeIds.push_back(n1->getVtkId());
-  nodeIds.push_back(n2->getVtkId());
-  nodeIds.push_back(n3->getVtkId());
+  myNodeIds.resize(15);
+  myNodeIds[0] = n1->getVtkId();
+  myNodeIds[1] = n2->getVtkId();
+  myNodeIds[2] = n3->getVtkId();
 
-  nodeIds.push_back(n4->getVtkId());
-  nodeIds.push_back(n5->getVtkId());
-  nodeIds.push_back(n6->getVtkId());
+  myNodeIds[3] = n4->getVtkId();
+  myNodeIds[4] = n5->getVtkId();
+  myNodeIds[5] = n6->getVtkId();
 
-  nodeIds.push_back(n12->getVtkId());
-  nodeIds.push_back(n23->getVtkId());
-  nodeIds.push_back(n31->getVtkId());
+  myNodeIds[6] = n12->getVtkId();
+  myNodeIds[7] = n23->getVtkId();
+  myNodeIds[8] = n31->getVtkId();
 
-  nodeIds.push_back(n45->getVtkId());
-  nodeIds.push_back(n56->getVtkId());
-  nodeIds.push_back(n64->getVtkId());
+  myNodeIds[9] = n45->getVtkId();
+  myNodeIds[10] = n56->getVtkId();
+  myNodeIds[11] = n64->getVtkId();
 
-  nodeIds.push_back(n14->getVtkId());
-  nodeIds.push_back(n25->getVtkId());
-  nodeIds.push_back(n36->getVtkId());
+  myNodeIds[12] = n14->getVtkId();
+  myNodeIds[13] = n25->getVtkId();
+  myNodeIds[14] = n36->getVtkId();
 
   SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-  volvtk->init(nodeIds, this);
+  volvtk->init(myNodeIds, this);
   if (!this->registerElement(ID,volvtk))
-    {
-      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-      myVolumePool->destroy(volvtk);
-      return 0;
-    }
+  {
+    this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+    myVolumePool->destroy(volvtk);
+    return 0;
+  }
   adjustmyCellsCapacity(ID);
   myCells[ID] = volvtk;
   myInfo.myNbQuadPrisms++;
 
-//  if (!registerElement(ID, volvtk)) {
-//    RemoveElement(volvtk, false);
-//    volvtk = NULL;
-//  }
+  //  if (!registerElement(ID, volvtk)) {
+  //    RemoveElement(volvtk, false);
+  //    volvtk = NULL;
+  //  }
   return volvtk;
 }
 
@@ -4428,49 +4393,48 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     // creation quadratic faces - not implemented
   }
   // --- retrieve nodes ID
-  vector<vtkIdType> nodeIds;
-  nodeIds.clear();
-  nodeIds.push_back(n1->getVtkId());
-  nodeIds.push_back(n4->getVtkId());
-  nodeIds.push_back(n3->getVtkId());
-  nodeIds.push_back(n2->getVtkId());
-
-  nodeIds.push_back(n5->getVtkId());
-  nodeIds.push_back(n8->getVtkId());
-  nodeIds.push_back(n7->getVtkId());
-  nodeIds.push_back(n6->getVtkId());
-
-  nodeIds.push_back(n41->getVtkId());
-  nodeIds.push_back(n34->getVtkId());
-  nodeIds.push_back(n23->getVtkId());
-  nodeIds.push_back(n12->getVtkId());
-
-  nodeIds.push_back(n85->getVtkId());
-  nodeIds.push_back(n78->getVtkId());
-  nodeIds.push_back(n67->getVtkId());
-  nodeIds.push_back(n56->getVtkId());
-
-  nodeIds.push_back(n15->getVtkId());
-  nodeIds.push_back(n48->getVtkId());
-  nodeIds.push_back(n37->getVtkId());
-  nodeIds.push_back(n26->getVtkId());
+  myNodeIds.resize(20);
+  myNodeIds[0] = n1->getVtkId();
+  myNodeIds[1] = n4->getVtkId();
+  myNodeIds[2] = n3->getVtkId();
+  myNodeIds[3] = n2->getVtkId();
+
+  myNodeIds[4] = n5->getVtkId();
+  myNodeIds[5] = n8->getVtkId();
+  myNodeIds[6] = n7->getVtkId();
+  myNodeIds[7] = n6->getVtkId();
+
+  myNodeIds[8] = n41->getVtkId();
+  myNodeIds[9] = n34->getVtkId();
+  myNodeIds[10] = n23->getVtkId();
+  myNodeIds[11] = n12->getVtkId();
+
+  myNodeIds[12] = n85->getVtkId();
+  myNodeIds[13] = n78->getVtkId();
+  myNodeIds[14] = n67->getVtkId();
+  myNodeIds[15] = n56->getVtkId();
+
+  myNodeIds[16] = n15->getVtkId();
+  myNodeIds[17] = n48->getVtkId();
+  myNodeIds[18] = n37->getVtkId();
+  myNodeIds[19] = n26->getVtkId();
 
   SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-  volvtk->init(nodeIds, this);
+  volvtk->init(myNodeIds, this);
   if (!this->registerElement(ID,volvtk))
-    {
-      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-      myVolumePool->destroy(volvtk);
-      return 0;
-    }
+  {
+    this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+    myVolumePool->destroy(volvtk);
+    return 0;
+  }
   adjustmyCellsCapacity(ID);
   myCells[ID] = volvtk;
   myInfo.myNbQuadHexas++;
 
-//  if (!registerElement(ID, volvtk)) {
-//    RemoveElement(volvtk, false);
-//    volvtk = NULL;
-//  }
+  //  if (!registerElement(ID, volvtk)) {
+  //    RemoveElement(volvtk, false);
+  //    volvtk = NULL;
+  //  }
   return volvtk;
 }
 
@@ -4601,49 +4565,48 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
     // creation quadratic faces - not implemented
   }
   // --- retrieve nodes ID
-  vector<vtkIdType> nodeIds;
-  nodeIds.clear();
-  nodeIds.push_back(n1->getVtkId());
-  nodeIds.push_back(n4->getVtkId());
-  nodeIds.push_back(n3->getVtkId());
-  nodeIds.push_back(n2->getVtkId());
-
-  nodeIds.push_back(n5->getVtkId());
-  nodeIds.push_back(n8->getVtkId());
-  nodeIds.push_back(n7->getVtkId());
-  nodeIds.push_back(n6->getVtkId());
-
-  nodeIds.push_back(n41->getVtkId());
-  nodeIds.push_back(n34->getVtkId());
-  nodeIds.push_back(n23->getVtkId());
-  nodeIds.push_back(n12->getVtkId());
-
-  nodeIds.push_back(n85->getVtkId());
-  nodeIds.push_back(n78->getVtkId());
-  nodeIds.push_back(n67->getVtkId());
-  nodeIds.push_back(n56->getVtkId());
-
-  nodeIds.push_back(n15->getVtkId());
-  nodeIds.push_back(n48->getVtkId());
-  nodeIds.push_back(n37->getVtkId());
-  nodeIds.push_back(n26->getVtkId());
-
-  nodeIds.push_back(n1256->getVtkId());
-  nodeIds.push_back(n3478->getVtkId());
-  nodeIds.push_back(n1458->getVtkId());
-  nodeIds.push_back(n2367->getVtkId());
-  nodeIds.push_back(n1234->getVtkId());
-  nodeIds.push_back(n5678->getVtkId());
-  nodeIds.push_back(nCenter->getVtkId());
+  myNodeIds.resize(27);
+  myNodeIds[0] = n1->getVtkId();
+  myNodeIds[1] = n4->getVtkId();
+  myNodeIds[2] = n3->getVtkId();
+  myNodeIds[3] = n2->getVtkId();
+
+  myNodeIds[4] = n5->getVtkId();
+  myNodeIds[5] = n8->getVtkId();
+  myNodeIds[6] = n7->getVtkId();
+  myNodeIds[7] = n6->getVtkId();
+
+  myNodeIds[8] = n41->getVtkId();
+  myNodeIds[9] = n34->getVtkId();
+  myNodeIds[10] = n23->getVtkId();
+  myNodeIds[11] = n12->getVtkId();
+
+  myNodeIds[12] = n85->getVtkId();
+  myNodeIds[13] = n78->getVtkId();
+  myNodeIds[14] = n67->getVtkId();
+  myNodeIds[15] = n56->getVtkId();
+
+  myNodeIds[16] = n15->getVtkId();
+  myNodeIds[17] = n48->getVtkId();
+  myNodeIds[18] = n37->getVtkId();
+  myNodeIds[19] = n26->getVtkId();
+
+  myNodeIds[20] = n1256->getVtkId();
+  myNodeIds[21] = n3478->getVtkId();
+  myNodeIds[22] = n1458->getVtkId();
+  myNodeIds[23] = n2367->getVtkId();
+  myNodeIds[24] = n1234->getVtkId();
+  myNodeIds[25] = n5678->getVtkId();
+  myNodeIds[26] = nCenter->getVtkId();
 
   SMDS_VtkVolume *volvtk = myVolumePool->getNew();
-  volvtk->init(nodeIds, this);
+  volvtk->init(myNodeIds, this);
   if (!this->registerElement(ID,volvtk))
-    {
-      this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
-      myVolumePool->destroy(volvtk);
-      return 0;
-    }
+  {
+    this->myGrid->GetCellTypesArray()->SetValue(volvtk->getVtkId(), VTK_EMPTY_CELL);
+    myVolumePool->destroy(volvtk);
+    return 0;
+  }
   adjustmyCellsCapacity(ID);
   myCells[ID] = volvtk;
   myInfo.myNbTriQuadHexas++;
@@ -4651,93 +4614,49 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
   return volvtk;
 }
 
-
-void SMDS_Mesh::updateNodeMinMax()
-{
-  myNodeMin = 0;
-  if (myNodes.size() == 0)
-  {
-        myNodeMax=0;
-        return;
-  }
-  while (!myNodes[myNodeMin] && (myNodeMin<myNodes.size()))
-    myNodeMin++;
-  myNodeMax=myNodes.size()-1;
-  while (!myNodes[myNodeMax] && (myNodeMin>=0))
-    myNodeMin--;
-}
-
-void SMDS_Mesh::incrementNodesCapacity(int nbNodes)
-{
-//  int val = myCellIdSmdsToVtk.size();
-//  MESSAGE(" ------------------- resize myCellIdSmdsToVtk " << val << " --> " << val + nbNodes);
-//  myCellIdSmdsToVtk.resize(val + nbNodes, -1); // fill new elements with -1
-  int val = myNodes.size();
-  MESSAGE(" ------------------- resize myNodes " << val << " --> " << val + nbNodes);
-  myNodes.resize(val +nbNodes, 0);
-}
-
-void SMDS_Mesh::incrementCellsCapacity(int nbCells)
-{
-  int val = myCellIdVtkToSmds.size();
-  MESSAGE(" ------------------- resize myCellIdVtkToSmds " << val << " --> " << val + nbCells);
-  myCellIdVtkToSmds.resize(val + nbCells, -1); // fill new elements with -1
-  val = myCells.size();
-  MESSAGE(" ------------------- resize myCells " << val << " --> " << val + nbCells);
-  myNodes.resize(val +nbCells, 0);
-}
-
-void SMDS_Mesh::adjustStructure()
-{
-  myGrid->GetPoints()->GetData()->SetNumberOfTuples(myNodeIDFactory->GetMaxID());
-}
-
 void SMDS_Mesh::dumpGrid(string ficdump)
 {
-        MESSAGE("SMDS_Mesh::dumpGrid " << ficdump);
-//  vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
-//  aWriter->SetFileName(ficdump.c_str());
-//  aWriter->SetInput(myGrid);
-//  if(myGrid->GetNumberOfCells())
-//  {
-//    aWriter->Write();
-//  }
-//  aWriter->Delete();
+  //  vtkUnstructuredGridWriter* aWriter = vtkUnstructuredGridWriter::New();
+  //  aWriter->SetFileName(ficdump.c_str());
+  //  aWriter->SetInput(myGrid);
+  //  if(myGrid->GetNumberOfCells())
+  //  {
+  //    aWriter->Write();
+  //  }
+  //  aWriter->Delete();
   ficdump = ficdump + "_connectivity";
   ofstream ficcon(ficdump.c_str(), ios::out);
   int nbPoints = myGrid->GetNumberOfPoints();
   ficcon << "-------------------------------- points " <<  nbPoints << endl;
   for (int i=0; i<nbPoints; i++)
   {
-        ficcon << i << " " << *(myGrid->GetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl;
+    ficcon << i << " " << *(myGrid->GetPoint(i)) << " " << *(myGrid->GetPoint(i)+1) << " " << " " << *(myGrid->GetPoint(i)+2) << endl;
   }
   int nbCells = myGrid->GetNumberOfCells();
   ficcon << "-------------------------------- cells " <<  nbCells << endl;
   for (int i=0; i<nbCells; i++)
   {
-//      MESSAGE(i << " " << myGrid->GetCell(i));
-//      MESSAGE("  " << myGrid->GetCell(i)->GetCellType());
-        ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -";
-        int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints();
-        vtkIdList *listid = myGrid->GetCell(i)->GetPointIds();
-        for (int j=0; j<nbptcell; j++)
-        {
-                ficcon << " " <<  listid->GetId(j);
-        }
-        ficcon << endl;
+    ficcon << i << " - " << myGrid->GetCell(i)->GetCellType() << " -";
+    int nbptcell = myGrid->GetCell(i)->GetNumberOfPoints();
+    vtkIdList *listid = myGrid->GetCell(i)->GetPointIds();
+    for (int j=0; j<nbptcell; j++)
+    {
+      ficcon << " " <<  listid->GetId(j);
+    }
+    ficcon << endl;
   }
   ficcon << "-------------------------------- connectivity " <<  nbPoints << endl;
-        vtkCellLinks *links = myGrid->GetCellLinks();
+  vtkCellLinks *links = myGrid->GetLinks();
   for (int i=0; i<nbPoints; i++)
   {
-        int ncells = links->GetNcells(i);
-        vtkIdType *cells = links->GetCells(i);
-        ficcon << i << " - " << ncells << " -";
-        for (int j=0; j<ncells; j++)
-        {
-                ficcon << " " << cells[j];
-        }
-        ficcon << endl;
+    int ncells = links->GetNcells(i);
+    vtkIdType *cells = links->GetCells(i);
+    ficcon << i << " - " << ncells << " -";
+    for (int j=0; j<ncells; j++)
+    {
+      ficcon << " " << cells[j];
+    }
+    ficcon << endl;
   }
   ficcon.close();
 
@@ -4745,38 +4664,38 @@ void SMDS_Mesh::dumpGrid(string ficdump)
 
 void SMDS_Mesh::compactMesh()
 {
-  MESSAGE("SMDS_Mesh::compactMesh do nothing!");
+  this->myCompactTime = this->myModifTime;
 }
 
 int SMDS_Mesh::fromVtkToSmds(int vtkid)
 {
-  if (vtkid >= 0 && vtkid < myCellIdVtkToSmds.size())
+  if (vtkid >= 0 && vtkid < (int)myCellIdVtkToSmds.size())
     return myCellIdVtkToSmds[vtkid];
   throw SALOME_Exception(LOCALIZED ("vtk id out of bounds"));
 }
 
-void SMDS_Mesh::updateBoundingBox()
-{
-  xmin = 0; xmax = 0;
-  ymin = 0; ymax = 0;
-  zmin = 0; zmax = 0;
-  vtkPoints *points = myGrid->GetPoints();
-  int myNodesSize = this->myNodes.size();
-  for (int i = 0; i < myNodesSize; i++)
-    {
-      if (SMDS_MeshNode *n = myNodes[i])
-        {
-          double coords[3];
-          points->GetPoint(n->myVtkID, coords);
-          if (coords[0] < xmin) xmin = coords[0];
-          else if (coords[0] > xmax) xmax = coords[0];
-          if (coords[1] < ymin) ymin = coords[1];
-          else if (coords[1] > ymax) ymax = coords[1];
-          if (coords[2] < zmin) zmin = coords[2];
-          else if (coords[2] > zmax) zmax = coords[2];
-        }
-    }
-}
+// void SMDS_Mesh::updateBoundingBox()
+// {
+//   xmin = 0; xmax = 0;
+//   ymin = 0; ymax = 0;
+//   zmin = 0; zmax = 0;
+//   vtkPoints *points = myGrid->GetPoints();
+//   int myNodesSize = this->myNodes.size();
+//   for (int i = 0; i < myNodesSize; i++)
+//     {
+//       if (SMDS_MeshNode *n = myNodes[i])
+//         {
+//           double coords[3];
+//           points->GetPoint(n->myVtkID, coords);
+//           if (coords[0] < xmin) xmin = coords[0];
+//           else if (coords[0] > xmax) xmax = coords[0];
+//           if (coords[1] < ymin) ymin = coords[1];
+//           else if (coords[1] > ymax) ymax = coords[1];
+//           if (coords[2] < zmin) zmin = coords[2];
+//           else if (coords[2] > zmax) zmax = coords[2];
+//         }
+//     }
+// }
 
 double SMDS_Mesh::getMaxDim()
 {
@@ -4784,7 +4703,6 @@ double SMDS_Mesh::getMaxDim()
   if ((xmax - xmin) > dmax) dmax = xmax -xmin;
   if ((ymax - ymin) > dmax) dmax = ymax -ymin;
   if ((zmax - zmin) > dmax) dmax = zmax -zmin;
-  MESSAGE("getMaxDim " << dmax);
   return dmax;
 }
 
@@ -4792,26 +4710,19 @@ double SMDS_Mesh::getMaxDim()
 void SMDS_Mesh::Modified()
 {
   if (this->myModified)
-    {
-      this->myModifTime++;
-      MESSAGE("modified");
-      myModified = false;
-    }
+  {
+    this->myModifTime++;
+    myModified = false;
+  }
 }
 
 //! get last modification timeStamp
-unsigned long SMDS_Mesh::GetMTime() const
+vtkMTimeType SMDS_Mesh::GetMTime() const
 {
   return this->myModifTime;
 }
 
 bool SMDS_Mesh::isCompacted()
 {
-  if (this->myModifTime > this->myCompactTime)
-    {
-      MESSAGE(" *** isCompacted " << myCompactTime << " < " << myModifTime);
-      this->myCompactTime = this->myModifTime;
-      return false;
-    }
-  return true;
+  return this->myCompactTime == this->myModifTime;
 }