1 // Copyright (C) 2007-2016 CEA/DEN, EDF R&D, OPEN CASCADE
3 // Copyright (C) 2003-2007 OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
6 // This library is free software; you can redistribute it and/or
7 // modify it under the terms of the GNU Lesser General Public
8 // License as published by the Free Software Foundation; either
9 // version 2.1 of the License, or (at your option) any later version.
11 // This library is distributed in the hope that it will be useful,
12 // but WITHOUT ANY WARRANTY; without even the implied warranty of
13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 // Lesser General Public License for more details.
16 // You should have received a copy of the GNU Lesser General Public
17 // License along with this library; if not, write to the Free Software
18 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
23 // SMESH SMESHDS : management of mesh data and SMESH document
24 // File : SMESH_SubMesh.cxx
25 // Author : Yves FRICAUD, OCC
29 #include "SMESHDS_SubMesh.hxx"
30 #include "SMESHDS_Mesh.hxx"
32 #include "utilities.h"
33 #include "SMDS_SetIterator.hxx"
40 //================================================================================
44 //================================================================================
46 SMESHDS_SubMesh::SMESHDS_SubMesh(SMESHDS_Mesh *parent, int index)
51 myUnusedIdElements = 0;
54 //================================================================================
58 //================================================================================
60 SMESHDS_SubMesh::~SMESHDS_SubMesh()
64 //=======================================================================
65 //function : AddElement
67 //=======================================================================
69 void SMESHDS_SubMesh::AddElement(const SMDS_MeshElement * ME)
71 if (!IsComplexSubmesh())
73 if ( ME->GetType() == SMDSAbs_Node )
75 AddNode( static_cast< const SMDS_MeshNode* >( ME ));
78 int oldShapeId = ME->getshapeId();
81 if (oldShapeId != myIndex)
83 throw SALOME_Exception
84 (LOCALIZED("add element in subshape already belonging to a subshape"));
86 int idInSubShape = ME->getIdInShape();
87 if (idInSubShape >= 0)
89 MESSAGE("add element in subshape already belonging to that subshape "
90 << ME->GetID() << " " << oldShapeId << " " << idInSubShape);
91 // check if ok: do nothing if ok
92 if (idInSubShape >= (int)myElements.size())
94 throw SALOME_Exception(LOCALIZED("out of bounds"));
96 if (ME != myElements[idInSubShape])
98 throw SALOME_Exception(LOCALIZED("not the same element"));
104 SMDS_MeshElement* elem = (SMDS_MeshElement*) (ME);
105 elem->setShapeId(myIndex);
106 elem->setIdInShape(myElements.size());
107 myElements.push_back(ME);
111 //=======================================================================
112 //function : RemoveElement
114 //=======================================================================
116 bool SMESHDS_SubMesh::RemoveElement(const SMDS_MeshElement * ME, bool isElemDeleted)
122 if (!IsComplexSubmesh())
124 if ( ME->getshapeId() != myIndex ) // elem not in a pool can loose it's data already
127 for ( size_t i = 0; i < myElements.size(); ++i )
128 if ( myElements[i] == ME )
131 ++myUnusedIdElements;
136 int idInSubShape = ME->getIdInShape();
137 SMDS_MeshElement* elem = (SMDS_MeshElement*) (ME);
139 elem->setIdInShape(-1);
140 if ((idInSubShape >= 0) && (idInSubShape < (int) myElements.size()))
142 myElements[idInSubShape] = 0; // this vector entry is no more used
143 if ( ++myUnusedIdElements == (int) myElements.size() )
145 clearVector( myElements );
146 myUnusedIdElements = 0;
155 //=======================================================================
158 //=======================================================================
160 void SMESHDS_SubMesh::AddNode(const SMDS_MeshNode * N)
162 if ( !IsComplexSubmesh() )
164 const int idInSubShape = N->getIdInShape();
165 const int shapeId = N->getshapeId();
166 if ((shapeId > 0) && (idInSubShape >= 0))
168 if ( shapeId != myIndex )
169 throw SALOME_Exception
170 (LOCALIZED("a node being in sub-mesh is added to another sub-mesh"));
171 if ( idInSubShape >= (int)myNodes.size() || myNodes[ idInSubShape ] != N )
172 throw SALOME_Exception
173 (LOCALIZED("a node with wrong idInSubShape is re-added to the same sub-mesh"));
174 return; // already in
176 SMDS_MeshNode* node = (SMDS_MeshNode*)(N);
177 node->setShapeId(myIndex);
178 node->setIdInShape(myNodes.size());
179 myNodes.push_back(N);
183 //=======================================================================
184 //function : RemoveNode
186 //=======================================================================
188 bool SMESHDS_SubMesh::RemoveNode(const SMDS_MeshNode * N, bool isNodeDeleted)
190 if (!IsComplexSubmesh())
192 if ( N->getshapeId() != myIndex )
195 for ( size_t i = 0; i < myNodes.size(); ++i )
196 if ( myNodes[i] == N )
204 int idInSubShape = N->getIdInShape();
205 SMDS_MeshNode* node = (SMDS_MeshNode*) (N);
207 node->setIdInShape(-1);
208 if ((idInSubShape >= 0) && (idInSubShape < (int) myNodes.size()))
210 myNodes[idInSubShape] = 0; // this vector entry is no more used
211 if ( ++myUnusedIdNodes == (int) myNodes.size() )
213 clearVector( myNodes );
223 //=======================================================================
224 //function : NbElements
226 //=======================================================================
228 int SMESHDS_SubMesh::NbElements() const
230 if ( !IsComplexSubmesh() )
231 return myElements.size() - myUnusedIdElements;
234 set<const SMESHDS_SubMesh*>::const_iterator it = mySubMeshes.begin();
235 for ( ; it != mySubMeshes.end(); it++ )
236 nbElems += (*it)->NbElements();
241 //=======================================================================
244 //=======================================================================
246 int SMESHDS_SubMesh::NbNodes() const
248 if ( !IsComplexSubmesh() )
249 return myNodes.size() - myUnusedIdNodes;
252 set<const SMESHDS_SubMesh*>::const_iterator it = mySubMeshes.begin();
253 for ( ; it != mySubMeshes.end(); it++ )
254 nbElems += (*it)->NbNodes();
260 * Template class used for iteration on vector of elements which can resize
261 * during iteration. The iterator returns only elements present upon its creation.
263 template <class ELEM, typename TSET> class MySetIterator : public SMDS_Iterator<ELEM>
266 int _iCur, _iEnd, _iDelta;
269 MySetIterator(const TSET& table, bool reverse): _table( table )
273 _iCur = _table.size()-1;
280 _iEnd = _table.size();
283 if ( more() && !_table[ _iCur ])
289 return ( _iEnd - _iCur ) * _iDelta > 0;
294 ELEM e = more() ? _table[ _iCur ] : 0;
296 while ( more() && !_table[ _iCur ])
302 // =====================
304 // =====================
306 template<typename VALUE> class MyIterator : public SMDS_Iterator<VALUE>
309 MyIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
310 : myMore(false), mySubIt( theSubMeshes.begin() ), mySubEnd( theSubMeshes.end() )
314 while (( !myElemIt.get() || !myElemIt->more() ) && mySubIt != mySubEnd)
316 myElemIt = getElements(*mySubIt);
319 myMore = myElemIt.get() && myElemIt->more();
326 elem = myElemIt->next();
330 virtual boost::shared_ptr< SMDS_Iterator<VALUE> >
331 getElements(const SMESHDS_SubMesh*) const = 0;
335 set<const SMESHDS_SubMesh*>::const_iterator mySubIt, mySubEnd;
336 boost::shared_ptr< SMDS_Iterator<VALUE> > myElemIt;
339 // =====================
340 // class MyElemIterator
341 // =====================
343 class MyElemIterator: public MyIterator<const SMDS_MeshElement*>
346 MyElemIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
347 :MyIterator<const SMDS_MeshElement*>( theSubMeshes ) {}
348 SMDS_ElemIteratorPtr getElements(const SMESHDS_SubMesh* theSubMesh) const
349 { return theSubMesh->GetElements(); }
352 // =====================
353 // class MyNodeIterator
354 // =====================
356 class MyNodeIterator: public MyIterator<const SMDS_MeshNode*>
359 MyNodeIterator (const set<const SMESHDS_SubMesh*>& theSubMeshes)
360 :MyIterator<const SMDS_MeshNode*>( theSubMeshes ) {}
361 SMDS_NodeIteratorPtr getElements(const SMESHDS_SubMesh* theSubMesh) const
362 { return theSubMesh->GetNodes(); }
365 //=======================================================================
366 //function : GetElements
368 //=======================================================================
370 SMDS_ElemIteratorPtr SMESHDS_SubMesh::GetElements( bool reverse ) const
372 if ( IsComplexSubmesh() )
373 return SMDS_ElemIteratorPtr( new MyElemIterator( mySubMeshes ));
375 typedef MySetIterator< const SMDS_MeshElement*, std::vector<const SMDS_MeshElement*> > TIter;
376 return SMDS_ElemIteratorPtr( new TIter( myElements, reverse ));
379 //=======================================================================
380 //function : GetNodes
382 //=======================================================================
384 SMDS_NodeIteratorPtr SMESHDS_SubMesh::GetNodes( bool reverse ) const
386 if ( IsComplexSubmesh() )
387 return SMDS_NodeIteratorPtr( new MyNodeIterator( mySubMeshes ));
389 typedef MySetIterator< const SMDS_MeshNode*, std::vector<const SMDS_MeshNode*> > TIter;
390 return SMDS_NodeIteratorPtr( new TIter( myNodes, reverse ));
393 //=======================================================================
394 //function : Contains
395 //purpose : check if elem or node is in
396 //=======================================================================
398 bool SMESHDS_SubMesh::Contains(const SMDS_MeshElement * ME) const
400 // DO NOT TRY TO FIND A REMOVED ELEMENT !!
401 //if ( IsComplexSubmesh() || !ME )
405 if ( IsComplexSubmesh() )
407 set<const SMESHDS_SubMesh*>::const_iterator aSubIt = mySubMeshes.begin();
408 for (; aSubIt != mySubMeshes.end(); aSubIt++)
409 if ((*aSubIt)->Contains(ME))
414 if (ME->GetType() == SMDSAbs_Node)
416 int idInShape = ME->getIdInShape();
417 if ((idInShape >= 0) && (idInShape < (int) myNodes.size()))
418 if (myNodes[idInShape] == ME)
423 int idInShape = ME->getIdInShape();
424 if ((idInShape >= 0) && (idInShape < (int) myElements.size()))
425 if (myElements[idInShape] == ME)
431 //=======================================================================
432 //function : IsQuadratic
433 //purpose : Return true if my 1st element is quadratic
434 //=======================================================================
436 bool SMESHDS_SubMesh::IsQuadratic() const
438 if ( IsComplexSubmesh() )
440 set<const SMESHDS_SubMesh*>::const_iterator aSubIt = mySubMeshes.begin();
441 for (; aSubIt != mySubMeshes.end(); aSubIt++)
442 if ((*aSubIt)->IsQuadratic())
447 for ( size_t i = 0; i < myElements.size(); ++i )
449 return myElements[i]->IsQuadratic();
454 //=======================================================================
455 //function : AddSubMesh
457 //=======================================================================
459 void SMESHDS_SubMesh::AddSubMesh( const SMESHDS_SubMesh* theSubMesh )
461 ASSERT( theSubMesh );
462 mySubMeshes.insert( theSubMesh );
465 //=======================================================================
466 //function : RemoveSubMesh
468 //=======================================================================
470 bool SMESHDS_SubMesh::RemoveSubMesh( const SMESHDS_SubMesh* theSubMesh )
472 return mySubMeshes.erase( theSubMesh );
475 //=======================================================================
476 //function : RemoveAllSubmeshes
478 //=======================================================================
480 void SMESHDS_SubMesh::RemoveAllSubmeshes()
485 //=======================================================================
486 //function : ContainsSubMesh
488 //=======================================================================
490 bool SMESHDS_SubMesh::ContainsSubMesh( const SMESHDS_SubMesh* theSubMesh ) const
492 return mySubMeshes.find( theSubMesh ) != mySubMeshes.end();
495 //=======================================================================
496 //function : GetSubMeshIterator
498 //=======================================================================
500 SMESHDS_SubMeshIteratorPtr SMESHDS_SubMesh::GetSubMeshIterator() const
502 typedef set<const SMESHDS_SubMesh*>::const_iterator TIterator;
503 return SMESHDS_SubMeshIteratorPtr
504 ( new SMDS_SetIterator< const SMESHDS_SubMesh*, TIterator >( mySubMeshes.begin(),
508 //=======================================================================
510 //purpose : remove the contents
511 //=======================================================================
513 void SMESHDS_SubMesh::Clear()
515 if ( myParent && myParent->NbNodes() > 0 )
517 for ( size_t i = 0; i < myElements.size(); ++i )
519 if ( myElements[i] &&
520 myElements[i]->GetID() > 0 &&
521 myElements[i] == myParent->FindElement( myElements[i]->GetID() )) // not deleted
522 const_cast< SMDS_MeshElement* >( myElements[i] )->setShapeId( 0 );
524 for ( size_t i = 0; i < myNodes.size(); ++i )
527 myNodes[i]->GetID() > 0 &&
528 myNodes[i] == myParent->FindNode( myNodes[i]->GetID() )) // not deleted
529 const_cast< SMDS_MeshNode* >( myNodes[i] )->setShapeId( 0 );
533 clearVector( myElements );
534 clearVector( myNodes );
536 myUnusedIdElements = 0;
537 if ( NbSubMeshes() > 0 )
539 SMESHDS_SubMeshIteratorPtr sub = GetSubMeshIterator();
540 while ( sub->more() ) {
541 if ( SMESHDS_SubMesh* sm = (SMESHDS_SubMesh*) sub->next())
547 int SMESHDS_SubMesh::getSize()
550 int d = NbElements();
554 void SMESHDS_SubMesh::compactList()
556 if ( myUnusedIdElements > 0 )
558 std::vector<const SMDS_MeshElement*> newElems;
559 newElems.reserve( myElements.size() - myUnusedIdElements );
560 for ( size_t i = 0; i < myElements.size(); i++)
563 SMDS_MeshElement* elem = (SMDS_MeshElement*)myElements[i];
564 elem->setIdInShape( newElems.size() );
565 newElems.push_back( elem );
567 myElements.swap(newElems);
568 myUnusedIdElements = 0;
572 std::vector<const SMDS_MeshElement*>( myElements ).swap( myElements );
575 if ( myUnusedIdNodes > 0 )
577 std::vector<const SMDS_MeshNode*> newNodes;
578 newNodes.reserve( myNodes.size() - myUnusedIdNodes );
579 for ( size_t i = 0; i < myNodes.size(); i++ )
582 SMDS_MeshNode* node = (SMDS_MeshNode*)myNodes[i];
583 node->setIdInShape( newNodes.size() );
584 newNodes.push_back( node );
586 myNodes.swap(newNodes);
591 std::vector<const SMDS_MeshNode*>( myNodes ).swap( myNodes );
595 //=======================================================================
596 //function : GetElement
597 //purpose : Return an element by its IdInShape
598 //=======================================================================
600 const SMDS_MeshElement* SMESHDS_SubMesh::GetElement( size_t idInShape ) const
602 return ( !IsComplexSubmesh() && idInShape < myElements.size() ) ? myElements[idInShape] : 0;
605 //=======================================================================
606 //function : GetElement
607 //purpose : Return a node by its IdInShape
608 //=======================================================================
610 const SMDS_MeshNode* SMESHDS_SubMesh::GetNode( size_t idInShape ) const
612 return ( !IsComplexSubmesh() && idInShape < myNodes.size() ) ? myNodes[idInShape] : 0;