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;
20 using namespace MEDMEM;
22 /* This class is a generic class for family and group */
27 //--------------------------------------------------------------------------
28 SUPPORT::SUPPORT(): _name(""), _description("None"), _mesh((MESH*)NULL),
29 _entity(MED_CELL), _numberOfGeometricType(0),
30 _geometricType((medGeometryElement*)NULL),
31 _numberOfGaussPoint((int*)NULL),
32 //_geometricTypeNumber((int*)NULL),
34 _numberOfElements((int*)NULL),
35 _totalNumberOfElements(0),
36 _number((MEDSKYLINEARRAY*)NULL)
37 //--------------------------------------------------------------------------
39 MESSAGE("SUPPORT::SUPPORT()");
45 //--------------------------------------------------------------------------
46 SUPPORT::SUPPORT(MESH* Mesh, string Name/*=""*/, medEntityMesh Entity/*=MED_CELL*/):
47 _name(Name), _description("None"), _mesh(Mesh), _entity(Entity),
48 _numberOfGeometricType(0),
49 _geometricType((medGeometryElement*)NULL),
50 _numberOfGaussPoint((int*)NULL),
51 //_geometricTypeNumber((int*)NULL),
53 _numberOfElements((int*)NULL),
54 _totalNumberOfElements(0),
55 _number((MEDSKYLINEARRAY*)NULL)
56 //--------------------------------------------------------------------------
58 MESSAGE("SUPPORT::SUPPORT(MESH*Mesh,string Name,medEntityMesh Entity)");
65 //--------------------------------------------------------------------------
66 SUPPORT::SUPPORT(const SUPPORT & m)
67 //--------------------------------------------------------------------------
69 const char * LOC = "SUPPORT::SUPPORT(SUPPORT & m) : " ;
73 _description = m._description;
74 _mesh = m._mesh; // on recopie uniquement l'adresse
76 _numberOfGeometricType = m._numberOfGeometricType;
77 if (m._geometricType != NULL)
79 _geometricType = new medGeometryElement[m._numberOfGeometricType];
80 memcpy(_geometricType,m._geometricType,m._numberOfGeometricType*sizeof(medGeometryElement));
83 _geometricType = (medGeometryElement *) NULL;
84 if (m._numberOfGaussPoint != NULL)
86 _numberOfGaussPoint = new int[m._numberOfGeometricType];
87 memcpy(_numberOfGaussPoint,m._numberOfGaussPoint,m._numberOfGeometricType*sizeof(int));
90 _numberOfGaussPoint = (int *) NULL;
91 // if (m._geometricTypeNumber != NULL)
93 // _geometricTypeNumber = new int[m._numberOfGeometricType];
94 // memcpy(_geometricTypeNumber,m._geometricTypeNumber,m._numberOfGeometricType*sizeof(int));
97 // _geometricTypeNumber = (int *) NULL;
98 _isOnAllElts = m._isOnAllElts;
99 if (m._numberOfElements != NULL)
101 _numberOfElements = new int[_numberOfGeometricType];
102 memcpy(_numberOfElements,m._numberOfElements,_numberOfGeometricType*sizeof(int));
105 _numberOfElements = (int *) NULL;
106 _totalNumberOfElements = m._totalNumberOfElements;
107 if (m._isOnAllElts == false)
108 _number = new MEDSKYLINEARRAY(* m._number);
110 _number = (MEDSKYLINEARRAY *) NULL;
123 MESSAGE("Destructeur ~SUPPORT()");
124 if (_geometricType != (medGeometryElement *) NULL)
125 delete [] _geometricType ;
126 if (_numberOfGaussPoint != (int *) NULL)
127 delete [] _numberOfGaussPoint ;
128 // if (_geometricTypeNumber!=NULL)
129 // delete[] _geometricTypeNumber ;
130 if (_numberOfElements != (int *) NULL)
131 delete[] _numberOfElements ;
132 if (_number != (MEDSKYLINEARRAY *) NULL)
139 //--------------------------------------------------
140 ostream & MEDMEM::operator<<(ostream &os, const SUPPORT &my)
141 //--------------------------------------------------
143 os << "Name : "<< my.getName() << endl ;
144 os << "Description : "<< my.getDescription() << endl ;
145 os << "Mesh name : ";
146 if (my.getMesh() == NULL)
147 os << "ERROR : Mesh not defined !" << endl ;
149 os << my._mesh->getName() << endl ;
150 os << "Entity : "<< my._entity << endl;
151 os << "Entity list : "<< endl;
152 if (!(my._isOnAllElts)) {
153 int numberoftypes = my._numberOfGeometricType ;
154 os << "NumberOfTypes : "<<numberoftypes<<endl;
155 medGeometryElement * types = my._geometricType;
156 for (int j=0;j<numberoftypes;j++) {
157 int numberOfElements = my._numberOfElements[j];
158 os << " * Type "<<types[j]<<" : there is(are) "<<numberOfElements<<" element(s) :" << endl;
159 // const int * number = my.getNumber(types[j]);
162 // for (int k=0; k<numberOfElements;k++)
163 // os << number[k] << " ";
167 os << "Is on all entities !"<< endl;
173 Updade the SUPPORT attributs with rigth MESH information.
175 It has an effect only if SUPPORT is on all elements.
177 No more need in future release.
179 //-------------------
180 void SUPPORT::update()
181 //-------------------
183 const char * LOC = "SUPPORT::update() : " ;
187 if (_entity == MED_NODE) {
188 _numberOfGeometricType=1 ;
189 _geometricType=new medGeometryElement[1] ;
190 _geometricType[0]=MED_NONE ;
191 _numberOfElements = new int[1] ;
192 _numberOfElements[0]=_mesh->getNumberOfNodes();
193 _totalNumberOfElements=_numberOfElements[0];
194 _numberOfGaussPoint = new int[1] ;
195 _numberOfGaussPoint[0]=1;
196 } else { // we duplicate information from _mesh
197 _numberOfGeometricType=_mesh->getNumberOfTypes(_entity);
198 if (_geometricType == (medGeometryElement *) NULL)
199 _geometricType = new medGeometryElement[_numberOfGeometricType] ;
200 memcpy(_geometricType,_mesh->getTypes(_entity),_numberOfGeometricType*sizeof(medGeometryElement));
201 if (_numberOfElements == (int *) NULL)
202 _numberOfElements = new int[_numberOfGeometricType] ;
203 if (_numberOfGaussPoint == (int *) NULL)
204 _numberOfGaussPoint = new int[_numberOfGeometricType] ;
205 _totalNumberOfElements=0;
206 for (int i=0;i<_numberOfGeometricType;i++) {
207 _numberOfElements[i]=_mesh->getNumberOfElements(_entity,_geometricType[i]) ;
208 _totalNumberOfElements+=_numberOfElements[i];
209 _numberOfGaussPoint[i]=1 ;
217 Blend the given SUPPORT mySupport into the calling object SUPPORT.
219 //-------------------
220 void SUPPORT::blending(SUPPORT * mySupport) throw (MEDEXCEPTION)
221 //-------------------
223 const char * LOC = "SUPPORT::blending() : " ;
226 MESSAGE(LOC<< "SUPPORT entry : " << *mySupport) ;
229 if ( _entity != mySupport->getEntity() )
230 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Entities are different !"));
232 int * tmp_NumberOfElementsInType = new int[MED_NBR_GEOMETRIE_MAILLE];
233 medGeometryElement * myType = new medGeometryElement[MED_NBR_GEOMETRIE_MAILLE];
234 int * whereIsType = new int[MED_NBR_GEOMETRIE_MAILLE];
235 //MESH_ENTITIES myMeshEntities() ;
236 list<MED_FR::med_geometrie_element>::const_iterator listIt ;
238 for(listIt=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).begin();listIt!=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).end();listIt++) {
239 tmp_NumberOfElementsInType[it]=0;
243 tmp_int = getNumberOfElements((medGeometryElement)(*listIt)) ;
244 tmp_NumberOfElementsInType[it]+=tmp_int ;
247 catch (MEDEXCEPTION & ex) { SCRUTE(sizeof(ex)); };
250 tmp_int = mySupport->getNumberOfElements((medGeometryElement)(*listIt)) ;
251 tmp_NumberOfElementsInType[it]+=tmp_int ;
254 catch (const MEDEXCEPTION & ex) {};
255 if (whereIsType[it]!=0) {
256 myType[it]=(medGeometryElement)(*listIt) ;
257 SCRUTE(myType[it]);SCRUTE(it);SCRUTE((*listIt));
262 // int * numberOfElements=_numberOfElements ;
263 // _numberOfElements = new int[it] ;
264 int * numberOfElements= new int[it];
265 _totalNumberOfElements = 0 ;
266 //int totalSize = 0 ;
267 int ** tmp_array = new int*[it];
268 for (int i=0;i<it;i++) {
269 int numberOfElementsInType = tmp_NumberOfElementsInType[i] ;
270 numberOfElements[i] = numberOfElementsInType ;
271 tmp_array[i] = new int[numberOfElementsInType] ;
272 //totalSize+=numberOfElementsInType*(myType[i]%100) ;
273 _totalNumberOfElements+=numberOfElementsInType ;
274 if (whereIsType[i] == 1) { // only first Support
275 memcpy(tmp_array[i],getNumber(myType[i]),sizeof(int)*numberOfElementsInType);
276 } else if (whereIsType[i] == 2) { // only second Support
277 memcpy(tmp_array[i],mySupport->getNumber(myType[i]),sizeof(int)*numberOfElementsInType);
278 } else if (whereIsType[i] == 3) { // more difficult :-)
279 set<int> elementList ;
280 //int i1 = 0 ; !! UNUSED VARIABLE !!
281 //int i2 = 0 ; !!UNUSED VARIABLE !!
283 const int * number1 = getNumber(myType[i]) ;
284 const int * number2 = mySupport->getNumber(myType[i]) ;
289 int numberOfElements1 = getNumberOfElements(myType[i]) ;
290 int numberOfElements2 = mySupport->getNumberOfElements(myType[i]) ;
292 SCRUTE(numberOfElements1);
293 SCRUTE(numberOfElements2);
295 MESSAGE(LOC << " Type : " << myType[i] << " " << i);
297 for(int j=0;j<numberOfElements1;j++){
298 elementList.insert(number1[j]) ;
301 for(int j=0;j<numberOfElements2;j++){
302 elementList.insert(number2[j]) ;
306 int newNumberOfElements = elementList.size() ;
308 SCRUTE(newNumberOfElements);
310 numberOfElements[i] = newNumberOfElements ;
311 int * tmp_arrayNew = new int[newNumberOfElements];
313 set<int>::iterator its ;
314 for(its=elementList.begin();its!=elementList.end(); its++) {
315 tmp_arrayNew[ii]=*its ;
319 delete[] tmp_array[i] ;
320 tmp_array[i] = tmp_arrayNew ;
321 _totalNumberOfElements-=(numberOfElementsInType-newNumberOfElements) ;
324 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"ERROR")) ;
326 delete[] whereIsType ;
327 delete[] tmp_NumberOfElementsInType ;
328 delete [] _numberOfElements;
330 _numberOfElements = numberOfElements;
332 _numberOfGeometricType = it ;
333 medGeometryElement * geometricType=_geometricType ;
334 _geometricType = new medGeometryElement[it] ;
335 int * numberOfGaussPoint=_numberOfGaussPoint ;
336 _numberOfGaussPoint= new int[it] ;
337 // int * geometricTypeNumber=_geometricTypeNumber ;
338 // _geometricTypeNumber = new int[it] ;
340 // MEDSKYLINEARRAY* numberNew = new MEDSKYLINEARRAY(it,_totalNumberOfElements);
341 // int * numberIndex = numberNew->getIndex() ;
342 int size = _mesh->getNumberOfElements(_entity,MED_ALL_ELEMENTS);
343 if (_totalNumberOfElements == size) _isOnAllElts = true;
345 int * numberValue = new int[_totalNumberOfElements] ;
346 int * numberIndex = new int[it+1] ;
348 for (int i=0;i<it;i++) {
349 memcpy(numberValue+numberIndex[i]-1,tmp_array[i],sizeof(int)*_numberOfElements[i]) ;
350 delete[] tmp_array[i] ;
351 numberIndex[i+1]=numberIndex[i]+_numberOfElements[i] ;
353 _geometricType[i]=myType[i] ;
354 _numberOfGaussPoint[i]=1 ;
356 if ( _number != (MEDSKYLINEARRAY *) NULL) delete _number ;
357 //_number = numberNew ;
358 _number = new MEDSKYLINEARRAY(it,_totalNumberOfElements,numberIndex,numberValue);
359 delete[] numberIndex;
361 delete[] numberValue;
366 delete[] geometricType ;
367 delete[] numberOfGaussPoint ;
368 // delete[] geometricTypeNumber ;
369 // delete[] numberOfElements ;
374 MESSAGE(LOC<<"Printing of the object SUPPORT blended "<< *this);
383 This function allows the user to set a support not on all entities Entity,
384 it should be used after an initialisation with the constructor
385 SUPPORT(MESH* Mesh, string Name="", medEntityMesh Entity=MED_CELL) and
386 after the call to the function setAll(false).
387 It allocates and initialises all the attributs of the class SUPPORT.
390 //-------------------
391 void SUPPORT::setpartial(string Description, int NumberOfGeometricType,
392 int TotalNumberOfElements,
393 medGeometryElement *GeometricType,
394 int *NumberOfElements, int *NumberValue)
395 //-------------------
397 const char * LOC = "SUPPORT::setpartial(string , int , int , medGeometryElement * , int * , int *) : " ;
400 _isOnAllElts = false ;
402 _description=Description;
404 _numberOfGeometricType=NumberOfGeometricType;
406 if (_geometricType!=NULL) delete[] _geometricType ;
407 _geometricType = new medGeometryElement[NumberOfGeometricType];
408 if (_numberOfElements!=NULL) delete[] _numberOfElements ;
409 _numberOfElements = new int[NumberOfGeometricType];
410 _totalNumberOfElements = TotalNumberOfElements;
411 if (_numberOfGaussPoint!=NULL) delete[] _numberOfGaussPoint ;
412 _numberOfGaussPoint = new int[NumberOfGeometricType];
413 int * index = new int[_numberOfGeometricType+1];
415 for (int i=0;i<_numberOfGeometricType;i++) {
416 _geometricType[i] = GeometricType[i] ;
417 _numberOfElements[i] = NumberOfElements[i] ;
418 _numberOfGaussPoint[i] = 1 ;
419 index[i+1] = index[i]+NumberOfElements[i] ;
422 if (_number!=NULL) delete _number ;
423 _number = new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfElements,index,NumberValue);
432 This method gets the boundary elements of the mesh. The support has to be
433 build using the constructor SUPPORT(MESH *,string, medEntityMesh) or
434 SUPPORT() followed by setMesh(MESH*) setName(string) and
435 setEntity(medEntityMesh) before using this method.
437 //-------------------
438 void SUPPORT::getBoundaryElements() throw (MEDEXCEPTION)
439 //-------------------
441 const char * LOC = "SUPPORT::getBoundaryElements() : " ;
444 if (_mesh == (MESH*)NULL) throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"You shlould use the appropriate SUPPORT Constructor before calling this method"));
446 int spaceDimension = _mesh->getSpaceDimension();
448 if (spaceDimension == 3)
449 if (_entity != MED_FACE)
450 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Not defined in 3D mesh for entity "<<_entity<<" !"));
451 if (spaceDimension == 2)
452 if (_entity != MED_EDGE)
453 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Not defined in 2D mesh for entity "<<_entity<<" !"));
457 const int * myConnectivityValue = _mesh->getReverseConnectivity(MED_DESCENDING) ;
458 const int * myConnectivityIndex = _mesh->getReverseConnectivityIndex(MED_DESCENDING) ;
459 int numberOf = _mesh->getNumberOfElements(_entity,MED_ALL_ELEMENTS) ;
460 list<int> myElementsList ;
463 for (int i=0 ; i<numberOf; i++)
464 if (myConnectivityValue[myConnectivityIndex[i]] == 0) {
466 myElementsList.push_back(i+1) ;
470 // Well, we must know how many geometric type we have found
471 int * myListArray = new int[size] ;
473 list<int>::iterator myElementsListIt ;
474 for (myElementsListIt=myElementsList.begin();myElementsListIt!=myElementsList.end();myElementsListIt++) {
475 myListArray[id]=(*myElementsListIt) ;
477 SCRUTE(myListArray[id]);
481 int numberOfGeometricType ;
482 medGeometryElement* geometricType ;
483 int * numberOfGaussPoint ;
484 int * geometricTypeNumber ;
485 int * numberOfElements ;
486 //MEDSKYLINEARRAY * mySkyLineArray = new MEDSKYLINEARRAY() ;
487 int * mySkyLineArrayIndex ;
489 int numberOfType = _mesh->getNumberOfTypes(_entity) ;
490 if (numberOfType == 1) { // wonderfull : it's easy !
491 numberOfGeometricType = 1 ;
492 geometricType = new medGeometryElement[1] ;
493 const medGeometryElement * allType = _mesh->getTypes(_entity);
494 geometricType[0] = allType[0] ;
495 numberOfGaussPoint = new int[1] ;
496 numberOfGaussPoint[0] = 1 ;
497 geometricTypeNumber = new int[1] ; // not use, but initialized to nothing
498 geometricTypeNumber[0] = 0 ;
499 numberOfElements = new int[1] ;
500 numberOfElements[0] = size ;
501 mySkyLineArrayIndex = new int[2] ;
502 mySkyLineArrayIndex[0]=1 ;
503 mySkyLineArrayIndex[1]=1+size ;
506 map<medGeometryElement,int> theType ;
507 for (myElementsListIt=myElementsList.begin();myElementsListIt!=myElementsList.end();myElementsListIt++) {
508 medGeometryElement myType = _mesh->getElementType(_entity,*myElementsListIt) ;
509 if (theType.find(myType) != theType.end() )
514 numberOfGeometricType = theType.size() ;
515 geometricType = new medGeometryElement[numberOfGeometricType] ;
516 //const medGeometryElement * allType = _mesh->getTypes(_entity); !! UNUSED VARIABLE !!
517 numberOfGaussPoint = new int[numberOfGeometricType] ;
518 geometricTypeNumber = new int[numberOfGeometricType] ; // not use, but initialized to nothing
519 numberOfElements = new int[numberOfGeometricType] ;
520 mySkyLineArrayIndex = new int[numberOfGeometricType+1] ;
522 mySkyLineArrayIndex[0]=1 ;
523 map<medGeometryElement,int>::iterator theTypeIt ;
524 for (theTypeIt=theType.begin();theTypeIt!=theType.end();theTypeIt++) {
525 geometricType[index] = (*theTypeIt).first ;
526 numberOfGaussPoint[index] = 1 ;
527 geometricTypeNumber[index] = 0 ;
528 numberOfElements[index] = (*theTypeIt).second ;
529 mySkyLineArrayIndex[index+1]=mySkyLineArrayIndex[index]+numberOfElements[index] ;
533 //mySkyLineArray->setMEDSKYLINEARRAY(numberOfGeometricType,size,mySkyLineArrayIndex,myListArray) ;
534 MEDSKYLINEARRAY * mySkyLineArray = new MEDSKYLINEARRAY(numberOfGeometricType,size,mySkyLineArrayIndex,myListArray) ;
536 setNumberOfGeometricType(numberOfGeometricType) ;
537 // setGeometricType(geometricType) ;
538 // setNumberOfGaussPoint(numberOfGaussPoint) ;
539 for (int i=0;i<numberOfGeometricType;i++)
541 _numberOfGaussPoint[i] = numberOfGaussPoint[i];
542 _geometricType[i] = geometricType[i];
545 setNumberOfElements(numberOfElements) ;
546 setTotalNumberOfElements(size) ;
547 // setNumber(mySkyLineArray) ;
549 _number = new MEDSKYLINEARRAY(numberOfGeometricType,size);
551 _number->setIndex(mySkyLineArrayIndex);
553 for (int i=0;i<size;i++)
555 _number->setIndexValue(i+1,myListArray[i]);
558 delete[] numberOfElements;
559 delete[] geometricTypeNumber;
560 delete[] numberOfGaussPoint;
561 delete[] geometricType;
562 delete[] mySkyLineArrayIndex;
563 delete[] myListArray;
564 delete mySkyLineArray;
570 intersect the given SUPPORT mySupport into the calling SUPPORT object.
572 //-------------------
573 void SUPPORT::intersecting(SUPPORT * mySupport) throw (MEDEXCEPTION)
574 //-------------------
576 const char * LOC = "SUPPORT::intersecting(SUPPORT *) : " ;
579 MESSAGE(LOC<< "SUPPORT entry : " << *mySupport) ;
581 MESSAGE(LOC<< "SUPPORT (calling object) : " << *this) ;
584 if ( _entity != mySupport->getEntity() )
585 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Entities are different !"));
587 int * tmp_NumberOfElementsInType = new int[MED_NBR_GEOMETRIE_MAILLE];
588 medGeometryElement * myType = new medGeometryElement[MED_NBR_GEOMETRIE_MAILLE];
589 int * whereIsType = new int[MED_NBR_GEOMETRIE_MAILLE];
590 //MESH_ENTITIES myMeshEntities() ;
591 list<MED_FR::med_geometrie_element>::const_iterator listIt ;
593 for(listIt=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).begin();listIt!=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).end();listIt++) {
594 tmp_NumberOfElementsInType[it]=0;
596 myType[it]= MED_NONE;
598 tmp_NumberOfElementsInType[it]+=getNumberOfElements((medGeometryElement)(*listIt)) ;
601 catch (const MEDEXCEPTION & ex) {};
603 tmp_NumberOfElementsInType[it]+=mySupport->getNumberOfElements((medGeometryElement)(*listIt)) ;
606 catch (const MEDEXCEPTION & ex) {};
607 if (whereIsType[it]==3) {
608 myType[it]=(medGeometryElement)(*listIt) ;
613 MESSAGE("it = "<< it);
616 int * numberOfElements=_numberOfElements ;
617 _numberOfElements = new int[it] ;
618 _totalNumberOfElements = 0 ;
619 //int totalSize = 0 ;
620 int ** tmp_array = new int*[it];
621 for (int i=0;i<it;i++) {
622 int numberOfElementsInType = tmp_NumberOfElementsInType[i] ;
623 _numberOfElements[i] = numberOfElementsInType ;
624 tmp_array[i] = new int[numberOfElementsInType] ;
625 _totalNumberOfElements+=numberOfElementsInType ;
626 if (whereIsType[i] == 3) {
627 const int * number1 = getNumber(myType[i]) ;
628 const int * number2 = mySupport->getNumber(myType[i]) ;
633 int numberOfElements1 = numberOfElements[i] ;
634 int numberOfElements2 = mySupport->getNumberOfElements(myType[i]) ;
636 SCRUTE(numberOfElements1);
637 SCRUTE(numberOfElements2);
639 set<int> setList1(number1,number1+numberOfElements1);
640 set<int> setList2(number2,number2+numberOfElements2);
642 for(set<int>::iterator its=setList1.begin();its!=setList1.end(); its++)
644 MESSAGE("Number1 " << *its);
647 for(set<int>::iterator its=setList2.begin();its!=setList2.end(); its++)
649 MESSAGE("Number2 " << *its);
652 set<int> setListIntersect;
654 set_intersection(setList1.begin(),setList1.end(),setList2.begin(),
655 setList2.end(),inserter(setListIntersect,
656 setListIntersect.begin()));
658 for(set<int>::iterator its=setListIntersect.begin();
659 its!=setListIntersect.end(); its++)
661 MESSAGE("Number1 intersect Number2 " << *its);
664 int newNumberOfElements = setListIntersect.size() ;
666 SCRUTE(newNumberOfElements);
668 _numberOfElements[i] = newNumberOfElements ;
669 int * tmp_arrayNew = new int[newNumberOfElements];
673 for(set<int>::iterator its=setListIntersect.begin();
674 its!=setListIntersect.end(); its++) {
675 tmp_arrayNew[ii]=*its ;
676 SCRUTE(tmp_arrayNew[ii]);
680 delete[] tmp_array[i] ;
681 tmp_array[i] = tmp_arrayNew ;
682 _totalNumberOfElements-=(numberOfElementsInType-newNumberOfElements) ;
685 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"ERROR")) ;
687 delete[] whereIsType ;
688 delete[] tmp_NumberOfElementsInType ;
690 _numberOfGeometricType = it ;
691 medGeometryElement * geometricType=_geometricType ;
692 _geometricType = new medGeometryElement[it] ;
693 int * numberOfGaussPoint=_numberOfGaussPoint ;
694 _numberOfGaussPoint= new int[it] ;
696 int size = _mesh->getNumberOfElements(_entity,MED_ALL_ELEMENTS);
697 if (_totalNumberOfElements == size) _isOnAllElts = true;
699 int * numberValue = new int[_totalNumberOfElements] ;
700 int * numberIndex = new int[it+1] ;
702 for (int i=0;i<it;i++) {
703 memcpy(numberValue+numberIndex[i]-1,tmp_array[i],sizeof(int)*_numberOfElements[i]) ;
704 delete[] tmp_array[i] ;
705 numberIndex[i+1]=numberIndex[i]+_numberOfElements[i] ;
707 _geometricType[i]=myType[i] ;
708 _numberOfGaussPoint[i]=1 ;
710 if ( _number != (MEDSKYLINEARRAY *) NULL) delete _number ;
712 _number = new MEDSKYLINEARRAY(it,_totalNumberOfElements,numberIndex,numberValue);
713 delete[] numberIndex;
715 delete[] numberValue;
720 delete[] geometricType ;
721 delete[] numberOfGaussPoint ;
722 // delete[] geometricTypeNumber ;
723 delete[] numberOfElements ;
729 operator == This operator does not compare attributs _name and _description.
731 //--------------------------------------------------
732 bool MEDMEM::SUPPORT::operator == (const SUPPORT &support) const
733 //--------------------------------------------------
735 const char * LOC = "bool SUPPORT::operator ==(const SUPPORT &support) const : ";
739 bool operatorReturn = false;
741 operatorReturn = (_mesh == support._mesh) && (_entity == support._entity) &&
742 (_numberOfGeometricType == support._numberOfGeometricType) &&
743 (_isOnAllElts == support._isOnAllElts) &&
744 (_totalNumberOfElements == support._totalNumberOfElements);
750 for (int i=0; i<_numberOfGeometricType; i++)
752 operatorReturn = operatorReturn &&
753 (_geometricType[i] == support._geometricType[i]) &&
754 (_numberOfElements[i] == support._numberOfElements[i]) &&
755 (_numberOfGaussPoint[i] == support._numberOfGaussPoint[i]);
759 for (int j=0; j<_numberOfElements[i]; j++)
761 operatorReturn = operatorReturn &&
762 (getNumber(_geometricType[i])[j] ==
763 support.getNumber(_geometricType[i])[j]);
772 return operatorReturn;