11 //#include "utilities.h"
12 //#include "MEDMEM_define.hxx"
13 #include "MEDMEM_DriversDef.hxx"
14 #include "MEDMEM_Support.hxx"
15 //#include "MEDMEM_Family.hxx"
16 //#include "MEDMEM_Group.hxx"
17 #include "MEDMEM_Mesh.hxx"
19 using namespace MED_EN;
21 /* This class is a generic class for family and group */
26 //--------------------------------------------------------------------------
27 SUPPORT::SUPPORT(): _name(""), _description(""), _mesh((MESH*)NULL),
28 _entity(MED_CELL), _numberOfGeometricType(0),
29 _geometricType((medGeometryElement*)NULL),
30 _numberOfGaussPoint((int*)NULL),
31 //_geometricTypeNumber((int*)NULL),
33 _numberOfElements((int*)NULL),
34 _totalNumberOfElements(0),
35 _number((MEDSKYLINEARRAY*)NULL)
36 //--------------------------------------------------------------------------
38 MESSAGE("SUPPORT::SUPPORT()");
44 //--------------------------------------------------------------------------
45 SUPPORT::SUPPORT(MESH* Mesh, string Name/*=""*/, medEntityMesh Entity/*=MED_CELL*/):
46 _name(Name), _description(""), _mesh(Mesh), _entity(Entity),
47 _numberOfGeometricType(0),
48 _geometricType((medGeometryElement*)NULL),
49 _numberOfGaussPoint((int*)NULL),
50 //_geometricTypeNumber((int*)NULL),
52 _numberOfElements((int*)NULL),
53 _totalNumberOfElements(0),
54 _number((MEDSKYLINEARRAY*)NULL)
55 //--------------------------------------------------------------------------
57 MESSAGE("SUPPORT::SUPPORT(MESH*Mesh,string Name,medEntityMesh Entity)");
64 //--------------------------------------------------------------------------
65 SUPPORT::SUPPORT(const SUPPORT & m)
66 //--------------------------------------------------------------------------
68 const char * LOC = "SUPPORT::SUPPORT(SUPPORT & m) : " ;
72 _description = m._description;
73 _mesh = m._mesh; // on recopie uniquement l'adresse
75 _numberOfGeometricType = m._numberOfGeometricType;
76 if (m._geometricType != NULL)
78 _geometricType = new medGeometryElement[m._numberOfGeometricType];
79 memcpy(_geometricType,m._geometricType,m._numberOfGeometricType*sizeof(medGeometryElement));
82 _geometricType = (medGeometryElement *) NULL;
83 if (m._numberOfGaussPoint != NULL)
85 _numberOfGaussPoint = new int[m._numberOfGeometricType];
86 memcpy(_numberOfGaussPoint,m._numberOfGaussPoint,m._numberOfGeometricType*sizeof(int));
89 _numberOfGaussPoint = (int *) NULL;
90 // if (m._geometricTypeNumber != NULL)
92 // _geometricTypeNumber = new int[m._numberOfGeometricType];
93 // memcpy(_geometricTypeNumber,m._geometricTypeNumber,m._numberOfGeometricType*sizeof(int));
96 // _geometricTypeNumber = (int *) NULL;
97 _isOnAllElts = m._isOnAllElts;
98 if (m._numberOfElements != NULL)
100 _numberOfElements = new int[_numberOfGeometricType];
101 memcpy(_numberOfElements,m._numberOfElements,_numberOfGeometricType*sizeof(int));
104 _numberOfElements = (int *) NULL;
105 _totalNumberOfElements = m._totalNumberOfElements;
106 if (m._isOnAllElts == false)
107 _number = new MEDSKYLINEARRAY(* m._number);
109 _number = (MEDSKYLINEARRAY *) NULL;
122 MESSAGE("Destructeur ~SUPPORT()");
123 if (_geometricType != (medGeometryElement *) NULL)
124 delete [] _geometricType ;
125 if (_numberOfGaussPoint != (int *) NULL)
126 delete [] _numberOfGaussPoint ;
127 // if (_geometricTypeNumber!=NULL)
128 // delete[] _geometricTypeNumber ;
129 if (_numberOfElements != (int *) NULL)
130 delete[] _numberOfElements ;
131 if (_number != (MEDSKYLINEARRAY *) NULL)
138 //--------------------------------------------------
139 ostream & operator<<(ostream &os, const SUPPORT &my)
140 //--------------------------------------------------
142 os << "Name : "<< my.getName() << endl ;
143 os << "Description : "<< my.getDescription() << endl ;
144 os << "Mesh name : ";
145 if (my.getMesh() == NULL)
146 os << "ERROR : Mesh not defined !" << endl ;
148 os << my._mesh->getName() << endl ;
149 os << "Entity : "<< my._entity << endl;
150 os << "Entity list : "<< endl;
151 if (!(my._isOnAllElts)) {
152 int numberoftypes = my._numberOfGeometricType ;
153 os << "NumberOfTypes : "<<numberoftypes<<endl;
154 medGeometryElement * types = my._geometricType;
155 for (int j=0;j<numberoftypes;j++) {
156 int numberOfElements = my._numberOfElements[j];
157 os << " * Type "<<types[j]<<" : there is(are) "<<numberOfElements<<" element(s) : ";
158 const int * number = my.getNumber(types[j]);
160 for (int k=0; k<numberOfElements;k++)
161 os << number[k] << " ";
165 os << "Is on all entities !"<< endl;
171 Updade the SUPPORT attributs with rigth MESH information.
173 It has an effect only if SUPPORT is on all elements.
175 No more need in future release.
177 //-------------------
178 void SUPPORT::update()
179 //-------------------
181 const char * LOC = "SUPPORT::update() : " ;
185 if (_entity == MED_NODE) {
186 _numberOfGeometricType=1 ;
187 _geometricType=new medGeometryElement[1] ;
188 _geometricType[0]=MED_NONE ;
189 _numberOfElements = new int[1] ;
190 _numberOfElements[0]=_mesh->getNumberOfNodes();
191 _totalNumberOfElements=_numberOfElements[0];
192 _numberOfGaussPoint = new int[1] ;
193 _numberOfGaussPoint[0]=1;
194 } else { // we duplicate information from _mesh
195 _numberOfGeometricType=_mesh->getNumberOfTypes(_entity);
196 if (_geometricType == (medGeometryElement *) NULL)
197 _geometricType = new medGeometryElement[_numberOfGeometricType] ;
198 memcpy(_geometricType,_mesh->getTypes(_entity),_numberOfGeometricType*sizeof(medGeometryElement));
199 if (_numberOfElements == (int *) NULL)
200 _numberOfElements = new int[_numberOfGeometricType] ;
201 if (_numberOfGaussPoint == (int *) NULL)
202 _numberOfGaussPoint = new int[_numberOfGeometricType] ;
203 _totalNumberOfElements=0;
204 for (int i=0;i<_numberOfGeometricType;i++) {
205 _numberOfElements[i]=_mesh->getNumberOfElements(_entity,_geometricType[i]) ;
206 _totalNumberOfElements+=_numberOfElements[i];
207 _numberOfGaussPoint[i]=1 ;
215 Blend the given SUPPORT mySupport into the calling object SUPPORT.
217 //-------------------
218 void SUPPORT::blending(SUPPORT * mySupport) throw (MEDEXCEPTION)
219 //-------------------
221 const char * LOC = "SUPPORT::blending() : " ;
224 MESSAGE(LOC<< "SUPPORT entry : " << *mySupport) ;
227 if ( _entity != mySupport->getEntity() )
228 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Entities are different !"));
230 int * tmp_NumberOfElementsInType = new int[MED_NBR_GEOMETRIE_MAILLE];
231 medGeometryElement * myType = new medGeometryElement[MED_NBR_GEOMETRIE_MAILLE];
232 int * whereIsType = new int[MED_NBR_GEOMETRIE_MAILLE];
233 //MESH_ENTITIES myMeshEntities() ;
234 list<MED_FR::med_geometrie_element>::const_iterator listIt ;
236 for(listIt=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).begin();listIt!=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).end();listIt++) {
237 tmp_NumberOfElementsInType[it]=0;
241 tmp_int = getNumberOfElements((medGeometryElement)(*listIt)) ;
242 tmp_NumberOfElementsInType[it]+=tmp_int ;
245 catch (MEDEXCEPTION & ex) { SCRUTE(sizeof(ex)); };
248 tmp_int = mySupport->getNumberOfElements((medGeometryElement)(*listIt)) ;
249 tmp_NumberOfElementsInType[it]+=tmp_int ;
252 catch (const MEDEXCEPTION & ex) {};
253 if (whereIsType[it]!=0) {
254 myType[it]=(medGeometryElement)(*listIt) ;
255 SCRUTE(myType[it]);SCRUTE(it);SCRUTE((*listIt));
260 // int * numberOfElements=_numberOfElements ;
261 // _numberOfElements = new int[it] ;
262 int * numberOfElements= new int[it];
263 _totalNumberOfElements = 0 ;
264 //int totalSize = 0 ;
265 int ** tmp_array = new (int*)[it];
266 for (int i=0;i<it;i++) {
267 int numberOfElementsInType = tmp_NumberOfElementsInType[i] ;
268 numberOfElements[i] = numberOfElementsInType ;
269 tmp_array[i] = new int[numberOfElementsInType] ;
270 //totalSize+=numberOfElementsInType*(myType[i]%100) ;
271 _totalNumberOfElements+=numberOfElementsInType ;
272 if (whereIsType[i] == 1) { // only first Support
273 memcpy(tmp_array[i],getNumber(myType[i]),sizeof(int)*numberOfElementsInType);
274 } else if (whereIsType[i] == 2) { // only second Support
275 memcpy(tmp_array[i],mySupport->getNumber(myType[i]),sizeof(int)*numberOfElementsInType);
276 } else if (whereIsType[i] == 3) { // more difficult :-)
277 set<int> elementList ;
278 //int i1 = 0 ; !! UNUSED VARIABLE !!
279 //int i2 = 0 ; !!UNUSED VARIABLE !!
281 const int * number1 = getNumber(myType[i]) ;
282 const int * number2 = mySupport->getNumber(myType[i]) ;
287 int numberOfElements1 = getNumberOfElements(myType[i]) ;
288 int numberOfElements2 = mySupport->getNumberOfElements(myType[i]) ;
290 SCRUTE(numberOfElements1);
291 SCRUTE(numberOfElements2);
293 MESSAGE(LOC << " Type : " << myType[i] << " " << i);
295 for(int j=0;j<numberOfElements1;j++){
296 elementList.insert(number1[j]) ;
299 for(int j=0;j<numberOfElements2;j++){
300 elementList.insert(number2[j]) ;
304 int newNumberOfElements = elementList.size() ;
306 SCRUTE(newNumberOfElements);
308 numberOfElements[i] = newNumberOfElements ;
309 int * tmp_arrayNew = new int[newNumberOfElements];
311 set<int>::iterator its ;
312 for(its=elementList.begin();its!=elementList.end(); its++) {
313 tmp_arrayNew[ii]=*its ;
317 delete[] tmp_array[i] ;
318 tmp_array[i] = tmp_arrayNew ;
319 _totalNumberOfElements-=(numberOfElementsInType-newNumberOfElements) ;
322 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"ERROR")) ;
324 delete[] whereIsType ;
325 delete[] tmp_NumberOfElementsInType ;
326 delete [] _numberOfElements;
328 _numberOfElements = numberOfElements;
330 _numberOfGeometricType = it ;
331 medGeometryElement * geometricType=_geometricType ;
332 _geometricType = new medGeometryElement[it] ;
333 int * numberOfGaussPoint=_numberOfGaussPoint ;
334 _numberOfGaussPoint= new int[it] ;
335 // int * geometricTypeNumber=_geometricTypeNumber ;
336 // _geometricTypeNumber = new int[it] ;
338 // MEDSKYLINEARRAY* numberNew = new MEDSKYLINEARRAY(it,_totalNumberOfElements);
339 // int * numberIndex = numberNew->getIndex() ;
340 int size = _mesh->getNumberOfElements(_entity,MED_ALL_ELEMENTS);
341 if (_totalNumberOfElements == size) _isOnAllElts = true;
343 int * numberValue = new int[_totalNumberOfElements] ;
344 int * numberIndex = new int[it+1] ;
346 for (int i=0;i<it;i++) {
347 memcpy(numberValue+numberIndex[i]-1,tmp_array[i],sizeof(int)*_numberOfElements[i]) ;
348 delete[] tmp_array[i] ;
349 numberIndex[i+1]=numberIndex[i]+_numberOfElements[i] ;
351 _geometricType[i]=myType[i] ;
352 _numberOfGaussPoint[i]=1 ;
354 if ( _number != (MEDSKYLINEARRAY *) NULL) delete _number ;
355 //_number = numberNew ;
356 _number = new MEDSKYLINEARRAY(it,_totalNumberOfElements,numberIndex,numberValue);
357 delete[] numberIndex;
359 delete[] numberValue;
364 delete[] geometricType ;
365 delete[] numberOfGaussPoint ;
366 // delete[] geometricTypeNumber ;
367 // delete[] numberOfElements ;
372 MESSAGE(LOC<<"Printing of the object SUPPORT blended "<< *this);
381 This function allows the user to set a support not on all entities Entity,
382 it should be used after an initialisation with the constructor
383 SUPPORT(MESH* Mesh, string Name="", medEntityMesh Entity=MED_CELL) and
384 after the call to the function setAll(false).
385 It allocates and initialises all the attributs of the class SUPPORT.
388 //-------------------
389 void SUPPORT::setpartial(string Description, int NumberOfGeometricType,
390 int TotalNumberOfElements,
391 medGeometryElement *GeometricType,
392 int *NumberOfElements, int *NumberValue)
393 //-------------------
395 const char * LOC = "SUPPORT::setpartial(string , int , int , medGeometryElement * , int * , int *) : " ;
398 _isOnAllElts = false ;
400 _description=Description;
402 _numberOfGeometricType=NumberOfGeometricType;
404 if (_geometricType!=NULL) delete[] _geometricType ;
405 _geometricType = new medGeometryElement[NumberOfGeometricType];
406 if (_numberOfElements!=NULL) delete[] _numberOfElements ;
407 _numberOfElements = new int[NumberOfGeometricType];
408 _totalNumberOfElements = TotalNumberOfElements;
409 if (_numberOfGaussPoint!=NULL) delete[] _numberOfGaussPoint ;
410 _numberOfGaussPoint = new int[NumberOfGeometricType];
411 int * index = new int[_numberOfGeometricType+1];
413 for (int i=0;i<_numberOfGeometricType;i++) {
414 _geometricType[i] = GeometricType[i] ;
415 _numberOfElements[i] = NumberOfElements[i] ;
416 _numberOfGaussPoint[i] = 1 ;
417 index[i+1] = index[i]+NumberOfElements[i] ;
420 if (_number!=NULL) delete _number ;
421 _number = new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfElements,index,NumberValue);
430 This method gets the boundary elements of the mesh. The support has to be
431 build using the constructor SUPPORT(MESH *,string, medEntityMesh) or
432 SUPPORT() followed by setMesh(MESH*) setName(string) and
433 setEntity(medEntityMesh) before using this method.
435 //-------------------
436 void SUPPORT::getBoundaryElements() throw (MEDEXCEPTION)
437 //-------------------
439 const char * LOC = "SUPPORT::getBoundaryElements() : " ;
442 if (_mesh == (MESH*)NULL) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"You shlould use the appropriate SUPPORT Constructor before calling this method"));
444 int spaceDimension = _mesh->getSpaceDimension();
446 if (spaceDimension == 3)
447 if (_entity != MED_FACE)
448 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Not defined in 3D mesh for entity "<<_entity<<" !"));
449 if (spaceDimension == 2)
450 if (_entity != MED_EDGE)
451 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Not defined in 2D mesh for entity "<<_entity<<" !"));
455 const int * myConnectivityValue = _mesh->getReverseConnectivity(MED_DESCENDING) ;
456 const int * myConnectivityIndex = _mesh->getReverseConnectivityIndex(MED_DESCENDING) ;
457 int numberOf = _mesh->getNumberOfElements(_entity,MED_ALL_ELEMENTS) ;
458 list<int> myElementsList ;
461 for (int i=0 ; i<numberOf; i++)
462 if (myConnectivityValue[myConnectivityIndex[i]] == 0) {
464 myElementsList.push_back(i+1) ;
468 // Well, we must know how many geometric type we have found
469 int * myListArray = new int[size] ;
471 list<int>::iterator myElementsListIt ;
472 for (myElementsListIt=myElementsList.begin();myElementsListIt!=myElementsList.end();myElementsListIt++) {
473 myListArray[id]=(*myElementsListIt) ;
475 SCRUTE(myListArray[id]);
479 int numberOfGeometricType ;
480 medGeometryElement* geometricType ;
481 int * numberOfGaussPoint ;
482 int * geometricTypeNumber ;
483 int * numberOfElements ;
484 //MEDSKYLINEARRAY * mySkyLineArray = new MEDSKYLINEARRAY() ;
485 int * mySkyLineArrayIndex ;
487 int numberOfType = _mesh->getNumberOfTypes(_entity) ;
488 if (numberOfType == 1) { // wonderfull : it's easy !
489 numberOfGeometricType = 1 ;
490 geometricType = new medGeometryElement[1] ;
491 const medGeometryElement * allType = _mesh->getTypes(_entity);
492 geometricType[0] = allType[0] ;
493 numberOfGaussPoint = new int[1] ;
494 numberOfGaussPoint[0] = 1 ;
495 geometricTypeNumber = new int[1] ; // not use, but initialized to nothing
496 geometricTypeNumber[0] = 0 ;
497 numberOfElements = new int[1] ;
498 numberOfElements[0] = size ;
499 mySkyLineArrayIndex = new int[2] ;
500 mySkyLineArrayIndex[0]=1 ;
501 mySkyLineArrayIndex[1]=1+size ;
504 map<medGeometryElement,int> theType ;
505 for (myElementsListIt=myElementsList.begin();myElementsListIt!=myElementsList.end();myElementsListIt++) {
506 medGeometryElement myType = _mesh->getElementType(_entity,*myElementsListIt) ;
507 if (theType.find(myType) != theType.end() )
512 numberOfGeometricType = theType.size() ;
513 geometricType = new medGeometryElement[numberOfGeometricType] ;
514 //const medGeometryElement * allType = _mesh->getTypes(_entity); !! UNUSED VARIABLE !!
515 numberOfGaussPoint = new int[numberOfGeometricType] ;
516 geometricTypeNumber = new int[numberOfGeometricType] ; // not use, but initialized to nothing
517 numberOfElements = new int[numberOfGeometricType] ;
518 mySkyLineArrayIndex = new int[numberOfGeometricType+1] ;
520 mySkyLineArrayIndex[0]=1 ;
521 map<medGeometryElement,int>::iterator theTypeIt ;
522 for (theTypeIt=theType.begin();theTypeIt!=theType.end();theTypeIt++) {
523 geometricType[index] = (*theTypeIt).first ;
524 numberOfGaussPoint[index] = 1 ;
525 geometricTypeNumber[index] = 0 ;
526 numberOfElements[index] = (*theTypeIt).second ;
527 mySkyLineArrayIndex[index+1]=mySkyLineArrayIndex[index]+numberOfElements[index] ;
531 //mySkyLineArray->setMEDSKYLINEARRAY(numberOfGeometricType,size,mySkyLineArrayIndex,myListArray) ;
532 MEDSKYLINEARRAY * mySkyLineArray = new MEDSKYLINEARRAY(numberOfGeometricType,size,mySkyLineArrayIndex,myListArray) ;
534 setNumberOfGeometricType(numberOfGeometricType) ;
535 // setGeometricType(geometricType) ;
536 // setNumberOfGaussPoint(numberOfGaussPoint) ;
537 for (int i=0;i<numberOfGeometricType;i++)
539 _numberOfGaussPoint[i] = numberOfGaussPoint[i];
540 _geometricType[i] = geometricType[i];
543 setNumberOfElements(numberOfElements) ;
544 setTotalNumberOfElements(size) ;
545 // setNumber(mySkyLineArray) ;
547 _number = new MEDSKYLINEARRAY(numberOfGeometricType,size);
549 _number->setIndex(mySkyLineArrayIndex);
551 for (int i=0;i<size;i++)
553 _number->setIndexValue(i+1,myListArray[i]);
556 delete[] numberOfElements;
557 delete[] geometricTypeNumber;
558 delete[] numberOfGaussPoint;
559 delete[] geometricType;
560 delete[] mySkyLineArrayIndex;
561 delete[] myListArray;
562 delete mySkyLineArray;
568 intersect the given SUPPORT mySupport into the calling SUPPORT object.
570 //-------------------
571 void SUPPORT::intersecting(SUPPORT * mySupport) throw (MEDEXCEPTION)
572 //-------------------
574 const char * LOC = "SUPPORT::intersecting(SUPPORT *) : " ;
577 MESSAGE(LOC<< "SUPPORT entry : " << *mySupport) ;
579 MESSAGE(LOC<< "SUPPORT (calling object) : " << *this) ;
582 if ( _entity != mySupport->getEntity() )
583 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Entities are different !"));
585 int * tmp_NumberOfElementsInType = new int[MED_NBR_GEOMETRIE_MAILLE];
586 medGeometryElement * myType = new medGeometryElement[MED_NBR_GEOMETRIE_MAILLE];
587 int * whereIsType = new int[MED_NBR_GEOMETRIE_MAILLE];
588 //MESH_ENTITIES myMeshEntities() ;
589 list<MED_FR::med_geometrie_element>::const_iterator listIt ;
591 for(listIt=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).begin();listIt!=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).end();listIt++) {
592 tmp_NumberOfElementsInType[it]=0;
594 myType[it]= MED_NONE;
596 tmp_NumberOfElementsInType[it]+=getNumberOfElements((medGeometryElement)(*listIt)) ;
599 catch (const MEDEXCEPTION & ex) {};
601 tmp_NumberOfElementsInType[it]+=mySupport->getNumberOfElements((medGeometryElement)(*listIt)) ;
604 catch (const MEDEXCEPTION & ex) {};
605 if (whereIsType[it]==3) {
606 myType[it]=(medGeometryElement)(*listIt) ;
611 MESSAGE("it = "<< it);
614 int * numberOfElements=_numberOfElements ;
615 _numberOfElements = new int[it] ;
616 _totalNumberOfElements = 0 ;
617 //int totalSize = 0 ;
618 int ** tmp_array = new (int*)[it];
619 for (int i=0;i<it;i++) {
620 int numberOfElementsInType = tmp_NumberOfElementsInType[i] ;
621 _numberOfElements[i] = numberOfElementsInType ;
622 tmp_array[i] = new int[numberOfElementsInType] ;
623 _totalNumberOfElements+=numberOfElementsInType ;
624 if (whereIsType[i] == 3) {
625 const int * number1 = getNumber(myType[i]) ;
626 const int * number2 = mySupport->getNumber(myType[i]) ;
631 int numberOfElements1 = numberOfElements[i] ;
632 int numberOfElements2 = mySupport->getNumberOfElements(myType[i]) ;
634 SCRUTE(numberOfElements1);
635 SCRUTE(numberOfElements2);
637 set<int> setList1(number1,number1+numberOfElements1);
638 set<int> setList2(number2,number2+numberOfElements2);
640 for(set<int>::iterator its=setList1.begin();its!=setList1.end(); its++)
642 MESSAGE("Number1 " << *its);
645 for(set<int>::iterator its=setList2.begin();its!=setList2.end(); its++)
647 MESSAGE("Number2 " << *its);
650 set<int> setListIntersect;
652 set_intersection(setList1.begin(),setList1.end(),setList2.begin(),
653 setList2.end(),inserter(setListIntersect,
654 setListIntersect.begin()));
656 for(set<int>::iterator its=setListIntersect.begin();
657 its!=setListIntersect.end(); its++)
659 MESSAGE("Number1 intersect Number2 " << *its);
662 int newNumberOfElements = setListIntersect.size() ;
664 SCRUTE(newNumberOfElements);
666 _numberOfElements[i] = newNumberOfElements ;
667 int * tmp_arrayNew = new int[newNumberOfElements];
671 for(set<int>::iterator its=setListIntersect.begin();
672 its!=setListIntersect.end(); its++) {
673 tmp_arrayNew[ii]=*its ;
674 SCRUTE(tmp_arrayNew[ii]);
678 delete[] tmp_array[i] ;
679 tmp_array[i] = tmp_arrayNew ;
680 _totalNumberOfElements-=(numberOfElementsInType-newNumberOfElements) ;
683 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"ERROR")) ;
685 delete[] whereIsType ;
686 delete[] tmp_NumberOfElementsInType ;
688 _numberOfGeometricType = it ;
689 medGeometryElement * geometricType=_geometricType ;
690 _geometricType = new medGeometryElement[it] ;
691 int * numberOfGaussPoint=_numberOfGaussPoint ;
692 _numberOfGaussPoint= new int[it] ;
694 int size = _mesh->getNumberOfElements(_entity,MED_ALL_ELEMENTS);
695 if (_totalNumberOfElements == size) _isOnAllElts = true;
697 int * numberValue = new int[_totalNumberOfElements] ;
698 int * numberIndex = new int[it+1] ;
700 for (int i=0;i<it;i++) {
701 memcpy(numberValue+numberIndex[i]-1,tmp_array[i],sizeof(int)*_numberOfElements[i]) ;
702 delete[] tmp_array[i] ;
703 numberIndex[i+1]=numberIndex[i]+_numberOfElements[i] ;
705 _geometricType[i]=myType[i] ;
706 _numberOfGaussPoint[i]=1 ;
708 if ( _number != (MEDSKYLINEARRAY *) NULL) delete _number ;
710 _number = new MEDSKYLINEARRAY(it,_totalNumberOfElements,numberIndex,numberValue);
711 delete[] numberIndex;
713 delete[] numberValue;
718 delete[] geometricType ;
719 delete[] numberOfGaussPoint ;
720 // delete[] geometricTypeNumber ;
721 delete[] numberOfElements ;