X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESHDS%2FSMESHDS_SubMesh.cxx;h=73007402cebf090d4fd869b6ac36bfb84e90fb65;hp=e2e1494adb9d375749adf7c6cd3c3fde0f73f50b;hb=HEAD;hpb=2d46bce2985c40bfac0593abad88d590a8efca48 diff --git a/src/SMESHDS/SMESHDS_SubMesh.cxx b/src/SMESHDS/SMESHDS_SubMesh.cxx index e2e1494ad..1a559f77c 100644 --- a/src/SMESHDS/SMESHDS_SubMesh.cxx +++ b/src/SMESHDS/SMESHDS_SubMesh.cxx @@ -1,154 +1,542 @@ -// SMESH SMESHDS : management of mesh data and SMESH document +// 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 +// +// This library is free software; you can redistribute it and/or +// modify it under the terms of the GNU Lesser General Public +// License as published by the Free Software Foundation; either +// version 2.1 of the License, or (at your option) any later version. // -// Copyright (C) 2003 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN, -// CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS -// -// This library is free software; you can redistribute it and/or -// modify it under the terms of the GNU Lesser General Public -// License as published by the Free Software Foundation; either -// version 2.1 of the License. -// -// This library is distributed in the hope that it will be useful, -// but WITHOUT ANY WARRANTY; without even the implied warranty of -// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU -// Lesser General Public License for more details. -// -// You should have received a copy of the GNU Lesser General Public -// License along with this library; if not, write to the Free Software -// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA -// -// See http://www.opencascade.org/SALOME/ or email : webmaster.salome@opencascade.org +// This library is distributed in the hope that it will be useful, +// but WITHOUT ANY WARRANTY; without even the implied warranty of +// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU +// Lesser General Public License for more details. // +// You should have received a copy of the GNU Lesser General Public +// License along with this library; if not, write to the Free Software +// Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA // +// See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com // + +// SMESH SMESHDS : management of mesh data and SMESH document // File : SMESH_SubMesh.cxx // Author : Yves FRICAUD, OCC // Module : SMESH // $Header: - -using namespace std; +// #include "SMESHDS_SubMesh.hxx" -//======================================================================= -//function : SMESHDS_SubMesh -//purpose : -//======================================================================= -SMESHDS_SubMesh::SMESHDS_SubMesh(const SMDS_Mesh * M):myMesh(M) +#include "SMDS_ElementFactory.hxx" +#include "SMDS_IteratorOnIterators.hxx" +#include "SMDS_SetIterator.hxx" +#include "SMESHDS_Mesh.hxx" + +#include + +namespace +{ + typedef const SMDS_MeshElement* PElem; + typedef const SMDS_MeshNode* PNode; + + typedef SMDS_SetIterator< PElem, PElem const *, + SMDS::SimpleAccessor< PElem, PElem const * >, + SMDS::NonNullFilter< PElem > > EArrayIterator; + + typedef SMDS_SetIterator< PNode, PNode const *, + SMDS::SimpleAccessor< PNode, PNode const * >, + SMDS::NonNullFilter< PNode > > NArrayIterator; + + int ind1st( SMDSAbs_ElementType t ) + { + return t == SMDSAbs_Node; + } + + //======================================================================= + //class : _MyElemIteratorFromNodeIterator + //======================================================================= + class _MyElemIteratorFromNodeIterator : public SMDS_ElemIterator + { + SMDS_NodeIteratorPtr myItr; + public: + _MyElemIteratorFromNodeIterator(SMDS_NodeIteratorPtr nodeItr): myItr( nodeItr ) {} + bool more() { return myItr->more(); } + const SMDS_MeshElement* next() { return myItr->next(); } + }; +} + +//================================================================================ +/*! + * \brief Constructor + */ +//================================================================================ + +SMESHDS_SubMesh::SMESHDS_SubMesh(const SMESHDS_Mesh *parent, int index) + : SMDS_ElementHolder( parent ) +{ + myParent = parent; + myIndex = index; + myNbElements = 0; + myNbNodes = 0; + my1stElemNode[0] = my1stElemNode[1] = 0; +} + +//================================================================================ +/*! + * \brief Destructor + */ +//================================================================================ + +SMESHDS_SubMesh::~SMESHDS_SubMesh() { - myListOfEltIDIsUpdate = false; - myListOfNodeIDIsUpdate = false; } //======================================================================= //function : AddElement -//purpose : +//purpose : //======================================================================= -void SMESHDS_SubMesh::AddElement(const SMDS_MeshElement * ME) + +void SMESHDS_SubMesh::AddElement(const SMDS_MeshElement * elem) { - myElements.insert(ME); - myListOfEltIDIsUpdate = false; + if (!IsComplexSubmesh()) + { + if ( elem->GetType() == SMDSAbs_Node ) + { + AddNode( static_cast< const SMDS_MeshNode* >( elem )); + return; + } + int oldShapeId = elem->GetShapeID(); + if ( oldShapeId > 0 ) + { + if (oldShapeId != myIndex) + { + throw SALOME_Exception + (LOCALIZED("add element in subshape already belonging to a subshape")); + } + } + else + { + ++myNbElements; + } + + elem->setShapeID( myIndex ); + + // remember element with smallest ID to optimize iteration on them + add( elem ); + } } //======================================================================= //function : RemoveElement -//purpose : +//purpose : //======================================================================= -void SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME) + +bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * elem ) { - myElements.erase(ME); - myListOfEltIDIsUpdate = false; + if ( myNbElements == 0 || !elem || elem->IsNull() || elem->getshapeId() != myIndex ) + { + return false; + } + if ( !IsComplexSubmesh() ) + { + elem->setShapeID( 0 ); + myNbElements--; + + const SMDS_MeshElement* & elem1st = my1stElemNode[ ind1st( elem->GetType() )]; + if ( elem1st == elem ) + { + if ( myNbElements > 0 ) + { + SMDS_ElemIteratorPtr it = myParent->shapeElementsIterator( myIndex, 1, elem1st ); + if ( it->more() ) + elem1st = it->next(); + else + throw SALOME_Exception(LOCALIZED("invalid myNbElements")); + } + else + { + elem1st = 0; + } + } + return true; + } + return false; } //======================================================================= //function : AddNode -//purpose : +//purpose : //======================================================================= + void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N) { - myNodes.insert(N); - myListOfNodeIDIsUpdate = false; + if ( !IsComplexSubmesh() ) + { + const int shapeId = N->getshapeId(); + if ( shapeId > 0 ) + { + if ( shapeId != myIndex ) + throw SALOME_Exception + (LOCALIZED("a node being in sub-mesh is added to another sub-mesh")); + return; // already in + } + else + { + ++myNbNodes; + } + N->setShapeID( myIndex ); + + // remember node with smallest ID to optimize iteration on them + add( N ); + } } //======================================================================= //function : RemoveNode -//purpose : +//purpose : //======================================================================= -void SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N) + +bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N) { - myNodes.erase(N); - myListOfNodeIDIsUpdate = false; + if ( myNbNodes == 0 || !N || N->getshapeId() != myIndex ) + { + return false; + } + if ( !IsComplexSubmesh() ) + { + N->setShapeID( 0 ); + myNbNodes--; + + const SMDS_MeshElement* & node1st = my1stElemNode[ ind1st( SMDSAbs_Node )]; + if ( node1st == N ) + { + if ( myNbNodes > 0 ) + { + SMDS_NodeIteratorPtr it = + myParent->shapeNodesIterator( myIndex, 1, static_cast< PNode >( node1st )); + if ( it->more() ) + node1st = it->next(); + else + throw SALOME_Exception(LOCALIZED("invalid myNbNodes")); + } + else + { + node1st = 0; + } + } + return true; + } + return false; } //======================================================================= //function : NbElements -//purpose : +//purpose : //======================================================================= -int SMESHDS_SubMesh::NbElements() const + +smIdType SMESHDS_SubMesh::NbElements() const { - return myElements.size(); + if ( !IsComplexSubmesh() ) + return myNbElements; + + smIdType nbElems = 0; + TSubMeshSet::const_iterator it = mySubMeshes.begin(); + for ( ; it != mySubMeshes.end(); it++ ) + nbElems += (*it)->NbElements(); + + return nbElems; } //======================================================================= -//function : GetElements -//purpose : +//function : NbNodes +//purpose : //======================================================================= -const set & SMESHDS_SubMesh::GetElements() + +smIdType SMESHDS_SubMesh::NbNodes() const { - return myElements; + if ( !IsComplexSubmesh() ) + return myNbNodes; + + smIdType nbElems = 0; + TSubMeshSet::const_iterator it = mySubMeshes.begin(); + for ( ; it != mySubMeshes.end(); it++ ) + nbElems += (*it)->NbNodes(); + + return nbElems; } +// ===================== +// class MyIterator +// ===================== + +template class MyIterator : public SMDS_Iterator +{ +public: + MyIterator (const TSubMeshSet& theSubMeshes) + : myMore(false), mySubIt( theSubMeshes.begin() ), mySubEnd( theSubMeshes.end() ) + {} + bool more() + { + while (( !myElemIt.get() || !myElemIt->more() ) && mySubIt != mySubEnd) + { + myElemIt = getElements(*mySubIt); + mySubIt++; + } + myMore = myElemIt.get() && myElemIt->more(); + return myMore; + } + VALUE next() + { + VALUE elem = 0; + if ( myMore ) + elem = myElemIt->next(); + return elem; + } +protected: + virtual boost::shared_ptr< SMDS_Iterator > + getElements(const SMESHDS_SubMesh*) const = 0; + +private: + bool myMore; + TSubMeshSet::const_iterator mySubIt, mySubEnd; + boost::shared_ptr< SMDS_Iterator > myElemIt; +}; + +// ===================== +// class MyElemIterator +// ===================== + +class MyElemIterator: public MyIterator +{ +public: + MyElemIterator (const TSubMeshSet& theSubMeshes) + :MyIterator( theSubMeshes ) {} + SMDS_ElemIteratorPtr getElements(const SMESHDS_SubMesh* theSubMesh) const + { return theSubMesh->GetElements(); } +}; + +// ===================== +// class MyNodeIterator +// ===================== + +class MyNodeIterator: public MyIterator +{ +public: + MyNodeIterator (const TSubMeshSet& theSubMeshes) + :MyIterator( theSubMeshes ) {} + SMDS_NodeIteratorPtr getElements(const SMESHDS_SubMesh* theSubMesh) const + { return theSubMesh->GetNodes(); } +}; + //======================================================================= -//function : NbNodes -//purpose : +//function : GetElements +//purpose : //======================================================================= -int SMESHDS_SubMesh::NbNodes() const + +SMDS_ElemIteratorPtr SMESHDS_SubMesh::GetElements() const { - return myNodes.size(); + if ( IsComplexSubmesh() ) + return SMDS_ElemIteratorPtr( new MyElemIterator( mySubMeshes )); + + const SMDS_MeshElement* const * elem1st = & my1stElemNode[ ind1st( SMDSAbs_All )]; + if ( myNbElements < 2 ) + { + return boost::make_shared< EArrayIterator >( elem1st, elem1st + myNbElements ); + } + + return myParent->shapeElementsIterator( myIndex, myNbElements, *elem1st ); } //======================================================================= //function : GetNodes -//purpose : +//purpose : //======================================================================= -const set & SMESHDS_SubMesh::GetNodes() const + +SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes() const { - return myNodes; + if ( IsComplexSubmesh() ) + return SMDS_NodeIteratorPtr( new MyNodeIterator( mySubMeshes )); + + PNode const * node1st = + reinterpret_cast< PNode const* >( & my1stElemNode[ ind1st( SMDSAbs_Node )] ); + if ( myNbNodes < 2 ) + { + return boost::make_shared< NArrayIterator >( node1st, node1st + myNbNodes ); + } + + return myParent->shapeNodesIterator( myIndex, myNbNodes, *node1st ); } //======================================================================= -//function : GetIDElements +//function : Contains +//purpose : check if elem or node is in +//======================================================================= + +bool SMESHDS_SubMesh::Contains(const SMDS_MeshElement * ME) const +{ + if ( !ME || ME->IsNull() ) + return false; + + if ( IsComplexSubmesh() ) + { + TSubMeshSet::const_iterator aSubIt = mySubMeshes.begin(); + for (; aSubIt != mySubMeshes.end(); aSubIt++) + if ((*aSubIt)->Contains(ME)) + return true; + return false; + } + return ME->getshapeId() == myIndex; +} + +//======================================================================= +//function : IsQuadratic +//purpose : Return true if my 1st element is quadratic +//======================================================================= + +bool SMESHDS_SubMesh::IsQuadratic() const +{ + if ( IsComplexSubmesh() ) + { + TSubMeshSet::const_iterator aSubIt = mySubMeshes.begin(); + for (; aSubIt != mySubMeshes.end(); aSubIt++) + if ((*aSubIt)->IsQuadratic()) + return true; + return false; + } + + if ( myNbElements == 0 ) + return false; + + SMDS_ElemIteratorPtr it = GetElements(); + return it->more() && it->next()->IsQuadratic(); +} + +//======================================================================= +//function : AddSubMesh +//purpose : +//======================================================================= + +void SMESHDS_SubMesh::AddSubMesh( const SMESHDS_SubMesh* theSubMesh ) +{ + ASSERT( theSubMesh ); + mySubMeshes.insert( theSubMesh ); +} + +//======================================================================= +//function : RemoveSubMesh //purpose : //======================================================================= -const vector & SMESHDS_SubMesh::GetIDElements() + +bool SMESHDS_SubMesh::RemoveSubMesh( const SMESHDS_SubMesh* theSubMesh ) { - if (!myListOfEltIDIsUpdate) - { - myListOfEltID.clear(); - set::iterator it=myElements.begin(); - for (; it!=myElements.end(); it++) - { - myListOfEltID.push_back((*it)->GetID()); - } - myListOfEltIDIsUpdate = true; - } - return myListOfEltID; + return mySubMeshes.erase( theSubMesh ); } //======================================================================= -//function : GetIDNodes +//function : RemoveAllSubmeshes //purpose : //======================================================================= -const vector & SMESHDS_SubMesh::GetIDNodes() -{ - if (!myListOfNodeIDIsUpdate) - { - myListOfNodeID.clear(); - set::iterator it=myNodes.begin(); - for (; it!=myNodes.end(); it++) - { - myListOfNodeID.push_back((*it)->GetID()); - } - myListOfNodeIDIsUpdate = true; - } - return myListOfNodeID; + +void SMESHDS_SubMesh::RemoveAllSubmeshes() +{ + mySubMeshes.clear(); +} + +//======================================================================= +//function : ContainsSubMesh +//purpose : +//======================================================================= + +bool SMESHDS_SubMesh::ContainsSubMesh( const SMESHDS_SubMesh* theSubMesh ) const +{ + return mySubMeshes.find( theSubMesh ) != mySubMeshes.end(); +} + +//======================================================================= +//function : GetSubMeshIterator +//purpose : +//======================================================================= + +SMESHDS_SubMeshIteratorPtr SMESHDS_SubMesh::GetSubMeshIterator() const +{ + typedef SMDS_SetIterator< const SMESHDS_SubMesh*, TSubMeshSet::const_iterator > TIterator; + return boost::make_shared< TIterator >( mySubMeshes.begin(), mySubMeshes.end()); +} + +//======================================================================= +//function : Clear +//purpose : remove the contents +//======================================================================= + +void SMESHDS_SubMesh::Clear() +{ + if ( myParent && myParent->NbNodes() > 0 ) + { + if ( myNbElements > 0 ) + for ( SMDS_ElemIteratorPtr it = GetElements(); it->more(); ) + { + const SMDS_MeshElement * elem = it->next(); + elem->setShapeID( 0 ); + } + if ( myNbNodes > 0 ) + for ( SMDS_NodeIteratorPtr it = GetNodes(); it->more(); ) + { + const SMDS_MeshNode * elem = it->next(); + elem->setShapeID( 0 ); + } + } + + myNbElements = 0; + myNbNodes = 0; + my1stElemNode[0] = my1stElemNode[1] = 0; + + if ( NbSubMeshes() > 0 ) + { + SMESHDS_SubMeshIteratorPtr sub = GetSubMeshIterator(); + while ( sub->more() ) { + if ( SMESHDS_SubMesh* sm = (SMESHDS_SubMesh*) sub->next()) + sm->Clear(); + } + } +} + +//======================================================================= +//function : getElements +//purpose : Return iterator on all elements and nodes during compacting +//======================================================================= + +SMDS_ElemIteratorPtr SMESHDS_SubMesh::getElements() +{ + if ( IsComplexSubmesh() ) // return nothing + boost::make_shared< EArrayIterator >( & my1stElemNode[0], & my1stElemNode[0] ); + + typedef std::vector< SMDS_ElemIteratorPtr > TIterVec; + TIterVec iterVec(2); + iterVec[0] = GetElements(); + iterVec[1].reset( new _MyElemIteratorFromNodeIterator( GetNodes() )); + + return boost::make_shared< SMDS_IteratorOnIterators< PElem, TIterVec > >( iterVec ); +} + +//======================================================================= +//function : tmpClear +//purpose : clean up after compacting +//======================================================================= + +void SMESHDS_SubMesh::tmpClear() +{ + my1stElemNode[0] = my1stElemNode[1] = 0; +} + +//======================================================================= +//function : add +//purpose : update my1stElemNode +//======================================================================= + +void SMESHDS_SubMesh::add( const SMDS_MeshElement* elem ) +{ + const SMDS_MeshElement* & oldElem = my1stElemNode[ ind1st( elem->GetType() )]; + if ( !oldElem || oldElem->GetID() > elem->GetID() ) + oldElem = elem; }