10 #include "utilities.h"
11 #include "MEDMEM_define.hxx"
12 #include "MEDMEM_DriversDef.hxx"
13 #include "MEDMEM_Support.hxx"
14 #include "MEDMEM_Family.hxx"
15 #include "MEDMEM_Group.hxx"
16 #include "MEDMEM_Mesh.hxx"
18 using namespace MED_EN;
20 /* This class is a generic class for family and group */
21 //--------------------------------------------------------------------------
22 SUPPORT::SUPPORT(): _name(""), _description(""), _mesh((MESH*)NULL),
23 _entity(MED_CELL), _numberOfGeometricType(0),
24 _geometricType((medGeometryElement*)NULL),
25 _numberOfGaussPoint((int*)NULL),
26 _geometricTypeNumber((int*)NULL), _isOnAllElts(false),
27 _numberOfEntities((int*)NULL), _totalNumberOfEntities(0),
28 _number((MEDSKYLINEARRAY*)NULL)
29 //--------------------------------------------------------------------------
31 MESSAGE("Constructeur SUPPORT sans parametre");
34 //--------------------------------------------------------------------------
35 SUPPORT::SUPPORT(MESH* Mesh, string Name/*=""*/, medEntityMesh Entity/*=MED_CELL*/):
36 _name(Name), _description(""), _mesh(Mesh), _entity(Entity),
37 _numberOfGeometricType(0),
38 _geometricType((medGeometryElement*)NULL),
39 _numberOfGaussPoint((int*)NULL),
40 _geometricTypeNumber((int*)NULL),
41 _isOnAllElts(true), _numberOfEntities((int*)NULL),
42 _totalNumberOfEntities(0),
43 _number((MEDSKYLINEARRAY*)NULL)
44 //--------------------------------------------------------------------------
46 MESSAGE("Constructeur SUPPORT avec parametres MESH* Mesh,string name,medEntityMesh Entity");
47 if ( Entity == MED_NODE) {
48 _numberOfGeometricType=1 ;
49 _geometricType=new medGeometryElement[1] ;
50 _geometricType[0]=MED_NONE ;
54 //--------------------------------------------------------------------------
55 SUPPORT::SUPPORT(SUPPORT & m)
56 //--------------------------------------------------------------------------
58 const char * LOC = "SUPPORT::SUPPORT(SUPPORT & m) : " ;
62 _description = m._description;
63 _mesh = m._mesh; // on recopie uniquement l'adresse
65 _numberOfGeometricType = m._numberOfGeometricType;
66 if (m._geometricType != NULL)
68 _geometricType = new medGeometryElement[m._numberOfGeometricType];
69 memcpy(_geometricType,m._geometricType,m._numberOfGeometricType*sizeof(medGeometryElement));
72 _geometricType = (medGeometryElement *) NULL;
73 if (m._numberOfGaussPoint != NULL)
75 _numberOfGaussPoint = new int[m._numberOfGeometricType];
76 memcpy(_numberOfGaussPoint,m._numberOfGaussPoint,m._numberOfGeometricType*sizeof(int));
79 _numberOfGaussPoint = (int *) NULL;
80 if (m._geometricTypeNumber != NULL)
82 _geometricTypeNumber = new int[m._numberOfGeometricType];
83 memcpy(_geometricTypeNumber,m._geometricTypeNumber,m._numberOfGeometricType*sizeof(int));
86 _geometricTypeNumber = (int *) NULL;
87 _isOnAllElts = m._isOnAllElts;
88 if (m._numberOfEntities != NULL)
90 _numberOfEntities = new int[m._numberOfGeometricType];
91 memcpy(_numberOfEntities,m._numberOfEntities,m._numberOfGeometricType*sizeof(int));
94 _numberOfEntities = (int *) NULL;
95 _totalNumberOfEntities = m._totalNumberOfEntities;
96 if (m._isOnAllElts == false)
97 _number = new MEDSKYLINEARRAY(* m._number);
99 _number = (MEDSKYLINEARRAY *) NULL;
108 MESSAGE("Destructeur ~SUPPORT()");
109 if (_geometricType!=NULL)
110 delete[] _geometricType ;
111 if (_numberOfGaussPoint!=NULL)
112 delete[] _numberOfGaussPoint ;
113 if (_geometricTypeNumber!=NULL)
114 delete[] _geometricTypeNumber ;
115 if (_numberOfEntities!=NULL)
116 delete[] _numberOfEntities ;
121 //--------------------------------------------------
122 ostream & operator<<(ostream &os, const SUPPORT &my)
123 //--------------------------------------------------
125 os << "Name : "<<my._name<< endl ;
126 os << "Description : "<< my._description << endl ;
127 os << "Mesh name : ";
129 os << "ERROR : Mesh not defined !" << endl ;
131 os << my._mesh->getName() << endl ;
132 os << "Entity : "<< my._entity << endl;
133 os << "Entity list : "<< endl;
134 if (!(my._isOnAllElts)) {
135 int NumberOfTypes = my._numberOfGeometricType ;
136 os << "NumberOfTypes : "<<NumberOfTypes<<endl;
137 medGeometryElement * Types = my._geometricType ;
138 for (int j=0;j<NumberOfTypes;j++) {
139 os << " * Type "<<Types[j]<<" : ";
140 int NumberOfElements = my._numberOfEntities[j] ;
141 int * Number = my._number->getI(j+1) ;
142 for (int k=0; k<NumberOfElements;k++)
143 os << Number[k] << " ";
147 os << "Is on all entities !"<< endl;
153 //-------------------
154 void SUPPORT::update()
155 //-------------------
157 const char * LOC = "SUPPORT::update() : " ;
161 if (_numberOfGaussPoint==NULL) {
162 MESSAGE( "ENTITY : "<< _entity );
163 int NumberOfTypes = _mesh->getNumberOfTypes(_entity) ;
164 MESSAGE( "NumberOfTypes : "<< NumberOfTypes );
165 _numberOfGaussPoint = new int[NumberOfTypes] ;
166 for (int i=0;i<NumberOfTypes;i++)
167 _numberOfGaussPoint[i]=1 ;
169 if (_entity == MED_NODE)
170 _totalNumberOfEntities = _mesh->getNumberOfNodes();
176 //-------------------
177 void SUPPORT::blending(SUPPORT * mySupport)
178 //-------------------
180 const char * LOC = "SUPPORT::blending() : " ;
183 MESSAGE(LOC<< "SUPPORT entry : " << *mySupport) ;
186 if ( _entity != mySupport->getEntity() )
187 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Entities are different !"));
189 int * tmp_NumberOfElementsInType = new int[MED_NBR_GEOMETRIE_MAILLE];
190 medGeometryElement * myType = new medGeometryElement[MED_NBR_GEOMETRIE_MAILLE];
191 int * whereIsType = new int[MED_NBR_GEOMETRIE_MAILLE];
192 //MESH_ENTITIES myMeshEntities() ;
193 list<MED_FR::med_geometrie_element>::const_iterator listIt ;
195 for(listIt=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).begin();listIt!=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).end();listIt++){
196 tmp_NumberOfElementsInType[it]=0;
199 tmp_NumberOfElementsInType[it]+=getNumberOfElements((medGeometryElement)(*listIt)) ;
202 catch (const MEDEXCEPTION & ex) {};
204 tmp_NumberOfElementsInType[it]+=mySupport->getNumberOfElements((medGeometryElement)(*listIt)) ;
207 catch (const MEDEXCEPTION & ex) {};
208 if (whereIsType[it]!=0) {
209 myType[it]=(medGeometryElement)(*listIt) ;
214 int * numberOfEntities=_numberOfEntities ;
215 _numberOfEntities = new int[it] ;
216 _totalNumberOfEntities = 0 ;
217 // int totalSize = 0 ;
218 int ** tmp_array = new (int*)[it];
219 for (int i=0;i<it;i++) {
220 int numberOfElementsInType = tmp_NumberOfElementsInType[i] ;
221 _numberOfEntities[i] = numberOfElementsInType ;
222 tmp_array[i] = new int[numberOfElementsInType] ;
223 //totalSize+=numberOfElementsInType*(myType[i]%100) ;
224 _totalNumberOfEntities+=numberOfElementsInType ;
225 if (whereIsType[i] == 1) { // only first Support
226 memcpy(tmp_array[i],getNumber(myType[i]),sizeof(int)*numberOfElementsInType);
227 } else if (whereIsType[i] == 2) { // only second Support
228 memcpy(tmp_array[i],mySupport->getNumber(myType[i]),sizeof(int)*numberOfElementsInType);
229 } else if (whereIsType[i] == 3) { // more difficult :-)
230 set<int> elementList ;
234 int * number1 = getNumber(myType[i]) ;
235 int * number2 = mySupport->getNumber(myType[i]) ;
240 int numberOfElements1 = numberOfEntities[i] ;
241 int numberOfElements2 = mySupport->getNumberOfElements(myType[i]) ;
243 SCRUTE(numberOfElements1);
244 SCRUTE(numberOfElements2);
246 for(int j=0;j<numberOfElements1;j++){
247 elementList.insert(number1[j]) ;
250 for(int j=0;j<numberOfElements2;j++){
252 elementList.insert(number2[j]) ;
256 int newNumberOfEntities = elementList.size() ;
257 _numberOfEntities[i] = newNumberOfEntities ;
258 int * tmp_arrayNew = new int[newNumberOfEntities];
260 set<int>::iterator its ;
261 for(its=elementList.begin();its!=elementList.end(); its++) {
262 tmp_arrayNew[ii]=*its ;
266 delete[] tmp_array[i] ;
267 tmp_array[i] = tmp_arrayNew ;
268 _totalNumberOfEntities-=(numberOfElementsInType-newNumberOfEntities) ;
271 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"ERROR")) ;
273 delete[] whereIsType ;
274 delete[] tmp_NumberOfElementsInType ;
276 _numberOfGeometricType = it ;
277 medGeometryElement * geometricType=_geometricType ;
278 _geometricType = new medGeometryElement[it] ;
279 int * numberOfGaussPoint=_numberOfGaussPoint ;
280 _numberOfGaussPoint= new int[it] ;
281 int * geometricTypeNumber=_geometricTypeNumber ;
282 _geometricTypeNumber = new int[it] ;
284 MEDSKYLINEARRAY* numberNew = new MEDSKYLINEARRAY(it,_totalNumberOfEntities);
285 int * numberIndex = numberNew->getIndex() ;
287 for (int i=0;i<it;i++) {
288 memcpy(numberNew->getI(i+1),tmp_array[i],sizeof(int)*_numberOfEntities[i]) ;
289 delete[] tmp_array[i] ;
290 numberIndex[i+1]=numberIndex[i]+_numberOfEntities[i] ;
292 _geometricType[i]=myType[i] ;
293 _numberOfGaussPoint[i]=1 ;
294 _geometricTypeNumber[i]=0 ;
298 _number = numberNew ;
303 delete[] geometricType ;
304 delete[] numberOfGaussPoint ;
305 delete[] geometricTypeNumber ;
306 delete[] numberOfEntities ;
312 This function allows the user to set a support not on all entities Entity,
313 it should be used after an initialisation with the constructor
314 SUPPORT(MESH* Mesh, string Name="", medEntityMesh Entity=MED_CELL) and
315 after the call to the function setAll(false).
316 It allocates and initialises all the attributs of the class SUPPORT.;
317 useful for the Python API.
320 //-------------------
321 void SUPPORT::setpartial(string Description, int NumberOfGeometricType,
322 int TotalNumberOfEntity,
323 medGeometryElement *GeometricType,
324 int *NumberOfEntity, int *NumberValue)
325 //-------------------
327 const char * LOC = "SUPPORT::setpartial(string , int , int , medGeometryElement * , int * , int *) : " ;
330 _description=Description;
332 _numberOfGeometricType=NumberOfGeometricType;
334 _totalNumberOfEntities=TotalNumberOfEntity;
336 _geometricType = new medGeometryElement[NumberOfGeometricType];
337 _geometricType = GeometricType;
339 // attributes initialised at 0 because not really useful but it has to be
340 // allocated !! WARNING !!
342 _geometricTypeNumber = new int[NumberOfGeometricType] ;
343 for (int i=0;i<NumberOfGeometricType;i++) _geometricTypeNumber[i] = 0;
345 //_numberOfEntities = new int[NumberOfGeometricType] ;
346 _numberOfEntities = NumberOfEntity;
348 MEDSKYLINEARRAY * number = new MEDSKYLINEARRAY();
350 int * index = new int[_numberOfGeometricType+1];
353 for (int i=0;i<_numberOfGeometricType;i++)
354 index[i+1] = index[i]+_numberOfEntities[i] ;
356 number->setMEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities,index,NumberValue);
358 if (_number!=NULL) delete _number ;