7 #include "MEDMEM_Mesh.hxx"
8 #include "MEDMEM_Family.hxx"
10 FAMILY::FAMILY():_identifier(0), _numberOfAttribute(0),
11 _attributeIdentifier((int*)NULL),_attributeValue((int*)NULL), _attributeDescription((string*)NULL),
12 _numberOfGroup(0), _groupName((string*)NULL)
14 MESSAGE("FAMILY::FAMILY()");
17 FAMILY::FAMILY(MESH* Mesh, int Identifier, string Name, int NumberOfAttribute,
18 int *AttributeIdentifier, int *AttributeValue, string AttributeDescription,
19 int NumberOfGroup, string GroupName
20 ): SUPPORT(Mesh,Name),
21 _identifier(Identifier),
22 _numberOfAttribute(NumberOfAttribute),
23 _attributeIdentifier(AttributeIdentifier),
24 _attributeValue(AttributeValue),
25 _numberOfGroup(NumberOfGroup)
27 MESSAGE("FAMILY(int Identifier, string Name, int NumberOfAttribute,int *AttributeIdentifier,int *AttributeValue,string AttributeDescription,int NumberOfGroup,string GroupName, int ** Number) : "<<Identifier);
29 _attributeDescription=new string[_numberOfAttribute];
30 for (int i=0;i<NumberOfAttribute;i++) {
31 _attributeDescription[i].assign(AttributeDescription,i*MED_TAILLE_DESC,MED_TAILLE_DESC);
32 _attributeDescription[i].erase(strlen(_attributeDescription[i].c_str()));
33 //SCRUTE(_attributeDescription[i]);
36 _groupName=new string[_numberOfGroup];
37 for (int i=0;i<NumberOfGroup;i++) {
38 _groupName[i].assign(GroupName,i*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
39 _groupName[i].erase(strlen(_groupName[i].c_str()));
40 //SCRUTE(_groupName[i]);
43 // well, we must set SUPPORT attribut
44 _description = "FAMILY" ;
45 // on which geometric type :
49 // ************************ NODES RELATED PART *************************************************
50 // Scan every node family number <NodeFamilyNumber[i]> in order to create
51 // the list <tmp_NodesList> of node numbers <i+1> belonging to the family <_identifier>
52 int NumberOfNodes = _mesh->getNumberOfNodes();
53 int NumberOfNodesInFamily = 0 ;
54 int * NodeFamilyNumber = _mesh->getMEDArrayNodeFamily() ; // EF : TEMPORAIRE !!
55 int * tmp_NodesList = new int[NumberOfNodes] ; // Un peu brutal...., oui mais ce n'est qu'un tableau de travail !
56 for (int i=0; i<NumberOfNodes; i++)
57 if ( _identifier == NodeFamilyNumber[i] ) {
58 tmp_NodesList[NumberOfNodesInFamily]=i+1 ;
59 NumberOfNodesInFamily++;
62 // If we found nodes set the family attributes adequatly
63 if (NumberOfNodesInFamily>0) {
68 _numberOfGeometricType = 1 ;
69 _geometricType = new medGeometryElement[1] ;
70 _geometricType[0]=MED_NONE ;
73 if (NumberOfNodesInFamily==NumberOfNodes)
77 _numberOfEntities = new int[1] ;
78 _numberOfEntities[0]=NumberOfNodesInFamily ;
79 _totalNumberOfEntities=NumberOfNodesInFamily;
81 _number=new MEDSKYLINEARRAY(1,NumberOfNodesInFamily) ;
82 int * NumberIndex = _number->getIndex();
83 int * NumberValue = _number->getValue();
84 NumberIndex[0]=1; //set the MEDSKYLINEARRAY Index table
85 NumberIndex[1]=1+NumberOfNodesInFamily; //set the MEDSKYLINEARRAY Index table
86 for(int i=0; i<NumberOfNodesInFamily; i++) // OH LA LA...
87 NumberValue[i]=tmp_NodesList[i] ; // RESIZE de tmp_NodesList serait plus efficace !!!!!!!!
88 // PG : pas de problème, si ca marche. Il faudra déplacer le delete !
91 delete[] tmp_NodesList ;
95 // ************************ CELLS RELATED PART *************************************************
96 // If we previously found nodes in our family don't scan the CELLS because a
97 // family contains different geometic types of only one entity type.
98 // ?? Scan every cell family number <NodeFamilyNumber[i]> in order to create
99 // ?? the list <tmp_NodesList> of node numbers <i+1> belonging to the family <_identifier>
102 // Get cell types information from <_mesh>
103 int numberOfCellTypes = _mesh->getNumberOfTypes(MED_CELL) ;
104 medGeometryElement * cellTypes = _mesh->getTypes(MED_CELL) ;
106 int * numberOfCellsInFamily = new int[numberOfCellTypes] ;
107 int numberOfCellTypesInFamily = 0 ;
109 medGeometryElement * tmp_CellsTypes = new medGeometryElement[numberOfCellTypes];
110 int ** tmp_CellsLists = new int*[numberOfCellTypes] ;
111 int * GeometricTypeNumber = new int[numberOfCellTypes] ;
112 int ** CellFamilyNumber = _mesh->getMEDArrayCellFamily(); // EF: TEMPORAIRE
113 int * GlobalNumberingIndex = _mesh->getGlobalNumberingIndex(MED_CELL);
115 // we search for all cell in this family
116 for (int cellTypeNumber=0; cellTypeNumber < numberOfCellTypes; cellTypeNumber++) {
118 int NumberOfCells = _mesh->getNumberOfElements(MED_CELL,cellTypes[cellTypeNumber]) ;
119 int NumberOfCellsInThisFamily = 0 ;
120 int * CellsOfThisFamilyNumber = CellFamilyNumber[cellTypeNumber];
121 int * tmp_CellsList = new int[NumberOfCells];
123 for (int i=0; i<NumberOfCells; i++)
124 if (_identifier == CellsOfThisFamilyNumber[i]) {
125 tmp_CellsList[NumberOfCellsInThisFamily]=i+GlobalNumberingIndex[cellTypeNumber] ;
126 NumberOfCellsInThisFamily++;
129 if (NumberOfCellsInThisFamily>0) {// we have found some cells
130 numberOfCellsInFamily[numberOfCellTypesInFamily]=NumberOfCellsInThisFamily;
131 int * CellsList=new int[NumberOfCellsInThisFamily] ;
133 for (int i=0;i<NumberOfCellsInThisFamily;i++)
134 CellsList[i]=tmp_CellsList[i] ; // RESIZE de tmp_NodesList serait plus efficace !!!!!!!!
136 tmp_CellsLists[numberOfCellTypesInFamily]=CellsList ;
137 tmp_CellsTypes[numberOfCellTypesInFamily]=cellTypes[cellTypeNumber];
138 GeometricTypeNumber[numberOfCellTypesInFamily]=cellTypeNumber+1;
139 numberOfCellTypesInFamily++;
142 delete[] tmp_CellsList ;
145 // we define all attribut in SUPPORT :
146 if (numberOfCellTypesInFamily>0) { // we have found cells
149 _numberOfGeometricType = numberOfCellTypesInFamily ;
150 _geometricType = new medGeometryElement[numberOfCellTypesInFamily] ;
151 _geometricTypeNumber = new int[numberOfCellTypesInFamily] ;
152 _isOnAllElts = false ;
153 _numberOfEntities = new int[numberOfCellTypesInFamily] ;
154 _totalNumberOfEntities=0;
155 for (int i=0; i<numberOfCellTypesInFamily; i++) {
156 _geometricType[i]=tmp_CellsTypes[i] ;
157 _geometricTypeNumber[i]=GeometricTypeNumber[i];
158 _numberOfEntities[i]=numberOfCellsInFamily[i] ;
159 _totalNumberOfEntities+=numberOfCellsInFamily[i] ;
161 delete[] numberOfCellsInFamily;
162 delete[] tmp_CellsTypes;
163 delete[] GeometricTypeNumber;
165 // family on all CELL ?
166 if (_totalNumberOfEntities==Mesh->getNumberOfElements(MED_CELL,MED_ALL_ELEMENTS)) {
167 _isOnAllElts = true ;
168 delete[] _numberOfEntities ;
169 _numberOfEntities=(int*)NULL;
171 _number=new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities);
172 int *NumberValue=_number->getValue();
173 int *NumberIndex=_number->getIndex();
175 for (int i=0; i<_numberOfGeometricType; i++) {
176 NumberIndex[i+1]=NumberIndex[i]+_numberOfEntities[i];
177 for (int j=NumberIndex[i]; j<NumberIndex[i+1]; j++)
178 NumberValue[j-1]=tmp_CellsLists[i][j-NumberIndex[i]];
179 delete[] tmp_CellsLists[i];
181 delete[] tmp_CellsLists;
187 if ((_mesh->existConnectivity(MED_NODAL,MED_FACE))|(_mesh->existConnectivity(MED_DESCENDING,MED_FACE))) {
188 int NumberOfFacesType = _mesh->getNumberOfTypes(MED_FACE) ;
189 medGeometryElement * FacesType = _mesh->getTypes(MED_FACE) ;
190 int * NumberOfFacesInFamily = new int[NumberOfFacesType] ;
191 int NumberOfFacesTypeInFamily = 0 ;
192 medGeometryElement * tmp_FacesTypes = new medGeometryElement[NumberOfFacesType];
193 int ** tmp_FacesLists = new int*[NumberOfFacesType] ;
194 int * GeometricTypeNumber = new int[NumberOfFacesType] ;
195 int ** FaceFamilyNumber = _mesh->getMEDArrayFaceFamily();
196 int * GlobalNumberingIndex = _mesh->getGlobalNumberingIndex(MED_FACE);
197 // we search all face in this family
198 for (int FaceTypeNumber=0; FaceTypeNumber<NumberOfFacesType; FaceTypeNumber++) {
199 int NumberOfThisFaces = _mesh->getNumberOfElements(MED_FACE,FacesType[FaceTypeNumber]) ;
200 int NumberOfFacesInThisFamily = 0 ;
201 int * FaceOfThisFamilyNumber = FaceFamilyNumber[FaceTypeNumber];
202 int * tmp_FacesList = new int[NumberOfThisFaces];
203 for (int i=0; i<NumberOfThisFaces; i++)
204 if (_identifier == FaceOfThisFamilyNumber[i]) {
205 tmp_FacesList[NumberOfFacesInThisFamily]=i+GlobalNumberingIndex[FaceTypeNumber] ;
206 NumberOfFacesInThisFamily++;
209 SCRUTE(NumberOfFacesInThisFamily);
212 if (NumberOfFacesInThisFamily>0) {// we have found some faces
213 NumberOfFacesInFamily[NumberOfFacesTypeInFamily]=NumberOfFacesInThisFamily;
214 int * FacesList=new int[NumberOfFacesInThisFamily] ;
215 for (int i=0;i<NumberOfFacesInThisFamily;i++)
216 FacesList[i]=tmp_FacesList[i] ;
217 tmp_FacesLists[NumberOfFacesTypeInFamily]=FacesList ;
218 tmp_FacesTypes[NumberOfFacesTypeInFamily]=FacesType[FaceTypeNumber];
219 GeometricTypeNumber[NumberOfFacesTypeInFamily]=FaceTypeNumber+1;
220 NumberOfFacesTypeInFamily++;
222 delete[] tmp_FacesList ;
224 // we define all attribut in SUPPORT :
225 if (NumberOfFacesTypeInFamily>0) { // we have found faces
228 _numberOfGeometricType = NumberOfFacesTypeInFamily ;
229 _geometricType = new medGeometryElement[NumberOfFacesTypeInFamily] ;
230 _geometricTypeNumber = new int[NumberOfFacesTypeInFamily] ;
231 _isOnAllElts = false ;
232 _numberOfEntities = new int[NumberOfFacesTypeInFamily] ;
233 _totalNumberOfEntities=0;
234 for (int i=0; i<NumberOfFacesTypeInFamily; i++) {
235 _geometricType[i]=tmp_FacesTypes[i] ;
236 _geometricTypeNumber[i]=GeometricTypeNumber[i];
237 _numberOfEntities[i]=NumberOfFacesInFamily[i] ;
238 _totalNumberOfEntities+=NumberOfFacesInFamily[i] ;
240 delete[] NumberOfFacesInFamily;
241 delete[] tmp_FacesTypes;
242 delete[] GeometricTypeNumber;
244 // family on all FACE ?
246 // we suppose family is never on all face !!!!!!!!!
247 // in all case, family is only on boundary and connectivity is partial
249 // if (_totalNumberOfEntities==Mesh->getNumberOfElements(MED_FACE,MED_ALL_ELEMENTS)) {
250 // _isOnAllElts = true ;
251 // delete[] _numberOfEntities ;
252 // _numberOfEntities=(int*)NULL;
254 _number=new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities);
255 int *NumberValue=_number->getValue();
256 int *NumberIndex=_number->getIndex();
258 for (int i=0; i<_numberOfGeometricType; i++) {
259 NumberIndex[i+1]=NumberIndex[i]+_numberOfEntities[i];
260 for (int j=NumberIndex[i]; j<NumberIndex[i+1]; j++)
261 NumberValue[j-1]=tmp_FacesLists[i][j-NumberIndex[i]];
262 delete[] tmp_FacesLists[i];
264 delete[] tmp_FacesLists;
271 if ((_mesh->existConnectivity(MED_NODAL,MED_EDGE))|(_mesh->existConnectivity(MED_DESCENDING,MED_EDGE))) {
272 int NumberOfEdgesType = _mesh->getNumberOfTypes(MED_EDGE) ;
273 medGeometryElement * EdgesType = _mesh->getTypes(MED_EDGE) ;
274 int * NumberOfEdgesInFamily = new int[NumberOfEdgesType] ;
275 int NumberOfEdgesTypeInFamily = 0 ;
276 medGeometryElement * tmp_EdgesTypes = new medGeometryElement[NumberOfEdgesType];
277 int ** tmp_EdgesLists = new int*[NumberOfEdgesType] ;
278 int * GeometricTypeNumber = new int[NumberOfEdgesType] ;
279 int ** EdgeFamilyNumber = _mesh->getMEDArrayEdgeFamily();
280 int * GlobalNumberingIndex = _mesh->getGlobalNumberingIndex(MED_EDGE);
281 // we search all edge in this family
282 for (int EdgeTypeNumber=0; EdgeTypeNumber<NumberOfEdgesType; EdgeTypeNumber++) {
283 int NumberOfThisEdges = _mesh->getNumberOfElements(MED_EDGE,EdgesType[EdgeTypeNumber]) ;
284 int NumberOfEdgesInThisFamily = 0 ;
285 int * EdgeOfThisFamilyNumber = EdgeFamilyNumber[EdgeTypeNumber];
286 int * tmp_EdgesList = new int[NumberOfThisEdges];
287 for (int i=0; i<NumberOfThisEdges; i++)
288 if (_identifier == EdgeOfThisFamilyNumber[i]) {
289 tmp_EdgesList[NumberOfEdgesInThisFamily]=i+GlobalNumberingIndex[EdgeTypeNumber] ;
290 NumberOfEdgesInThisFamily++;
292 if (NumberOfEdgesInThisFamily>0) {// we have found some edges
293 NumberOfEdgesInFamily[NumberOfEdgesTypeInFamily]=NumberOfEdgesInThisFamily;
294 int * EdgesList=new int[NumberOfEdgesInThisFamily] ;
295 for (int i=0;i<NumberOfEdgesInThisFamily;i++)
296 EdgesList[i]=tmp_EdgesList[i] ;
297 tmp_EdgesLists[NumberOfEdgesTypeInFamily]=EdgesList ;
298 tmp_EdgesTypes[NumberOfEdgesTypeInFamily]=EdgesType[EdgeTypeNumber];
299 GeometricTypeNumber[NumberOfEdgesTypeInFamily]=EdgeTypeNumber+1;
300 NumberOfEdgesTypeInFamily++;
302 delete[] tmp_EdgesList ;
304 // we define all attribut in SUPPORT :
305 if (NumberOfEdgesTypeInFamily>0) { // we have found edges
308 _numberOfGeometricType = NumberOfEdgesTypeInFamily ;
309 _geometricType = new medGeometryElement[NumberOfEdgesTypeInFamily] ;
310 _geometricTypeNumber = new int[NumberOfEdgesTypeInFamily] ;
311 _isOnAllElts = false ;
312 _numberOfEntities = new int[NumberOfEdgesTypeInFamily] ;
313 _totalNumberOfEntities=0;
314 for (int i=0; i<NumberOfEdgesTypeInFamily; i++) {
315 _geometricType[i]=tmp_EdgesTypes[i] ;
316 _geometricTypeNumber[i]=GeometricTypeNumber[i];
317 _numberOfEntities[i]=NumberOfEdgesInFamily[i] ;
318 _totalNumberOfEntities+=NumberOfEdgesInFamily[i] ;
320 delete[] NumberOfEdgesInFamily;
321 delete[] tmp_EdgesTypes;
322 delete[] GeometricTypeNumber;
324 // family on all EDGE ?
326 // we suppose family is never on all edge !!!!!!!!!
327 // in all case, family is only on boundary and connectivity is partial
329 // if (_totalNumberOfEntities==Mesh->getNumberOfElements(MED_EDGE,MED_ALL_ELEMENTS)) {
330 // _isOnAllElts = true ;
331 // delete[] _numberOfEntities ;
332 // _numberOfEntities=(int*)NULL;
334 _number=new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities);
335 int *NumberValue=_number->getValue();
336 int *NumberIndex=_number->getIndex();
338 for (int i=0; i<_numberOfGeometricType; i++) {
339 NumberIndex[i+1]=NumberIndex[i]+_numberOfEntities[i];
340 for (int j=NumberIndex[i]; j<NumberIndex[i+1]; j++)
341 NumberValue[j-1]=tmp_EdgesLists[i][j-NumberIndex[i]];
342 delete[] tmp_EdgesLists[i];
344 delete[] tmp_EdgesLists;
350 // if not find : no entity in familly !!!
352 _numberOfGeometricType = 0 ;
353 _isOnAllElts = false ;
354 MESSAGE ("FAMILY() : No entity found !") ;
355 } else { // set gauss point number to be equal one !
356 _numberOfGaussPoint = new int[_numberOfGeometricType] ;
357 for (int i=0; i<_numberOfGeometricType; i++)
358 _numberOfGaussPoint[i]=1 ;
362 FAMILY::FAMILY(FAMILY & m):SUPPORT(m)
364 _identifier = m._identifier;
365 _numberOfAttribute = m._numberOfAttribute;
366 if (m._attributeIdentifier != NULL)
368 _attributeIdentifier = new int[m._numberOfAttribute];
369 memcpy(_attributeIdentifier,m._attributeIdentifier,m._numberOfAttribute*sizeof(int));
372 _attributeIdentifier = (int *) NULL;
373 if (m._attributeValue != NULL)
375 _attributeValue = new int[m._numberOfAttribute];
376 memcpy(_attributeValue,m._attributeValue,m._numberOfAttribute*sizeof(int));
379 _attributeValue = (int *) NULL;
380 if (m._attributeDescription != NULL)
382 _attributeDescription = new string[m._numberOfAttribute];
383 for (int i=0;i<m._numberOfAttribute;i++)
384 _attributeDescription[i] = m._attributeDescription[i];
387 _attributeDescription = (string *) NULL;
388 _numberOfGroup = m._numberOfGroup;
389 if (m._groupName != NULL)
391 _groupName = new string[m._numberOfGroup];
392 for (int i=0;i<m._numberOfGroup;i++)
393 _groupName[i]=m._groupName[i];
396 _groupName = (string *) NULL;
401 MESSAGE("~FAMILY()");
402 if(_attributeIdentifier!=NULL)
403 delete[] _attributeIdentifier;
404 if(_attributeValue!=NULL)
405 delete[] _attributeValue;
406 if(_attributeDescription!=NULL)
407 delete[] _attributeDescription;
412 FAMILY & FAMILY::operator=(const FAMILY &fam)
414 MESSAGE("FAMILY::operator=");
415 _identifier = fam._identifier;
416 _numberOfAttribute = fam._numberOfAttribute;
417 _attributeIdentifier = fam._attributeIdentifier;
418 _attributeValue = fam._attributeValue;
419 _attributeDescription = fam._attributeDescription;
420 _numberOfGroup = fam._numberOfGroup;
421 _groupName = fam._groupName;