-// Copyright (C) 2007-2008 CEA/DEN, EDF R&D, OPEN CASCADE
+// Copyright (C) 2007-2010 CEA/DEN, EDF R&D, OPEN CASCADE
//
// Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
//
// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
//
+
// SMESH SMESHDS : management of mesh data and SMESH document
// File : SMESH_Mesh.cxx
// Author : Yves FRICAUD, OCC
#include "SMDS_EdgePosition.hxx"
#include "SMDS_FacePosition.hxx"
#include "SMDS_SpacePosition.hxx"
+#include "SMDS_Downward.hxx"
#include "SMESHDS_GroupOnGeom.hxx"
-#include <TopExp_Explorer.hxx>
+#include <Standard_ErrorHandler.hxx>
+#include <Standard_OutOfRange.hxx>
#include <TopExp.hxx>
+#include <TopExp_Explorer.hxx>
#include <TopoDS_Iterator.hxx>
#include "utilities.h"
{
myScript = new SMESHDS_Script(theIsEmbeddedMode);
myCurSubMesh = 0;
+ SetPersistentId(theMeshID);
}
//=======================================================================
return myIsEmbeddedMode;
}
+//================================================================================
+/*!
+ * \brief Store ID persistent during lifecycle
+ */
+//================================================================================
+
+void SMESHDS_Mesh::SetPersistentId(int id)
+{
+ if (NbNodes() == 0)
+ myPersistentID = id;
+}
+//================================================================================
+/*!
+ * \brief Return ID persistent during lifecycle
+ */
+//================================================================================
+
+int SMESHDS_Mesh::GetPersistentId() const
+{
+ return myPersistentID;
+}
+
//=======================================================================
//function : ShapeToMesh
//purpose :
if ( !i_sub->second->IsComplexSubmesh() ) {
SMDS_NodeIteratorPtr nIt = i_sub->second->GetNodes();
while ( nIt->more() )
- nIt->next()->GetPosition()->SetShapeId( 0 );
+ i_sub->second->RemoveNode(nIt->next(), false);
}
}
// - sub-meshes
const SMDS_MeshNode * nodes[],
const int nbnodes)
{
+ //MESSAGE("SMESHDS_Mesh::ChangeElementNodes");
if ( ! SMDS_Mesh::ChangeElementNodes( elem, nodes, nbnodes ))
return false;
void SMESHDS_Mesh::Renumber (const bool isNodes, const int startID, const int deltaID)
{
- SMDS_Mesh::Renumber( isNodes, startID, deltaID );
- myScript->Renumber( isNodes, startID, 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 );
}
//=======================================================================
//function : AddPolygonalFace
//purpose :
//=======================================================================
-SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (std::vector<int> nodes_ids,
- const int ID)
+SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID (const std::vector<int>& nodes_ids,
+ const int ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes_ids, ID);
if (anElem) {
}
SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFaceWithID
- (std::vector<const SMDS_MeshNode*> nodes,
- const int ID)
+ (const std::vector<const SMDS_MeshNode*>& nodes,
+ const int ID)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFaceWithID(nodes, ID);
if (anElem) {
}
SMDS_MeshFace* SMESHDS_Mesh::AddPolygonalFace
- (std::vector<const SMDS_MeshNode*> nodes)
+ (const std::vector<const SMDS_MeshNode*>& nodes)
{
SMDS_MeshFace *anElem = SMDS_Mesh::AddPolygonalFace(nodes);
if (anElem) {
//function : AddPolyhedralVolume
//purpose :
//=======================================================================
-SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (std::vector<int> nodes_ids,
- std::vector<int> quantities,
- const int ID)
+SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID (const std::vector<int>& nodes_ids,
+ const std::vector<int>& quantities,
+ const int ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes_ids, quantities, ID);
if (anElem) {
}
SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolumeWithID
- (std::vector<const SMDS_MeshNode*> nodes,
- std::vector<int> quantities,
- const int ID)
+ (const std::vector<const SMDS_MeshNode*>& nodes,
+ const std::vector<int>& quantities,
+ const int ID)
{
SMDS_MeshVolume *anElem = SMDS_Mesh::AddPolyhedralVolumeWithID(nodes, quantities, ID);
if (anElem) {
}
SMDS_MeshVolume* SMESHDS_Mesh::AddPolyhedralVolume
- (std::vector<const SMDS_MeshNode*> nodes,
- 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) {
// Rm from sub-meshes
// Element should belong to only one sub-mesh
- map<int,SMESHDS_SubMesh*>::iterator SubIt = theSubMeshes.begin();
- for ( ; SubIt != theSubMeshes.end(); SubIt++ )
+ if ( !theSubMeshes.empty() )
{
- int size = isNode ? (*SubIt).second->NbNodes() : (*SubIt).second->NbElements();
- if ( size == 0 ) continue;
-
+ SMESHDS_Mesh* mesh = theSubMeshes.begin()->second->getParent();
list<const SMDS_MeshElement *>::iterator elIt = theElems.begin();
- while ( elIt != theElems.end() )
- {
- bool removed = false;
- if ( isNode )
- removed = (*SubIt).second->RemoveNode( static_cast<const SMDS_MeshNode*> (*elIt), deleted );
- else
- removed = (*SubIt).second->RemoveElement( *elIt, deleted );
-
- if (removed)
- {
- elIt = theElems.erase( elIt );
- if ( theElems.empty() )
- return; // all elements are found and removed
- }
- else
- {
- elIt++ ;
- }
+ if ( isNode ) {
+ for ( ; elIt != theElems.end(); ++elIt )
+ if ( SMESHDS_SubMesh* sm = mesh->MeshElements( (*elIt)->getshapeId() ))
+ sm->RemoveNode( static_cast<const SMDS_MeshNode*> (*elIt), deleted );
+ }
+ else {
+ for ( ; elIt != theElems.end(); ++elIt )
+ if ( SMESHDS_SubMesh* sm = mesh->MeshElements( (*elIt)->getshapeId() ))
+ sm->RemoveElement( *elIt, deleted );
}
}
}
-
+
//=======================================================================
//function : RemoveNode
//purpose :
{
SMESHDS_SubMesh* subMesh=0;
map<int,SMESHDS_SubMesh*>::iterator SubIt =
- myShapeIndexToSubMesh.find( n->GetPosition()->GetShapeId() );
+ myShapeIndexToSubMesh.find( n->getshapeId() );
if ( SubIt != myShapeIndexToSubMesh.end() )
subMesh = SubIt->second;
else
for ( ; !subMesh && SubIt != myShapeIndexToSubMesh.end(); SubIt++ )
if (!SubIt->second->IsComplexSubmesh() && SubIt->second->Contains( elt ))
subMesh = SubIt->second;
-
+ //MESSAGE("subMesh " << elt->getshapeId());
RemoveFreeElement( elt, subMesh, true);
return;
}
SMESHDS_SubMesh * subMesh,
bool fromGroups)
{
+ //MESSAGE(" --------------------------------> SMESHDS_Mesh::RemoveFreeElement " << subMesh << " " << fromGroups);
if (elt->GetType() == SMDSAbs_Node) {
RemoveFreeNode( static_cast<const SMDS_MeshNode*>(elt), subMesh);
return;
if ( Index != myCurSubID ) {
map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
if ( it == myShapeIndexToSubMesh.end() )
- it = myShapeIndexToSubMesh.insert( make_pair(Index, new SMESHDS_SubMesh() )).first;
+ it = myShapeIndexToSubMesh.insert( make_pair(Index, new SMESHDS_SubMesh(this, Index) )).first;
myCurSubMesh = it->second;
myCurSubID = Index;
myCurSubShape.Nullify(); // myCurSubShape no more corresponds to submesh
return false;
}
-namespace {
-
- //================================================================================
- /*!
- * \brief Creates a node position in volume
- */
- //================================================================================
-
- inline SMDS_PositionPtr volumePosition(int volId)
- {
- SMDS_SpacePosition* pos = new SMDS_SpacePosition();
- pos->SetShapeId( volId );
- return SMDS_PositionPtr(pos);
- }
-}
-
//=======================================================================
//function : SetNodeOnVolume
//purpose :
const TopoDS_Shell & S)
{
if ( add( aNode, getSubmesh(S) ))
- aNode->SetPosition ( volumePosition( myCurSubID ));
+ aNode->SetPosition ( SMDS_SpacePosition::originSpacePosition() );
}
+
//=======================================================================
//function : SetNodeOnVolume
//purpose :
const TopoDS_Solid & S)
{
if ( add( aNode, getSubmesh(S) ))
- aNode->SetPosition ( volumePosition( myCurSubID ));
+ aNode->SetPosition ( SMDS_SpacePosition::originSpacePosition() );
}
//=======================================================================
double v)
{
if ( add( aNode, getSubmesh(S) ))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition(myCurSubID, u, v)));
+ aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
}
//=======================================================================
double u)
{
if ( add( aNode, getSubmesh(S) ))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(myCurSubID, u)));
+ aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
}
//=======================================================================
const TopoDS_Vertex & S)
{
if ( add( aNode, getSubmesh(S) ))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition(myCurSubID)));
+ aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
}
//=======================================================================
//=======================================================================
void SMESHDS_Mesh::UnSetNodeOnShape(const SMDS_MeshNode* aNode)
{
- if ( aNode && aNode->GetPosition() ) {
- map<int,SMESHDS_SubMesh*>::iterator it =
- myShapeIndexToSubMesh.find( aNode->GetPosition()->GetShapeId() );
- if ( it != myShapeIndexToSubMesh.end() )
- it->second->RemoveNode( aNode, /*deleted=*/false );
- }
+ int shapeId = aNode->getshapeId();
+ if (shapeId >= 0)
+ {
+ map<int, SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find(shapeId);
+ if (it != myShapeIndexToSubMesh.end())
+ it->second->RemoveNode(aNode, /*deleted=*/false);
+ }
}
//=======================================================================
map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.find( Index );
if ( it != myShapeIndexToSubMesh.end() )
- if ( elem->GetType() == SMDSAbs_Node )
- it->second->RemoveNode( static_cast<const SMDS_MeshNode* >( elem ), /*deleted=*/false );
- else
- it->second->RemoveElement( elem, /*deleted=*/false );
+ {
+ if (elem->GetType() == SMDSAbs_Node)
+ it->second->RemoveNode(static_cast<const SMDS_MeshNode*> (elem), /*deleted=*/false);
+ else
+ it->second->RemoveElement(elem, /*deleted=*/false);
+ }
}
//=======================================================================
bool SMESHDS_Mesh::IsGroupOfSubShapes (const TopoDS_Shape& theShape) const
{
- if ( myShape.IsSame( theShape ))
+ if ( myIndexToShape.Contains(theShape) )
return true;
- for ( TopoDS_Iterator it( theShape ); it.More(); it.Next() ) {
- if (myIndexToShape.Contains( it.Value() ) ||
- IsGroupOfSubShapes( it.Value() ))
+ for ( TopoDS_Iterator it( theShape ); it.More(); it.Next() )
+ if (IsGroupOfSubShapes( it.Value() ))
return true;
- }
-
+
return false;
}
///////////////////////////////////////////////////////////////////////////////
/// Return the sub mesh by Id of shape it is linked to
///////////////////////////////////////////////////////////////////////////////
-SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const int Index)
+SMESHDS_SubMesh * SMESHDS_Mesh::MeshElements(const int Index) const
{
TShapeIndexToSubMesh::const_iterator anIter = myShapeIndexToSubMesh.find(Index);
if (anIter != myShapeIndexToSubMesh.end())
//function : SubMeshIndices
//purpose :
//=======================================================================
-list<int> SMESHDS_Mesh::SubMeshIndices()
+list<int> SMESHDS_Mesh::SubMeshIndices() const
{
list<int> anIndices;
- std::map<int,SMESHDS_SubMesh*>::iterator anIter = myShapeIndexToSubMesh.begin();
+ std::map<int,SMESHDS_SubMesh*>::const_iterator anIter = myShapeIndexToSubMesh.begin();
for (; anIter != myShapeIndexToSubMesh.end(); anIter++) {
anIndices.push_back((*anIter).first);
}
//function : HasMeshElements
//purpose :
//=======================================================================
-bool SMESHDS_Mesh::HasMeshElements(const TopoDS_Shape & S)
+bool SMESHDS_Mesh::HasMeshElements(const TopoDS_Shape & S) const
{
if (myShape.IsNull()) MESSAGE("myShape is NULL");
int Index = myIndexToShape.FindIndex(S);
TShapeIndexToSubMesh::iterator anIter = myShapeIndexToSubMesh.find(Index);
if (anIter == myShapeIndexToSubMesh.end())
{
- SM = new SMESHDS_SubMesh();
+ SM = new SMESHDS_SubMesh(this, Index);
myShapeIndexToSubMesh[Index]=SM;
}
else
TopAbs_ShapeEnum type)
{
int aMainIndex = 0;
- if ( IsGroupOfSubShapes( S ) || (S.ShapeType() == TopAbs_VERTEX && myIndexToShape.Contains(S)) )
+ if ( IsGroupOfSubShapes( S ))
{
aMainIndex = myIndexToShape.Add( S );
bool all = ( type == TopAbs_SHAPE );
//=======================================================================
const TopoDS_Shape& SMESHDS_Mesh::IndexToShape(int ShapeIndex) const
{
- return myIndexToShape.FindKey(ShapeIndex);
+ try
+ {
+ return myIndexToShape.FindKey(ShapeIndex);
+ }
+ catch ( Standard_OutOfRange )
+ {
+ }
+ static TopoDS_Shape nullShape;
+ return nullShape;
+}
+
+//================================================================================
+/*!
+ * \brief Return max index of sub-mesh
+ */
+//================================================================================
+
+int SMESHDS_Mesh::MaxSubMeshIndex() const
+{
+ return myShapeIndexToSubMesh.empty() ? 0 : myShapeIndexToSubMesh.rbegin()->first;
}
//=======================================================================
//=======================================================================
void SMESHDS_Mesh::SetNodeInVolume(const SMDS_MeshNode* aNode, int Index)
{
+ //add(aNode, getSubmesh(Index));
if ( add( aNode, getSubmesh( Index )))
- ((SMDS_MeshNode*) aNode)->SetPosition( volumePosition( Index ));
+ ((SMDS_MeshNode*) aNode)->SetPosition( SMDS_SpacePosition::originSpacePosition());
}
//=======================================================================
{
//Set Position on Node
if ( add( aNode, getSubmesh( Index )))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition(Index, u, v)));
+ aNode->SetPosition(SMDS_PositionPtr(new SMDS_FacePosition( u, v)));
}
//=======================================================================
{
//Set Position on Node
if ( add( aNode, getSubmesh( Index )))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(Index, u)));
+ aNode->SetPosition(SMDS_PositionPtr(new SMDS_EdgePosition(u)));
}
//=======================================================================
{
//Set Position on Node
if ( add( aNode, getSubmesh( Index )))
- aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition(Index)));
+ aNode->SetPosition(SMDS_PositionPtr(new SMDS_VertexPosition()));
}
//=======================================================================
ID);
}
+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;
+ }
+ }
+
+ myCells.swap(newCells);
+ //myCellIdSmdsToVtk.swap(newSmdsToVtk);
+ myCellIdVtkToSmds.swap(newVtkToSmds);
+ MESSAGE("myCells.size()=" << myCells.size()
+ << " myCellIdVtkToSmds.size()=" << myCellIdVtkToSmds.size() );
+ this->myElementIDFactory->emptyPool(newSmdsId);
+
+ this->myScript->SetModified(true); // notify GUI client for buildPrs when update
+
+ // --- compact list myNodes and myElements in submeshes
+
+ map<int,SMESHDS_SubMesh*>::iterator it = myShapeIndexToSubMesh.begin();
+ for(; it != myShapeIndexToSubMesh.end(); ++it)
+ {
+ (*it).second->compactList();
+ }
+
+}
+
+void SMESHDS_Mesh::BuildDownWardConnectivity(bool withEdges)
+{
+ myGrid->BuildDownwardConnectivity(withEdges);
+}
+/*! change some nodes in cell without modifying type or internal connectivity.
+ * Nodes inverse connectivity is maintained up to date.
+ * @param vtkVolId vtk id of the cell.
+ * @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)
+{
+ myGrid->ModifyCellNodes(vtkVolId, localClonedNodeIds);
+ return true;
+}
