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