]> SALOME platform Git repositories - modules/smesh.git/blob - src/SMDS/SMDS_ElementFactory.cxx
Salome HOME
a6d61e8496bf5570fa4ae783b67a4cc62534a6b4
[modules/smesh.git] / src / SMDS / SMDS_ElementFactory.cxx
1 // Copyright (C) 2007-2016  CEA/DEN, EDF R&D, OPEN CASCADE
2 //
3 // Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
4 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
5 //
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.
10 //
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.
15 //
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
19 //
20 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
21 //
22 //  File   : SMDS_ElementFactory.cxx
23 //  Module : SMESH
24 //
25
26 #include "SMDS_ElementFactory.hxx"
27
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"
34
35 namespace
36 {
37   // nb of elements allocated by SMDS_ElementChunk at once
38   const int theChunkSize = 1024;
39
40   const int theDefaultShapeDim = 3;
41
42   // classes allowing to modify parameters of SMDS_Position stored in SMDS_ElementFactory
43
44   struct _EdgePosition : public SMDS_EdgePosition
45   {
46     TParam* myUParameter;
47
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 ); }
52   };
53
54   struct _FacePosition : public SMDS_FacePosition
55   {
56     TParam* myParameter;
57
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 ); }
66   };
67 }
68
69 //================================================================================
70 /*!
71  * \brief Create a factory of cells or nodes in a given mesh
72  */
73 //================================================================================
74
75 SMDS_ElementFactory::SMDS_ElementFactory( SMDS_Mesh* mesh, const bool isNodal )
76   : myIsNodal( isNodal ), myMesh( mesh ), myNbUsedElements( 0 )
77 {
78 }
79
80 //================================================================================
81 /*!
82  * \brief Destructor
83  */
84 //================================================================================
85
86 SMDS_ElementFactory::~SMDS_ElementFactory()
87 {
88   myChunksWithUnused.clear();
89   myChunks.clear();
90 }
91
92 //================================================================================
93 /*!
94  * \brief Return a number of elements in a chunk
95  *  \return int - chunk size
96  */
97 //================================================================================
98
99 int SMDS_ElementFactory::ChunkSize()
100 {
101   return theChunkSize;
102 }
103
104 //================================================================================
105 /*!
106  * \brief Return minimal ID of a non-used element
107  *  \return int - minimal element ID
108  */
109 //================================================================================
110
111 int SMDS_ElementFactory::GetFreeID()
112 {
113   if ( myChunksWithUnused.empty() )
114   {
115     int id0 = myChunks.size() * theChunkSize + 1;
116     myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
117   }
118   SMDS_ElementChunk * chunk = (*myChunksWithUnused.begin());
119   return chunk->GetUnusedID();
120 }
121
122 //================================================================================
123 /*!
124  * \brief Return maximal ID of an used element
125  *  \return int - element ID
126  */
127 //================================================================================
128
129 int SMDS_ElementFactory::GetMaxID()
130 {
131   int id = 0;
132   TIndexRanges usedRanges;
133   for ( int i = myChunks.size() - 1; i >= 0; --i )
134     if ( myChunks[i].GetUsedRanges().GetIndices( true, usedRanges ))
135     {
136       int index = usedRanges.back().second-1;
137       id = myChunks[i].Get1stID() + index;
138       break;
139     }
140   return id;
141 }
142
143 //================================================================================
144 /*!
145  * \brief Return minimal ID of an used element
146  *  \return int - element ID
147  */
148 //================================================================================
149
150 int SMDS_ElementFactory::GetMinID()
151 {
152   int id = 0;
153   TIndexRanges usedRanges;
154   for ( size_t i = 0; i < myChunks.size(); ++i )
155     if ( myChunks[i].GetUsedRanges().GetIndices( true, usedRanges ))
156     {
157       int index = usedRanges[0].first;
158       id = myChunks[i].Get1stID() + index;
159       break;
160     }
161   return id;
162 }
163
164 //================================================================================
165 /*!
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
169  */
170 //================================================================================
171
172 SMDS_MeshElement* SMDS_ElementFactory::NewElement( const int id )
173 {
174   int iChunk = ( id - 1 ) / theChunkSize;
175   int index  = ( id - 1 ) % theChunkSize;
176   while ((int) myChunks.size() <= iChunk )
177   {
178     int id0 = myChunks.size() * theChunkSize + 1;
179     myChunks.push_back( new SMDS_ElementChunk( this, id0 ));
180   }
181   SMDS_MeshElement* e = myChunks[iChunk].Element( index );
182   if ( !e->IsNull() )
183     return 0; // element with given ID already exists
184
185   myChunks[iChunk].UseElement( index );
186   ++myNbUsedElements;
187
188   e->myHolder = & myChunks[iChunk];
189
190   myMesh->setMyModified();
191
192   return e;
193 }
194
195 //================================================================================
196 /*!
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
200  */
201 //================================================================================
202
203 const SMDS_MeshElement* SMDS_ElementFactory::FindElement( const int id ) const
204 {
205   if ( id > 0 )
206   {
207     int iChunk = ( id - 1 ) / theChunkSize;
208     int index  = ( id - 1 ) % theChunkSize;
209     if ( iChunk < (int) myChunks.size() )
210     {
211       const SMDS_MeshElement* e = myChunks[iChunk].Element( index );
212       return e->IsNull() ? 0 : e;
213     }
214   }
215   return 0;
216 }
217
218 //================================================================================
219 /*!
220  * \brief Return an SMDS ID by a Vtk one
221  *  \param [inout] vtkID - Vtk ID
222  *  \return int - SMDS ID
223  */
224 //================================================================================
225
226 int SMDS_ElementFactory::FromVtkToSmds( vtkIdType vtkID )
227 {
228   if ( vtkID >= 0 && vtkID < (vtkIdType)mySmdsIDs.size() )
229     return mySmdsIDs[vtkID] + 1;
230   return vtkID + 1;
231 }
232
233 //================================================================================
234 /*!
235  * \brief Mark the element as non-used
236  *  \param [in] e - element
237  */
238 //================================================================================
239
240 void SMDS_ElementFactory::Free( const SMDS_MeshElement* e )
241 {
242   if ( !myVtkIDs.empty() )
243   {
244     size_t    id = e->GetID() - 1;
245     size_t vtkID = e->GetVtkID();
246     if ( id < myVtkIDs.size() )
247       myVtkIDs[ id ] = -1;
248     if ( vtkID < mySmdsIDs.size() )
249       mySmdsIDs[ vtkID ] = -1;
250   }
251   e->myHolder->Free( e );
252   const_cast< SMDS_MeshElement*>( e )->myHolder = 0;
253   --myNbUsedElements;
254
255   myMesh->setMyModified();
256 }
257
258 //================================================================================
259 /*!
260  * \brief De-allocate all elements
261  */
262 //================================================================================
263
264 void SMDS_ElementFactory::Clear()
265 {
266   myChunksWithUnused.clear();
267   clearVector( myChunks );
268   clearVector( myVtkIDs );
269   clearVector( mySmdsIDs );
270   myNbUsedElements = 0;
271 }
272
273 //================================================================================
274 /*!
275  * \brief Remove unused elements located not at the end of the last chunk.
276  *        Minimize allocated memory
277  *  \param [out] theVtkIDsNewToOld - theVtkIDsNewToOld[ new VtkID ] = old VtkID
278  */
279 //================================================================================
280
281 void SMDS_ElementFactory::Compact( std::vector<int>& theVtkIDsNewToOld )
282 {
283   int  newNbCells = NbUsedElements();
284   int   maxCellID = GetMaxID();
285   int newNbChunks = newNbCells / theChunkSize + bool ( newNbCells % theChunkSize );
286
287   theVtkIDsNewToOld.resize( newNbCells );
288
289   if ( newNbCells == 0 ) // empty mesh
290   {
291     clearVector( myChunks );
292   }
293   else if ( newNbCells == maxCellID ) // no holes
294   {
295     int newID, minLastID = std::min( myVtkIDs.size(), theVtkIDsNewToOld.size() );
296     for ( newID = 0; newID < minLastID; ++newID )
297       theVtkIDsNewToOld[ newID ] = myVtkIDs[ newID ];
298     for ( ; newID < newNbCells; ++newID )
299       theVtkIDsNewToOld[ newID ] = newID;
300   }
301   else // there are holes in SMDS IDs
302   {
303     int newVtkID = 0; // same as new smds ID (-1)
304     for ( int oldID = 1; oldID <= maxCellID; ++oldID ) // smds IDs
305     {
306       const SMDS_MeshElement* oldElem = FindElement( oldID );
307       if ( !oldElem ) continue;
308       theVtkIDsNewToOld[ newVtkID++ ] = oldElem->GetVtkID(); // now newVtkID == new smds ID
309       if ( oldID != newVtkID )
310       {
311         const SMDS_MeshElement* newElem = FindElement( newVtkID );
312         if ( !newElem )
313           newElem = NewElement( newVtkID );
314         if ( int shapeID = oldElem->GetShapeID() )
315           const_cast< SMDS_MeshElement* >( newElem )->setShapeID( shapeID );
316         if ( oldID > newNbCells )
317           Free( oldElem );
318       }
319     }
320   }
321   myChunks.resize( newNbChunks );
322
323   myChunksWithUnused.clear();
324   if ( !myChunks.empty() && myChunks.back().GetUsedRanges().Size() > 1 )
325     myChunksWithUnused.insert( & myChunks.back() );
326
327   for ( size_t i = 0; i < myChunks.size(); ++i )
328     myChunks[i].Compact();
329
330   clearVector( myVtkIDs );
331   clearVector( mySmdsIDs );
332 }
333
334
335 //================================================================================
336 /*!
337  * \brief Return true if Compact() will change IDs of elements
338  */
339 //================================================================================
340
341 bool SMDS_ElementFactory::CompactChangePointers()
342 {
343   // there can be VTK_EMPTY_CELL's in the VTK grid as well as "holes" in SMDS numeration
344   return ( NbUsedElements() != GetMaxID() );
345 }
346
347 //================================================================================
348 /*!
349  * \brief Create a factory of nodes in a given mesh
350  */
351 //================================================================================
352
353 SMDS_NodeFactory::SMDS_NodeFactory( SMDS_Mesh* mesh )
354   : SMDS_ElementFactory( mesh, /*isNodal=*/true )
355 {
356 }
357
358 //================================================================================
359 /*!
360  * \brief Destructor
361  */
362 //================================================================================
363
364 SMDS_NodeFactory::~SMDS_NodeFactory()
365 {
366   Clear();
367 }
368
369 //================================================================================
370 /*!
371  * \brief Remove unused nodes located not at the end of the last chunk.
372  *        Minimize allocated memory
373  *  \param [out] theVtkIDsOldToNew - vector storing change of vtk IDs
374  */
375 //================================================================================
376
377 void SMDS_NodeFactory::Compact( std::vector<int>& theVtkIDsOldToNew )
378 {
379   // IDs of VTK nodes always correspond to SMDS IDs but there can be "holes"
380   // in the chunks. So we remove holes and report relocation in theVtkIDsOldToNew:
381   // theVtkIDsOldToNew[ old VtkID ] = new VtkID
382
383   int  oldNbNodes = myMesh->GetGrid()->GetNumberOfPoints();
384   int  newNbNodes = NbUsedElements();
385   int newNbChunks = newNbNodes / theChunkSize + bool ( newNbNodes % theChunkSize );
386   int   maxNodeID = GetMaxID();
387
388   theVtkIDsOldToNew.resize( oldNbNodes, -1 );
389
390   if ( newNbNodes == 0 ) // empty mesh
391   {
392     clearVector( myChunks );
393   }
394   else if ( maxNodeID > newNbNodes ) // there are holes
395   {
396     size_t newID = 0;
397     for ( size_t oldID = 0; oldID < theVtkIDsOldToNew.size(); ++oldID )
398     {
399       const SMDS_MeshElement* oldNode = FindNode( oldID+1 );
400       if ( !oldNode )
401         continue;
402       theVtkIDsOldToNew[ oldID ] = newID;
403       if ( oldID != newID )
404       {
405         const SMDS_MeshElement* newNode = FindElement( newID+1 );
406         if ( !newNode )
407           newNode = NewElement( newID+1 );
408         int  shapeID = oldNode->GetShapeID();
409         int shapeDim = GetShapeDim( shapeID );
410         int   iChunk = newID / theChunkSize;
411         myChunks[ iChunk ].SetShapeID( newNode, shapeID );
412         if ( shapeDim == 2 || shapeDim == 1 )
413         {
414           int iChunkOld = oldID / theChunkSize;
415           TParam* oldPos = myChunks[ iChunkOld ].GetPositionPtr( oldNode );
416           TParam* newPos = myChunks[ iChunk    ].GetPositionPtr( newNode, /*allocate=*/true );
417           if ( oldPos )
418           {
419             newPos[0] = oldPos[0];
420             newPos[1] = oldPos[1];
421           }
422         }
423         if ( oldNode->GetID() > newNbNodes )
424           Free( oldNode );
425       }
426       ++newID;
427     }
428   }
429   else // no holes
430   {
431     for ( int i = 0; i < newNbNodes; ++i )
432       theVtkIDsOldToNew[ i ] = i;
433   }
434   myChunks.resize( newNbChunks );
435
436   myChunksWithUnused.clear();
437   if ( !myChunks.empty() && myChunks.back().GetUsedRanges().Size() > 1 )
438     myChunksWithUnused.insert( & myChunks.back() );
439
440   for ( size_t i = 0; i < myChunks.size(); ++i )
441     myChunks[i].Compact();
442
443   ASSERT( newNbNodes == GetMaxID() );
444   ASSERT( newNbNodes == NbUsedElements() );
445 }
446
447 //================================================================================
448 /*!
449  * \brief Return true if Compact() will change IDs of elements
450  */
451 //================================================================================
452
453 bool SMDS_NodeFactory::CompactChangePointers()
454 {
455   // IDs of VTK nodes always correspond to SMDS IDs but there can be "holes" in SMDS numeration
456   return ( NbUsedElements() != GetMaxID() );
457 }
458
459 //================================================================================
460 /*!
461  * \brief De-allocate all nodes
462  */
463 //================================================================================
464
465 void SMDS_NodeFactory::Clear()
466 {
467   SMDS_ElementFactory::Clear();
468 }
469
470 //================================================================================
471 /*!
472  * \brief Set a total number of sub-shapes in the main shape
473  */
474 //================================================================================
475
476 void SMDS_NodeFactory::SetNbShapes( size_t nbShapes )
477 {
478   clearVector( myShapeDim );
479   myShapeDim.resize( nbShapes+1, theDefaultShapeDim );
480 }
481
482 //================================================================================
483 /*!
484  * \brief Return a dimension of a shape
485  */
486 //================================================================================
487
488 int SMDS_NodeFactory::GetShapeDim( int shapeID ) const
489 {
490   return shapeID < (int)myShapeDim.size() ? myShapeDim[ shapeID ] : theDefaultShapeDim;
491 }
492
493 //================================================================================
494 /*!
495  * \brief Set a dimension of a shape
496  */
497 //================================================================================
498
499 void SMDS_NodeFactory::SetShapeDim( int shapeID, int dim )
500 {
501   if ( shapeID >= (int)myShapeDim.size() )
502     myShapeDim.resize( shapeID + 10, theDefaultShapeDim );
503   myShapeDim[ shapeID ] = dim;
504 }
505
506 //================================================================================
507 /*!
508  * \brief SMDS_ElementChunk constructor
509  *  \param [in] factory - the factory
510  *  \param [in] id0 - ID of the 1st element
511  */
512 //================================================================================
513
514 SMDS_ElementChunk::SMDS_ElementChunk( SMDS_ElementFactory* factory, int id0 ):
515   myFactory( factory ),
516   my1stID( id0 ),
517   myMinSubID( std::numeric_limits<int>::max() ),
518   myMaxSubID( 0 )
519 {
520   if ( !myFactory )
521     return;
522   if ( myFactory->myIsNodal )
523     myElements = new SMDS_MeshNode[ theChunkSize ];
524   else
525     myElements = new SMDS_MeshCell[ theChunkSize ];
526
527   myUsedRanges.mySet.reserve(2);
528   mySubIDRanges.mySet.insert( _ShapeIDRange( 0, 0 ));
529   myUsedRanges.mySet.insert( _UsedRange( 0, false ));
530   myFactory->myChunksWithUnused.insert( this );
531 }
532
533 //================================================================================
534 /*!
535  * \brief SMDS_ElementChunk destructor
536  */
537 //================================================================================
538
539 SMDS_ElementChunk::~SMDS_ElementChunk()
540 {
541   delete [] myElements;
542   myFactory->myChunksWithUnused.erase( this );
543 }
544
545 //================================================================================
546 /*!
547  * \brief Mark an element as used
548  */
549 //================================================================================
550
551 void SMDS_ElementChunk::UseElement( const int index )
552 {
553   myUsedRanges.SetValue( index, true );
554   if ( myUsedRanges.Size() == 1 ) // all elements used
555     myFactory->myChunksWithUnused.erase( this );
556 }
557
558 //================================================================================
559 /*!
560  * \brief Return ID of the first non-used element
561  */
562 //================================================================================
563
564 int SMDS_ElementChunk::GetUnusedID() const
565 {
566   TUsedRangeSet::set_iterator r = myUsedRanges.mySet.begin();
567   for ( ; r != myUsedRanges.mySet.end(); ++r )
568     if ( !IsUsed( *r ))
569       break;
570
571   return my1stID + r->my1st;
572 }
573
574 //================================================================================
575 /*!
576  * \brief Mark an element as non-used
577  */
578 //================================================================================
579
580 void SMDS_ElementChunk::Free( const SMDS_MeshElement* e )
581 {
582   bool hasHoles = ( myUsedRanges.Size() > 1 );
583   myUsedRanges.SetValue( Index( e ), false );
584   SetShapeID( e, 0 ); // sub-mesh must do it?
585   SetIsMarked( e, false );
586   if ( !hasHoles )
587     myFactory->myChunksWithUnused.insert( this );
588
589   if ( myUsedRanges.Size() == 1 )
590   {
591     clearVector( myMarkedSet );
592     clearVector( myPositions );
593   }
594 }
595
596 //================================================================================
597 /*!
598  * \brief Return an SMDS ID of an element
599  */
600 //================================================================================
601
602 int SMDS_ElementChunk::GetID( const SMDS_MeshElement* e ) const
603 {
604   return my1stID + Index( e );
605 }
606
607 //================================================================================
608 /*!
609  * \brief Set a Vtk ID of an element
610  */
611 //================================================================================
612
613 void SMDS_ElementChunk::SetVTKID( const SMDS_MeshElement* e, const vtkIdType vtkID )
614 {
615   if ( e->GetID() - 1 != vtkID )
616   {
617     if ((int) myFactory->myVtkIDs.size() <= e->GetID() - 1 )
618     {
619       size_t i = myFactory->myVtkIDs.size();
620       myFactory->myVtkIDs.resize( e->GetID() + 100 );
621       for ( ; i < myFactory->myVtkIDs.size(); ++i )
622         myFactory->myVtkIDs[i] = i;
623     }
624     myFactory->myVtkIDs[ e->GetID() - 1 ] = vtkID;
625
626     if ((vtkIdType) myFactory->mySmdsIDs.size() <= vtkID )
627     {
628       size_t i = myFactory->mySmdsIDs.size();
629       myFactory->mySmdsIDs.resize( vtkID + 100 );
630       for ( ; i < myFactory->mySmdsIDs.size(); ++i )
631         myFactory->mySmdsIDs[i] = i;
632     }
633     myFactory->mySmdsIDs[ vtkID ] = e->GetID() - 1;
634   }
635 }
636
637 //================================================================================
638 /*!
639  * \brief Return a Vtk ID of an element
640  */
641 //================================================================================
642
643 int SMDS_ElementChunk::GetVtkID( const SMDS_MeshElement* e ) const
644 {
645   size_t dfltVtkID = e->GetID() - 1;
646   return ( dfltVtkID < myFactory->myVtkIDs.size() ) ? myFactory->myVtkIDs[ dfltVtkID ] : dfltVtkID;
647 }
648
649 //================================================================================
650 /*!
651  * \brief Return ID of a shape an element is assigned to
652  */
653 //================================================================================
654
655 int SMDS_ElementChunk::GetShapeID( const SMDS_MeshElement* e ) const
656 {
657   return mySubIDRanges.GetValue( Index( e ));
658 }
659
660 //================================================================================
661 /*!
662  * \brief Set ID of a shape an element is assigned to
663  */
664 //================================================================================
665
666 void SMDS_ElementChunk::SetShapeID( const SMDS_MeshElement* e, int shapeID ) const
667 {
668   const size_t nbRanges = mySubIDRanges.Size();
669
670   SMDS_ElementChunk* me = const_cast<SMDS_ElementChunk*>( this );
671   int oldShapeID = me->mySubIDRanges.SetValue( Index( e ), shapeID );
672   if ( oldShapeID == shapeID ) return;
673
674   if ( const SMDS_MeshNode* n = dynamic_cast< const SMDS_MeshNode* >( e ))
675     if ( TParam* uv = me->GetPositionPtr( n ))
676     {
677       uv[0] = 0.;
678       uv[1] = 0.;
679     }
680   // update min/max
681   if (( nbRanges > mySubIDRanges.Size() ) &&
682       ( myMinSubID == oldShapeID || myMaxSubID == oldShapeID ))
683   {
684     me->myMinSubID = ( std::numeric_limits<int>::max() );
685     me->myMaxSubID = 0;
686     TSubIDRangeSet::set_iterator it;
687     for ( it = mySubIDRanges.mySet.begin(); it < mySubIDRanges.mySet.end(); ++it )
688       if ( it->myValue > 0 )
689       {
690         me->myMinSubID = std::min( myMinSubID, it->myValue );
691         me->myMaxSubID = std::max( myMaxSubID, it->myValue );
692       }
693   }
694   else if ( shapeID > 0 )
695   {
696     me->myMinSubID = std::min( myMinSubID, shapeID );
697     me->myMaxSubID = std::max( myMaxSubID, shapeID );
698   }
699 }
700
701 //================================================================================
702 /*!
703  * \brief Set isMarked flag of an element
704  */
705 //================================================================================
706
707 bool SMDS_ElementChunk::IsMarked( const SMDS_MeshElement* e ) const
708 {
709   return ( !myMarkedSet.empty() && myMarkedSet[ Index( e )]);
710 }
711
712 //================================================================================
713 /*!
714  * \brief Return isMarked flag of an element
715  */
716 //================================================================================
717
718 void SMDS_ElementChunk::SetIsMarked( const SMDS_MeshElement* e, bool is )
719 {
720   if ( !is && myMarkedSet.empty() ) return;
721   if ( myMarkedSet.empty() ) myMarkedSet.resize( theChunkSize, false );
722   myMarkedSet[ Index( e )] = is;
723 }
724
725 //================================================================================
726 /*!
727  * \brief Return SMDS_Position of a node on a shape
728  */
729 //================================================================================
730
731 SMDS_PositionPtr SMDS_ElementChunk::GetPosition( const SMDS_MeshNode* n ) const
732 {
733   int  shapeID = GetShapeID( n );
734   int shapeDim = static_cast< SMDS_NodeFactory* >( myFactory )->GetShapeDim( shapeID );
735
736   SMDS_ElementChunk* me = const_cast< SMDS_ElementChunk* >( this );
737
738   switch ( shapeDim ) {
739   case 2:
740   {
741     return SMDS_PositionPtr( new _FacePosition( me->GetPositionPtr( n )));
742   }
743   case 1:
744   {
745     return SMDS_PositionPtr( new _EdgePosition( me->GetPositionPtr( n )));
746   }
747   case 0:
748     return SMDS_VertexPosition::StaticPosition();
749   }
750
751   return SMDS_SpacePosition::originSpacePosition();
752 }
753
754 //================================================================================
755 /*!
756  * \brief Set SMDS_Position of a node on a shape
757  */
758 //================================================================================
759
760 void SMDS_ElementChunk::SetPosition( const SMDS_MeshNode* n, const SMDS_PositionPtr& pos, int shapeID )
761 {
762   int shapeDim = pos ? pos->GetDim() : theDefaultShapeDim;
763   if ( shapeID < 1 )
764   {
765     if ( shapeDim == theDefaultShapeDim )
766       return;
767     shapeID = GetShapeID( n );
768     if ( shapeID < 1 )
769       throw SALOME_Exception("SetPosition() No shape ID provided");
770   }
771
772   static_cast< SMDS_NodeFactory* >( myFactory )->SetShapeDim( shapeID, shapeDim );
773
774   switch ( shapeDim ) {
775   case 2:
776   {
777     TParam* uv = GetPositionPtr( n, /*allocate=*/true );
778     uv[0] = (TParam) pos->GetParameters()[0];
779     uv[1] = (TParam) pos->GetParameters()[1];
780     break;
781   }
782   case 1:
783   {
784     GetPositionPtr( n, /*allocate=*/true )[0] = (TParam) pos->GetParameters()[0];
785     break;
786   }
787   }
788 }
789
790 //================================================================================
791 /*!
792  * \brief Return pointer to on-shape-parameters of a node
793  */
794 //================================================================================
795
796 TParam* SMDS_ElementChunk::GetPositionPtr( const SMDS_MeshElement* n, bool allocate )
797 {
798   if ( myPositions.empty() && !allocate )
799     return 0;
800
801   myPositions.resize( theChunkSize * 2 );
802   return myPositions.data() + 2 * Index( n );
803 }
804
805 //================================================================================
806 /*!
807  * \brief Minimize allocated memory
808  */
809 //================================================================================
810
811 void SMDS_ElementChunk::Compact()
812 {
813   mySubIDRanges.mySet.shrink_to_fit();
814   if ( myUsedRanges.mySet.capacity() > 2 )
815     myUsedRanges.mySet.shrink_to_fit();
816
817   clearVector( myMarkedSet );
818
819   if ( !myPositions.empty() )
820   {
821     // look for the last position that must be kept
822     TSubIDRangeSet::set_t::reverse_iterator it;
823     for ( it = mySubIDRanges.mySet.rbegin(); it != mySubIDRanges.mySet.rend(); ++it )
824     {
825       int shapeDim = static_cast< SMDS_NodeFactory* >( myFactory )->GetShapeDim( it->myValue );
826       if ( shapeDim == 1 || shapeDim == 2 )
827         break;
828     }
829     if ( it == mySubIDRanges.mySet.rend() )
830     {
831       clearVector( myPositions );
832     }
833     else if ( it != mySubIDRanges.mySet.rbegin() )
834     {
835       int nbNodes = (it-1)->my1st;
836       myPositions.resize( nbNodes * 2 );
837       std::vector<TParam> newPos( myPositions.begin(), myPositions.end() );
838       myPositions.swap( newPos );
839     }
840   }
841 }
842
843 //================================================================================
844 /*!
845  * \brief Print some data for debug purposes
846  */
847 //================================================================================
848
849 void SMDS_ElementChunk::Dump() const
850 {
851   std::cout << "1stID: " << my1stID << std::endl;
852
853   std::cout << "SubID min/max: " << myMinSubID << ", " << myMaxSubID << std::endl;
854   std::cout << "SubIDRanges: " << mySubIDRanges.Size() << " ";
855   {
856     TSubIDRangeSet::set_iterator i = mySubIDRanges.mySet.begin();
857     for ( int cnt = 0; i != mySubIDRanges.mySet.end(); ++i, ++cnt )
858       std::cout << "|" << cnt << " - (" << i->my1st << ", " << i->myValue << ") ";
859     std::cout << std::endl;
860   }
861   {
862     std::cout << "UsedRanges: " << myUsedRanges.Size() << " ";
863     TUsedRangeSet::set_iterator i = myUsedRanges.mySet.begin();
864     for ( int cnt = 0; i != myUsedRanges.mySet.end(); ++i, ++cnt )
865       std::cout << cnt << " - (" << i->my1st << ", " << i->myValue << ") ";
866     std::cout << std::endl;
867   }
868 }
869
870 //================================================================================
871 /*!
872  * \brief Compare SMDS_ElementChunk's
873  */
874 //================================================================================
875
876 bool _ChunkCompare::operator () (const SMDS_ElementChunk* e1, const SMDS_ElementChunk* e2) const
877 {
878   return e1->Get1stID() < e2->Get1stID();
879 }
880