1 // Copyright (C) 2007-2020 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
22 // File : SMDS_ElementFactory.cxx
26 #include "SMDS_ElementFactory.hxx"
28 #include "ObjectPool.hxx"
29 #include "SMDS_EdgePosition.hxx"
30 #include "SMDS_FacePosition.hxx"
31 #include "SMDS_Mesh.hxx"
32 #include "SMDS_SpacePosition.hxx"
33 #include "SMDS_VertexPosition.hxx"
37 // nb of elements allocated by SMDS_ElementChunk at once
38 const int theChunkSize = 1024;
40 const int theDefaultShapeDim = 3;
42 // classes allowing to modify parameters of SMDS_Position stored in SMDS_ElementFactory
44 struct _EdgePosition : public SMDS_EdgePosition
48 _EdgePosition( TParam* aUParam ) : myUParameter( aUParam )
49 { SMDS_EdgePosition::SetUParameter( aUParam[0]); }
50 virtual void SetUParameter(double aUparam)
51 { *myUParameter = (TParam) aUparam; SMDS_EdgePosition::SetUParameter( aUparam ); }
54 struct _FacePosition : public SMDS_FacePosition
58 _FacePosition(TParam* aParam) : myParameter( aParam )
59 { SMDS_FacePosition::SetParameters( aParam[0], aParam[1] ); }
60 virtual void SetUParameter(double aUparam)
61 { myParameter[0] = (TParam) aUparam; SMDS_FacePosition::SetUParameter( aUparam ); }
62 virtual void SetVParameter(double aVparam)
63 { myParameter[1] = (TParam) aVparam; SMDS_FacePosition::SetVParameter( aVparam ); }
64 virtual void SetParameters(double aU, double aV)
65 { myParameter[0] = aU; myParameter[1] = aV; SMDS_FacePosition::SetParameters( aU, aV ); }
69 //================================================================================
71 * \brief Create a factory of cells or nodes in a given mesh
73 //================================================================================
75 SMDS_ElementFactory::SMDS_ElementFactory( SMDS_Mesh* mesh, const bool isNodal )
76 : myIsNodal( isNodal ), myMesh( mesh ), myNbUsedElements( 0 )
80 //================================================================================
84 //================================================================================
86 SMDS_ElementFactory::~SMDS_ElementFactory()
88 myChunksWithUnused.clear();
92 //================================================================================
94 * \brief Return a number of elements in a chunk
95 * \return int - chunk size
97 //================================================================================
99 int SMDS_ElementFactory::ChunkSize()
104 //================================================================================
106 * \brief Return minimal ID of a non-used element
107 * \return int - minimal element ID
109 //================================================================================
111 int SMDS_ElementFactory::GetFreeID()
113 if ( myChunksWithUnused.empty() )
115 int id0 = myChunks.size() * theChunkSize + 1;
116 myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
118 SMDS_ElementChunk * chunk = (*myChunksWithUnused.begin());
119 return chunk->GetUnusedID();
122 //================================================================================
124 * \brief Return maximal ID of an used element
125 * \return int - element ID
127 //================================================================================
129 int SMDS_ElementFactory::GetMaxID()
132 TIndexRanges usedRanges;
133 for ( int i = myChunks.size() - 1; i >= 0; --i )
134 if ( myChunks[i].GetUsedRanges().GetIndices( true, usedRanges ))
136 int index = usedRanges.back().second-1;
137 id = myChunks[i].Get1stID() + index;
143 //================================================================================
145 * \brief Return minimal ID of an used element
146 * \return int - element ID
148 //================================================================================
150 int SMDS_ElementFactory::GetMinID()
153 TIndexRanges usedRanges;
154 for ( size_t i = 0; i < myChunks.size(); ++i )
155 if ( myChunks[i].GetUsedRanges().GetIndices( true, usedRanges ))
157 int index = usedRanges[0].first;
158 id = myChunks[i].Get1stID() + index;
164 //================================================================================
166 * \brief Return an element by ID. NULL if the element with the given ID is already used
167 * \param [in] id - element ID
168 * \return SMDS_MeshElement* - element pointer
170 //================================================================================
172 SMDS_MeshElement* SMDS_ElementFactory::NewElement( const int id )
174 int iChunk = ( id - 1 ) / theChunkSize;
175 int index = ( id - 1 ) % theChunkSize;
176 while ((int) myChunks.size() <= iChunk )
178 int id0 = myChunks.size() * theChunkSize + 1;
179 myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
181 SMDS_MeshElement* e = myChunks[iChunk].Element( index );
183 return 0; // element with given ID already exists
185 myChunks[iChunk].UseElement( index );
188 e->myHolder = & myChunks[iChunk];
190 myMesh->setMyModified();
195 //================================================================================
197 * \brief Return an used element by ID. NULL if the element with the given ID is not yet used
198 * \param [in] id - element ID
199 * \return const SMDS_MeshElement* - element pointer
201 //================================================================================
203 const SMDS_MeshElement* SMDS_ElementFactory::FindElement( const int id ) const
207 int iChunk = ( id - 1 ) / theChunkSize;
208 int index = ( id - 1 ) % theChunkSize;
209 if ( iChunk < (int) myChunks.size() )
211 const SMDS_MeshElement* e = myChunks[iChunk].Element( index );
212 return e->IsNull() ? 0 : e;
218 //================================================================================
220 * \brief Return an SMDS ID by a Vtk one
221 * \param [inout] vtkID - Vtk ID
222 * \return int - SMDS ID
224 //================================================================================
226 int SMDS_ElementFactory::FromVtkToSmds( vtkIdType vtkID )
228 if ( vtkID >= 0 && vtkID < (vtkIdType)mySmdsIDs.size() )
229 return mySmdsIDs[vtkID] + 1;
233 //================================================================================
235 * \brief Mark the element as non-used
236 * \param [in] e - element
238 //================================================================================
240 void SMDS_ElementFactory::Free( const SMDS_MeshElement* e )
242 if ( e != FindElement( e->GetID() ))
243 SALOME_Exception("SMDS_ElementFactory::Free(): element of other mesh");
245 if ( !myVtkIDs.empty() )
247 size_t id = e->GetID() - 1;
248 size_t vtkID = e->GetVtkID();
249 if ( id < myVtkIDs.size() )
251 if ( vtkID < mySmdsIDs.size() )
252 mySmdsIDs[ vtkID ] = -1;
254 e->myHolder->Free( e );
255 const_cast< SMDS_MeshElement*>( e )->myHolder = 0;
258 myMesh->setMyModified();
261 //================================================================================
263 * \brief De-allocate all elements
265 //================================================================================
267 void SMDS_ElementFactory::Clear()
269 myChunksWithUnused.clear();
270 clearVector( myChunks );
271 clearVector( myVtkIDs );
272 clearVector( mySmdsIDs );
273 myNbUsedElements = 0;
276 //================================================================================
278 * \brief Remove unused elements located not at the end of the last chunk.
279 * Minimize allocated memory
280 * \param [out] theVtkIDsNewToOld - theVtkIDsNewToOld[ new VtkID ] = old VtkID
282 //================================================================================
284 void SMDS_ElementFactory::Compact( std::vector<int>& theVtkIDsNewToOld )
286 int newNbCells = NbUsedElements();
287 int maxCellID = GetMaxID();
288 int newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
290 theVtkIDsNewToOld.resize( newNbCells );
292 if ( newNbCells == 0 ) // empty mesh
294 clearVector( myChunks );
296 else if ( newNbCells == maxCellID ) // no holes
298 int newID, minLastID = std::min( myVtkIDs.size(), theVtkIDsNewToOld.size() );
299 for ( newID = 0; newID < minLastID; ++newID )
300 theVtkIDsNewToOld[ newID ] = myVtkIDs[ newID ];
301 for ( ; newID < newNbCells; ++newID )
302 theVtkIDsNewToOld[ newID ] = newID;
304 else // there are holes in SMDS IDs
306 int newVtkID = 0; // same as new smds ID (-1)
307 for ( int oldID = 1; oldID <= maxCellID; ++oldID ) // smds IDs
309 const SMDS_MeshElement* oldElem = FindElement( oldID );
310 if ( !oldElem ) continue;
311 theVtkIDsNewToOld[ newVtkID++ ] = oldElem->GetVtkID(); // now newVtkID == new smds ID
312 if ( oldID != newVtkID )
314 const SMDS_MeshElement* newElem = FindElement( newVtkID );
316 newElem = NewElement( newVtkID );
317 if ( int shapeID = oldElem->GetShapeID() )
318 const_cast< SMDS_MeshElement* >( newElem )->setShapeID( shapeID );
319 if ( oldID > newNbCells )
324 myChunks.resize( newNbChunks );
326 myChunksWithUnused.clear();
327 if ( !myChunks.empty() && myChunks.back().GetUsedRanges().Size() > 1 )
328 myChunksWithUnused.insert( & myChunks.back() );
330 for ( size_t i = 0; i < myChunks.size(); ++i )
331 myChunks[i].Compact();
333 clearVector( myVtkIDs );
334 clearVector( mySmdsIDs );
338 //================================================================================
340 * \brief Return true if Compact() will change IDs of elements
342 //================================================================================
344 bool SMDS_ElementFactory::CompactChangePointers()
346 // there can be VTK_EMPTY_CELL's in the VTK grid as well as "holes" in SMDS numeration
347 return ( NbUsedElements() != GetMaxID() );
350 //================================================================================
352 * \brief Create a factory of nodes in a given mesh
354 //================================================================================
356 SMDS_NodeFactory::SMDS_NodeFactory( SMDS_Mesh* mesh )
357 : SMDS_ElementFactory( mesh, /*isNodal=*/true )
361 //================================================================================
365 //================================================================================
367 SMDS_NodeFactory::~SMDS_NodeFactory()
372 //================================================================================
374 * \brief Remove unused nodes located not at the end of the last chunk.
375 * Minimize allocated memory
376 * \param [out] theVtkIDsOldToNew - vector storing change of vtk IDs
378 //================================================================================
380 void SMDS_NodeFactory::Compact( std::vector<int>& theVtkIDsOldToNew )
382 // IDs of VTK nodes always correspond to SMDS IDs but there can be "holes"
383 // in the chunks. So we remove holes and report relocation in theVtkIDsOldToNew:
384 // theVtkIDsOldToNew[ old VtkID ] = new VtkID
386 int oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
387 int newNbNodes = NbUsedElements();
388 int newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
389 int maxNodeID = GetMaxID();
391 theVtkIDsOldToNew.resize( oldNbNodes, -1 );
393 if ( newNbNodes == 0 ) // empty mesh
395 clearVector( myChunks );
397 else if ( maxNodeID > newNbNodes ) // there are holes
400 for ( size_t oldID = 0; oldID < theVtkIDsOldToNew.size(); ++oldID )
402 const SMDS_MeshElement* oldNode = FindNode( oldID+1 );
405 theVtkIDsOldToNew[ oldID ] = newID;
406 if ( oldID != newID )
408 const SMDS_MeshElement* newNode = FindElement( newID+1 );
410 newNode = NewElement( newID+1 );
411 int shapeID = oldNode->GetShapeID();
412 int shapeDim = GetShapeDim( shapeID );
413 int iChunk = newID / theChunkSize;
414 myChunks[ iChunk ].SetShapeID( newNode, shapeID );
415 if ( shapeDim == 2 || shapeDim == 1 )
417 int iChunkOld = oldID / theChunkSize;
418 TParam* oldPos = myChunks[ iChunkOld ].GetPositionPtr( oldNode );
419 TParam* newPos = myChunks[ iChunk ].GetPositionPtr( newNode, /*allocate=*/true );
422 newPos[0] = oldPos[0];
423 newPos[1] = oldPos[1];
426 if ( oldNode->GetID() > newNbNodes )
434 for ( int i = 0; i < newNbNodes; ++i )
435 theVtkIDsOldToNew[ i ] = i;
437 myChunks.resize( newNbChunks );
439 myChunksWithUnused.clear();
440 if ( !myChunks.empty() && myChunks.back().GetUsedRanges().Size() > 1 )
441 myChunksWithUnused.insert( & myChunks.back() );
443 for ( size_t i = 0; i < myChunks.size(); ++i )
444 myChunks[i].Compact();
446 ASSERT( newNbNodes == GetMaxID() );
447 ASSERT( newNbNodes == NbUsedElements() );
450 //================================================================================
452 * \brief Return true if Compact() will change IDs of elements
454 //================================================================================
456 bool SMDS_NodeFactory::CompactChangePointers()
458 // IDs of VTK nodes always correspond to SMDS IDs but there can be "holes" in SMDS numeration
459 return ( NbUsedElements() != GetMaxID() );
462 //================================================================================
464 * \brief De-allocate all nodes
466 //================================================================================
468 void SMDS_NodeFactory::Clear()
470 SMDS_ElementFactory::Clear();
473 //================================================================================
475 * \brief Set a total number of sub-shapes in the main shape
477 //================================================================================
479 void SMDS_NodeFactory::SetNbShapes( size_t nbShapes )
481 clearVector( myShapeDim );
482 myShapeDim.resize( nbShapes+1, theDefaultShapeDim );
485 //================================================================================
487 * \brief Return a dimension of a shape
489 //================================================================================
491 int SMDS_NodeFactory::GetShapeDim( int shapeID ) const
493 return shapeID < (int)myShapeDim.size() ? myShapeDim[ shapeID ] : theDefaultShapeDim;
496 //================================================================================
498 * \brief Set a dimension of a shape
500 //================================================================================
502 void SMDS_NodeFactory::SetShapeDim( int shapeID, int dim )
504 if ( shapeID >= (int)myShapeDim.size() )
505 myShapeDim.resize( shapeID + 10, theDefaultShapeDim );
506 myShapeDim[ shapeID ] = dim;
509 //================================================================================
511 * \brief SMDS_ElementChunk constructor
512 * \param [in] factory - the factory
513 * \param [in] id0 - ID of the 1st element
515 //================================================================================
517 SMDS_ElementChunk::SMDS_ElementChunk( SMDS_ElementFactory* factory, int id0 ):
518 myFactory( factory ),
521 // myMinSubID( std::numeric_limits<int>::max() ),
526 if ( myFactory->myIsNodal )
527 myElements = new SMDS_MeshNode[ theChunkSize ];
529 myElements = new SMDS_MeshCell[ theChunkSize ];
531 myUsedRanges.mySet.reserve(2);
532 mySubIDRanges.mySet.insert( _ShapeIDRange( 0, 0 ));
533 myUsedRanges.mySet.insert( _UsedRange( 0, false ));
534 myFactory->myChunksWithUnused.insert( this );
537 //================================================================================
539 * \brief SMDS_ElementChunk destructor
541 //================================================================================
543 SMDS_ElementChunk::~SMDS_ElementChunk()
545 delete [] myElements;
546 myFactory->myChunksWithUnused.erase( this );
549 //================================================================================
551 * \brief Mark an element as used
553 //================================================================================
555 void SMDS_ElementChunk::UseElement( const int index )
557 myUsedRanges.SetValue( index, true );
558 if ( myUsedRanges.Size() == 1 ) // all elements used
559 myFactory->myChunksWithUnused.erase( this );
562 //================================================================================
564 * \brief Return ID of the first non-used element
566 //================================================================================
568 int SMDS_ElementChunk::GetUnusedID() const
570 TUsedRangeSet::set_iterator r = myUsedRanges.mySet.begin();
571 for ( ; r != myUsedRanges.mySet.end(); ++r )
575 return my1stID + r->my1st;
578 //================================================================================
580 * \brief Mark an element as non-used
582 //================================================================================
584 void SMDS_ElementChunk::Free( const SMDS_MeshElement* e )
586 bool hasHoles = ( myUsedRanges.Size() > 1 );
587 myUsedRanges.SetValue( Index( e ), false );
588 SetShapeID( e, 0 ); // sub-mesh must do it?
589 SetIsMarked( e, false );
591 myFactory->myChunksWithUnused.insert( this );
593 if ( myUsedRanges.Size() == 1 )
595 clearVector( myMarkedSet );
596 clearVector( myPositions );
600 //================================================================================
602 * \brief Return an SMDS ID of an element
604 //================================================================================
606 int SMDS_ElementChunk::GetID( const SMDS_MeshElement* e ) const
608 return my1stID + Index( e );
611 //================================================================================
613 * \brief Set a Vtk ID of an element
615 //================================================================================
617 void SMDS_ElementChunk::SetVTKID( const SMDS_MeshElement* e, const vtkIdType vtkID )
619 if ( e->GetID() - 1 != vtkID )
621 if ((int) myFactory->myVtkIDs.size() <= e->GetID() - 1 )
623 size_t i = myFactory->myVtkIDs.size();
624 myFactory->myVtkIDs.resize( e->GetID() + 100 );
625 for ( ; i < myFactory->myVtkIDs.size(); ++i )
626 myFactory->myVtkIDs[i] = i;
628 myFactory->myVtkIDs[ e->GetID() - 1 ] = vtkID;
630 if ((vtkIdType) myFactory->mySmdsIDs.size() <= vtkID )
632 size_t i = myFactory->mySmdsIDs.size();
633 myFactory->mySmdsIDs.resize( vtkID + 100 );
634 for ( ; i < myFactory->mySmdsIDs.size(); ++i )
635 myFactory->mySmdsIDs[i] = i;
637 myFactory->mySmdsIDs[ vtkID ] = e->GetID() - 1;
641 //================================================================================
643 * \brief Return a Vtk ID of an element
645 //================================================================================
647 int SMDS_ElementChunk::GetVtkID( const SMDS_MeshElement* e ) const
649 size_t dfltVtkID = e->GetID() - 1;
650 return ( dfltVtkID < myFactory->myVtkIDs.size() ) ? myFactory->myVtkIDs[ dfltVtkID ] : dfltVtkID;
653 //================================================================================
655 * \brief Return ID of a shape an element is assigned to
657 //================================================================================
659 int SMDS_ElementChunk::GetShapeID( const SMDS_MeshElement* e ) const
661 return mySubIDRanges.GetValue( Index( e ));
664 //================================================================================
666 * \brief Set ID of a shape an element is assigned to
668 //================================================================================
670 void SMDS_ElementChunk::SetShapeID( const SMDS_MeshElement* e, int shapeID ) const
672 //const size_t nbRanges = mySubIDRanges.Size();
674 SMDS_ElementChunk* me = const_cast<SMDS_ElementChunk*>( this );
675 int oldShapeID = me->mySubIDRanges.SetValue( Index( e ), shapeID );
676 if ( oldShapeID == shapeID ) return;
678 if ( const SMDS_MeshNode* n = dynamic_cast< const SMDS_MeshNode* >( e ))
679 if ( TParam* uv = me->GetPositionPtr( n ))
685 // if (( nbRanges > mySubIDRanges.Size() ) &&
686 // ( myMinSubID == oldShapeID || myMaxSubID == oldShapeID ))
688 // me->myMinSubID = ( std::numeric_limits<int>::max() );
689 // me->myMaxSubID = 0;
690 // TSubIDRangeSet::set_iterator it;
691 // for ( it = mySubIDRanges.mySet.begin(); it < mySubIDRanges.mySet.end(); ++it )
692 // if ( it->myValue > 0 )
694 // me->myMinSubID = std::min( myMinSubID, it->myValue );
695 // me->myMaxSubID = std::max( myMaxSubID, it->myValue );
698 // else if ( shapeID > 0 )
700 // me->myMinSubID = std::min( myMinSubID, shapeID );
701 // me->myMaxSubID = std::max( myMaxSubID, shapeID );
705 //================================================================================
707 * \brief Set isMarked flag of an element
709 //================================================================================
711 bool SMDS_ElementChunk::IsMarked( const SMDS_MeshElement* e ) const
713 return ( !myMarkedSet.empty() && myMarkedSet[ Index( e )]);
716 //================================================================================
718 * \brief Return isMarked flag of an element
720 //================================================================================
722 void SMDS_ElementChunk::SetIsMarked( const SMDS_MeshElement* e, bool is )
724 if ( !is && myMarkedSet.empty() ) return;
725 if ( myMarkedSet.empty() ) myMarkedSet.resize( theChunkSize, false );
726 myMarkedSet[ Index( e )] = is;
729 //================================================================================
731 * \brief Return SMDS_Position of a node on a shape
733 //================================================================================
735 SMDS_PositionPtr SMDS_ElementChunk::GetPosition( const SMDS_MeshNode* n ) const
737 int shapeID = GetShapeID( n );
738 int shapeDim = static_cast< SMDS_NodeFactory* >( myFactory )->GetShapeDim( shapeID );
740 SMDS_ElementChunk* me = const_cast< SMDS_ElementChunk* >( this );
742 switch ( shapeDim ) {
745 return SMDS_PositionPtr( new _FacePosition( me->GetPositionPtr( n )));
749 return SMDS_PositionPtr( new _EdgePosition( me->GetPositionPtr( n )));
752 return SMDS_VertexPosition::StaticPosition();
755 return SMDS_SpacePosition::originSpacePosition();
758 //================================================================================
760 * \brief Set SMDS_Position of a node on a shape
762 //================================================================================
764 void SMDS_ElementChunk::SetPosition( const SMDS_MeshNode* n, const SMDS_PositionPtr& pos, int shapeID )
766 int shapeDim = pos ? pos->GetDim() : theDefaultShapeDim;
769 if ( shapeDim == theDefaultShapeDim )
771 shapeID = GetShapeID( n );
773 throw SALOME_Exception("SetPosition() No shape ID provided");
776 static_cast< SMDS_NodeFactory* >( myFactory )->SetShapeDim( shapeID, shapeDim );
778 switch ( shapeDim ) {
781 TParam* uv = GetPositionPtr( n, /*allocate=*/true );
782 uv[0] = (TParam) pos->GetParameters()[0];
783 uv[1] = (TParam) pos->GetParameters()[1];
788 GetPositionPtr( n, /*allocate=*/true )[0] = (TParam) pos->GetParameters()[0];
794 //================================================================================
796 * \brief Return pointer to on-shape-parameters of a node
798 //================================================================================
800 TParam* SMDS_ElementChunk::GetPositionPtr( const SMDS_MeshElement* n, bool allocate )
802 if ( myPositions.empty() && !allocate )
805 myPositions.resize( theChunkSize * 2 );
806 return myPositions.data() + 2 * Index( n );
809 //================================================================================
811 * \brief Minimize allocated memory
813 //================================================================================
815 void SMDS_ElementChunk::Compact()
817 mySubIDRanges.mySet.shrink_to_fit();
818 if ( myUsedRanges.mySet.capacity() > 2 )
819 myUsedRanges.mySet.shrink_to_fit();
821 clearVector( myMarkedSet );
823 if ( !myPositions.empty() )
825 // look for the last position that must be kept
826 TSubIDRangeSet::set_t::reverse_iterator it;
827 for ( it = mySubIDRanges.mySet.rbegin(); it != mySubIDRanges.mySet.rend(); ++it )
829 int shapeDim = static_cast< SMDS_NodeFactory* >( myFactory )->GetShapeDim( it->myValue );
830 if ( shapeDim == 1 || shapeDim == 2 )
833 if ( it == mySubIDRanges.mySet.rend() )
835 clearVector( myPositions );
837 else if ( it != mySubIDRanges.mySet.rbegin() )
839 int nbNodes = (it-1)->my1st;
840 myPositions.resize( nbNodes * 2 );
841 std::vector<TParam> newPos( myPositions.begin(), myPositions.end() );
842 myPositions.swap( newPos );
847 //================================================================================
849 * \brief Print some data for debug purposes
851 //================================================================================
853 void SMDS_ElementChunk::Dump() const
855 std::cout << "1stID: " << my1stID << std::endl;
857 //std::cout << "SubID min/max: " << myMinSubID << ", " << myMaxSubID << std::endl;
858 std::cout << "SubIDRanges: " << mySubIDRanges.Size() << " ";
860 TSubIDRangeSet::set_iterator i = mySubIDRanges.mySet.begin();
861 for ( int cnt = 0; i != mySubIDRanges.mySet.end(); ++i, ++cnt )
862 std::cout << "|" << cnt << " - (" << i->my1st << ", " << i->myValue << ") ";
863 std::cout << std::endl;
866 std::cout << "UsedRanges: " << myUsedRanges.Size() << " ";
867 TUsedRangeSet::set_iterator i = myUsedRanges.mySet.begin();
868 for ( int cnt = 0; i != myUsedRanges.mySet.end(); ++i, ++cnt )
869 std::cout << cnt << " - (" << i->my1st << ", " << i->myValue << ") ";
870 std::cout << std::endl;
874 //================================================================================
876 * \brief Compare SMDS_ElementChunk's
878 //================================================================================
880 bool _ChunkCompare::operator () (const SMDS_ElementChunk* e1, const SMDS_ElementChunk* e2) const
882 return e1->Get1stID() < e2->Get1stID();