X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMDS%2FSMDS_Mesh.cxx;h=87a2f15589acdfe42066b515bf39be6ad6ebca0c;hp=fe6f186e496b9b33a9f76da95648fa5b9a0a5598;hb=193c49c87753b6ccabb2b5e6dc935aa480d2d43e;hpb=bd4e115a78b52e3fbc016e5e30bb0e19b2a9e7d6

diff --git a/src/SMDS/SMDS_Mesh.cxx b/src/SMDS/SMDS_Mesh.cxx
index fe6f186e4..87a2f1558 100644
--- a/src/SMDS/SMDS_Mesh.cxx
+++ b/src/SMDS/SMDS_Mesh.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2012  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2015  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
@@ -53,6 +53,7 @@
 #include <map>
 #include <iostream>
 #include <fstream>
+#include <iterator>
 using namespace std;
 
 #ifndef WIN32
@@ -124,24 +125,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)
+  :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)
 {
   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);
@@ -160,10 +154,10 @@ SMDS_Mesh::SMDS_Mesh()
   myGrid->Initialize();
   myGrid->Allocate();
   vtkPoints* points = vtkPoints::New();
-  // 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.
+  // bug "21125: EDF 1233 SMESH: Degrardation of precision in a test case for quadratic conversion"
+  // Use double type for storing coordinates of nodes instead of float.
   points->SetDataType(VTK_DOUBLE);
-  points->SetNumberOfPoints(SMDS_Mesh::chunkSize);
+  points->SetNumberOfPoints(0 /*SMDS_Mesh::chunkSize*/);
   myGrid->SetPoints( points );
   points->Delete();
   myGrid->BuildLinks();
@@ -328,11 +322,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++;
@@ -643,7 +637,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n4,
                                             int ID)
 {
-    //MESSAGE("AddVolumeWithID " << ID);
+  //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@@ -663,31 +657,30 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
   }
   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;
 }
 
@@ -750,7 +743,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n5,
                                             int ID)
 {
-    //MESSAGE("AddVolumeWithID " << ID);
+  //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@@ -770,32 +763,31 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
   }
   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;
 }
 
@@ -862,7 +854,7 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                             const SMDS_MeshNode * n6,
                                             int ID)
 {
-    //MESSAGE("AddVolumeWithID " << ID);
+  //MESSAGE("AddVolumeWithID " << ID);
   SMDS_MeshVolume* volume = 0;
   if ( !n1 || !n2 || !n3 || !n4 || !n5 || !n6) return volume;
   if ( NbVolumes() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
@@ -883,33 +875,32 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(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(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;
 }
 
@@ -1012,29 +1003,29 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
   }
   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;
@@ -1139,35 +1130,34 @@ SMDS_MeshVolume* SMDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
   }
   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;
 }
 
@@ -1335,57 +1325,40 @@ 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;
-    }
+  {
+    MESSAGE("Error : Not implemented");
+    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;
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1398,6 +1371,69 @@ 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())
+  {
+    MESSAGE("Error : Not implemented");
+    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
@@ -1425,63 +1461,61 @@ 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;
-    }
+  {
+    MESSAGE("Error : Not implemented");
+    return NULL;
+  }
   else if (hasConstructionEdges())
-    {
-      MESSAGE("Error : Not implemented");
-      return NULL;
-    }
+  {
+    MESSAGE("Error : Not implemented");
+    return NULL;
+  }
   else
+  {
+    //#ifdef VTK_HAVE_POLYHEDRON
+    //MESSAGE("AddPolyhedralVolumeWithID vtk " << ID);
+    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
+    //      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++;
+  }
 
-//#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;
 }
 
@@ -1597,6 +1631,9 @@ SMDS_MeshFace* SMDS_Mesh::AddFaceFromVtkIdsWithID(const std::vector<vtkIdType>&
     case VTK_BIQUADRATIC_QUAD:
       myInfo.myNbBiQuadQuadrangles++;
       break;
+    case VTK_BIQUADRATIC_TRIANGLE:
+      myInfo.myNbBiQuadTriangles++;
+      break;
     case VTK_POLYGON:
       myInfo.myNbPolygons++;
       break;
@@ -1638,6 +1675,17 @@ bool SMDS_Mesh::registerElement(int ID, SMDS_MeshElement* element)
   return true;
 }
 
+//=======================================================================
+//function : MoveNode
+//purpose  : 
+//=======================================================================
+
+void SMDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z)
+{
+  SMDS_MeshNode * node=const_cast<SMDS_MeshNode*>(n);
+  node->setXYZ(x,y,z);
+}
+
 ///////////////////////////////////////////////////////////////////////////////
 /// Return the node whose SMDS ID is 'ID'.
 ///////////////////////////////////////////////////////////////////////////////
@@ -1697,21 +1745,20 @@ 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;
@@ -1735,7 +1782,7 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
   if ( NbFaces() % CHECKMEMORY_INTERVAL == 0 ) CheckMemory();
   if(hasConstructionEdges())
   {
-      //MESSAGE("createQuadrangle hasConstructionEdges "<< ID);
+    //MESSAGE("createQuadrangle hasConstructionEdges "<< ID);
     SMDS_MeshEdge *edge1, *edge2, *edge3, *edge4;
     edge1=FindEdgeOrCreate(node1,node2);
     edge2=FindEdgeOrCreate(node2,node3);
@@ -1751,22 +1798,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;
@@ -1781,8 +1827,8 @@ SMDS_MeshFace * SMDS_Mesh::createQuadrangle(const SMDS_MeshNode * node1,
 
 void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
 {
-    MESSAGE("RemoveNode");
-        RemoveElement(node, true);
+  MESSAGE("RemoveNode");
+  RemoveElement(node, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1791,7 +1837,7 @@ void SMDS_Mesh::RemoveNode(const SMDS_MeshNode * node)
 
 void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
 {
-    MESSAGE("Remove0DElement");
+  MESSAGE("Remove0DElement");
   RemoveElement(elem0d,true);
 }
 
@@ -1801,8 +1847,8 @@ void SMDS_Mesh::Remove0DElement(const SMDS_Mesh0DElement * elem0d)
 
 void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
 {
-    MESSAGE("RemoveEdge");
-        RemoveElement(edge,true);
+  MESSAGE("RemoveEdge");
+  RemoveElement(edge,true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1811,8 +1857,8 @@ void SMDS_Mesh::RemoveEdge(const SMDS_MeshEdge * edge)
 
 void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
 {
-    MESSAGE("RemoveFace");
-        RemoveElement(face, true);
+  MESSAGE("RemoveFace");
+  RemoveElement(face, true);
 }
 
 ///////////////////////////////////////////////////////////////////////////////
@@ -1821,8 +1867,8 @@ void SMDS_Mesh::RemoveFace(const SMDS_MeshFace * face)
 
 void SMDS_Mesh::RemoveVolume(const SMDS_MeshVolume * volume)
 {
-    MESSAGE("RemoveVolume");
-        RemoveElement(volume, true);
+  MESSAGE("RemoveVolume");
+  RemoveElement(volume, true);
 }
 
 //=======================================================================
@@ -1832,8 +1878,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));
 }
 
 //=======================================================================
@@ -1843,20 +1889,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;
 }
 
 //=======================================================================
@@ -1876,10 +1922,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
 
@@ -2086,19 +2132,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++;
@@ -2439,14 +2484,14 @@ const SMDS_MeshElement* SMDS_Mesh::FindElement (const vector<const SMDS_MeshNode
       int nbNodesToCheck = noMedium ? e->NbCornerNodes() : e->NbNodes();
       if ( nbNodesToCheck == 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 )
             e = 0;
         }
         if ( e )
-          return static_cast<const SMDS_MeshFace *> (e);
+          return e;
       }
     }
   }
@@ -2656,6 +2701,13 @@ SMDS_Mesh::~SMDS_Mesh()
         myNodeIDFactory->ReleaseID(node->GetID(), node->getVtkId());
       }
   }
+  myGrid->Delete();
+
+  delete myNodePool;
+  delete myVolumePool;
+  delete myFacePool;
+  delete myEdgePool;
+  delete myBallPool;
 }
 
 //================================================================================
@@ -2688,50 +2740,56 @@ void SMDS_Mesh::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;
-      }
-    }
-  myCells.clear();
-  myCellIdVtkToSmds.clear();
-  //myCellIdSmdsToVtk.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();
+  myBallPool->clear();
+
+  clearVector( myCells );
+  clearVector( myCellIdVtkToSmds );
 
   SMDS_NodeIteratorPtr itn = nodesIterator();
   while (itn->more())
     {
       SMDS_MeshNode *node = (SMDS_MeshNode*)(itn->next());
       node->SetPosition(SMDS_SpacePosition::originSpacePosition());
-      myNodePool->destroy(node);
+      //myNodePool->destroy(node);
     }
-  myNodes.clear();
+  myNodePool->clear();
+  clearVector( myNodes );
 
   list<SMDS_Mesh*>::iterator itc=myChildren.begin();
   while(itc!=myChildren.end())
     (*itc)->Clear();
 
   myModified = false;
+  myModifTime++;
   xmin = 0; xmax = 0;
   ymin = 0; ymax = 0;
   zmin = 0; zmax = 0;
@@ -2916,6 +2974,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;
@@ -3343,6 +3406,7 @@ void SMDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elem)
       myNodes[elemId] = 0;
       myInfo.myNbNodes--;
       ((SMDS_MeshNode*) n)->SetPosition(SMDS_SpacePosition::originSpacePosition());
+      ((SMDS_MeshNode*) n)->SMDS_MeshElement::init( -1, -1, -1 ); // avoid reuse
       myNodePool->destroy(static_cast<SMDS_MeshNode*>(todest));
       myNodeIDFactory->ReleaseID(elemId, vtkId);
     }
@@ -3564,30 +3628,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;
 
 }
@@ -3645,33 +3708,119 @@ 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;
+  }
+}
+
+
+//=======================================================================
+//function : AddFace
+//purpose  :
+//=======================================================================
+SMDS_MeshFace* SMDS_Mesh::AddFace(const SMDS_MeshNode * n1,
+                                  const SMDS_MeshNode * n2,
+                                  const SMDS_MeshNode * n3,
+                                  const SMDS_MeshNode * n12,
+                                  const SMDS_MeshNode * n23,
+                                  const SMDS_MeshNode * n31,
+                                  const SMDS_MeshNode * nCenter)
+{
+  return SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,
+                                  myElementIDFactory->GetFreeID());
+}
+
+//=======================================================================
+//function : AddFaceWithID
+//purpose  :
+//=======================================================================
+SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
+                                        int n12,int n23,int n31, int nCenter, int ID)
+{
+  return SMDS_Mesh::AddFaceWithID
+    ((SMDS_MeshNode *)myNodeIDFactory->MeshElement(n1) ,
+     (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n2) ,
+     (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n3) ,
+     (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n12),
+     (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n23),
+     (SMDS_MeshNode *)myNodeIDFactory->MeshElement(n31),
+     (SMDS_MeshNode *)myNodeIDFactory->MeshElement(nCenter),
+     ID);
+}
+
+//=======================================================================
+//function : AddFaceWithID
+//purpose  :
+//=======================================================================
+SMDS_MeshFace* SMDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
+                                        const SMDS_MeshNode * n2,
+                                        const SMDS_MeshNode * n3,
+                                        const SMDS_MeshNode * n12,
+                                        const SMDS_MeshNode * n23,
+                                        const SMDS_MeshNode * n31,
+                                        const SMDS_MeshNode * nCenter,
+                                        int ID)
+{
+  if ( !n1 || !n2 || !n3 || !n12 || !n23 || !n31 || !nCenter) return 0;
+  if(hasConstructionEdges()) {
+    // creation quadratic edges - not implemented
+    return 0;
+  }
+  else
+  {
+    // --- retrieve nodes ID
+    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(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.myNbBiQuadTriangles++;
+
+    //    if (!registerElement(ID, face)) {
+    //      RemoveElement(face, false);
+    //      face = NULL;
+    //    }
     return face;
   }
 }
@@ -3730,40 +3879,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;
   }
 }
@@ -3824,41 +3972,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;
   }
 }
@@ -3931,37 +4078,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;
 }
 
@@ -4044,40 +4190,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;
 }
 
@@ -4168,44 +4313,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;
 }
 
@@ -4311,49 +4455,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;
 }
 
@@ -4484,49 +4627,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++;
@@ -4540,8 +4682,8 @@ void SMDS_Mesh::updateNodeMinMax()
   myNodeMin = 0;
   if (myNodes.size() == 0)
   {
-        myNodeMax=0;
-        return;
+    myNodeMax=0;
+    return;
   }
   while (!myNodes[myNodeMin] && (myNodeMin<myNodes.size()))
     myNodeMin++;