X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHDS%2FSMESHDS_Mesh.cxx;h=df229269b72301b0883d5975b9a08eb8b62c3144;hp=7c233db58e7c600d57822f4c449c121d2103fb61;hb=HEAD;hpb=f3e2b7fea2d36b7dbe2df39f3e08e9c4d9b30e6d

diff --git a/src/SMESHDS/SMESHDS_Mesh.cxx b/src/SMESHDS/SMESHDS_Mesh.cxx
index 7c233db58..adc79ad75 100644
--- a/src/SMESHDS/SMESHDS_Mesh.cxx
+++ b/src/SMESHDS/SMESHDS_Mesh.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2024  CEA, EDF, OPEN CASCADE
 //
 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
@@ -50,22 +50,20 @@
 
 #include "utilities.h"
 
-using namespace std;
-
 class SMESHDS_Mesh::SubMeshHolder : public SMESHDS_TSubMeshHolder< const SMESHDS_SubMesh >
 {
 };
 
 //=======================================================================
 //function : Create
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMESHDS_Mesh::SMESHDS_Mesh(int theMeshID, bool theIsEmbeddedMode):
-  myMeshID(theMeshID),
   mySubMeshHolder( new SubMeshHolder ),
   myIsEmbeddedMode(theIsEmbeddedMode)
 {
   myScript = new SMESHDS_Script(theIsEmbeddedMode);
+
   SetPersistentId(theMeshID);
 }
 
@@ -101,11 +99,11 @@ int SMESHDS_Mesh::GetPersistentId() const
 
 //=======================================================================
 //function : ShapeToMesh
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::ShapeToMesh(const TopoDS_Shape & S)
 {
-  if ( !myShape.IsNull() && S.IsNull() )
+  if ( !myShape.IsNull() && S.IsNull() ) // case: "save study" after geometry removal
   {
     // removal of a shape to mesh, delete ...
     // - hypotheses
@@ -116,7 +114,7 @@ void SMESHDS_Mesh::ShapeToMesh(const TopoDS_Shape & S)
       if ( !sm->IsComplexSubmesh() ) {
         SMDS_NodeIteratorPtr nIt = sm->GetNodes();
         while ( nIt->more() )
-          sm->RemoveNode(nIt->next(), false);
+          sm->RemoveNode(nIt->next());
       }
     }
     // - sub-meshes
@@ -124,7 +122,7 @@ void SMESHDS_Mesh::ShapeToMesh(const TopoDS_Shape & S)
 
     myIndexToShape.Clear();
     // - groups on geometry
-    set<SMESHDS_GroupBase*>::iterator gr = myGroups.begin();
+    std::set<SMESHDS_GroupBase*>::iterator gr = myGroups.begin();
     while ( gr != myGroups.end() ) {
       if ( dynamic_cast<SMESHDS_GroupOnGeom*>( *gr ))
         myGroups.erase( gr++ );
@@ -137,25 +135,27 @@ void SMESHDS_Mesh::ShapeToMesh(const TopoDS_Shape & S)
     if ( !S.IsNull() )
       TopExp::MapShapes(myShape, myIndexToShape);
   }
+
+  SMDS_Mesh::setNbShapes( MaxShapeIndex() );
 }
 
 //=======================================================================
 //function : AddHypothesis
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 bool SMESHDS_Mesh::AddHypothesis(const TopoDS_Shape & SS,
                                  const SMESHDS_Hypothesis * H)
 {
   if (!myShapeToHypothesis.IsBound(SS/*.Oriented(TopAbs_FORWARD)*/)) {
-    list<const SMESHDS_Hypothesis *> aList;
+    std::list<const SMESHDS_Hypothesis *> aList;
     myShapeToHypothesis.Bind(SS/*.Oriented(TopAbs_FORWARD)*/, aList);
   }
-  list<const SMESHDS_Hypothesis *>& alist =
+  std::list<const SMESHDS_Hypothesis *>& alist =
     myShapeToHypothesis(SS/*.Oriented(TopAbs_FORWARD)*/); // ignore orientation of SS
 
   //Check if the Hypothesis is still present
-  list<const SMESHDS_Hypothesis*>::iterator ith = find(alist.begin(),alist.end(), H );
+  std::list<const SMESHDS_Hypothesis*>::iterator ith = find(alist.begin(),alist.end(), H );
 
   if (alist.end() != ith) return false;
 
@@ -165,7 +165,7 @@ bool SMESHDS_Mesh::AddHypothesis(const TopoDS_Shape & SS,
 
 //=======================================================================
 //function : RemoveHypothesis
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 bool SMESHDS_Mesh::RemoveHypothesis(const TopoDS_Shape &       S,
@@ -173,8 +173,8 @@ bool SMESHDS_Mesh::RemoveHypothesis(const TopoDS_Shape &       S,
 {
   if( myShapeToHypothesis.IsBound( S/*.Oriented(TopAbs_FORWARD)*/ ) )
   {
-    list<const SMESHDS_Hypothesis *>& alist=myShapeToHypothesis.ChangeFind( S/*.Oriented(TopAbs_FORWARD)*/ );
-    list<const SMESHDS_Hypothesis*>::iterator ith=find(alist.begin(),alist.end(), H );
+    std::list<const SMESHDS_Hypothesis *>& alist=myShapeToHypothesis.ChangeFind( S/*.Oriented(TopAbs_FORWARD)*/ );
+    std::list<const SMESHDS_Hypothesis*>::iterator ith=find(alist.begin(),alist.end(), H );
     if (ith != alist.end())
     {
       alist.erase(ith);
@@ -186,15 +186,17 @@ bool SMESHDS_Mesh::RemoveHypothesis(const TopoDS_Shape &       S,
 
 //=======================================================================
 //function : AddNode
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshNode* SMESHDS_Mesh::AddNode(double x, double y, double z){
+SMDS_MeshNode* SMESHDS_Mesh::AddNode(double x, double y, double z)
+{
   SMDS_MeshNode* node = SMDS_Mesh::AddNode(x, y, z);
   if(node!=NULL) myScript->AddNode(node->GetID(), x, y, z);
   return node;
 }
 
-SMDS_MeshNode* SMESHDS_Mesh::AddNodeWithID(double x, double y, double z, int ID){
+SMDS_MeshNode* SMESHDS_Mesh::AddNodeWithID(double x, double y, double z, smIdType ID)
+{
   SMDS_MeshNode* node = SMDS_Mesh::AddNodeWithID(x,y,z,ID);
   if(node!=NULL) myScript->AddNode(node->GetID(), x, y, z);
   return node;
@@ -202,7 +204,7 @@ SMDS_MeshNode* SMESHDS_Mesh::AddNodeWithID(double x, double y, double z, int ID)
 
 //=======================================================================
 //function : MoveNode
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 void SMESHDS_Mesh::MoveNode(const SMDS_MeshNode *n, double x, double y, double z)
@@ -223,8 +225,8 @@ bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
   if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
     return false;
 
-  vector<int> IDs( nbnodes );
-  for ( int i = 0; i < nbnodes; i++ )
+  std::vector<smIdType> IDs( nbnodes );
+  for ( smIdType i = 0; i < nbnodes; i++ )
     IDs [ i ] = nodes[ i ]->GetID();
   myScript->ChangeElementNodes( elem->GetID(), &IDs[0], nbnodes);
 
@@ -233,11 +235,10 @@ bool SMESHDS_Mesh::ChangeElementNodes(const SMDS_MeshElement * elem,
 
 //=======================================================================
 //function : ChangePolygonNodes
-//purpose  : 
+//purpose  :
 //=======================================================================
-bool SMESHDS_Mesh::ChangePolygonNodes
-                   (const SMDS_MeshElement *     elem,
-                    vector<const SMDS_MeshNode*> nodes)
+bool SMESHDS_Mesh::ChangePolygonNodes (const SMDS_MeshElement *           elem,
+                                       std::vector<const SMDS_MeshNode*>& nodes)
 {
   ASSERT(nodes.size() > 3);
 
@@ -246,23 +247,23 @@ bool SMESHDS_Mesh::ChangePolygonNodes
 
 //=======================================================================
 //function : ChangePolyhedronNodes
-//purpose  : 
+//purpose  :
 //=======================================================================
-bool SMESHDS_Mesh::ChangePolyhedronNodes
-                   (const SMDS_MeshElement * elem,
-                    std::vector<const SMDS_MeshNode*> nodes,
-                    std::vector<int>                  quantities)
+bool SMESHDS_Mesh
+::ChangePolyhedronNodes (const SMDS_MeshElement *                 elem,
+                         const std::vector<const SMDS_MeshNode*>& nodes,
+                         const std::vector<int> &                 quantities)
 {
   ASSERT(nodes.size() > 3);
 
-  if (!SMDS_Mesh::ChangePolyhedronNodes(elem, nodes, quantities))
+  size_t i, len = nodes.size();
+  std::vector<smIdType> nodes_ids( len );
+  for ( i = 0; i < len; i++ )
+    nodes_ids[i] = nodes[i]->GetID();
+
+  if ( !SMDS_Mesh::ChangePolyhedronNodes( elem, nodes, quantities ))
     return false;
 
-  int i, len = nodes.size();
-  std::vector<int> nodes_ids (len);
-  for (i = 0; i < len; i++) {
-    nodes_ids[i] = nodes[i]->GetID();
-  }
   myScript->ChangePolyhedronNodes(elem->GetID(), nodes_ids, quantities);
 
   return true;
@@ -270,23 +271,23 @@ bool SMESHDS_Mesh::ChangePolyhedronNodes
 
 //=======================================================================
 //function : Renumber
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-void SMESHDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
+void SMESHDS_Mesh::Renumber (const bool /*isNodes*/, const smIdType /*startID*/, const smIdType /*deltaID*/)
 {
   // TODO not possible yet to have node numbers not starting to O and continuous.
-  if (!this->isCompacted())
-    this->compactMesh();
-//  SMDS_Mesh::Renumber( isNodes, startID, deltaID );
-//  myScript->Renumber( isNodes, startID, deltaID );
+  if ( !this->IsCompacted() )
+    this->CompactMesh();
+  //  SMDS_Mesh::Renumber( isNodes, startID, deltaID );
+  //  myScript->Renumber( isNodes, startID, deltaID );
 }
 
 //=======================================================================
 //function : Add0DElement
 //purpose  :
 //=======================================================================
-SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(int nodeID, int ID)
+SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(smIdType nodeID, smIdType ID)
 {
   SMDS_Mesh0DElement* anElem = SMDS_Mesh::Add0DElementWithID(nodeID, ID);
   if (anElem) myScript->Add0DElement(ID, nodeID);
@@ -294,7 +295,7 @@ SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID(int nodeID, int ID)
 }
 
 SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElementWithID
-                                  (const SMDS_MeshNode * node, int ID)
+(const SMDS_MeshNode * node, smIdType ID)
 {
   return Add0DElementWithID(node->GetID(), ID);
 }
@@ -308,10 +309,10 @@ SMDS_Mesh0DElement* SMESHDS_Mesh::Add0DElement(const SMDS_MeshNode * node)
 
 //=======================================================================
 //function :AddBallWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(int node, double diameter, int ID)
+SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(smIdType node, double diameter, smIdType ID)
 {
   SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
   if (anElem) myScript->AddBall(anElem->GetID(), node, diameter);
@@ -320,7 +321,7 @@ SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(int node, double diameter, int ID)
 
 SMDS_BallElement* SMESHDS_Mesh::AddBallWithID(const SMDS_MeshNode * node,
                                               double                diameter,
-                                              int                   ID)
+                                              smIdType                   ID)
 {
   SMDS_BallElement* anElem = SMDS_Mesh::AddBallWithID(node,diameter,ID);
   if (anElem) myScript->AddBall(anElem->GetID(), node->GetID(), diameter);
@@ -337,10 +338,10 @@ SMDS_BallElement* SMESHDS_Mesh::AddBall (const SMDS_MeshNode * node,
 
 //=======================================================================
 //function :AddEdgeWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int ID)
+SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(smIdType n1, smIdType n2, smIdType ID)
 {
   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,ID);
   if(anElem) myScript->AddEdge(ID,n1,n2);
@@ -348,8 +349,8 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int ID)
 }
 
 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
-                                           const SMDS_MeshNode * n2, 
-                                           int ID)
+                                           const SMDS_MeshNode * n2,
+                                           smIdType ID)
 {
   return AddEdgeWithID(n1->GetID(),
                        n2->GetID(),
@@ -360,17 +361,17 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2)
 {
   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdge(n1,n2);
-  if(anElem) myScript->AddEdge(anElem->GetID(), 
-                               n1->GetID(), 
+  if(anElem) myScript->AddEdge(anElem->GetID(),
+                               n1->GetID(),
                                n2->GetID());
   return anElem;
 }
 
 //=======================================================================
 //function :AddFace
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, ID);
   if(anElem) myScript->AddFace(ID,n1,n2,n3);
@@ -379,8 +380,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int ID)
 
 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
-                                           const SMDS_MeshNode * n3, 
-                                           int ID)
+                                           const SMDS_MeshNode * n3,
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(),
                        n2->GetID(),
@@ -393,8 +394,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace( const SMDS_MeshNode * n1,
                                       const SMDS_MeshNode * n3)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1, n2, n3);
-  if(anElem) myScript->AddFace(anElem->GetID(), 
-                               n1->GetID(), 
+  if(anElem) myScript->AddFace(anElem->GetID(),
+                               n1->GetID(),
                                n2->GetID(),
                                n3->GetID());
   return anElem;
@@ -402,9 +403,9 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace( const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function :AddFace
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1, n2, n3, n4, ID);
   if(anElem) myScript->AddFace(ID, n1, n2, n3, n4);
@@ -414,8 +415,8 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4, int I
 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
                                            const SMDS_MeshNode * n3,
-                                           const SMDS_MeshNode * n4, 
-                                           int ID)
+                                           const SMDS_MeshNode * n4,
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(),
                        n2->GetID(),
@@ -430,9 +431,9 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n4)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1, n2, n3, n4);
-  if(anElem) myScript->AddFace(anElem->GetID(), 
-                               n1->GetID(), 
-                               n2->GetID(), 
+  if(anElem) myScript->AddFace(anElem->GetID(),
+                               n1->GetID(),
+                               n2->GetID(),
                                n3->GetID(),
                                n4->GetID());
   return anElem;
@@ -440,9 +441,9 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function :AddVolume
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, ID);
   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4);
@@ -452,11 +453,11 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, i
 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n2,
                                                const SMDS_MeshNode * n3,
-                                               const SMDS_MeshNode * n4, 
-                                               int ID)
+                                               const SMDS_MeshNode * n4,
+                                               smIdType ID)
 {
-  return AddVolumeWithID(n1->GetID(), 
-                         n2->GetID(), 
+  return AddVolumeWithID(n1->GetID(),
+                         n2->GetID(),
                          n3->GetID(),
                          n4->GetID(),
                          ID);
@@ -468,9 +469,9 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                          const SMDS_MeshNode * n4)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4);
-  if(anElem) myScript->AddVolume(anElem->GetID(), 
-                                 n1->GetID(), 
-                                 n2->GetID(), 
+  if(anElem) myScript->AddVolume(anElem->GetID(),
+                                 n1->GetID(),
+                                 n2->GetID(),
                                  n3->GetID(),
                                  n4->GetID());
   return anElem;
@@ -478,9 +479,9 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function :AddVolume
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, ID);
   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5);
@@ -491,13 +492,13 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n2,
                                                const SMDS_MeshNode * n3,
                                                const SMDS_MeshNode * n4,
-                                               const SMDS_MeshNode * n5, 
-                                               int ID)
+                                               const SMDS_MeshNode * n5,
+                                               smIdType ID)
 {
-  return AddVolumeWithID(n1->GetID(), 
-                         n2->GetID(), 
+  return AddVolumeWithID(n1->GetID(),
+                         n2->GetID(),
                          n3->GetID(),
-                         n4->GetID(), 
+                         n4->GetID(),
                          n5->GetID(),
                          ID);
 }
@@ -509,20 +510,20 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                          const SMDS_MeshNode * n5)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5);
-  if(anElem) myScript->AddVolume(anElem->GetID(), 
-                                 n1->GetID(), 
-                                 n2->GetID(), 
+  if(anElem) myScript->AddVolume(anElem->GetID(),
+                                 n1->GetID(),
+                                 n2->GetID(),
                                  n3->GetID(),
-                                 n4->GetID(), 
+                                 n4->GetID(),
                                  n5->GetID());
   return anElem;
 }
 
 //=======================================================================
 //function :AddVolume
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType ID)
 {
   SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, ID);
   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6);
@@ -534,14 +535,14 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n3,
                                                const SMDS_MeshNode * n4,
                                                const SMDS_MeshNode * n5,
-                                               const SMDS_MeshNode * n6, 
-                                               int ID)
+                                               const SMDS_MeshNode * n6,
+                                               smIdType ID)
 {
-  return AddVolumeWithID(n1->GetID(), 
-                         n2->GetID(), 
+  return AddVolumeWithID(n1->GetID(),
+                         n2->GetID(),
                          n3->GetID(),
-                         n4->GetID(), 
-                         n5->GetID(), 
+                         n4->GetID(),
+                         n5->GetID(),
                          n6->GetID(),
                          ID);
 }
@@ -554,21 +555,21 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                          const SMDS_MeshNode * n6)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5, n6);
-  if(anElem) myScript->AddVolume(anElem->GetID(), 
-                                 n1->GetID(), 
-                                 n2->GetID(), 
+  if(anElem) myScript->AddVolume(anElem->GetID(),
+                                 n1->GetID(),
+                                 n2->GetID(),
                                  n3->GetID(),
-                                 n4->GetID(), 
-                                 n5->GetID(), 
+                                 n4->GetID(),
+                                 n5->GetID(),
                                  n6->GetID());
   return anElem;
 }
 
 //=======================================================================
 //function :AddVolume
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5, int n6, int n7, int n8, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5, smIdType n6, smIdType n7, smIdType n8, smIdType ID)
 {
   SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, ID);
   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8);
@@ -582,16 +583,16 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n5,
                                                const SMDS_MeshNode * n6,
                                                const SMDS_MeshNode * n7,
-                                               const SMDS_MeshNode * n8, 
-                                               int ID)
+                                               const SMDS_MeshNode * n8,
+                                               smIdType ID)
 {
-  return AddVolumeWithID(n1->GetID(), 
-                         n2->GetID(), 
+  return AddVolumeWithID(n1->GetID(),
+                         n2->GetID(),
                          n3->GetID(),
-                         n4->GetID(), 
-                         n5->GetID(), 
-                         n6->GetID(), 
-                         n7->GetID(), 
+                         n4->GetID(),
+                         n5->GetID(),
+                         n6->GetID(),
+                         n7->GetID(),
                          n8->GetID(),
                          ID);
 }
@@ -606,14 +607,14 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                          const SMDS_MeshNode * n8)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5, n6, n7, n8);
-  if(anElem) myScript->AddVolume(anElem->GetID(), 
-                                 n1->GetID(), 
-                                 n2->GetID(), 
+  if(anElem) myScript->AddVolume(anElem->GetID(),
+                                 n1->GetID(),
+                                 n2->GetID(),
                                  n3->GetID(),
-                                 n4->GetID(), 
-                                 n5->GetID(), 
-                                 n6->GetID(), 
-                                 n7->GetID(), 
+                                 n4->GetID(),
+                                 n5->GetID(),
+                                 n6->GetID(),
+                                 n7->GetID(),
                                  n8->GetID());
   return anElem;
 }
@@ -623,10 +624,10 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 //function :AddVolume
 //purpose  : add hexagonal prism
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                               int n5, int n6, int n7, int n8,
-                                               int n9, int n10, int n11, int n12,
-                                               int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                               smIdType n5, smIdType n6, smIdType n7, smIdType n8,
+                                               smIdType n9, smIdType n10, smIdType n11, smIdType n12,
+                                               smIdType ID)
 {
   SMDS_MeshVolume *anElem= SMDS_Mesh::AddVolumeWithID(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12, ID);
   if(anElem) myScript->AddVolume(ID, n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12);
@@ -640,14 +641,14 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n5,
                                                const SMDS_MeshNode * n6,
                                                const SMDS_MeshNode * n7,
-                                               const SMDS_MeshNode * n8, 
-                                               const SMDS_MeshNode * n9, 
-                                               const SMDS_MeshNode * n10, 
-                                               const SMDS_MeshNode * n11, 
-                                               const SMDS_MeshNode * n12, 
-                                               int ID)
-{
-  return AddVolumeWithID(n1->GetID(), 
+                                               const SMDS_MeshNode * n8,
+                                               const SMDS_MeshNode * n9,
+                                               const SMDS_MeshNode * n10,
+                                               const SMDS_MeshNode * n11,
+                                               const SMDS_MeshNode * n12,
+                                               smIdType ID)
+{
+  return AddVolumeWithID(n1->GetID(),
                          n2->GetID(),
                          n3->GetID(),
                          n4->GetID(),
@@ -669,14 +670,14 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
                                          const SMDS_MeshNode * n5,
                                          const SMDS_MeshNode * n6,
                                          const SMDS_MeshNode * n7,
-                                         const SMDS_MeshNode * n8, 
-                                         const SMDS_MeshNode * n9, 
-                                         const SMDS_MeshNode * n10, 
-                                         const SMDS_MeshNode * n11, 
+                                         const SMDS_MeshNode * n8,
+                                         const SMDS_MeshNode * n9,
+                                         const SMDS_MeshNode * n10,
+                                         const SMDS_MeshNode * n11,
                                          const SMDS_MeshNode * n12)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1, n2, n3, n4, n5, n6, n7, n8, n9, n10, n11, n12);
-  if(anElem) myScript->AddVolume(anElem->GetID(), 
+  if(anElem) myScript->AddVolume(anElem->GetID(),
                                  n1->GetID(),
                                  n2->GetID(),
                                  n3->GetID(),
@@ -695,10 +696,10 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddPolygonalFace
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nodes_ids,
-                                                     const int               ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
+                                                     const smIdType               ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes_ids, ID);
   if (anElem) {
@@ -709,12 +710,12 @@ SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nod
 
 SMDS_MeshFace*
 SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
-                                      const int                                ID)
+                                      const smIdType                                ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -728,8 +729,8 @@ SMESHDS_Mesh::AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFace(nodes);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -741,10 +742,10 @@ SMESHDS_Mesh::AddPolygonalFace (const std::vector<const SMDS_MeshNode*>& nodes)
 
 //=======================================================================
 //function : AddQuadPolygonalFace
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int>& nodes_ids,
-                                                         const int               ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<smIdType>& nodes_ids,
+                                                         const smIdType               ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes_ids, ID);
   if (anElem) {
@@ -755,12 +756,12 @@ SMDS_MeshFace* SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<int>&
 
 SMDS_MeshFace*
 SMESHDS_Mesh::AddQuadPolygonalFaceWithID (const std::vector<const SMDS_MeshNode*>& nodes,
-                                          const int                                ID)
+                                          const smIdType                                ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFaceWithID(nodes, ID);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -774,8 +775,8 @@ SMESHDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_MeshNode*>& nod
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddQuadPolygonalFace(nodes);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -787,11 +788,11 @@ SMESHDS_Mesh::AddQuadPolygonalFace (const std::vector<const SMDS_MeshNode*>& nod
 
 //=======================================================================
 //function : AddPolyhedralVolume
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>& nodes_ids,
-                                                          const std::vector<int>& quantities,
-                                                          const int               ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<smIdType>& nodes_ids,
+                                                          const std::vector<int>&      quantities,
+                                                          const smIdType               ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes_ids, quantities, ID);
   if (anElem) {
@@ -801,14 +802,14 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>
 }
 
 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
-                               (const std::vector<const SMDS_MeshNode*>& nodes,
-                                const std::vector<int>&                  quantities,
-                                const int                                ID)
+(const std::vector<const SMDS_MeshNode*>& nodes,
+ const std::vector<int>&                  quantities,
+ const smIdType                           ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -818,13 +819,13 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
 }
 
 SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
-                               (const std::vector<const SMDS_MeshNode*>& nodes,
-                                const std::vector<int>&                  quantities)
+(const std::vector<const SMDS_MeshNode*>& nodes,
+ const std::vector<int>&                  quantities)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolume(nodes, quantities);
   if (anElem) {
-    int i, len = nodes.size();
-    std::vector<int> nodes_ids (len);
+    smIdType i, len = nodes.size();
+    std::vector<smIdType> nodes_ids (len);
     for (i = 0; i < len; i++) {
       nodes_ids[i] = nodes[i]->GetID();
     }
@@ -835,13 +836,12 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
 
 //=======================================================================
 //function : removeFromContainers
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-static void removeFromContainers (SMESHDS_Mesh*                  theMesh,
-                                  set<SMESHDS_GroupBase*>&       theGroups,
-                                  list<const SMDS_MeshElement*>& theElems,
-                                  const bool                     isNode)
+static void removeFromContainers (SMESHDS_Mesh*                         /*theMesh*/,
+                                  std::set<SMESHDS_GroupBase*>&         theGroups,
+                                  std::vector<const SMDS_MeshElement*>& theElems)
 {
   if ( theElems.empty() )
     return;
@@ -850,13 +850,13 @@ static void removeFromContainers (SMESHDS_Mesh*                  theMesh,
   // Element can belong to several groups
   if ( !theGroups.empty() )
   {
-    set<SMESHDS_GroupBase*>::iterator GrIt = theGroups.begin();
+    std::set<SMESHDS_GroupBase*>::iterator GrIt = theGroups.begin();
     for ( ; GrIt != theGroups.end(); GrIt++ )
     {
       SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>( *GrIt );
       if ( !group || group->IsEmpty() ) continue;
 
-      list<const SMDS_MeshElement *>::iterator elIt = theElems.begin();
+      std::vector<const SMDS_MeshElement *>::iterator elIt = theElems.begin();
       for ( ; elIt != theElems.end(); elIt++ )
       {
         group->SMDSGroup().Remove( *elIt );
@@ -865,24 +865,24 @@ static void removeFromContainers (SMESHDS_Mesh*                  theMesh,
     }
   }
 
-  const bool deleted=true;
+  //const bool deleted=true;
 
   // Rm from sub-meshes
   // Element should belong to only one sub-mesh
-  if ( theMesh->SubMeshes()->more() )
-  {
-    list<const SMDS_MeshElement *>::iterator elIt = theElems.begin();
-    if ( isNode ) {
-      for ( ; elIt != theElems.end(); ++elIt )
-        if ( SMESHDS_SubMesh* sm = theMesh->MeshElements( (*elIt)->getshapeId() ))
-          sm->RemoveNode( static_cast<const SMDS_MeshNode*> (*elIt), deleted );
-    }
-    else {
-      for ( ; elIt != theElems.end(); ++elIt )
-        if ( SMESHDS_SubMesh* sm = theMesh->MeshElements( (*elIt)->getshapeId() ))
-          sm->RemoveElement( *elIt, deleted );
-    }
-  }
+  // if ( theMesh->SubMeshes()->more() )
+  // {
+  //   std::list<const SMDS_MeshElement *>::iterator elIt = theElems.begin();
+  //   if ( isNode ) {
+  //     for ( ; elIt != theElems.end(); ++elIt )
+  //       if ( SMESHDS_SubMesh* sm = theMesh->MeshElements( (*elIt)->getshapeId() ))
+  //         sm->RemoveNode( static_cast<const SMDS_MeshNode*> (*elIt), deleted );
+  //   }
+  //   else {
+  //     for ( ; elIt != theElems.end(); ++elIt )
+  //       if ( SMESHDS_SubMesh* sm = theMesh->MeshElements( (*elIt)->getshapeId() ))
+  //         sm->RemoveElement( *elIt, deleted );
+  //   }
+  // }
 }
 
 //=======================================================================
@@ -891,56 +891,69 @@ static void removeFromContainers (SMESHDS_Mesh*                  theMesh,
 //=======================================================================
 void SMESHDS_Mesh::RemoveNode(const SMDS_MeshNode * n)
 {
-  if ( n->NbInverseElements() == 0 && !(hasConstructionEdges() || hasConstructionFaces()))
-  {
-    RemoveFreeNode( n, 0, true );
+  if ( RemoveFreeNode( n, 0, true ))
     return;
-  }
 
   myScript->RemoveNode(n->GetID());
 
-  list<const SMDS_MeshElement *> removedElems;
-  list<const SMDS_MeshElement *> removedNodes;
+  // remove inverse elements from the sub-meshes
+  for ( SMDS_ElemIteratorPtr eIt = n->GetInverseElementIterator(); eIt->more() ; )
+  {
+    const SMDS_MeshElement* e = eIt->next();
+    if ( SMESHDS_SubMesh * sm = MeshElements( e->getshapeId() ))
+      sm->RemoveElement( e );
+  }
+  if ( SMESHDS_SubMesh * sm = MeshElements( n->getshapeId() ))
+    sm->RemoveNode( n );
+
+
+  std::vector<const SMDS_MeshElement *> removedElems;
+  std::vector<const SMDS_MeshElement *> removedNodes;
 
   SMDS_Mesh::RemoveElement( n, removedElems, removedNodes, true );
 
-  removeFromContainers( this, myGroups, removedElems, false );
-  removeFromContainers( this, myGroups, removedNodes, true );
+  removeFromContainers( this, myGroups, removedElems );
+  removeFromContainers( this, myGroups, removedNodes );
 }
 
 //=======================================================================
 //function : RemoveFreeNode
-//purpose  : 
+//purpose  :
 //=======================================================================
-void SMESHDS_Mesh::RemoveFreeNode(const SMDS_MeshNode * n,
+bool SMESHDS_Mesh::RemoveFreeNode(const SMDS_MeshNode * n,
                                   SMESHDS_SubMesh *     subMesh,
                                   bool                  fromGroups)
 {
+  if ( n->NbInverseElements() > 0 )
+    return false;
+
   myScript->RemoveNode(n->GetID());
 
   // Rm from group
   // Node can belong to several groups
-  if (fromGroups && !myGroups.empty()) {
-    set<SMESHDS_GroupBase*>::iterator GrIt = myGroups.begin();
+  if ( fromGroups && !myGroups.empty() ) {
+    std::set<SMESHDS_GroupBase*>::iterator GrIt = myGroups.begin();
     for (; GrIt != myGroups.end(); GrIt++) {
       SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>(*GrIt);
-      if (group && !group->IsEmpty())
+      if (group && group->GetType() == SMDSAbs_Node )
         group->SMDSGroup().Remove(n);
     }
   }
 
   // Rm from sub-mesh
   // Node should belong to only one sub-mesh
-  if ( !subMesh || !subMesh->RemoveNode(n,/*deleted=*/false))
+  if ( !subMesh || !subMesh->RemoveNode( n ))
     if (( subMesh = MeshElements( n->getshapeId() )))
-      subMesh->RemoveNode(n,/*deleted=*/false );
+      subMesh->RemoveNode(n);
 
   SMDS_Mesh::RemoveFreeElement(n);
+
+  return true;
 }
 
 //=======================================================================
 //function : RemoveElement
-//purpose  : 
+//purpose  :
 //========================================================================
 void SMESHDS_Mesh::RemoveElement(const SMDS_MeshElement * elt)
 {
@@ -949,7 +962,7 @@ void SMESHDS_Mesh::RemoveElement(const SMDS_MeshElement * elt)
     RemoveNode( static_cast<const SMDS_MeshNode*>( elt ));
     return;
   }
-  if (!hasConstructionEdges() && !hasConstructionFaces())
+  //if (!hasConstructionEdges() && !hasConstructionFaces())
   {
     SMESHDS_SubMesh* subMesh=0;
     if ( elt->getshapeId() > 0 )
@@ -958,20 +971,20 @@ void SMESHDS_Mesh::RemoveElement(const SMDS_MeshElement * elt)
     RemoveFreeElement( elt, subMesh, true );
     return;
   }
- 
+
   myScript->RemoveElement(elt->GetID());
 
-  list<const SMDS_MeshElement *> removedElems;
-  list<const SMDS_MeshElement *> removedNodes;
+  std::vector<const SMDS_MeshElement *> removedElems;
+  std::vector<const SMDS_MeshElement *> removedNodes;
+
+  SMDS_Mesh::RemoveElement(elt, removedElems, removedNodes );
 
-  SMDS_Mesh::RemoveElement(elt, removedElems, removedNodes, false );
-  
-  removeFromContainers( this, myGroups, removedElems, false );
+  removeFromContainers( this, myGroups, removedElems );
 }
 
 //=======================================================================
 //function : RemoveFreeElement
-//purpose  : 
+//purpose  :
 //========================================================================
 void SMESHDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elt,
                                      SMESHDS_SubMesh *        subMesh,
@@ -982,16 +995,16 @@ void SMESHDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elt,
     return;
   }
 
-  if (hasConstructionEdges() || hasConstructionFaces())
-    // this methods is only for meshes without descendants
-    return;
+  // if (hasConstructionEdges() || hasConstructionFaces())
+  //   // this methods is only for meshes without descendants
+  //   return;
 
   myScript->RemoveElement(elt->GetID());
 
   // Rm from group
   // Element can belong to several groups
   if ( fromGroups && !myGroups.empty() ) {
-    set<SMESHDS_GroupBase*>::iterator GrIt = myGroups.begin();
+    std::set<SMESHDS_GroupBase*>::iterator GrIt = myGroups.begin();
     for (; GrIt != myGroups.end(); GrIt++) {
       SMESHDS_Group* group = dynamic_cast<SMESHDS_Group*>(*GrIt);
       if (group && !group->IsEmpty())
@@ -1004,7 +1017,7 @@ void SMESHDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elt,
   if ( !subMesh && elt->getshapeId() > 0 )
     subMesh = MeshElements( elt->getshapeId() );
   if ( subMesh )
-    subMesh->RemoveElement( elt, /*deleted=*/false );
+    subMesh->RemoveElement( elt );
 
   SMDS_Mesh::RemoveFreeElement( elt );
 }
@@ -1035,7 +1048,7 @@ void SMESHDS_Mesh::ClearMesh()
     }
     else
     {
-      (*group)->Extent(); // to free cashed elements in GroupOnFilter's
+      (*group)->Extent(); // to free cached elements in GroupOnFilter's
     }
   }
 }
@@ -1043,8 +1056,8 @@ void SMESHDS_Mesh::ClearMesh()
 //================================================================================
 /*!
  * \brief return submesh by shape
-  * \param shape - the sub-shape
-  * \retval SMESHDS_SubMesh* - the found submesh
+ * \param shape - the sub-shape
+ * \retval SMESHDS_SubMesh* - the found submesh
  */
 //================================================================================
 
@@ -1059,101 +1072,110 @@ SMESHDS_SubMesh* SMESHDS_Mesh::getSubmesh( const TopoDS_Shape & shape )
 //================================================================================
 /*!
  * \brief Add element or node to submesh
-  * \param elem - element to add
-  * \param subMesh - submesh to be filled in
+ * \param elem - element to add
+ * \param subMesh - submesh to be filled in
  */
 //================================================================================
 
-bool SMESHDS_Mesh::add(const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh )
+int SMESHDS_Mesh::add(const SMDS_MeshElement* elem, SMESHDS_SubMesh* subMesh )
 {
   if ( elem && subMesh ) {
-    if ( elem->GetType() == SMDSAbs_Node )
-      subMesh->AddNode( static_cast<const SMDS_MeshNode* >( elem ));
-    else
-      subMesh->AddElement( elem );
-    return true;
+    subMesh->AddElement( elem );
+    return subMesh->GetID();
   }
-  return false;
+  return 0;
 }
 
 //=======================================================================
 //function : SetNodeOnVolume
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode,
                                    const TopoDS_Shell & S)
 {
-  if ( add( aNode, getSubmesh(S) ))
+  if ( int shapeID = add( aNode, getSubmesh( S )))
     const_cast< SMDS_MeshNode* >
-      ( aNode )->SetPosition( SMDS_SpacePosition::originSpacePosition() );
+      ( aNode )->SetPosition( SMDS_SpacePosition::originSpacePosition(), shapeID );
 }
 
 //=======================================================================
 //function : SetNodeOnVolume
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode *      aNode,
                                    const TopoDS_Solid & S)
 {
-  if ( add( aNode, getSubmesh(S) ))
+  if ( int shapeID = add( aNode, getSubmesh( S )))
     const_cast< SMDS_MeshNode* >
-      ( aNode )->SetPosition( SMDS_SpacePosition::originSpacePosition() );
+      ( aNode )->SetPosition( SMDS_SpacePosition::originSpacePosition(), shapeID );
 }
 
 //=======================================================================
 //function : SetNodeOnFace
-//purpose  : 
+//purpose  :
 //=======================================================================
-void SMESHDS_Mesh::SetNodeOnFace(const SMDS_MeshNode *     aNode,
-                                 const TopoDS_Face & S,
-                                 double              u,
-                                 double              v)
+void SMESHDS_Mesh::SetNodeOnFace(const SMDS_MeshNode * aNode,
+                                 const TopoDS_Face &   S,
+                                 double                u,
+                                 double                v)
 {
-  if ( add( aNode, getSubmesh(S) ))
+  if ( int shapeID = add( aNode, getSubmesh( S )))
     const_cast< SMDS_MeshNode* >
-      ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
+      ( aNode )->SetPosition(SMDS_PositionPtr( new SMDS_FacePosition( u, v )), shapeID );
 }
 
 //=======================================================================
 //function : SetNodeOnEdge
-//purpose  : 
+//purpose  :
 //=======================================================================
-void SMESHDS_Mesh::SetNodeOnEdge(const SMDS_MeshNode *     aNode,
-                                 const TopoDS_Edge & S,
-                                 double              u)
+void SMESHDS_Mesh::SetNodeOnEdge(const SMDS_MeshNode * aNode,
+                                 const TopoDS_Edge &   S,
+                                 double                u)
 {
-  if ( add( aNode, getSubmesh(S) ))
+  if ( int shapeID = add( aNode, getSubmesh( S )))
     const_cast< SMDS_MeshNode* >
-      ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
+      ( aNode )->SetPosition(SMDS_PositionPtr( new SMDS_EdgePosition( u )), shapeID );
 }
 
 //=======================================================================
 //function : SetNodeOnVertex
-//purpose  : 
+//purpose  :
 //=======================================================================
-void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode *       aNode,
+void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode * aNode,
                                    const TopoDS_Vertex & S)
 {
-  if ( add( aNode, getSubmesh(S) ))
+  if ( int shapeID = add( aNode, getSubmesh( S )))
     const_cast< SMDS_MeshNode* >
-      ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
+      ( aNode )->SetPosition(SMDS_PositionPtr( new SMDS_VertexPosition()), shapeID );
 }
 
 //=======================================================================
 //function : UnSetNodeOnShape
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::UnSetNodeOnShape(const SMDS_MeshNode* aNode)
 {
   int shapeId = aNode->getshapeId();
   if (shapeId > 0)
     if ( SMESHDS_SubMesh* sm = MeshElements( shapeId ))
-      sm->RemoveNode(aNode, /*deleted=*/false);
+      sm->RemoveNode(aNode);
+}
+
+//=======================================================================
+//function : UnSetElementOnShape
+//purpose  :
+//=======================================================================
+void SMESHDS_Mesh::UnSetElementOnShape(const SMDS_MeshElement * anElement)
+{
+  int shapeId = anElement->getshapeId();
+  if (shapeId > 0)
+    if ( SMESHDS_SubMesh* sm = MeshElements( shapeId ))
+      sm->RemoveElement(anElement);
 }
 
 //=======================================================================
 //function : SetMeshElementOnShape
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement * anElement,
                                          const TopoDS_Shape &     S)
@@ -1163,23 +1185,18 @@ void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement * anElement,
 
 //=======================================================================
 //function : UnSetMeshElementOnShape
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::UnSetMeshElementOnShape(const SMDS_MeshElement * elem,
                                            const TopoDS_Shape &     S)
 {
   if ( SMESHDS_SubMesh* sm = MeshElements( S ))
-  {
-    if (elem->GetType() == SMDSAbs_Node)
-      sm->RemoveNode(static_cast<const SMDS_MeshNode*> (elem), /*deleted=*/false);
-    else
-      sm->RemoveElement(elem, /*deleted=*/false);
-  }
+    sm->RemoveElement(elem);
 }
 
 //=======================================================================
 //function : ShapeToMesh
-//purpose  : 
+//purpose  :
 //=======================================================================
 TopoDS_Shape SMESHDS_Mesh::ShapeToMesh() const
 {
@@ -1198,7 +1215,7 @@ bool SMESHDS_Mesh::IsGroupOfSubShapes (const TopoDS_Shape& theShape) const
     return true;
 
   for ( TopoDS_Iterator it( theShape ); it.More(); it.Next() )
-    if (IsGroupOfSubShapes( it.Value() ))
+    if ( IsGroupOfSubShapes( it.Value() ))
       return true;
 
   return false;
@@ -1224,11 +1241,11 @@ SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const int Index) const
 
 //=======================================================================
 //function : SubMeshIndices
-//purpose  : 
+//purpose  :
 //=======================================================================
-list<int> SMESHDS_Mesh::SubMeshIndices() const
+std::list<int> SMESHDS_Mesh::SubMeshIndices() const
 {
-  list<int> anIndices;
+  std::list<int> anIndices;
   SMESHDS_SubMeshIteratorPtr smIt = SubMeshes();
   while ( const SMESHDS_SubMesh* sm = smIt->next() )
     anIndices.push_back( sm->GetID() );
@@ -1238,7 +1255,7 @@ list<int> SMESHDS_Mesh::SubMeshIndices() const
 
 //=======================================================================
 //function : SubMeshes
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 SMESHDS_SubMeshIteratorPtr SMESHDS_Mesh::SubMeshes() const
@@ -1248,16 +1265,16 @@ SMESHDS_SubMeshIteratorPtr SMESHDS_Mesh::SubMeshes() const
 
 //=======================================================================
 //function : GetHypothesis
-//purpose  : 
+//purpose  :
 //=======================================================================
 
-const list<const SMESHDS_Hypothesis*>&
+const std::list<const SMESHDS_Hypothesis*>&
 SMESHDS_Mesh::GetHypothesis(const TopoDS_Shape & S) const
 {
   if ( myShapeToHypothesis.IsBound( S/*.Oriented(TopAbs_FORWARD)*/ ) ) // ignore orientation of S
-     return myShapeToHypothesis.Find( S/*.Oriented(TopAbs_FORWARD)*/ );
+    return myShapeToHypothesis.Find( S/*.Oriented(TopAbs_FORWARD)*/ );
 
-  static list<const SMESHDS_Hypothesis*> empty;
+  static std::list<const SMESHDS_Hypothesis*> empty;
   return empty;
 }
 
@@ -1278,25 +1295,25 @@ bool SMESHDS_Mesh::IsUsedHypothesis(const SMESHDS_Hypothesis * H) const
 
 //=======================================================================
 //function : GetScript
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMESHDS_Script* SMESHDS_Mesh::GetScript()
 {
-        return myScript;
+  return myScript;
 }
 
 //=======================================================================
 //function : ClearScript
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::ClearScript()
 {
-        myScript->Clear();
+  myScript->Clear();
 }
 
 //=======================================================================
 //function : HasMeshElements
-//purpose  : 
+//purpose  :
 //=======================================================================
 bool SMESHDS_Mesh::HasMeshElements(const TopoDS_Shape & S) const
 {
@@ -1306,7 +1323,7 @@ bool SMESHDS_Mesh::HasMeshElements(const TopoDS_Shape & S) const
 
 //=======================================================================
 //function : HasHypothesis
-//purpose  : 
+//purpose  :
 //=======================================================================
 bool SMESHDS_Mesh::HasHypothesis(const TopoDS_Shape & S)
 {
@@ -1314,8 +1331,8 @@ bool SMESHDS_Mesh::HasHypothesis(const TopoDS_Shape & S)
 }
 
 //=======================================================================
-//function : NewSubMesh 
-//purpose  : 
+//function : NewSubMesh
+//purpose  :
 //=======================================================================
 SMESHDS_SubMesh * SMESHDS_Mesh::NewSubMesh(int Index)
 {
@@ -1330,7 +1347,7 @@ SMESHDS_SubMesh * SMESHDS_Mesh::NewSubMesh(int Index)
 
 //=======================================================================
 //function : AddCompoundSubmesh
-//purpose  : 
+//purpose  :
 //=======================================================================
 
 int SMESHDS_Mesh::AddCompoundSubmesh(const TopoDS_Shape& S,
@@ -1365,7 +1382,7 @@ int SMESHDS_Mesh::AddCompoundSubmesh(const TopoDS_Shape& S,
 
 //=======================================================================
 //function : IndexToShape
-//purpose  : 
+//purpose  :
 //=======================================================================
 const TopoDS_Shape& SMESHDS_Mesh::IndexToShape(int ShapeIndex) const
 {
@@ -1374,7 +1391,7 @@ const TopoDS_Shape& SMESHDS_Mesh::IndexToShape(int ShapeIndex) const
     if ( ShapeIndex > 0 )
       return myIndexToShape.FindKey(ShapeIndex);
   }
-  catch ( Standard_OutOfRange )
+  catch ( ... )
   {
   }
   static TopoDS_Shape nullShape;
@@ -1394,69 +1411,65 @@ int SMESHDS_Mesh::MaxSubMeshIndex() const
 
 //=======================================================================
 //function : ShapeToIndex
-//purpose  : 
+//purpose  :
 //=======================================================================
 int SMESHDS_Mesh::ShapeToIndex(const TopoDS_Shape & S) const
 {
-  if (myShape.IsNull())
-    MESSAGE("myShape is NULL");
-
   int index = myIndexToShape.FindIndex(S);
-  
   return index;
 }
 
 //=======================================================================
 //function : SetNodeOnVolume
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode, int Index)
 {
-  if ( add( aNode, NewSubMesh( Index )))
-    ((SMDS_MeshNode*) aNode)->SetPosition( SMDS_SpacePosition::originSpacePosition());
+  if ( int shapeID = add( aNode, NewSubMesh( Index )))
+    ((SMDS_MeshNode*) aNode)->SetPosition( SMDS_SpacePosition::originSpacePosition(), shapeID );
 }
 
 //=======================================================================
 //function : SetNodeOnFace
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::SetNodeOnFace(const SMDS_MeshNode* aNode, int Index, double u, double v)
 {
   //Set Position on Node
-  if ( add( aNode, NewSubMesh( Index )))
+  if ( int shapeID = add( aNode, NewSubMesh( Index )))
     const_cast< SMDS_MeshNode* >
-      ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
+      ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v )), shapeID );
 }
 
 //=======================================================================
 //function : SetNodeOnEdge
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::SetNodeOnEdge(const SMDS_MeshNode* aNode,
                                  int                  Index,
                                  double               u)
 {
   //Set Position on Node
-  if ( add( aNode, NewSubMesh( Index )))
+  if (  int shapeID = add( aNode, NewSubMesh( Index )))
     const_cast< SMDS_MeshNode* >
-      ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
+      ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition( u )), shapeID );
 }
 
 //=======================================================================
 //function : SetNodeOnVertex
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::SetNodeOnVertex(const SMDS_MeshNode* aNode, int Index)
 {
   //Set Position on Node
-  if ( add( aNode, NewSubMesh( Index )))
+  if (  int shapeID = add( aNode, NewSubMesh( Index )))
     const_cast< SMDS_MeshNode* >
-      ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
+      ( aNode )->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()), shapeID );
 }
 
 //=======================================================================
 //function : SetMeshElementOnShape
-//purpose  : 
+//purpose  :
 //=======================================================================
 void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement* anElement,
                                          int                     Index)
@@ -1466,7 +1479,7 @@ void SMESHDS_Mesh::SetMeshElementOnShape(const SMDS_MeshElement* anElement,
 
 //=======================================================================
 //function : ~SMESHDS_Mesh
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMESHDS_Mesh::~SMESHDS_Mesh()
 {
@@ -1487,9 +1500,9 @@ SMESHDS_Mesh::~SMESHDS_Mesh()
 
 //=======================================================================
 //function : AddEdgeWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID) 
+SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(smIdType n1, smIdType n2, smIdType n12, smIdType ID)
 {
   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdgeWithID(n1,n2,n12,ID);
   if(anElem) myScript->AddEdge(ID,n1,n2,n12);
@@ -1498,15 +1511,15 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(int n1, int n2, int n12, int ID)
 
 //=======================================================================
 //function : AddEdge
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
                                      const SMDS_MeshNode* n2,
                                      const SMDS_MeshNode* n12)
 {
   SMDS_MeshEdge* anElem = SMDS_Mesh::AddEdge(n1,n2,n12);
-  if(anElem) myScript->AddEdge(anElem->GetID(), 
-                               n1->GetID(), 
+  if(anElem) myScript->AddEdge(anElem->GetID(),
+                               n1->GetID(),
                                n2->GetID(),
                                n12->GetID());
   return anElem;
@@ -1514,12 +1527,12 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdge(const SMDS_MeshNode* n1,
 
 //=======================================================================
 //function : AddEdgeWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
-                                           const SMDS_MeshNode * n2, 
-                                           const SMDS_MeshNode * n12, 
-                                           int ID)
+                                           const SMDS_MeshNode * n2,
+                                           const SMDS_MeshNode * n12,
+                                           smIdType ID)
 {
   return AddEdgeWithID(n1->GetID(),
                        n2->GetID(),
@@ -1530,7 +1543,7 @@ SMDS_MeshEdge* SMESHDS_Mesh::AddEdgeWithID(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddFace
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
@@ -1540,7 +1553,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n31)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n12,n23,n31);
-  if(anElem) myScript->AddFace(anElem->GetID(), 
+  if(anElem) myScript->AddFace(anElem->GetID(),
                                n1->GetID(), n2->GetID(), n3->GetID(),
                                n12->GetID(), n23->GetID(), n31->GetID());
   return anElem;
@@ -1548,10 +1561,10 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddFaceWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
-                                           int n12,int n23,int n31, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
+                                           smIdType n12,smIdType n23,smIdType n31, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,ID);
   if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31);
@@ -1560,15 +1573,15 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
 
 //=======================================================================
 //function : AddFaceWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshFace* SMESHDS_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, 
-                                           int ID)
+                                           const SMDS_MeshNode * n31,
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
                        n12->GetID(), n23->GetID(), n31->GetID(),
@@ -1577,7 +1590,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddFace
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
@@ -1588,7 +1601,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * nCenter)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n12,n23,n31,nCenter);
-  if(anElem) myScript->AddFace(anElem->GetID(), 
+  if(anElem) myScript->AddFace(anElem->GetID(),
                                n1->GetID(), n2->GetID(), n3->GetID(),
                                n12->GetID(), n23->GetID(), n31->GetID(),
                                nCenter->GetID());
@@ -1597,10 +1610,10 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddFaceWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
-                                           int n12,int n23,int n31, int nCenter, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3,
+                                           smIdType n12,smIdType n23,smIdType n31, smIdType nCenter, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n12,n23,n31,nCenter,ID);
   if(anElem) myScript->AddFace(ID,n1,n2,n3,n12,n23,n31,nCenter);
@@ -1609,16 +1622,16 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3,
 
 //=======================================================================
 //function : AddFaceWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshFace* SMESHDS_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)
+                                           const SMDS_MeshNode * n31,
+                                           const SMDS_MeshNode * nCenter,
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(),
                        n12->GetID(), n23->GetID(), n31->GetID(),
@@ -1628,7 +1641,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddFace
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
@@ -1640,7 +1653,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n41)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n4,n12,n23,n34,n41);
-  if(anElem) myScript->AddFace(anElem->GetID(), 
+  if(anElem) myScript->AddFace(anElem->GetID(),
                                n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                                n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID());
   return anElem;
@@ -1648,10 +1661,10 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddFaceWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
-                                           int n12,int n23,int n34,int n41, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,ID);
   if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41);
@@ -1660,7 +1673,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
 
 //=======================================================================
 //function : AddFaceWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
@@ -1668,9 +1681,9 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n4,
                                            const SMDS_MeshNode * n12,
                                            const SMDS_MeshNode * n23,
-                                           const SMDS_MeshNode * n34, 
-                                           const SMDS_MeshNode * n41, 
-                                           int ID)
+                                           const SMDS_MeshNode * n34,
+                                           const SMDS_MeshNode * n41,
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                        n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
@@ -1680,7 +1693,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddFace
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n2,
@@ -1689,11 +1702,11 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
                                      const SMDS_MeshNode * n12,
                                      const SMDS_MeshNode * n23,
                                      const SMDS_MeshNode * n34,
-                                     const SMDS_MeshNode * n41, 
+                                     const SMDS_MeshNode * n41,
                                      const SMDS_MeshNode * nCenter)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFace(n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
-  if(anElem) myScript->AddFace(anElem->GetID(), 
+  if(anElem) myScript->AddFace(anElem->GetID(),
                                n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                                n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
                                nCenter->GetID());
@@ -1702,11 +1715,11 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFace(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddFaceWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
-                                           int n12,int n23,int n34,int n41,
-                                           int nCenter, int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                           smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                           smIdType nCenter, smIdType ID)
 {
   SMDS_MeshFace *anElem = SMDS_Mesh::AddFaceWithID(n1,n2,n3,n4,n12,n23,n34,n41,nCenter,ID);
   if(anElem) myScript->AddFace(ID,n1,n2,n3,n4,n12,n23,n34,n41,nCenter);
@@ -1715,7 +1728,7 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(int n1, int n2, int n3, int n4,
 
 //=======================================================================
 //function : AddFaceWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n2,
@@ -1723,10 +1736,10 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
                                            const SMDS_MeshNode * n4,
                                            const SMDS_MeshNode * n12,
                                            const SMDS_MeshNode * n23,
-                                           const SMDS_MeshNode * n34, 
-                                           const SMDS_MeshNode * n41, 
-                                           const SMDS_MeshNode * nCenter, 
-                                           int ID)
+                                           const SMDS_MeshNode * n34,
+                                           const SMDS_MeshNode * n41,
+                                           const SMDS_MeshNode * nCenter,
+                                           smIdType ID)
 {
   return AddFaceWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                        n12->GetID(), n23->GetID(), n34->GetID(), n41->GetID(),
@@ -1736,21 +1749,21 @@ SMDS_MeshFace* SMESHDS_Mesh::AddFaceWithID(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddVolume
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
-                                         const SMDS_MeshNode * n2, 
+                                         const SMDS_MeshNode * n2,
                                          const SMDS_MeshNode * n3,
                                          const SMDS_MeshNode * n4,
                                          const SMDS_MeshNode * n12,
                                          const SMDS_MeshNode * n23,
                                          const SMDS_MeshNode * n31,
-                                         const SMDS_MeshNode * n14, 
+                                         const SMDS_MeshNode * n14,
                                          const SMDS_MeshNode * n24,
                                          const SMDS_MeshNode * n34)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n12,n23,n31,n14,n24,n34);
-  if(anElem) myScript->AddVolume(anElem->GetID(), 
+  if(anElem) myScript->AddVolume(anElem->GetID(),
                                  n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                                  n12->GetID(), n23->GetID(), n31->GetID(),
                                  n14->GetID(), n24->GetID(), n34->GetID());
@@ -1759,18 +1772,18 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddVolumeWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                               int n12,int n23,int n31,
-                                               int n14,int n24,int n34, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                               smIdType n12,smIdType n23,smIdType n31,
+                                               smIdType n14,smIdType n24,smIdType n34, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n12,n23,
                                                        n31,n14,n24,n34,ID);
   if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n12,n23,n31,n14,n24,n34);
   return anElem;
 }
-        
+
 //=======================================================================
 //function : AddVolumeWithID
 //purpose  : 2d order tetrahedron of 10 nodes
@@ -1782,10 +1795,10 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n12,
                                                const SMDS_MeshNode * n23,
                                                const SMDS_MeshNode * n31,
-                                               const SMDS_MeshNode * n14, 
+                                               const SMDS_MeshNode * n14,
                                                const SMDS_MeshNode * n24,
                                                const SMDS_MeshNode * n34,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                          n12->GetID(), n23->GetID(), n31->GetID(),
@@ -1795,18 +1808,18 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddVolume
-//purpose  : 
+//purpose  :
 //=======================================================================
 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
-                                         const SMDS_MeshNode * n2, 
+                                         const SMDS_MeshNode * n2,
                                          const SMDS_MeshNode * n3,
                                          const SMDS_MeshNode * n4,
-                                         const SMDS_MeshNode * n5, 
+                                         const SMDS_MeshNode * n5,
                                          const SMDS_MeshNode * n12,
                                          const SMDS_MeshNode * n23,
                                          const SMDS_MeshNode * n34,
                                          const SMDS_MeshNode * n41,
-                                         const SMDS_MeshNode * n15, 
+                                         const SMDS_MeshNode * n15,
                                          const SMDS_MeshNode * n25,
                                          const SMDS_MeshNode * n35,
                                          const SMDS_MeshNode * n45)
@@ -1823,11 +1836,11 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddVolumeWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, int n5,
-                                               int n12,int n23,int n34,int n41,
-                                               int n15,int n25,int n35,int n45, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4, smIdType n5,
+                                               smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                               smIdType n15,smIdType n25,smIdType n35,smIdType n45, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,
                                                        n12,n23,n34,n41,
@@ -1836,7 +1849,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4, i
                                  n15,n25,n35,n45);
   return anElem;
 }
-        
+
 //=======================================================================
 //function : AddVolumeWithID
 //purpose  : 2d order pyramid of 13 nodes
@@ -1845,16 +1858,16 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n2,
                                                const SMDS_MeshNode * n3,
                                                const SMDS_MeshNode * n4,
-                                               const SMDS_MeshNode * n5, 
+                                               const SMDS_MeshNode * n5,
                                                const SMDS_MeshNode * n12,
                                                const SMDS_MeshNode * n23,
                                                const SMDS_MeshNode * n34,
                                                const SMDS_MeshNode * n41,
-                                               const SMDS_MeshNode * n15, 
+                                               const SMDS_MeshNode * n15,
                                                const SMDS_MeshNode * n25,
                                                const SMDS_MeshNode * n35,
                                                const SMDS_MeshNode * n45,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
                          n4->GetID(), n5->GetID(),
@@ -1866,20 +1879,20 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddVolume
-//purpose  : 
+//purpose  : 2nd order pentahedron (prism) with 15 nodes
 //=======================================================================
 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
-                                         const SMDS_MeshNode * n2, 
+                                         const SMDS_MeshNode * n2,
                                          const SMDS_MeshNode * n3,
                                          const SMDS_MeshNode * n4,
-                                         const SMDS_MeshNode * n5, 
-                                         const SMDS_MeshNode * n6, 
+                                         const SMDS_MeshNode * n5,
+                                         const SMDS_MeshNode * n6,
                                          const SMDS_MeshNode * n12,
                                          const SMDS_MeshNode * n23,
-                                         const SMDS_MeshNode * n31, 
+                                         const SMDS_MeshNode * n31,
                                          const SMDS_MeshNode * n45,
                                          const SMDS_MeshNode * n56,
-                                         const SMDS_MeshNode * n64, 
+                                         const SMDS_MeshNode * n64,
                                          const SMDS_MeshNode * n14,
                                          const SMDS_MeshNode * n25,
                                          const SMDS_MeshNode * n36)
@@ -1897,13 +1910,13 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddVolumeWithID
-//purpose  : 
+//purpose  : 2nd order pentahedron (prism) with 15 nodes
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
-                                               int n4, int n5, int n6,
-                                               int n12,int n23,int n31,
-                                               int n45,int n56,int n64,
-                                               int n14,int n25,int n36, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
+                                               smIdType n4, smIdType n5, smIdType n6,
+                                               smIdType n12,smIdType n23,smIdType n31,
+                                               smIdType n45,smIdType n56,smIdType n64,
+                                               smIdType n14,smIdType n25,smIdType n36, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
                                                        n12,n23,n31,
@@ -1913,27 +1926,27 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3,
                                  n45,n56,n64,n14,n25,n36);
   return anElem;
 }
-        
+
 //=======================================================================
 //function : AddVolumeWithID
-//purpose  : 2d order Pentahedron with 15 nodes
+//purpose  : 2d order Pentahedron (prism) with 15 nodes
 //=======================================================================
 SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n2,
                                                const SMDS_MeshNode * n3,
                                                const SMDS_MeshNode * n4,
-                                               const SMDS_MeshNode * n5, 
-                                               const SMDS_MeshNode * n6, 
+                                               const SMDS_MeshNode * n5,
+                                               const SMDS_MeshNode * n6,
                                                const SMDS_MeshNode * n12,
                                                const SMDS_MeshNode * n23,
-                                               const SMDS_MeshNode * n31, 
+                                               const SMDS_MeshNode * n31,
                                                const SMDS_MeshNode * n45,
                                                const SMDS_MeshNode * n56,
-                                               const SMDS_MeshNode * n64, 
+                                               const SMDS_MeshNode * n64,
                                                const SMDS_MeshNode * n14,
                                                const SMDS_MeshNode * n25,
                                                const SMDS_MeshNode * n36,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
                          n4->GetID(), n5->GetID(), n6->GetID(),
@@ -1942,6 +1955,95 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                          n14->GetID(), n25->GetID(), n36->GetID(),
                          ID);
 }
+//=======================================================================
+//function : AddVolume
+//purpose  : 2nd order pentahedron (prism) with 18 nodes
+//=======================================================================
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
+                                         const SMDS_MeshNode * n2,
+                                         const SMDS_MeshNode * n3,
+                                         const SMDS_MeshNode * n4,
+                                         const SMDS_MeshNode * n5,
+                                         const SMDS_MeshNode * n6,
+                                         const SMDS_MeshNode * n12,
+                                         const SMDS_MeshNode * n23,
+                                         const SMDS_MeshNode * n31,
+                                         const SMDS_MeshNode * n45,
+                                         const SMDS_MeshNode * n56,
+                                         const SMDS_MeshNode * n64,
+                                         const SMDS_MeshNode * n14,
+                                         const SMDS_MeshNode * n25,
+                                         const SMDS_MeshNode * n36,
+                                         const SMDS_MeshNode * n1245,
+                                         const SMDS_MeshNode * n2356,
+                                         const SMDS_MeshNode * n1346)
+{
+  SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolume(n1,n2,n3,n4,n5,n6,n12,n23,n31,
+                                                 n45,n56,n64,n14,n25,n36,
+                                                 n1245, n2356, n1346);
+  if(anElem)
+    myScript->AddVolume(anElem->GetID(), n1->GetID(), n2->GetID(),
+                        n3->GetID(), n4->GetID(), n5->GetID(), n6->GetID(),
+                        n12->GetID(), n23->GetID(), n31->GetID(),
+                        n45->GetID(), n56->GetID(), n64->GetID(),
+                        n14->GetID(), n25->GetID(), n36->GetID(),
+                        n1245->GetID(), n2356->GetID(), n1346->GetID());
+  return anElem;
+}
+
+//=======================================================================
+//function : AddVolumeWithID
+//purpose  : 2nd order pentahedron (prism) with 18 nodes
+//=======================================================================
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3,
+                                               smIdType n4, smIdType n5, smIdType n6,
+                                               smIdType n12,smIdType n23,smIdType n31,
+                                               smIdType n45,smIdType n56,smIdType n64,
+                                               smIdType n14,smIdType n25,smIdType n36,
+                                               smIdType n1245, smIdType n2356, smIdType n1346,
+                                               smIdType ID)
+{
+  SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,
+                                                       n12,n23,n31,
+                                                       n45,n56,n64,
+                                                       n14,n25,n36,
+                                                       n1245, n2356, n1346, ID);
+  if(anElem) myScript->AddVolume(ID,n1,n2,n3,n4,n5,n6,n12,n23,n31,
+                                 n45,n56,n64,n14,n25,n36, n1245, n2356, n1346);
+  return anElem;
+}
+
+//=======================================================================
+//function : AddVolumeWithID
+//purpose  : 2d order Pentahedron with 18 nodes
+//=======================================================================
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
+                                               const SMDS_MeshNode * n2,
+                                               const SMDS_MeshNode * n3,
+                                               const SMDS_MeshNode * n4,
+                                               const SMDS_MeshNode * n5,
+                                               const SMDS_MeshNode * n6,
+                                               const SMDS_MeshNode * n12,
+                                               const SMDS_MeshNode * n23,
+                                               const SMDS_MeshNode * n31,
+                                               const SMDS_MeshNode * n45,
+                                               const SMDS_MeshNode * n56,
+                                               const SMDS_MeshNode * n64,
+                                               const SMDS_MeshNode * n14,
+                                               const SMDS_MeshNode * n25,
+                                               const SMDS_MeshNode * n36,
+                                               const SMDS_MeshNode * n1245,
+                                               const SMDS_MeshNode * n2356,
+                                               const SMDS_MeshNode * n1346,
+                                               smIdType ID)
+{
+  return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(),
+                         n4->GetID(), n5->GetID(), n6->GetID(),
+                         n12->GetID(), n23->GetID(), n31->GetID(),
+                         n45->GetID(), n56->GetID(), n64->GetID(),
+                         n14->GetID(), n25->GetID(), n36->GetID(),
+                         n1245->GetID(), n2356->GetID(), n1346->GetID(), ID);
+}
 
 
 //=======================================================================
@@ -1949,21 +2051,21 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
 //purpose  : add quadratic hexahedron
 //=======================================================================
 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
-                                         const SMDS_MeshNode * n2, 
+                                         const SMDS_MeshNode * n2,
                                          const SMDS_MeshNode * n3,
                                          const SMDS_MeshNode * n4,
-                                         const SMDS_MeshNode * n5, 
-                                         const SMDS_MeshNode * n6, 
+                                         const SMDS_MeshNode * n5,
+                                         const SMDS_MeshNode * n6,
                                          const SMDS_MeshNode * n7,
-                                         const SMDS_MeshNode * n8, 
+                                         const SMDS_MeshNode * n8,
                                          const SMDS_MeshNode * n12,
                                          const SMDS_MeshNode * n23,
                                          const SMDS_MeshNode * n34,
-                                         const SMDS_MeshNode * n41, 
+                                         const SMDS_MeshNode * n41,
                                          const SMDS_MeshNode * n56,
                                          const SMDS_MeshNode * n67,
                                          const SMDS_MeshNode * n78,
-                                         const SMDS_MeshNode * n85, 
+                                         const SMDS_MeshNode * n85,
                                          const SMDS_MeshNode * n15,
                                          const SMDS_MeshNode * n26,
                                          const SMDS_MeshNode * n37,
@@ -1985,13 +2087,13 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
 
 //=======================================================================
 //function : AddVolumeWithID
-//purpose  : 
+//purpose  :
 //=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                               int n5, int n6, int n7, int n8,
-                                               int n12,int n23,int n34,int n41,
-                                               int n56,int n67,int n78,int n85,
-                                               int n15,int n26,int n37,int n48, int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                               smIdType n5, smIdType n6, smIdType n7, smIdType n8,
+                                               smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                               smIdType n56,smIdType n67,smIdType n78,smIdType n85,
+                                               smIdType n15,smIdType n26,smIdType n37,smIdType n48, smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
                                                        n12,n23,n34,n41,
@@ -2001,7 +2103,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
                                  n56,n67,n78,n85,n15,n26,n37,n48);
   return anElem;
 }
-        
+
 //=======================================================================
 //function : AddVolumeWithID
 //purpose  : 2d order Hexahedrons with 20 nodes
@@ -2010,23 +2112,23 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n2,
                                                const SMDS_MeshNode * n3,
                                                const SMDS_MeshNode * n4,
-                                               const SMDS_MeshNode * n5, 
-                                               const SMDS_MeshNode * n6, 
+                                               const SMDS_MeshNode * n5,
+                                               const SMDS_MeshNode * n6,
                                                const SMDS_MeshNode * n7,
-                                               const SMDS_MeshNode * n8, 
+                                               const SMDS_MeshNode * n8,
                                                const SMDS_MeshNode * n12,
                                                const SMDS_MeshNode * n23,
                                                const SMDS_MeshNode * n34,
-                                               const SMDS_MeshNode * n41, 
+                                               const SMDS_MeshNode * n41,
                                                const SMDS_MeshNode * n56,
                                                const SMDS_MeshNode * n67,
                                                const SMDS_MeshNode * n78,
-                                               const SMDS_MeshNode * n85, 
+                                               const SMDS_MeshNode * n85,
                                                const SMDS_MeshNode * n15,
                                                const SMDS_MeshNode * n26,
                                                const SMDS_MeshNode * n37,
                                                const SMDS_MeshNode * n48,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                          n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
@@ -2042,25 +2144,25 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
 //=======================================================================
 
 SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
-                                         const SMDS_MeshNode * n2, 
+                                         const SMDS_MeshNode * n2,
                                          const SMDS_MeshNode * n3,
                                          const SMDS_MeshNode * n4,
-                                         const SMDS_MeshNode * n5, 
-                                         const SMDS_MeshNode * n6, 
+                                         const SMDS_MeshNode * n5,
+                                         const SMDS_MeshNode * n6,
                                          const SMDS_MeshNode * n7,
-                                         const SMDS_MeshNode * n8, 
+                                         const SMDS_MeshNode * n8,
                                          const SMDS_MeshNode * n12,
                                          const SMDS_MeshNode * n23,
                                          const SMDS_MeshNode * n34,
-                                         const SMDS_MeshNode * n41, 
+                                         const SMDS_MeshNode * n41,
                                          const SMDS_MeshNode * n56,
                                          const SMDS_MeshNode * n67,
                                          const SMDS_MeshNode * n78,
-                                         const SMDS_MeshNode * n85, 
+                                         const SMDS_MeshNode * n85,
                                          const SMDS_MeshNode * n15,
                                          const SMDS_MeshNode * n26,
                                          const SMDS_MeshNode * n37,
-                                         const SMDS_MeshNode * n48, 
+                                         const SMDS_MeshNode * n48,
                                          const SMDS_MeshNode * n1234,
                                          const SMDS_MeshNode * n1256,
                                          const SMDS_MeshNode * n2367,
@@ -2086,14 +2188,14 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolume(const SMDS_MeshNode * n1,
   return anElem;
 }
 
-SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(int n1, int n2, int n3, int n4,
-                                               int n5, int n6, int n7, int n8,
-                                               int n12,int n23,int n34,int n41,
-                                               int n56,int n67,int n78,int n85,
-                                               int n15,int n26,int n37,int n48,
-                                               int n1234,int n1256,int n2367,int n3478,
-                                               int n1458,int n5678,int nCenter,
-                                               int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(smIdType n1, smIdType n2, smIdType n3, smIdType n4,
+                                               smIdType n5, smIdType n6, smIdType n7, smIdType n8,
+                                               smIdType n12,smIdType n23,smIdType n34,smIdType n41,
+                                               smIdType n56,smIdType n67,smIdType n78,smIdType n85,
+                                               smIdType n15,smIdType n26,smIdType n37,smIdType n48,
+                                               smIdType n1234,smIdType n1256,smIdType n2367,smIdType n3478,
+                                               smIdType n1458,smIdType n5678,smIdType nCenter,
+                                               smIdType ID)
 {
   SMDS_MeshVolume *anElem = SMDS_Mesh::AddVolumeWithID(n1,n2,n3,n4,n5,n6,n7,n8,
                                                        n12,n23,n34,n41,
@@ -2128,7 +2230,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n15,
                                                const SMDS_MeshNode * n26,
                                                const SMDS_MeshNode * n37,
-                                               const SMDS_MeshNode * n48, 
+                                               const SMDS_MeshNode * n48,
                                                const SMDS_MeshNode * n1234,
                                                const SMDS_MeshNode * n1256,
                                                const SMDS_MeshNode * n2367,
@@ -2136,7 +2238,7 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                                                const SMDS_MeshNode * n1458,
                                                const SMDS_MeshNode * n5678,
                                                const SMDS_MeshNode * nCenter,
-                                               int ID)
+                                               smIdType ID)
 {
   return AddVolumeWithID(n1->GetID(), n2->GetID(), n3->GetID(), n4->GetID(),
                          n5->GetID(), n6->GetID(), n7->GetID(), n8->GetID(),
@@ -2147,158 +2249,14 @@ SMDS_MeshVolume* SMESHDS_Mesh::AddVolumeWithID(const SMDS_MeshNode * n1,
                          n1458->GetID(),n5678->GetID(),nCenter->GetID(), ID);
 }
 
-void SMESHDS_Mesh::compactMesh()
+void SMESHDS_Mesh::CompactMesh()
 {
-  int newNodeSize = 0;
-  int nbNodes = myNodes.size();
-  int nbVtkNodes = myGrid->GetNumberOfPoints();
-  //MESSAGE("nbNodes=" << nbNodes << " nbVtkNodes=" << nbVtkNodes);
-  int nbNodeTemp = nbVtkNodes;
-  if (nbNodes > nbVtkNodes)
-    nbNodeTemp = nbNodes;
-  vector<int> idNodesOldToNew;
-  idNodesOldToNew.clear();
-  idNodesOldToNew.resize(nbNodeTemp, -1); // all unused id will be -1
-
-  for (int i = 0; i < nbNodes; i++)
-  {
-    if (myNodes[i])
-    {
-      int vtkid = myNodes[i]->getVtkId();
-      idNodesOldToNew[vtkid] = i; // old vtkId --> old smdsId (valid smdsId are >= 0)
-      newNodeSize++;
-    }
-  }
-  bool areNodesModified = (newNodeSize < nbVtkNodes);
-  //MESSAGE("------------------------- compactMesh Nodes Modified: " << areNodesModified);
-  areNodesModified = true;
-
-  int newCellSize = 0;
-  int nbCells = myCells.size();
-  int nbVtkCells = myGrid->GetNumberOfCells();
-  //MESSAGE("nbCells=" << nbCells << " nbVtkCells=" << nbVtkCells);
-  int nbCellTemp = nbVtkCells;
-  if (nbCells > nbVtkCells)
-    nbCellTemp = nbCells;
-  vector<int> idCellsOldToNew;
-  idCellsOldToNew.clear();
-  idCellsOldToNew.resize(nbCellTemp, -1); // all unused id will be -1
-
-  for (int i = 0; i < nbCells; i++)
-  {
-    if (myCells[i])
-    {
-      //          //idCellsOldToNew[i] = myCellIdVtkToSmds[i]; // valid vtk indexes are > = 0
-      //          int vtkid = myCells[i]->getVtkId();
-      //          idCellsOldToNew[vtkid] = i; // old vtkId --> old smdsId (not used in input)
-      newCellSize++;
-    }
-  }
-  if (areNodesModified)
-    myGrid->compactGrid(idNodesOldToNew, newNodeSize, idCellsOldToNew, newCellSize);
-  else
-    myGrid->compactGrid(idNodesOldToNew, 0, idCellsOldToNew, newCellSize);
-
-  int nbVtkPts = myGrid->GetNumberOfPoints();
-  nbVtkCells = myGrid->GetNumberOfCells();
-  if (nbVtkPts != newNodeSize)
-  {
-    MESSAGE("===> nbVtkPts != newNodeSize " << nbVtkPts << " " << newNodeSize);
-    if (nbVtkPts > newNodeSize) newNodeSize = nbVtkPts; // several points with same SMDS Id
-  }
-  if (nbVtkCells != newCellSize)
-  {
-    MESSAGE("===> nbVtkCells != newCellSize " << nbVtkCells << " " << newCellSize);
-    if (nbVtkCells > newCellSize) newCellSize = nbVtkCells; // several cells with same SMDS Id
-  }
-
-  // --- SMDS_MeshNode and myNodes (id in SMDS and in VTK are the same), myNodeIdFactory
-
-  if (areNodesModified)
-  {
-    //MESSAGE("-------------- modify myNodes");
-    SetOfNodes newNodes;
-    newNodes.resize(newNodeSize+1,0); // 0 not used, SMDS numbers 1..n
-    int newSmdsId = 0;
-    for (int i = 0; i < nbNodes; i++)
-    {
-      if (myNodes[i])
-      {
-        newSmdsId++; // SMDS id start to 1
-        int oldVtkId = myNodes[i]->getVtkId();
-        int newVtkId = idNodesOldToNew[oldVtkId];
-        //MESSAGE("myNodes["<< i << "] vtkId " << oldVtkId << " --> " << newVtkId);
-        myNodes[i]->setVtkId(newVtkId);
-        myNodes[i]->setId(newSmdsId);
-        newNodes[newSmdsId] = myNodes[i];
-        //MESSAGE("myNodes["<< i << "] --> newNodes[" << newSmdsId << "]");
-      }
-    }
-    myNodes.swap(newNodes);
-    this->myNodeIDFactory->emptyPool(newSmdsId); // newSmdsId = number of nodes
-    //MESSAGE("myNodes.size " << myNodes.size());
-  }
-
-  // --- SMDS_MeshCell, myCellIdVtkToSmds, myCellIdSmdsToVtk, myCells
-
-  int vtkIndexSize = myCellIdVtkToSmds.size();
-  int maxVtkId = -1;
-  for (int oldVtkId = 0; oldVtkId < vtkIndexSize; oldVtkId++)
-  {
-    int oldSmdsId = this->myCellIdVtkToSmds[oldVtkId];
-    if (oldSmdsId > 0)
-    {
-      int newVtkId = idCellsOldToNew[oldVtkId];
-      if (newVtkId > maxVtkId)
-        maxVtkId = newVtkId;
-      //MESSAGE("myCells["<< oldSmdsId << "] vtkId " << oldVtkId << " --> " << newVtkId);
-      myCells[oldSmdsId]->setVtkId(newVtkId);
-    }
-  }
-  //  MESSAGE("myCells.size()=" << myCells.size()
-  //          << " myCellIdSmdsToVtk.size()=" << myCellIdSmdsToVtk.size()
-  //          << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
-
-  SetOfCells newCells;
-  //vector<int> newSmdsToVtk;
-  vector<int> newVtkToSmds;
-
-  assert(maxVtkId < newCellSize);
-  newCells.resize(newCellSize+1, 0); // 0 not used, SMDS numbers 1..n
-  //newSmdsToVtk.resize(newCellSize+1, -1);
-  newVtkToSmds.resize(newCellSize+1, -1);
-
-  int myCellsSize = myCells.size();
-  int newSmdsId = 0;
-  for (int i = 0; i < myCellsSize; i++)
-  {
-    if ( myCells[i] )
-    {
-      newSmdsId++; // SMDS id start to 1
-      assert(newSmdsId <= newCellSize);
-      newCells[newSmdsId] = myCells[i];
-      newCells[newSmdsId]->setId(newSmdsId);
-      //MESSAGE("myCells["<< i << "] --> newCells[" << newSmdsId << "]");
-      int idvtk = myCells[i]->getVtkId();
-      //newSmdsToVtk[newSmdsId] = idvtk;
-      assert(idvtk < newCellSize);
-      newVtkToSmds[idvtk] = newSmdsId;
-    }
-  }
+  if ( IsCompacted() )
+    return;
 
-  myCells.swap(newCells);
-  //myCellIdSmdsToVtk.swap(newSmdsToVtk);
-  myCellIdVtkToSmds.swap(newVtkToSmds);
-  //MESSAGE("myCells.size()="<< myCells.size()<<" myCellIdVtkToSmds.size()="<<myCellIdVtkToSmds.size() );
-  this->myElementIDFactory->emptyPool(newSmdsId);
+  SMDS_Mesh::CompactMesh();
 
   this->myScript->SetModified(true); // notify GUI client for buildPrs when update
-
-  // --- compact list myNodes and myElements in submeshes
-
-  SMESHDS_SubMeshIteratorPtr smIt = SubMeshes();
-  while ( SMESHDS_SubMesh* sm = const_cast< SMESHDS_SubMesh* >( smIt->next() ))
-    sm->compactList();
 }
 
 void SMESHDS_Mesh::CleanDownWardConnectivity()
@@ -2317,7 +2275,7 @@ void SMESHDS_Mesh::BuildDownWardConnectivity(bool withEdges)
  * @param localClonedNodeIds map old node id to new node id.
  * @return ok if success.
  */
-bool SMESHDS_Mesh::ModifyCellNodes(int vtkVolId, std::map<int,int> localClonedNodeIds)
+bool SMESHDS_Mesh::ModifyCellNodes(vtkIdType vtkVolId, std::map<int,int> localClonedNodeIds)
 {
   myGrid->ModifyCellNodes(vtkVolId, localClonedNodeIds);
   return true;