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

0020213: RadialPrism_3D_4 failed on V5_1 64 bits

Browse Source 
0020214: Project_2D_4 failed on V5_1 64 bits
   different ways of removing deleted and alive elements from submesh
This commit is contained in:
eap 2009-03-12 09:47:59 +00:00
parent bebf85204e
commit a84fe0415c
3 changed files with 87 additions and 42 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

44
src/SMESHDS/SMESHDS_Mesh.cxx
View File

@ -652,6 +652,8 @@ static void removeFromContainers (map<int,SMESHDS_SubMesh*>& theSubMeshes,
}
}
const bool deleted=true;
// Rm from sub-meshes
// Element should belong to only one sub-mesh
map<int,SMESHDS_SubMesh*>::iterator SubIt = theSubMeshes.begin();
@ -665,9 +667,9 @@ static void removeFromContainers (map<int,SMESHDS_SubMesh*>& theSubMeshes,
{
bool removed = false;
if ( isNode )
removed = (*SubIt).second->RemoveNode( static_cast<const SMDS_MeshNode*> (*elIt) );
removed = (*SubIt).second->RemoveNode( static_cast<const SMDS_MeshNode*> (*elIt), deleted );
else
removed = (*SubIt).second->RemoveElement( *elIt );
removed = (*SubIt).second->RemoveElement( *elIt, deleted );
if (removed)
{
@ -689,6 +691,23 @@ static void removeFromContainers (map<int,SMESHDS_SubMesh*>& theSubMeshes,
//=======================================================================
void SMESHDS_Mesh::RemoveNode(const SMDS_MeshNode * n)
{
if ( n->NbInverseElements() == 0 && !(hasConstructionEdges() || hasConstructionFaces()))
{
SMESHDS_SubMesh* subMesh=0;
map<int,SMESHDS_SubMesh*>::iterator SubIt =
myShapeIndexToSubMesh.find( n->GetPosition()->GetShapeId() );
if ( SubIt != myShapeIndexToSubMesh.end() )
subMesh = SubIt->second;
else
SubIt = myShapeIndexToSubMesh.begin();
for ( ; !subMesh && SubIt != myShapeIndexToSubMesh.end(); SubIt++ )
if ( SubIt->second->Contains( n ))
subMesh = SubIt->second;
RemoveFreeNode( n, subMesh, true);
return;
}
myScript->RemoveNode(n->GetID());
list<const SMDS_MeshElement *> removedElems;
@ -724,7 +743,7 @@ void SMESHDS_Mesh::RemoveFreeNode(const SMDS_MeshNode * n,
// Rm from sub-mesh
// Node should belong to only one sub-mesh
if( subMesh )
subMesh->RemoveNode(n);
subMesh->RemoveNode(n,/*deleted=*/false);
SMDS_Mesh::RemoveFreeElement(n);
}
@ -740,7 +759,18 @@ void SMESHDS_Mesh::RemoveElement(const SMDS_MeshElement * elt)
RemoveNode( static_cast<const SMDS_MeshNode*>( elt ));
return;
}
if (!hasConstructionEdges() && !hasConstructionFaces())
{
SMESHDS_SubMesh* subMesh=0;
map<int,SMESHDS_SubMesh*>::iterator SubIt = myShapeIndexToSubMesh.begin();
for ( ; !subMesh && SubIt != myShapeIndexToSubMesh.end(); SubIt++ )
if ( SubIt->second->Contains( elt ))
subMesh = SubIt->second;
RemoveFreeElement( elt, subMesh, true);
return;
}
myScript->RemoveElement(elt->GetID());
list<const SMDS_MeshElement *> removedElems;
@ -784,7 +814,7 @@ void SMESHDS_Mesh::RemoveFreeElement(const SMDS_MeshElement * elt,
// Rm from sub-mesh
// Element should belong to only one sub-mesh
if( subMesh )
subMesh->RemoveElement(elt);
subMesh->RemoveElement(elt, /*deleted=*/false);
SMDS_Mesh::RemoveFreeElement(elt);
}
@ -965,7 +995,7 @@ void SMESHDS_Mesh::UnSetNodeOnShape(const SMDS_MeshNode* aNode)
map<int,SMESHDS_SubMesh*>::iterator it =
myShapeIndexToSubMesh.find( aNode->GetPosition()->GetShapeId() );
if ( it != myShapeIndexToSubMesh.end() )
it->second->RemoveNode( aNode );
it->second->RemoveNode( aNode, /*deleted=*/false );
}
}
@ -991,9 +1021,9 @@ void SMESHDS_Mesh::UnSetMeshElementOnShape(const SMDS_MeshElement * elem,
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 ));
it->second->RemoveNode( static_cast<const SMDS_MeshNode* >( elem ), /*deleted=*/false );
else
it->second->RemoveElement( elem );
it->second->RemoveElement( elem, /*deleted=*/false );
}
//=======================================================================

75
src/SMESHDS/SMESHDS_SubMesh.cxx
View File

@ -46,10 +46,20 @@ void SMESHDS_SubMesh::AddElement(const SMDS_MeshElement * ME)
//function : RemoveElement
//purpose :
//=======================================================================
bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME)
bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME, bool isElemDeleted)
{
if ( !IsComplexSubmesh() && NbElements() )
return myElements.erase(ME);
if ( !IsComplexSubmesh() && NbElements() ) {
if (!isElemDeleted) // alive element has valid ID and can be found
return myElements.erase(ME);
TElemSet::iterator e = myElements.begin(), eEnd = myElements.end();
for ( ; e != eEnd; ++e )
if ( ME == *e ) {
myElements.erase( e );
return true;
}
}
return false;
}
@ -69,10 +79,20 @@ void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
//purpose :
//=======================================================================
bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N)
bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N, bool isNodeDeleted)
{
if ( !IsComplexSubmesh() && NbNodes() )
return myNodes.erase(N);
if ( !IsComplexSubmesh() && NbNodes() ) {
if (!isNodeDeleted) // alive node has valid ID and can be found
return myNodes.erase(N);
TElemSet::iterator e = myNodes.begin(), eEnd = myNodes.end();
for ( ; e != eEnd; ++e )
if ( N == *e ) {
myNodes.erase( e );
return true;
}
}
return false;
}
@ -116,12 +136,12 @@ int SMESHDS_SubMesh::NbNodes() const
// class MySetIterator
// =====================
template<typename TSet> class MySetIterator: public SMDS_SetIterator<typename TSet::key_type,
typename TSet::const_iterator >
template<class ELEM, typename TSET> class MySetIterator:
public SMDS_SetIterator<ELEM, typename TSET::const_iterator >
{
typedef SMDS_SetIterator<typename TSet::key_type, typename TSet::const_iterator > TFather;
typedef SMDS_SetIterator<ELEM, typename TSET::const_iterator > TFather;
public:
MySetIterator(const TSet& s):TFather(s.begin(),s.end())
MySetIterator(const TSET& s):TFather(s.begin(),s.end())
{
}
};
@ -134,12 +154,11 @@ template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
{
public:
MyIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
: mySubMeshes( theSubMeshes ), mySubIt( theSubMeshes.begin() ), myMore(false)
: mySubIt( theSubMeshes.begin() ), mySubEnd( theSubMeshes.end() ), myMore(false)
{}
bool more()
{
while (( !myElemIt.get() || !myElemIt->more() ) &&
mySubIt != mySubMeshes.end())
while (( !myElemIt.get() || !myElemIt->more() ) && mySubIt != mySubEnd)
{
myElemIt = getElements(*mySubIt);
mySubIt++;
@ -160,8 +179,7 @@ template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
private:
bool myMore;
const set<const SMESHDS_SubMesh*>& mySubMeshes;
set<const SMESHDS_SubMesh*>::const_iterator mySubIt;
set<const SMESHDS_SubMesh*>::const_iterator mySubIt, mySubEnd;
boost::shared_ptr< SMDS_Iterator<VALUE> > myElemIt;
};
@ -201,7 +219,7 @@ SMDS_ElemIteratorPtr SMESHDS_SubMesh::GetElements() const
if ( IsComplexSubmesh() )
return SMDS_ElemIteratorPtr( new MyElemIterator( mySubMeshes ));
return SMDS_ElemIteratorPtr(new MySetIterator<TElemSet>(myElements));
return SMDS_ElemIteratorPtr(new MySetIterator<const SMDS_MeshElement*,TElemSet>(myElements));
}
//=======================================================================
@ -214,7 +232,7 @@ SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes() const
if ( IsComplexSubmesh() )
return SMDS_NodeIteratorPtr( new MyNodeIterator( mySubMeshes ));
return SMDS_NodeIteratorPtr(new MySetIterator<TNodeSet>(myNodes));
return SMDS_NodeIteratorPtr(new MySetIterator<const SMDS_MeshNode*,TElemSet>(myNodes));
}
//=======================================================================
@ -225,23 +243,20 @@ SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes() const
bool SMESHDS_SubMesh::Contains(const SMDS_MeshElement * ME) const
{
// DO NOT TRY TO FIND A REMOVED ELEMENT !!
if ( !ME )
if ( IsComplexSubmesh() || !ME )
return false;
if ( IsComplexSubmesh() )
{
set<const SMESHDS_SubMesh*>::const_iterator aSubIt = mySubMeshes.begin();
for ( ; aSubIt != mySubMeshes.end(); aSubIt++ )
if ( (*aSubIt)->Contains( ME ))
return true;
return false;
}
// if ( IsComplexSubmesh() )
// {
// set<const SMESHDS_SubMesh*>::const_iterator aSubIt = mySubMeshes.begin();
// for ( ; aSubIt != mySubMeshes.end(); aSubIt++ )
// if ( (*aSubIt)->Contains( ME ))
// return true;
// return false;
// }
if ( ME->GetType() == SMDSAbs_Node )
{
const SMDS_MeshNode* n = static_cast<const SMDS_MeshNode*>( ME );
return ( myNodes.find( n ) != myNodes.end() );
}
return ( myNodes.find( ME ) != myNodes.end() );
return ( myElements.find( ME ) != myElements.end() );
}

10
src/SMESHDS/SMESHDS_SubMesh.hxx
View File

@ -43,9 +43,9 @@ class SMESHDS_EXPORT SMESHDS_SubMesh
// if !IsComplexSubmesh()
void AddElement(const SMDS_MeshElement * ME);
bool RemoveElement(const SMDS_MeshElement * ME); // ret true if ME was in
bool RemoveElement(const SMDS_MeshElement * ME, bool isElemDeleted); // ret true if ME was in
void AddNode(const SMDS_MeshNode * ME);
bool RemoveNode(const SMDS_MeshNode * ME); // ret true if ME was in
bool RemoveNode(const SMDS_MeshNode * ME, bool isNodeDeleted); // ret true if ME was in
// if IsComplexSubmesh()
void AddSubMesh( const SMESHDS_SubMesh* theSubMesh );
@ -65,14 +65,14 @@ class SMESHDS_EXPORT SMESHDS_SubMesh
void Clear();
private:
struct TIDCompare { // to have nodes and elements sorted by ID
bool operator () (const SMDS_MeshElement* e1, const SMDS_MeshElement* e2) const
{ return e1->GetID() < e2->GetID(); }
};
typedef std::set<const SMDS_MeshElement*, TIDCompare > TElemSet;
typedef std::set<const SMDS_MeshNode* , TIDCompare> TNodeSet;
TElemSet myElements;
TNodeSet myNodes;
TElemSet myElements, myNodes;
std::set<const SMESHDS_SubMesh*> mySubMeshes;
};
#endif