X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FOBJECT%2FSMESH_Object.cxx;h=6f8551d094964091a1f2783b1bea2c7b62dca616;hp=038a2a2bc092de49aaee6083a690cb055abb6d14;hb=HEAD;hpb=45b7e5c3e156b516962f86d15df69b12d8060363

diff --git a/src/OBJECT/SMESH_Object.cxx b/src/OBJECT/SMESH_Object.cxx
index 038a2a2bc..585442ccb 100644
--- a/src/OBJECT/SMESH_Object.cxx
+++ b/src/OBJECT/SMESH_Object.cxx
@@ -1,4 +1,4 @@
-// Copyright (C) 2007-2014  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
@@ -28,14 +28,17 @@
 #include "SMESH_ObjectDef.h"
 #include "SMESH_ActorUtils.h"
 
-#include "SMDS_Mesh.hxx"
-#include "SMDS_PolyhedralVolumeOfNodes.hxx"
 #include "SMDS_BallElement.hxx"
+#include "SMDS_Mesh.hxx"
+#include "SMDS_MeshCell.hxx"
+#include "SMESHDS_Mesh.hxx"
+#include "SMESHDS_Script.hxx"
 #include "SMESH_Actor.h"
 #include "SMESH_ControlsDef.hxx"
-#include "SalomeApp_Application.h"
-#include "VTKViewer_ExtractUnstructuredGrid.h"
-#include "VTKViewer_CellLocationsArray.h"
+
+#include <SalomeApp_Application.h>
+#include <VTKViewer_ExtractUnstructuredGrid.h>
+//#include <VTKViewer_CellLocationsArray.h>
 
 #include CORBA_SERVER_HEADER(SMESH_Gen)
 #include CORBA_SERVER_HEADER(SALOME_Exception)
@@ -52,7 +55,7 @@
 #include <stdexcept>
 #include <set>
 
-#include "utilities.h"
+#include <utilities.h>
 
 using namespace std;
 
@@ -64,74 +67,19 @@ using namespace std;
 }
 #endif
 
-#ifdef _DEBUG_
-static int MYDEBUG = 1;
 static int MYDEBUGWITHFILES = 0;//1;
-#else
-static int MYDEBUG = 0;
-static int MYDEBUGWITHFILES = 0;
-#endif
-
 
 /*
   Class       : SMESH_VisualObjDef
   Description : Base class for all mesh objects to be visuilised
 */
-
-//=================================================================================
-// function : getCellType
-// purpose  : Get type of VTK cell
-//=================================================================================
-static inline vtkIdType getCellType( const SMDSAbs_ElementType theType,
-                                     const bool                thePoly,
-                                     const int                 theNbNodes )
-{
-  switch( theType )
-  {
-    case SMDSAbs_0DElement:         return VTK_VERTEX;
-
-    case SMDSAbs_Ball:              return VTK_POLY_VERTEX;
-
-    case SMDSAbs_Edge: 
-      if( theNbNodes == 2 )         return VTK_LINE;
-      else if ( theNbNodes == 3 )   return VTK_QUADRATIC_EDGE;
-      else return VTK_EMPTY_CELL;
-
-    case SMDSAbs_Face  :
-      if (thePoly && theNbNodes>2 ) return VTK_POLYGON;
-      else if ( theNbNodes == 3 )   return VTK_TRIANGLE;
-      else if ( theNbNodes == 4 )   return VTK_QUAD;
-      else if ( theNbNodes == 6 )   return VTK_QUADRATIC_TRIANGLE;
-      else if ( theNbNodes == 8 )   return VTK_QUADRATIC_QUAD;
-      else if ( theNbNodes == 9 )   return VTK_BIQUADRATIC_QUAD;
-      else if ( theNbNodes == 7 )   return VTK_BIQUADRATIC_TRIANGLE;
-      else return VTK_EMPTY_CELL;
-      
-    case SMDSAbs_Volume:
-      if (thePoly && theNbNodes>3 ) return VTK_POLYHEDRON; //VTK_CONVEX_POINT_SET;
-      else if ( theNbNodes == 4 )   return VTK_TETRA;
-      else if ( theNbNodes == 5 )   return VTK_PYRAMID;
-      else if ( theNbNodes == 6 )   return VTK_WEDGE;
-      else if ( theNbNodes == 8 )   return VTK_HEXAHEDRON;
-      else if ( theNbNodes == 12 )  return VTK_HEXAGONAL_PRISM;
-      else if ( theNbNodes == 10 )  return VTK_QUADRATIC_TETRA;
-      else if ( theNbNodes == 20 )  return VTK_QUADRATIC_HEXAHEDRON;
-      else if ( theNbNodes == 27 )  return VTK_TRIQUADRATIC_HEXAHEDRON;
-      else if ( theNbNodes == 15 )  return VTK_QUADRATIC_WEDGE;
-      else if ( theNbNodes == 13 )  return VTK_QUADRATIC_PYRAMID; //VTK_CONVEX_POINT_SET;
-      else return VTK_EMPTY_CELL;
-
-    default: return VTK_EMPTY_CELL;
-  }
-}
-
 //=================================================================================
 // functions : SMESH_VisualObjDef
 // purpose   : Constructor
 //=================================================================================
 SMESH_VisualObjDef::SMESH_VisualObjDef()
 {
-  MESSAGE("---------------------------------------------SMESH_VisualObjDef::SMESH_VisualObjDef");
+  MESSAGE("-------------------------------SMESH_VisualObjDef::SMESH_VisualObjDef");
   myGrid = vtkUnstructuredGrid::New();
   myLocalGrid = false;
   ClearEntitiesFlags();
@@ -139,9 +87,8 @@ SMESH_VisualObjDef::SMESH_VisualObjDef()
 }
 SMESH_VisualObjDef::~SMESH_VisualObjDef()
 {
-  MESSAGE("---------------------------------------------SMESH_VisualObjDef::~SMESH_VisualObjDef");
-  //if ( MYDEBUG )
-    MESSAGE( "~SMESH_MeshObj - myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );
+  MESSAGE("--------------------------------SMESH_VisualObjDef::~SMESH_VisualObjDef");
+  MESSAGE( "myGrid->GetReferenceCount() = " << myGrid->GetReferenceCount() );
   myGrid->Delete();
 }
 
@@ -149,7 +96,7 @@ SMESH_VisualObjDef::~SMESH_VisualObjDef()
 // functions : GetNodeObjId, GetNodeVTKId, GetElemObjId, GetElemVTKId
 // purpose   : Methods for retrieving VTK IDs by SMDS IDs and  vice versa
 //=================================================================================
-vtkIdType SMESH_VisualObjDef::GetNodeObjId( int theVTKID )
+vtkIdType SMESH_VisualObjDef::GetNodeObjId( vtkIdType theVTKID )
 {
   if (myLocalGrid)
   {
@@ -160,10 +107,10 @@ vtkIdType SMESH_VisualObjDef::GetNodeObjId( int theVTKID )
   if( this->GetMesh() )
     aNode = this->GetMesh()->FindNodeVtk( theVTKID );
 
-  return aNode ? aNode->GetID() : -1;
+  return aNode ? FromSmIdType<vtkIdType>(aNode->GetID()) : -1;
 }
 
-vtkIdType SMESH_VisualObjDef::GetNodeVTKId( int theObjID )
+vtkIdType SMESH_VisualObjDef::GetNodeVTKId( vtkIdType theObjID )
 {
   if (myLocalGrid)
   {
@@ -175,20 +122,20 @@ vtkIdType SMESH_VisualObjDef::GetNodeVTKId( int theObjID )
   if( this->GetMesh() ) {
     aNode = this->GetMesh()->FindNode(theObjID);
   }
-  return aNode ? aNode->getVtkId() : -1;
+  return aNode ? aNode->GetVtkID() : -1;
 }
 
-vtkIdType SMESH_VisualObjDef::GetElemObjId( int theVTKID )
+vtkIdType SMESH_VisualObjDef::GetElemObjId( vtkIdType theVTKID )
 {
   if (myLocalGrid)
   {
     TMapOfIds::const_iterator i = myVTK2SMDSElems.find(theVTKID);
     return i == myVTK2SMDSElems.end() ? -1 : i->second;
   }
-  return this->GetMesh()->fromVtkToSmds(theVTKID);
+  return FromSmIdType<vtkIdType>(this->GetMesh()->FromVtkToSmds(theVTKID));
 }
 
-vtkIdType SMESH_VisualObjDef::GetElemVTKId( int theObjID )
+vtkIdType SMESH_VisualObjDef::GetElemVTKId( vtkIdType theObjID )
 {
   if (myLocalGrid)
   {
@@ -200,7 +147,7 @@ vtkIdType SMESH_VisualObjDef::GetElemVTKId( int theObjID )
   if ( this->GetMesh() )
     e = this->GetMesh()->FindElement(theObjID);
 
-  return e ? e->getVtkId() : -1;
+  return e ? e->GetVtkID() : -1;
 }
 
 //=================================================================================
@@ -217,7 +164,7 @@ void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
     return;
 
   TEntityList aNodes;
-  vtkIdType nbNodes = GetEntities( SMDSAbs_Node, aNodes );
+  vtkIdType nbNodes = FromSmIdType<vtkIdType>(GetEntities( SMDSAbs_Node, aNodes ));
   thePoints->SetNumberOfPoints( nbNodes );
 
   int nbPoints = 0;
@@ -229,9 +176,9 @@ void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
     if ( aNode != 0 )
     {
       thePoints->SetPoint( nbPoints, aNode->X(), aNode->Y(), aNode->Z() );
-      int anId = aNode->GetID();
-      mySMDS2VTKNodes.insert( TMapOfIds::value_type( anId, nbPoints ) );
-      myVTK2SMDSNodes.insert( TMapOfIds::value_type( nbPoints, anId ) );
+      smIdType anId = aNode->GetID();
+      mySMDS2VTKNodes.insert( mySMDS2VTKNodes.end(), std::make_pair( anId, nbPoints ));
+      myVTK2SMDSNodes.insert( myVTK2SMDSNodes.end(), std::make_pair( nbPoints, anId ));
       nbPoints++;
     }
   }
@@ -246,51 +193,54 @@ void SMESH_VisualObjDef::createPoints( vtkPoints* thePoints )
 //=================================================================================
 void SMESH_VisualObjDef::buildPrs(bool buildGrid)
 {
-  MESSAGE("----------------------------------------------------------SMESH_VisualObjDef::buildPrs " << buildGrid);
+  MESSAGE("---------------------------SMESH_VisualObjDef::buildPrs " << buildGrid);
   if (buildGrid)
   {
-        myLocalGrid = true;
-        try
-        {
-                mySMDS2VTKNodes.clear();
-                myVTK2SMDSNodes.clear();
-                mySMDS2VTKElems.clear();
-                myVTK2SMDSElems.clear();
-
-                if ( IsNodePrs() )
-                        buildNodePrs();
-                else
-                        buildElemPrs();
-        }
-        catch(...)
-        {
-                mySMDS2VTKNodes.clear();
-                myVTK2SMDSNodes.clear();
-                mySMDS2VTKElems.clear();
-                myVTK2SMDSElems.clear();
-
-                myGrid->SetPoints( 0 );
-                myGrid->SetCells( 0, 0, 0, 0, 0 );
-                throw;
-        }
+    myLocalGrid = true;
+    try
+    {
+      mySMDS2VTKNodes.clear();
+      myVTK2SMDSNodes.clear();
+      mySMDS2VTKElems.clear();
+      myVTK2SMDSElems.clear();
+
+      if ( IsNodePrs() )
+        buildNodePrs();
+      else
+        buildElemPrs();
+    }
+    catch(...)
+    {
+      mySMDS2VTKNodes.clear();
+      myVTK2SMDSNodes.clear();
+      mySMDS2VTKElems.clear();
+      myVTK2SMDSElems.clear();
+
+      myGrid->SetPoints( 0 );
+      myGrid->SetCells( 0, 0, 0, 0, 0 );
+      throw;
+    }
   }
   else
   {
-        myLocalGrid = false;
-        if (!GetMesh()->isCompacted())
-          {
-            MESSAGE("*** buildPrs ==> compactMesh!");
-            GetMesh()->compactMesh();
-          }
-        vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();
-        updateEntitiesFlags();
-        myGrid->ShallowCopy(theGrid);
-        //MESSAGE(myGrid->GetReferenceCount());
-        //MESSAGE( "Update - myGrid->GetNumberOfCells() = "<<myGrid->GetNumberOfCells() );
-        //MESSAGE( "Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints() );
-        if( MYDEBUGWITHFILES ) {
-          SMESH::WriteUnstructuredGrid( myGrid,"myPrs.vtu" );
-        }
+    myLocalGrid = false;
+    if (!GetMesh()->IsCompacted())
+    {
+      NulData(); // detach from the SMDS grid to allow immediate memory de-allocation in compactMesh()
+      MESSAGE("*** buildPrs ==> compactMesh!");
+      GetMesh()->CompactMesh();
+      if ( SMESHDS_Mesh* m = dynamic_cast<SMESHDS_Mesh*>( GetMesh() )) // IPAL53915
+        m->GetScript()->SetModified(false); // drop IsModified set in compactMesh()
+    }
+    vtkUnstructuredGrid *theGrid = GetMesh()->GetGrid();
+    updateEntitiesFlags();
+    myGrid->ShallowCopy(theGrid);
+    //MESSAGE(myGrid->GetReferenceCount());
+    //MESSAGE( "Update - myGrid->GetNumberOfCells() = "<<myGrid->GetNumberOfCells() );
+    //MESSAGE( "Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints() );
+    if( MYDEBUGWITHFILES ) {
+      SMESH::WriteUnstructuredGrid( myGrid,"myPrs.vtu" );
+    }
   }
 }
 
@@ -327,7 +277,7 @@ namespace{
     theConnect.clear();
     for(; theNodesIter->more();)
       theConnect.push_back(theNodesIter->next());
-    return theConnect.size();
+    return (int) theConnect.size();
   }
   
   inline 
@@ -335,7 +285,7 @@ namespace{
              const SMESH_VisualObjDef::TMapOfIds& theSMDS2VTKNodes, 
              const TConnect& theConnect, 
              int thePosition,
-             int theId)
+             vtkIdType theId)
   {
     theIdList->SetId(thePosition,theSMDS2VTKNodes.find(theConnect[theId]->GetID())->second);
   }
@@ -352,8 +302,7 @@ void SMESH_VisualObjDef::buildElemPrs()
   myGrid->SetPoints( aPoints );
   aPoints->Delete();
 
-  if ( MYDEBUG )
-    MESSAGE("Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints());
+  MESSAGE("Update - myGrid->GetNumberOfPoints() = "<<myGrid->GetNumberOfPoints());
 
   // Calculate cells size
 
@@ -362,7 +311,7 @@ void SMESH_VisualObjDef::buildElemPrs()
     { SMDSAbs_Edge, SMDSAbs_Face, SMDSAbs_Volume, SMDSAbs_Ball, SMDSAbs_0DElement };
 
   // get entity data
-  map<SMDSAbs_ElementType,int> nbEnts;
+  map<SMDSAbs_ElementType,smIdType> nbEnts;
   map<SMDSAbs_ElementType,TEntityList> anEnts;
 
   vtkIdType aNbCells = 0;
@@ -389,24 +338,23 @@ void SMESH_VisualObjDef::buildElemPrs()
         if((*anIter)->GetEntityType() != SMDSEntity_Polyhedra &&
            (*anIter)->GetEntityType() != SMDSEntity_Quad_Polyhedra) {
           aCellsSize += (*anIter)->NbNodes() + 1;
-        } 
+        }
         // Special case for the VTK_POLYHEDRON:
         // itsinput cellArray is of special format.
-        //  [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...]   
+        //  [nCellFaces, nFace0Pts, i, j, k, nFace1Pts, i, j, k, ...]
         else {
-          if( const SMDS_VtkVolume* ph = dynamic_cast<const SMDS_VtkVolume*>(*anIter) ) {
+          if ( const SMDS_MeshVolume* ph = SMDS_Mesh::DownCast<SMDS_MeshVolume>( *anIter )) {
             int nbFaces = ph->NbFaces();
             aCellsSize += (1 + ph->NbFaces());
-            for( int i = 1; i <= nbFaces; i++ ) {
+            for( int i = 1; i <= nbFaces; i++ )
               aCellsSize += ph->NbFaceNodes(i);
-            }
           }
         }
       }
     }
   }
-  if ( MYDEBUG )
-    MESSAGE( "Update - aNbCells = "<<aNbCells<<"; aCellsSize = "<<aCellsSize );
+
+  MESSAGE( "Update - aNbCells = "<<aNbCells<<"; aCellsSize = "<<aCellsSize );
 
   // Create cells
 
@@ -438,39 +386,37 @@ void SMESH_VisualObjDef::buildElemPrs()
   for ( int i = 0; i < nbTypes; i++ ) // iterate through all types of elements
   {
     if ( nbEnts[ aTypes[ i ] ] > 0 ) {
-      
+
       const SMDSAbs_ElementType& aType = aTypes[ i ];
       const TEntityList& aList = anEnts[ aType ];
       TEntityList::const_iterator anIter;
       for ( anIter = aList.begin(); anIter != aList.end(); ++anIter )
       {
         const SMDS_MeshElement* anElem = *anIter;
-        
+
         vtkIdType aNbNodes = anElem->NbNodes();
         anIdList->SetNumberOfIds( aNbNodes );
-        const vtkIdType vtkElemType = getCellType( aType, anElem->IsPoly(), aNbNodes );
-        
-        int anId = anElem->GetID();
-        
-        mySMDS2VTKElems.insert( TMapOfIds::value_type( anId, iElem ) );
-        myVTK2SMDSElems.insert( TMapOfIds::value_type( iElem, anId ) );
-        
+        const VTKCellType vtkElemType = SMDS_MeshCell::toVtkType( anElem->GetEntityType() );
+
+        smIdType anId = anElem->GetID();
+
+        mySMDS2VTKElems.insert( mySMDS2VTKElems.end(), std::make_pair( anId, iElem ));
+        myVTK2SMDSElems.insert( myVTK2SMDSElems.end(), std::make_pair( iElem, anId ));
+
         SMDS_ElemIteratorPtr aNodesIter = anElem->nodesIterator();
         {
-          // Convertions connectivities from SMDS to VTK
+          // Convert connectivities from SMDS to VTK
 
           if (aType == SMDSAbs_Volume && anElem->IsPoly() && aNbNodes > 3) { // POLYEDRE
             anIdList->Reset();
-            if ( const SMDS_VtkVolume* ph = dynamic_cast<const SMDS_VtkVolume*>(anElem) ) {
+            if ( const SMDS_MeshVolume* ph = SMDS_Mesh::DownCast<SMDS_MeshVolume>( anElem )) {
               int nbFaces = ph->NbFaces();
               anIdList->InsertNextId(nbFaces);
               for( int i = 1; i <= nbFaces; i++ ) {
                 anIdList->InsertNextId(ph->NbFaceNodes(i));
                 for(int j = 1; j <= ph->NbFaceNodes(i); j++) {
-                  const SMDS_MeshNode* n = ph->GetFaceNode(i,j);
-                  if(n) {
-                    anIdList->InsertNextId(mySMDS2VTKNodes[n->GetID()]);
-                  }
+                  if ( const SMDS_MeshNode* n = ph->GetFaceNode( i, j ))
+                    anIdList->InsertNextId( mySMDS2VTKNodes[ FromSmIdType<vtkIdType>(n->GetID()) ]);
                 }
               }
             }
@@ -481,13 +427,13 @@ void SMESH_VisualObjDef::buildElemPrs()
             if (aConnectivities.size() > 0) {
               aConnect.clear();
               GetConnect(aNodesIter,aConnect);
-              for (vtkIdType aNodeId = 0; aNodeId < aNbNodes; aNodeId++)
+              for (int aNodeId = 0; aNodeId < aNbNodes; aNodeId++)
                 SetId(anIdList,mySMDS2VTKNodes,aConnect,aNodeId,aConnectivities[aNodeId]);
             }
             else {
               for( vtkIdType aNodeId = 0; aNodesIter->more(); aNodeId++ ){
                 const SMDS_MeshElement* aNode = aNodesIter->next();
-                anIdList->SetId( aNodeId, mySMDS2VTKNodes[aNode->GetID()] );
+                anIdList->SetId( aNodeId, mySMDS2VTKNodes[FromSmIdType<vtkIdType>(aNode->GetID())]);
               }
             }
           }
@@ -498,11 +444,8 @@ void SMESH_VisualObjDef::buildElemPrs()
         //Store diameters of the balls
         if(aScalars) {
           double aDiam = 0;
-          if(aType == SMDSAbs_Ball) {
-            if (const SMDS_BallElement* ball = dynamic_cast<const SMDS_BallElement*>(anElem) ) {
-              aDiam = ball->GetDiameter();
-            }
-          }
+          if (const SMDS_BallElement* ball = SMDS_Mesh::DownCast<SMDS_BallElement>(anElem) )
+            aDiam = ball->GetDiameter();
           aScalars->SetTuple(aCurId,&aDiam);
         }
 
@@ -514,14 +457,15 @@ void SMESH_VisualObjDef::buildElemPrs()
 
   // Insert cells in grid
 
-  VTKViewer_CellLocationsArray* aCellLocationsArray = VTKViewer_CellLocationsArray::New();
+  vtkIdTypeArray* aCellLocationsArray = vtkIdTypeArray::New();
   aCellLocationsArray->SetNumberOfComponents( 1 );
   aCellLocationsArray->SetNumberOfTuples( aNbCells );
 
   SMDS_Mesh::CheckMemory(); // PAL16631
 
   aConnectivity->InitTraversal();
-  for( vtkIdType idType = 0, *pts, npts; aConnectivity->GetNextCell( npts, pts ); idType++ )
+  vtkIdType const *pts(nullptr);
+  for( vtkIdType idType = 0, npts; aConnectivity->GetNextCell( npts, pts ); idType++ )
     aCellLocationsArray->SetValue( idType, aConnectivity->GetTraversalLocation( npts ) );
 
   myGrid->SetCells( aCellTypesArray, aCellLocationsArray,aConnectivity );
@@ -537,12 +481,12 @@ void SMESH_VisualObjDef::buildElemPrs()
 
 //=================================================================================
 // function : GetEdgeNodes
-// purpose  : Retrieve ids of nodes from edge of elements ( edge is numbered from 1 )
+// purpose  : Retrieve ids of nodes from edge of elements ( edge is numbered from 0 )
 //=================================================================================
-bool SMESH_VisualObjDef::GetEdgeNodes( const int theElemId,
-                                       const int theEdgeNum,
-                                       int&      theNodeId1,
-                                       int&      theNodeId2 ) const
+bool SMESH_VisualObjDef::GetEdgeNodes( const smIdType theElemId,
+                                       const int      theEdgeNum,
+                                       smIdType&      theNodeId1,
+                                       smIdType&      theNodeId2 ) const
 {
   const SMDS_Mesh* aMesh = GetMesh();
   if ( aMesh == 0 )
@@ -554,36 +498,28 @@ bool SMESH_VisualObjDef::GetEdgeNodes( const int theElemId,
     
   int nbNodes = anElem->NbCornerNodes();
 
-  if ( theEdgeNum < 0 || theEdgeNum > 3 || (nbNodes != 3 && nbNodes != 4) || theEdgeNum > nbNodes )
+  if (( theEdgeNum < 0 || theEdgeNum > 3 ) ||
+      ( nbNodes != 3 && nbNodes != 4 ) ||
+      ( theEdgeNum >= nbNodes ))
     return false;
 
-  vector<int> anIds( nbNodes );
-  SMDS_ElemIteratorPtr anIter = anElem->nodesIterator();
-  int i = 0;
-  while( anIter->more() && i < nbNodes )
-    anIds[ i++ ] = anIter->next()->GetID();
-
-  if ( theEdgeNum < nbNodes - 1 )
-  {
-    theNodeId1 = anIds[ theEdgeNum ];
-    theNodeId2 = anIds[ theEdgeNum + 1 ];
-  }
-  else
-  {
-    theNodeId1 = anIds[ nbNodes - 1 ];
-    theNodeId2 = anIds[ 0 ];
-  }
+  theNodeId1 = anElem->GetNode(  theEdgeNum                 )->GetID();
+  theNodeId2 = anElem->GetNode(( theEdgeNum + 1 ) % nbNodes )->GetID();
 
   return true;
 }
 
 vtkUnstructuredGrid* SMESH_VisualObjDef::GetUnstructuredGrid()
 {
-  if ( !myLocalGrid && !GetMesh()->isCompacted() )
+  if ( !myLocalGrid && ( !GetMesh()->IsCompacted() || // !IsCompacted() is needed ???
+                         GetMesh()->GetGrid()->GetMTime() > myGrid->GetMTime() ))
   {
-    GetMesh()->compactMesh();
-        updateEntitiesFlags();
-    vtkUnstructuredGrid *theGrid = GetMesh()->getGrid();
+    NulData(); // detach from the SMDS grid to allow immediate memory de-allocation in CompactMesh()
+    GetMesh()->CompactMesh();
+    if ( SMESHDS_Mesh* m = dynamic_cast<SMESHDS_Mesh*>( GetMesh() )) // IPAL53915
+      m->GetScript()->SetModified(false); // drop IsModified set in CompactMesh()
+    updateEntitiesFlags();
+    vtkUnstructuredGrid *theGrid = GetMesh()->GetGrid();
     myGrid->ShallowCopy(theGrid);
   }
   return myGrid;
@@ -596,10 +532,9 @@ vtkUnstructuredGrid* SMESH_VisualObjDef::GetUnstructuredGrid()
 //=================================================================================
 bool SMESH_VisualObjDef::IsValid() const
 {
-        //MESSAGE("SMESH_VisualObjDef::IsValid");
-  return ( GetNbEntities(SMDSAbs_0DElement) > 0 || 
-           GetNbEntities(SMDSAbs_Ball     ) > 0 || 
-           GetNbEntities(SMDSAbs_Edge     ) > 0 || 
+  return ( GetNbEntities(SMDSAbs_0DElement) > 0 ||
+           GetNbEntities(SMDSAbs_Ball     ) > 0 ||
+           GetNbEntities(SMDSAbs_Edge     ) > 0 ||
            GetNbEntities(SMDSAbs_Face     ) > 0 ||
            GetNbEntities(SMDSAbs_Volume   ) > 0 ||
            GetNbEntities(SMDSAbs_Node     ) > 0 );
@@ -609,59 +544,67 @@ bool SMESH_VisualObjDef::IsValid() const
 // function : updateEntitiesFlags
 // purpose  : Update entities flags
 //=================================================================================
-void SMESH_VisualObjDef::updateEntitiesFlags() {
+void SMESH_VisualObjDef::updateEntitiesFlags()
+{
+  unsigned int tmp = myEntitiesState;
+  ClearEntitiesFlags();
 
-        unsigned int tmp = myEntitiesState;
-        ClearEntitiesFlags();
+  map<SMDSAbs_ElementType,::smIdType> entities = SMESH::GetEntitiesFromObject(this);
 
-        map<SMDSAbs_ElementType,int> entities = SMESH::GetEntitiesFromObject(this);
-        
 
-        if( myEntitiesCache[SMDSAbs_0DElement] != 0 ||  myEntitiesCache[SMDSAbs_0DElement] >= entities[SMDSAbs_0DElement] )
-                myEntitiesState &= ~SMESH_Actor::e0DElements;
+  if( myEntitiesCache[SMDSAbs_0DElement] != 0 ||
+      myEntitiesCache[SMDSAbs_0DElement] >= entities[SMDSAbs_0DElement] )
+    myEntitiesState &= ~SMESH_Actor::e0DElements;
 
-        if( myEntitiesCache[SMDSAbs_Ball] != 0 ||  myEntitiesCache[SMDSAbs_Ball] >= entities[SMDSAbs_Ball] )
-                myEntitiesState &= ~SMESH_Actor::eBallElem;
+  if( myEntitiesCache[SMDSAbs_Ball] != 0 ||
+      myEntitiesCache[SMDSAbs_Ball] >= entities[SMDSAbs_Ball] )
+    myEntitiesState &= ~SMESH_Actor::eBallElem;
 
-        if( myEntitiesCache[SMDSAbs_Edge] != 0 || myEntitiesCache[SMDSAbs_Edge] >= entities[SMDSAbs_Edge] )
-                myEntitiesState &= ~SMESH_Actor::eEdges; 
+  if( myEntitiesCache[SMDSAbs_Edge] != 0 ||
+      myEntitiesCache[SMDSAbs_Edge] >= entities[SMDSAbs_Edge] )
+    myEntitiesState &= ~SMESH_Actor::eEdges;
 
-        if( myEntitiesCache[SMDSAbs_Face] != 0 || myEntitiesCache[SMDSAbs_Face] >= entities[SMDSAbs_Face] )
-                myEntitiesState &= ~SMESH_Actor::eFaces; 
+  if( myEntitiesCache[SMDSAbs_Face] != 0 ||
+      myEntitiesCache[SMDSAbs_Face] >= entities[SMDSAbs_Face] )
+    myEntitiesState &= ~SMESH_Actor::eFaces;
 
-        if( myEntitiesCache[SMDSAbs_Volume] != 0 || myEntitiesCache[SMDSAbs_Volume] >= entities[SMDSAbs_Volume] )
-                myEntitiesState &= ~SMESH_Actor::eVolumes;
+  if( myEntitiesCache[SMDSAbs_Volume] != 0 ||
+      myEntitiesCache[SMDSAbs_Volume] >= entities[SMDSAbs_Volume] )
+    myEntitiesState &= ~SMESH_Actor::eVolumes;
 
-        if( tmp != myEntitiesState ) {
-                myEntitiesFlag = true;
-        }
-        
-        myEntitiesCache = entities;
+  if( tmp != myEntitiesState ) {
+    myEntitiesFlag = true;
+  }
+
+  myEntitiesCache = entities;
 }
 
 //=================================================================================
 // function : ClearEntitiesFlags
 // purpose  : Clear the entities flags
 //=================================================================================
-void SMESH_VisualObjDef::ClearEntitiesFlags() {
-        myEntitiesState = SMESH_Actor::eAllEntity;
-        myEntitiesFlag = false;
+void SMESH_VisualObjDef::ClearEntitiesFlags()
+{
+  myEntitiesState = SMESH_Actor::eAllEntity;
+  myEntitiesFlag = false;
 }
 
 //=================================================================================
 // function : GetEntitiesFlag
 // purpose  : Return the entities flag
 //=================================================================================
-bool SMESH_VisualObjDef::GetEntitiesFlag() {
-        return myEntitiesFlag;
+bool SMESH_VisualObjDef::GetEntitiesFlag()
+{
+  return myEntitiesFlag;
 }
 
 //=================================================================================
 // function : GetEntitiesState
 // purpose  : Return the entities state
 //=================================================================================
-unsigned int SMESH_VisualObjDef::GetEntitiesState() {
-        return myEntitiesState;
+unsigned int SMESH_VisualObjDef::GetEntitiesState()
+{
+  return myEntitiesState;
 }
 
 /*
@@ -677,8 +620,8 @@ SMESH_MeshObj::SMESH_MeshObj(SMESH::SMESH_Mesh_ptr theMesh):
   myClient(SalomeApp_Application::orb(),theMesh)
 {
         myEmptyGrid = 0;
-  if ( MYDEBUG ) 
-    MESSAGE("SMESH_MeshObj - this = "<<this<<"; theMesh->_is_nil() = "<<theMesh->_is_nil());
+
+  MESSAGE("SMESH_MeshObj - this = "<<this<<"; theMesh->_is_nil() = "<<theMesh->_is_nil());
 }
 
 //=================================================================================
@@ -687,8 +630,7 @@ SMESH_MeshObj::SMESH_MeshObj(SMESH::SMESH_Mesh_ptr theMesh):
 //=================================================================================
 SMESH_MeshObj::~SMESH_MeshObj()
 {
-  if ( MYDEBUG ) 
-    MESSAGE("SMESH_MeshObj - this = "<<this<<"\n");
+  MESSAGE("SMESH_MeshObj - this = "<<this<<"\n");
   if ( myEmptyGrid )
     myEmptyGrid->Delete();
 }
@@ -711,26 +653,26 @@ bool SMESH_MeshObj::Update( int theIsClear )
 
 bool SMESH_MeshObj::NulData()
 {
-        MESSAGE ("SMESH_MeshObj::NulData() ==================================================================================");
-        if (!myEmptyGrid)
-        {
-          myEmptyGrid = SMDS_UnstructuredGrid::New();
-          myEmptyGrid->Initialize();
-          myEmptyGrid->Allocate();
-          vtkPoints* points = vtkPoints::New();
-          points->SetNumberOfPoints(0);
-          myEmptyGrid->SetPoints( points );
-          points->Delete();
-          myEmptyGrid->BuildLinks();
-        }
-        myGrid->ShallowCopy(myEmptyGrid);
-        return true;
+  MESSAGE ("SMESH_MeshObj::NulData() =============================================");
+  if (!myEmptyGrid)
+  {
+    myEmptyGrid = SMDS_UnstructuredGrid::New();
+    myEmptyGrid->Initialize();
+    myEmptyGrid->Allocate();
+    vtkPoints* points = vtkPoints::New();
+    points->SetNumberOfPoints(0);
+    myEmptyGrid->SetPoints( points );
+    points->Delete();
+    //myEmptyGrid->BuildLinks();
+  }
+  myGrid->ShallowCopy(myEmptyGrid);
+  return true;
 }
 //=================================================================================
 // function : GetElemDimension
 // purpose  : Get dimension of element
 //=================================================================================
-int SMESH_MeshObj::GetElemDimension( const int theObjId )
+int SMESH_MeshObj::GetElemDimension( const smIdType theObjId )
 {
   const SMDS_MeshElement* anElem = myClient->FindElement( theObjId );
   if ( anElem == 0 )
@@ -752,7 +694,7 @@ int SMESH_MeshObj::GetElemDimension( const int theObjId )
 // function : GetEntities
 // purpose  : Get entities of specified type. Return number of entities
 //=================================================================================
-int SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
+smIdType SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
 {
   switch ( theType )
   {
@@ -791,7 +733,7 @@ int SMESH_MeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
   }
 }
 
-int SMESH_MeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theObjs ) const
+smIdType SMESH_MeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theObjs ) const
 {
   theObjs.clear();
 
@@ -870,7 +812,7 @@ bool SMESH_MeshObj::IsNodePrs() const
 //=================================================================================
 SMESH_SubMeshObj::SMESH_SubMeshObj( SMESH_MeshObj* theMeshObj )
 {
-  if ( MYDEBUG ) MESSAGE( "SMESH_SubMeshObj - theMeshObj = " << theMeshObj );
+  MESSAGE( "SMESH_SubMeshObj - theMeshObj = " << theMeshObj );
   
   myMeshObj = theMeshObj;
 }
@@ -883,7 +825,7 @@ SMESH_SubMeshObj::~SMESH_SubMeshObj()
 // function : GetElemDimension
 // purpose  : Get dimension of element
 //=================================================================================
-int SMESH_SubMeshObj::GetElemDimension( const int theObjId )
+int SMESH_SubMeshObj::GetElemDimension( const smIdType theObjId )
 {
   return myMeshObj == 0 ? 0 : myMeshObj->GetElemDimension( theObjId );
 }
@@ -904,7 +846,7 @@ void SMESH_SubMeshObj::UpdateFunctor( const SMESH::Controls::FunctorPtr& theFunc
 //=================================================================================
 bool SMESH_SubMeshObj::Update( int theIsClear )
 {
-  MESSAGE("SMESH_SubMeshObj::Update " << this)
+  MESSAGE("SMESH_SubMeshObj::Update " << this);
   bool changed = myMeshObj->Update( theIsClear );
   buildPrs(true);
   return changed;
@@ -925,13 +867,13 @@ SMESH_GroupObj::SMESH_GroupObj( SMESH::SMESH_GroupBase_ptr theGroup,
 : SMESH_SubMeshObj( theMeshObj ),
   myGroupServer( SMESH::SMESH_GroupBase::_duplicate(theGroup) )
 {
-  if ( MYDEBUG ) MESSAGE("SMESH_GroupObj - theGroup->_is_nil() = "<<theGroup->_is_nil());
+  MESSAGE("SMESH_GroupObj - theGroup->_is_nil() = "<<theGroup->_is_nil());
   myGroupServer->Register();
 }
 
 SMESH_GroupObj::~SMESH_GroupObj()
 {
-  if ( MYDEBUG ) MESSAGE("~SMESH_GroupObj");
+  MESSAGE("~SMESH_GroupObj");
   myGroupServer->UnRegister();
 }
 
@@ -957,13 +899,13 @@ SMDSAbs_ElementType SMESH_GroupObj::GetElementType() const
 // function : getNodesFromElems
 // purpose  : Retrieve nodes from elements
 //=================================================================================
-static int getNodesFromElems( SMESH::long_array_var&              theElemIds,
+static int getNodesFromElems( SMESH::smIdType_array_var&          theElemIds,
                               const SMDS_Mesh*                    theMesh,
                               std::list<const SMDS_MeshElement*>& theResList )
 {
   set<const SMDS_MeshElement*> aNodeSet;
 
-  for ( CORBA::Long i = 0, n = theElemIds->length(); i < n; i++ )
+  for ( CORBA::ULong i = 0, n = theElemIds->length(); i < n; i++ )
   {
     const SMDS_MeshElement* anElem = theMesh->FindElement( theElemIds[ i ] );
     if ( anElem != 0 )
@@ -978,23 +920,21 @@ static int getNodesFromElems( SMESH::long_array_var&              theElemIds,
     }
   }
 
-  set<const SMDS_MeshElement*>::const_iterator anIter;
-  for ( anIter = aNodeSet.begin(); anIter != aNodeSet.end(); ++anIter )
-    theResList.push_back( *anIter );
+  theResList.assign( aNodeSet.begin(), aNodeSet.end() );
 
-  return theResList.size();    
+  return (int) aNodeSet.size();
 }
 
 //=================================================================================
 // function : getPointers
 // purpose  : Get std::list<const SMDS_MeshElement*> from list of IDs
 //=================================================================================
-static int getPointers( const SMDSAbs_ElementType            theRequestType,
-                        SMESH::long_array_var&              theElemIds,
+static int getPointers( const SMDSAbs_ElementType           theRequestType,
+                        SMESH::smIdType_array_var&          theElemIds,
                         const SMDS_Mesh*                    theMesh,
                         std::list<const SMDS_MeshElement*>& theResList )
 {
-  for ( CORBA::Long i = 0, n = theElemIds->length(); i < n; i++ )
+  for ( CORBA::ULong i = 0, n = theElemIds->length(); i < n; i++ )
   {
     const SMDS_MeshElement* anElem = theRequestType == SMDSAbs_Node
       ? theMesh->FindNode( theElemIds[ i ] ) : theMesh->FindElement( theElemIds[ i ] );
@@ -1003,7 +943,7 @@ static int getPointers( const SMDSAbs_ElementType            theRequestType,
       theResList.push_back( anElem );
   }
 
-  return theResList.size();
+  return (int) theResList.size();
 }
 
 
@@ -1011,7 +951,7 @@ static int getPointers( const SMDSAbs_ElementType            theRequestType,
 // function : GetEntities
 // purpose  : Get entities of specified type. Return number of entities
 //=================================================================================
-int SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
+smIdType SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
 {
   if(SMDSAbs_ElementType(myGroupServer->GetType()) == theType) {
     return myGroupServer->Size();
@@ -1022,11 +962,11 @@ int SMESH_GroupObj::GetNbEntities( const SMDSAbs_ElementType theType) const
   return 0;
 }
 
-int SMESH_GroupObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
+smIdType SMESH_GroupObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
 {
   theResList.clear();
   SMDS_Mesh* aMesh = myMeshObj->GetMesh();
-  
+
   if ( aMesh == 0 )
     return 0;
 
@@ -1034,7 +974,7 @@ int SMESH_GroupObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList&
   if ( aGrpType != theType && theType != SMDSAbs_Node )
     return 0;
 
-  SMESH::long_array_var anIds = myGroupServer->GetListOfID();
+  SMESH::smIdType_array_var anIds = myGroupServer->GetListOfID();
   if ( anIds->length() == 0 )
     return 0;
 
@@ -1062,14 +1002,14 @@ SMESH_subMeshObj::SMESH_subMeshObj( SMESH::SMESH_subMesh_ptr theSubMesh,
 : SMESH_SubMeshObj( theMeshObj ),
   mySubMeshServer( SMESH::SMESH_subMesh::_duplicate( theSubMesh ) )
 {
-  if ( MYDEBUG ) MESSAGE( "SMESH_subMeshObj - theSubMesh->_is_nil() = " << theSubMesh->_is_nil() );
+  MESSAGE( "SMESH_subMeshObj - theSubMesh->_is_nil() = " << theSubMesh->_is_nil() );
   
   mySubMeshServer->Register();
 }
 
 SMESH_subMeshObj::~SMESH_subMeshObj()
 {
-  if ( MYDEBUG ) MESSAGE( "~SMESH_subMeshObj" );
+  MESSAGE( "~SMESH_subMeshObj" );
   mySubMeshServer->UnRegister();
 }
 
@@ -1077,7 +1017,7 @@ SMESH_subMeshObj::~SMESH_subMeshObj()
 // function : GetEntities
 // purpose  : Get entities of specified type. Return number of entities
 //=================================================================================
-int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
+smIdType SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
 {
   switch ( theType )
   {
@@ -1092,7 +1032,7 @@ int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
     case SMDSAbs_Face:
     case SMDSAbs_Volume:
     {
-      SMESH::long_array_var anIds = 
+      SMESH::smIdType_array_var anIds = 
         mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) );
       return anIds->length();
     }
@@ -1102,7 +1042,7 @@ int SMESH_subMeshObj::GetNbEntities( const SMDSAbs_ElementType theType) const
   }
 }
 
-int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
+smIdType SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityList& theResList ) const
 {
   theResList.clear();
 
@@ -1116,7 +1056,7 @@ int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityLis
   {
     if ( theType == SMDSAbs_Node )
     {
-      SMESH::long_array_var anIds = mySubMeshServer->GetNodesId();
+      SMESH::smIdType_array_var anIds = mySubMeshServer->GetNodesId();
       return getPointers( SMDSAbs_Node, anIds, aMesh, theResList );
     }
   }
@@ -1124,12 +1064,12 @@ int SMESH_subMeshObj::GetEntities( const SMDSAbs_ElementType theType, TEntityLis
   {
     if ( theType == SMDSAbs_Node )
     {
-      SMESH::long_array_var anIds = mySubMeshServer->GetElementsId();
+      SMESH::smIdType_array_var anIds = mySubMeshServer->GetElementsId();
       return getNodesFromElems( anIds, aMesh, theResList );
     }
     else
     {
-      SMESH::long_array_var anIds = 
+      SMESH::smIdType_array_var anIds = 
         mySubMeshServer->GetElementsByType( SMESH::ElementType(theType) );
       return getPointers( theType, anIds, aMesh, theResList );
     }