ForkMaster/smesh
1
0
Fork 0
mirror of https://git.salome-platform.org/gitpub/modules/smesh.git synced 2024-12-25 08:50:35 +05:00
Code Issues Packages Projects Releases Wiki Activity

0020427: EDF 868 SMESH : Be able to define the submeshing order

Browse Source 
fix SortByMeshOrder(), which replaces a submesh of lower priority
  by one of higher priority even if the last one is not in
  theListToSort
This commit is contained in:
eap 2009-12-10 09:55:48 +00:00
parent b03a1e6001
commit f2c45dcff7
1 changed files with 58 additions and 66 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

124
src/SMESH/SMESH_Mesh.cxx
View File

@ -61,6 +61,8 @@
#include "Utils_ExceptHandlers.hxx" #include "Utils_ExceptHandlers.hxx"
using namespace std;
// maximum stored group name length in MED file // maximum stored group name length in MED file
#define MAX_MED_GROUP_NAME_LENGTH 80 #define MAX_MED_GROUP_NAME_LENGTH 80
@ -116,7 +118,7 @@ SMESH_Mesh::~SMESH_Mesh()
sm->ComputeStateEngine( SMESH_subMesh::MESH_ENTITY_REMOVED ); sm->ComputeStateEngine( SMESH_subMesh::MESH_ENTITY_REMOVED );
// delete groups // delete groups
std::map < int, SMESH_Group * >::iterator itg; map < int, SMESH_Group * >::iterator itg;
for (itg = _mapGroup.begin(); itg != _mapGroup.end(); itg++) { for (itg = _mapGroup.begin(); itg != _mapGroup.end(); itg++) {
SMESH_Group *aGroup = (*itg).second; SMESH_Group *aGroup = (*itg).second;
delete aGroup; delete aGroup;
@ -144,12 +146,12 @@ void SMESH_Mesh::ShapeToMesh(const TopoDS_Shape & aShape)
{ {
// removal of a shape to mesh, delete objects referring to sub-shapes: // removal of a shape to mesh, delete objects referring to sub-shapes:
// - sub-meshes // - sub-meshes
std::map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin(); map <int, SMESH_subMesh *>::iterator i_sm = _mapSubMesh.begin();
for ( ; i_sm != _mapSubMesh.end(); ++i_sm ) for ( ; i_sm != _mapSubMesh.end(); ++i_sm )
delete i_sm->second; delete i_sm->second;
_mapSubMesh.clear(); _mapSubMesh.clear();
// - groups on geometry // - groups on geometry
std::map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin(); map <int, SMESH_Group *>::iterator i_gr = _mapGroup.begin();
while ( i_gr != _mapGroup.end() ) { while ( i_gr != _mapGroup.end() ) {
if ( dynamic_cast<SMESHDS_GroupOnGeom*>( i_gr->second->GetGroupDS() )) { if ( dynamic_cast<SMESHDS_GroupOnGeom*>( i_gr->second->GetGroupDS() )) {
_myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() ); _myMeshDS->RemoveGroup( i_gr->second->GetGroupDS() );
@ -362,7 +364,7 @@ int SMESH_Mesh::UNVToMesh(const char* theFileName)
aGroup->InitSubGroupsIterator(); aGroup->InitSubGroupsIterator();
while (aGroup->MoreSubGroups()) { while (aGroup->MoreSubGroups()) {
SMDS_MeshGroup* aSubGroup = (SMDS_MeshGroup*) aGroup->NextSubGroup(); SMDS_MeshGroup* aSubGroup = (SMDS_MeshGroup*) aGroup->NextSubGroup();
std::string aName = aGroupNames[aSubGroup]; string aName = aGroupNames[aSubGroup];
int aId; int aId;
SMESH_Group* aSMESHGroup = AddGroup( aSubGroup->GetType(), aName.c_str(), aId ); SMESH_Group* aSMESHGroup = AddGroup( aSubGroup->GetType(), aName.c_str(), aId );
@ -413,10 +415,10 @@ int SMESH_Mesh::MEDToMesh(const char* theFileName, const char* theMeshName)
} }
// Reading groups (sub-meshes are out of scope of MED import functionality) // Reading groups (sub-meshes are out of scope of MED import functionality)
std::list<TNameAndType> aGroupNames = myReader.GetGroupNamesAndTypes(); list<TNameAndType> aGroupNames = myReader.GetGroupNamesAndTypes();
if(MYDEBUG) MESSAGE("MEDToMesh - Nb groups = "<<aGroupNames.size()); if(MYDEBUG) MESSAGE("MEDToMesh - Nb groups = "<<aGroupNames.size());
int anId; int anId;
std::list<TNameAndType>::iterator name_type = aGroupNames.begin(); list<TNameAndType>::iterator name_type = aGroupNames.begin();
for ( ; name_type != aGroupNames.end(); name_type++ ) { for ( ; name_type != aGroupNames.end(); name_type++ ) {
SMESH_Group* aGroup = AddGroup( name_type->second, name_type->first.c_str(), anId ); SMESH_Group* aGroup = AddGroup( name_type->second, name_type->first.c_str(), anId );
if ( aGroup ) { if ( aGroup ) {
@ -615,7 +617,7 @@ SMESH_Hypothesis::Hypothesis_Status
*/ */
//============================================================================= //=============================================================================
const std::list<const SMESHDS_Hypothesis*>& const list<const SMESHDS_Hypothesis*>&
SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const SMESH_Mesh::GetHypothesisList(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception) throw(SALOME_Exception)
{ {
@ -640,8 +642,8 @@ const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape & aSubS
TopoDS_Shape* assignedTo) const TopoDS_Shape* assignedTo) const
{ {
{ {
const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape); const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
std::list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin(); list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
for ( ; hyp != hypList.end(); hyp++ ) { for ( ; hyp != hypList.end(); hyp++ ) {
const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp ); const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp );
if ( aFilter.IsOk( h, aSubShape)) { if ( aFilter.IsOk( h, aSubShape)) {
@ -653,13 +655,13 @@ const SMESH_Hypothesis * SMESH_Mesh::GetHypothesis(const TopoDS_Shape & aSubS
if ( andAncestors ) if ( andAncestors )
{ {
// user sorted submeshes of ancestors, according to stored submesh priority // user sorted submeshes of ancestors, according to stored submesh priority
const std::list<SMESH_subMesh*> smList = getAncestorsSubMeshes( aSubShape ); const list<SMESH_subMesh*> smList = getAncestorsSubMeshes( aSubShape );
std::list<SMESH_subMesh*>::const_iterator smIt = smList.begin(); list<SMESH_subMesh*>::const_iterator smIt = smList.begin();
for ( ; smIt != smList.end(); smIt++ ) for ( ; smIt != smList.end(); smIt++ )
{ {
const TopoDS_Shape& curSh = (*smIt)->GetSubShape(); const TopoDS_Shape& curSh = (*smIt)->GetSubShape();
const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(curSh); const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(curSh);
std::list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin(); list<const SMESHDS_Hypothesis*>::const_iterator hyp = hypList.begin();
for ( ; hyp != hypList.end(); hyp++ ) { for ( ; hyp != hypList.end(); hyp++ ) {
const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp ); const SMESH_Hypothesis * h = cSMESH_Hyp( *hyp );
if (aFilter.IsOk( h, curSh )) { if (aFilter.IsOk( h, curSh )) {
@ -695,7 +697,7 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape,
bool mainHypFound = false; bool mainHypFound = false;
// fill in hypTypes // fill in hypTypes
std::list<const SMESHDS_Hypothesis*>::const_iterator hyp; list<const SMESHDS_Hypothesis*>::const_iterator hyp;
for ( hyp = aHypList.begin(); hyp != aHypList.end(); hyp++ ) { for ( hyp = aHypList.begin(); hyp != aHypList.end(); hyp++ ) {
if ( hypTypes.insert( (*hyp)->GetName() ).second ) if ( hypTypes.insert( (*hyp)->GetName() ).second )
nbHyps++; nbHyps++;
@ -705,7 +707,7 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape,
// get hypos from aSubShape // get hypos from aSubShape
{ {
const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape); const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(aSubShape);
for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ ) for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
if ( aFilter.IsOk (cSMESH_Hyp( *hyp ), aSubShape) && if ( aFilter.IsOk (cSMESH_Hyp( *hyp ), aSubShape) &&
( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) && ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
@ -724,14 +726,14 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape,
TopTools_MapOfShape map; TopTools_MapOfShape map;
// user sorted submeshes of ancestors, according to stored submesh priority // user sorted submeshes of ancestors, according to stored submesh priority
const std::list<SMESH_subMesh*> smList = getAncestorsSubMeshes( aSubShape ); const list<SMESH_subMesh*> smList = getAncestorsSubMeshes( aSubShape );
std::list<SMESH_subMesh*>::const_iterator smIt = smList.begin(); list<SMESH_subMesh*>::const_iterator smIt = smList.begin();
for ( ; smIt != smList.end(); smIt++ ) for ( ; smIt != smList.end(); smIt++ )
{ {
const TopoDS_Shape& curSh = (*smIt)->GetSubShape(); const TopoDS_Shape& curSh = (*smIt)->GetSubShape();
if ( !map.Add( curSh )) if ( !map.Add( curSh ))
continue; continue;
const std::list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(curSh); const list<const SMESHDS_Hypothesis*>& hypList = _myMeshDS->GetHypothesis(curSh);
for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ ) for ( hyp = hypList.begin(); hyp != hypList.end(); hyp++ )
if (aFilter.IsOk( cSMESH_Hyp( *hyp ), curSh ) && if (aFilter.IsOk( cSMESH_Hyp( *hyp ), curSh ) &&
( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) && ( cSMESH_Hyp(*hyp)->IsAuxiliary() || !mainHypFound ) &&
@ -753,7 +755,7 @@ int SMESH_Mesh::GetHypotheses(const TopoDS_Shape & aSubShape,
*/ */
//============================================================================= //=============================================================================
const std::list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception) const list<SMESHDS_Command*> & SMESH_Mesh::GetLog() throw(SALOME_Exception)
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
if(MYDEBUG) MESSAGE("SMESH_Mesh::GetLog"); if(MYDEBUG) MESSAGE("SMESH_Mesh::GetLog");
@ -858,19 +860,19 @@ throw(SALOME_Exception)
*/ */
//================================================================================ //================================================================================
std::list<SMESH_subMesh*> list<SMESH_subMesh*>
SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const SMESH_Mesh::GetGroupSubMeshesContaining(const TopoDS_Shape & aSubShape) const
throw(SALOME_Exception) throw(SALOME_Exception)
{ {
Unexpect aCatch(SalomeException); Unexpect aCatch(SalomeException);
std::list<SMESH_subMesh*> found; list<SMESH_subMesh*> found;
SMESH_subMesh * subMesh = GetSubMeshContaining(aSubShape); SMESH_subMesh * subMesh = GetSubMeshContaining(aSubShape);
if ( !subMesh ) if ( !subMesh )
return found; return found;
// submeshes of groups have max IDs, so search from the map end // submeshes of groups have max IDs, so search from the map end
std::map<int, SMESH_subMesh *>::const_reverse_iterator i_sm; map<int, SMESH_subMesh *>::const_reverse_iterator i_sm;
for ( i_sm = _mapSubMesh.rbegin(); i_sm != _mapSubMesh.rend(); ++i_sm) { for ( i_sm = _mapSubMesh.rbegin(); i_sm != _mapSubMesh.rend(); ++i_sm) {
SMESHDS_SubMesh * ds = i_sm->second->GetSubMeshDS(); SMESHDS_SubMesh * ds = i_sm->second->GetSubMeshDS();
if ( ds && ds->IsComplexSubmesh() ) { if ( ds && ds->IsComplexSubmesh() ) {
@ -1028,9 +1030,9 @@ bool SMESH_Mesh::GetAutoColor() throw(SALOME_Exception)
bool SMESH_Mesh::HasDuplicatedGroupNamesMED() bool SMESH_Mesh::HasDuplicatedGroupNamesMED()
{ {
set<string> aGroupNames; set<string> aGroupNames;
for ( std::map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) { for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
SMESH_Group* aGroup = it->second; SMESH_Group* aGroup = it->second;
std::string aGroupName = aGroup->GetName(); string aGroupName = aGroup->GetName();
aGroupName.resize(MAX_MED_GROUP_NAME_LENGTH); aGroupName.resize(MAX_MED_GROUP_NAME_LENGTH);
if (!aGroupNames.insert(aGroupName).second) if (!aGroupNames.insert(aGroupName).second)
return true; return true;
@ -1068,7 +1070,7 @@ void SMESH_Mesh::ExportMED(const char *file,
set<string> aGroupNames; set<string> aGroupNames;
char aString [256]; char aString [256];
int maxNbIter = 10000; // to guarantee cycle finish int maxNbIter = 10000; // to guarantee cycle finish
for ( std::map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) { for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
SMESH_Group* aGroup = it->second; SMESH_Group* aGroup = it->second;
SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS(); SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
if ( aGroupDS ) { if ( aGroupDS ) {
@ -1108,11 +1110,11 @@ void SMESH_Mesh::ExportUNV(const char *file) throw(SALOME_Exception)
myWriter.SetMeshId(_idDoc); myWriter.SetMeshId(_idDoc);
// myWriter.SetGroups(_mapGroup); // myWriter.SetGroups(_mapGroup);
for ( std::map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) { for ( map<int, SMESH_Group*>::iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) {
SMESH_Group* aGroup = it->second; SMESH_Group* aGroup = it->second;
SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS(); SMESHDS_GroupBase* aGroupDS = aGroup->GetGroupDS();
if ( aGroupDS ) { if ( aGroupDS ) {
std::string aGroupName = aGroup->GetName(); string aGroupName = aGroup->GetName();
aGroupDS->SetStoreName( aGroupName.c_str() ); aGroupDS->SetStoreName( aGroupName.c_str() );
myWriter.AddGroup( aGroupDS ); myWriter.AddGroup( aGroupDS );
} }
@ -1374,10 +1376,10 @@ SMESH_Group* SMESH_Mesh::GetGroup (const int theGroupID)
*/ */
//============================================================================= //=============================================================================
std::list<int> SMESH_Mesh::GetGroupIds() const list<int> SMESH_Mesh::GetGroupIds() const
{ {
std::list<int> anIds; list<int> anIds;
for ( std::map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ ) for ( map<int, SMESH_Group*>::const_iterator it = _mapGroup.begin(); it != _mapGroup.end(); it++ )
anIds.push_back( it->first ); anIds.push_back( it->first );
return anIds; return anIds;
@ -1442,7 +1444,7 @@ ostream& SMESH_Mesh::Dump(ostream& save)
save << clause << ".1) Number of " << orderStr << " triangles: \t" << nb3 << endl; save << clause << ".1) Number of " << orderStr << " triangles: \t" << nb3 << endl;
save << clause << ".2) Number of " << orderStr << " quadrangles:\t" << nb4 << endl; save << clause << ".2) Number of " << orderStr << " quadrangles:\t" << nb4 << endl;
if ( nb3 + nb4 != NbFaces(order) ) { if ( nb3 + nb4 != NbFaces(order) ) {
std::map<int,int> myFaceMap; map<int,int> myFaceMap;
SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator(); SMDS_FaceIteratorPtr itFaces=_myMeshDS->facesIterator();
while( itFaces->more( ) ) { while( itFaces->more( ) ) {
int nbNodes = itFaces->next()->NbNodes(); int nbNodes = itFaces->next()->NbNodes();
@ -1467,7 +1469,7 @@ ostream& SMESH_Mesh::Dump(ostream& save)
save << clause << ".3) Number of " << orderStr << " prisms: \t" << nb6 << endl; save << clause << ".3) Number of " << orderStr << " prisms: \t" << nb6 << endl;
save << clause << ".4) Number of " << orderStr << " pyramids:\t" << nb5 << endl; save << clause << ".4) Number of " << orderStr << " pyramids:\t" << nb5 << endl;
if ( nb8 + nb4 + nb5 + nb6 != NbVolumes(order) ) { if ( nb8 + nb4 + nb5 + nb6 != NbVolumes(order) ) {
std::map<int,int> myVolumesMap; map<int,int> myVolumesMap;
SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator(); SMDS_VolumeIteratorPtr itVolumes=_myMeshDS->volumesIterator();
while( itVolumes->more( ) ) { while( itVolumes->more( ) ) {
int nbNodes = itVolumes->next()->NbNodes(); int nbNodes = itVolumes->next()->NbNodes();
@ -1506,7 +1508,7 @@ SMDSAbs_ElementType SMESH_Mesh::GetElementType( const int id, const bool iselem
SMESH_Group* SMESH_Mesh::ConvertToStandalone ( int theGroupID ) SMESH_Group* SMESH_Mesh::ConvertToStandalone ( int theGroupID )
{ {
SMESH_Group* aGroup = 0; SMESH_Group* aGroup = 0;
std::map < int, SMESH_Group * >::iterator itg = _mapGroup.find( theGroupID ); map < int, SMESH_Group * >::iterator itg = _mapGroup.find( theGroupID );
if ( itg == _mapGroup.end() ) if ( itg == _mapGroup.end() )
return aGroup; return aGroup;
@ -1593,54 +1595,44 @@ void SMESH_Mesh::fillAncestorsMap(const TopoDS_Shape& theShape)
*/ */
//============================================================================= //=============================================================================
bool SMESH_Mesh::SortByMeshOrder(std::list<SMESH_subMesh*>& theListToSort) const bool SMESH_Mesh::SortByMeshOrder(list<SMESH_subMesh*>& theListToSort) const
{ {
if ( !_mySubMeshOrder.size() || theListToSort.size() < 2) if ( !_mySubMeshOrder.size() || theListToSort.size() < 2)
return true; return true;
bool res = false; bool res = false;
std::list<SMESH_subMesh*> onlyOrderedList; list<SMESH_subMesh*> onlyOrderedList;
// collect all ordered submeshes in one list as pointers // collect all ordered submeshes in one list as pointers
// and get their positions within theListToSort
typedef list<SMESH_subMesh*>::iterator TPosInList;
map< int, TPosInList > sortedPos;
TPosInList smBeg = theListToSort.begin(), smEnd = theListToSort.end();
TListOfListOfInt::const_iterator listIddIt = _mySubMeshOrder.begin(); TListOfListOfInt::const_iterator listIddIt = _mySubMeshOrder.begin();
for( ; listIddIt != _mySubMeshOrder.end(); listIddIt++) { for( ; listIddIt != _mySubMeshOrder.end(); listIddIt++) {
const TListOfInt& listOfId = *listIddIt; const TListOfInt& listOfId = *listIddIt;
TListOfInt::const_iterator idIt = listOfId.begin(); TListOfInt::const_iterator idIt = listOfId.begin();
for ( ; idIt != listOfId.end(); idIt++ ) { for ( ; idIt != listOfId.end(); idIt++ ) {
map <int, SMESH_subMesh *>::const_iterator i_sm = _mapSubMesh.find(*idIt); if ( SMESH_subMesh * sm = GetSubMeshContaining( *idIt )) {
if ( i_sm != _mapSubMesh.end() ) TPosInList smPos = find( smBeg, smEnd, sm );
onlyOrderedList.push_back(i_sm->second); if ( smPos != smEnd ) {
onlyOrderedList.push_back( sm );
sortedPos[ distance( smBeg, smPos )] = smPos;
}
}
} }
} }
if (!onlyOrderedList.size()) if (onlyOrderedList.size() < 2)
return res; return res;
res = true;
std::list<SMESH_subMesh*>::iterator onlyBIt = onlyOrderedList.begin(); list<SMESH_subMesh*>::iterator onlyBIt = onlyOrderedList.begin();
std::list<SMESH_subMesh*>::iterator onlyEIt = onlyOrderedList.end(); list<SMESH_subMesh*>::iterator onlyEIt = onlyOrderedList.end();
// check positions where ordered submeshes should be in result list // iterates on ordered submeshes and insert them in detected positions
std::set<int> setOfPos; // remember positions of in set map< int, TPosInList >::iterator i_pos = sortedPos.begin();
std::list<SMESH_subMesh*>::const_iterator smIt = theListToSort.begin(); for ( ; onlyBIt != onlyEIt; ++onlyBIt )
int i = 0; *(i_pos->second) = *onlyBIt;
for( ; smIt != theListToSort.end(); i++, smIt++ )
if ( find( onlyBIt, onlyEIt, *smIt ) != onlyEIt )
setOfPos.insert(i);
if ( !setOfPos.size() )
return res;
// new list of all submeshes to be sorted
std::list<SMESH_subMesh*> aNewList;
// iterates on submeshes and insert ordered in detected positions
for ( i = 0, smIt = theListToSort.begin(); smIt != theListToSort.end(); i++, smIt++ )
if ( setOfPos.find( i ) != setOfPos.end() &&
onlyBIt != onlyEIt ) { // position of ordered submesh detected
aNewList.push_back( *onlyBIt ); // ordered submesh
onlyBIt++;
}
else
aNewList.push_back( *smIt ); // other submesh from list
theListToSort = aNewList;
return res; return res;
} }
@ -1652,10 +1644,10 @@ bool SMESH_Mesh::SortByMeshOrder(std::list<SMESH_subMesh*>& theListToSort) const
*/ */
//============================================================================= //=============================================================================
std::list<SMESH_subMesh*> SMESH_Mesh::getAncestorsSubMeshes list<SMESH_subMesh*> SMESH_Mesh::getAncestorsSubMeshes
(const TopoDS_Shape& theSubShape) const (const TopoDS_Shape& theSubShape) const
{ {
std::list<SMESH_subMesh*> listOfSubMesh; list<SMESH_subMesh*> listOfSubMesh;
TopTools_ListIteratorOfListOfShape it( GetAncestors( theSubShape )); TopTools_ListIteratorOfListOfShape it( GetAncestors( theSubShape ));
for (; it.More(); it.Next() ) { for (; it.More(); it.Next() ) {
int index = _myMeshDS->ShapeToIndex(it.Value()); int index = _myMeshDS->ShapeToIndex(it.Value());