src/MEDMEM/MEDMEM_Family.cxx

   1 /*
   2  File MEDMEM_Family.cxx
   3  $Header$
   4 */
   5
   6 #include "MEDMEM_Mesh.hxx"
   7 #include "MEDMEM_Family.hxx"
   8
   9 FAMILY::FAMILY():_identifier(0), _numberOfAttribute(0),
  10                  _attributeIdentifier((int*)NULL),_attributeValue((int*)NULL), _attributeDescription((string*)NULL),
  11                  _numberOfGroup(0), _groupName((string*)NULL)
  12 {
  13     MESSAGE("FAMILY::FAMILY()");
  14 };
  15
  16 FAMILY::FAMILY(MESH* Mesh, int Identifier, string Name, int NumberOfAttribute,
  17                int *AttributeIdentifier, int *AttributeValue, string AttributeDescription,
  18                int NumberOfGroup, string GroupName
  19                ): SUPPORT(Mesh,Name),
  20                   _identifier(Identifier),
  21                   _numberOfAttribute(NumberOfAttribute),
  22                   _attributeIdentifier(AttributeIdentifier),
  23                   _attributeValue(AttributeValue),
  24                   _numberOfGroup(NumberOfGroup)
  25 {
  26   MESSAGE("FAMILY(int Identifier, string Name, int NumberOfAttribute,int *AttributeIdentifier,int *AttributeValue,string AttributeDescription,int NumberOfGroup,string GroupName, int ** Number) : "<<Identifier);
  27
  28   _attributeDescription=new string[_numberOfAttribute];
  29   for (int i=0;i<NumberOfAttribute;i++) {
  30     _attributeDescription[i].assign(AttributeDescription,i*MED_TAILLE_DESC,MED_TAILLE_DESC);
  31     _attributeDescription[i].erase(strlen(_attributeDescription[i].c_str()));
  32     //SCRUTE(_attributeDescription[i]);
  33   }
  34
  35   _groupName=new string[_numberOfGroup];
  36   for (int i=0;i<NumberOfGroup;i++) {
  37     _groupName[i].assign(GroupName,i*MED_TAILLE_LNOM,MED_TAILLE_LNOM);
  38     _groupName[i].erase(strlen(_groupName[i].c_str()));
  39     //SCRUTE(_groupName[i]);
  40   }
  41
  42   // well, we must set SUPPORT attribut
  43   _description = "FAMILY" ;
  44   // on which geometric type :
  45   bool Find = false ;
  46
  47
  48   // ************************ NODES RELATED PART *************************************************
  49   // Scan every node family number <NodeFamilyNumber[i]> in order to create
  50   // the list <tmp_NodesList> of node numbers <i+1> belonging to the family <_identifier>
  51   int NumberOfNodes         = _mesh->getNumberOfNodes();
  52   int NumberOfNodesInFamily = 0 ;
  53   int * NodeFamilyNumber    = _mesh->getMEDArrayNodeFamily() ;   // EF : TEMPORAIRE !!
  54   int * tmp_NodesList       = new int[NumberOfNodes] ;           // Un peu brutal...., oui mais ce n'est qu'un tableau de travail !
  55   for (int i=0; i<NumberOfNodes; i++)
  56     if ( _identifier == NodeFamilyNumber[i] ) {
  57       tmp_NodesList[NumberOfNodesInFamily]=i+1 ;
  58       NumberOfNodesInFamily++;
  59     }
  60
  61   // If we found nodes set the family attributes adequatly
  62   if (NumberOfNodesInFamily>0) {
  63
  64     Find = true ;
  65
  66     _entity = MED_NODE ;
  67     _numberOfGeometricType = 1 ;
  68     _geometricType = new medGeometryElement[1] ;
  69     _geometricType[0]=MED_NONE ;
  70
  71     // family on all NODE
  72     if (NumberOfNodesInFamily==NumberOfNodes)
  73       _isOnAllElts = true ;
  74     else {
  75       _isOnAllElts= false ;
  76       _numberOfEntities = new int[1] ;
  77       _numberOfEntities[0]=NumberOfNodesInFamily ;
  78       _totalNumberOfEntities=NumberOfNodesInFamily;
  79
  80       _number=new MEDSKYLINEARRAY(1,NumberOfNodesInFamily) ;
  81       int * NumberIndex = _number->getIndex();
  82       int * NumberValue = _number->getValue();
  83       NumberIndex[0]=1;                          //set the MEDSKYLINEARRAY Index table
  84       NumberIndex[1]=1+NumberOfNodesInFamily;    //set the MEDSKYLINEARRAY Index table
  85       for(int i=0; i<NumberOfNodesInFamily; i++) // OH LA LA...
  86         NumberValue[i]=tmp_NodesList[i] ;        // RESIZE de tmp_NodesList serait plus efficace !!!!!!!!
  87       // PG : pas de problème, si ca marche. Il faudra déplacer le delete !
  88     }
  89   }
  90   delete[] tmp_NodesList ;
  91
  92
  93
  94   // ************************ CELLS RELATED PART *************************************************
  95   // If we previously found nodes in our family don't scan the CELLS because a
  96   // family contains different geometic types of only one entity type.
  97   // ?? Scan every cell family number <NodeFamilyNumber[i]> in order to create
  98   // ?? the list <tmp_NodesList> of node numbers <i+1> belonging to the family <_identifier>
  99   if (!Find) {
 100
 101     // Get cell types information from <_mesh>
 102     int    numberOfCellTypes             = _mesh->getNumberOfTypes(MED_CELL) ;
 103     medGeometryElement * cellTypes       = _mesh->getTypes(MED_CELL) ;
 104
 105     int *  numberOfCellsInFamily         = new int[numberOfCellTypes] ;
 106     int    numberOfCellTypesInFamily     = 0 ;
 107
 108     medGeometryElement * tmp_CellsTypes  = new medGeometryElement[numberOfCellTypes];
 109     int ** tmp_CellsLists                = new int*[numberOfCellTypes] ;
 110     int *  GeometricTypeNumber           = new int[numberOfCellTypes] ;
 111     int ** CellFamilyNumber              = _mesh->getMEDArrayCellFamily();             // EF:  TEMPORAIRE
 112     int *  GlobalNumberingIndex          = _mesh->getGlobalNumberingIndex(MED_CELL);
 113
 114     // we search for all cell in this family
 115     for (int cellTypeNumber=0; cellTypeNumber < numberOfCellTypes; cellTypeNumber++) {
 116
 117       int NumberOfCells             = _mesh->getNumberOfElements(MED_CELL,cellTypes[cellTypeNumber]) ;
 118       int NumberOfCellsInThisFamily = 0 ;
 119       int * CellsOfThisFamilyNumber = CellFamilyNumber[cellTypeNumber];
 120       int * tmp_CellsList           = new int[NumberOfCells];
 121
 122       for (int i=0; i<NumberOfCells; i++)
 123         if (_identifier == CellsOfThisFamilyNumber[i]) {
 124           tmp_CellsList[NumberOfCellsInThisFamily]=i+GlobalNumberingIndex[cellTypeNumber] ;
 125           NumberOfCellsInThisFamily++;
 126         }
 127
 128       if (NumberOfCellsInThisFamily>0) {// we have found some cells
 129         numberOfCellsInFamily[numberOfCellTypesInFamily]=NumberOfCellsInThisFamily;
 130         int * CellsList=new int[NumberOfCellsInThisFamily] ;
 131
 132         for (int i=0;i<NumberOfCellsInThisFamily;i++)
 133           CellsList[i]=tmp_CellsList[i] ;                         // RESIZE de tmp_NodesList serait plus efficace !!!!!!!!
 134
 135         tmp_CellsLists[numberOfCellTypesInFamily]=CellsList ;
 136         tmp_CellsTypes[numberOfCellTypesInFamily]=cellTypes[cellTypeNumber];
 137         GeometricTypeNumber[numberOfCellTypesInFamily]=cellTypeNumber+1;
 138         numberOfCellTypesInFamily++;
 139       }
 140
 141       delete[] tmp_CellsList ;
 142     }
 143
 144     // we define all attribut in SUPPORT :
 145     if (numberOfCellTypesInFamily>0) { // we have found cells
 146       Find = true ;
 147       _entity = MED_CELL ;
 148       _numberOfGeometricType = numberOfCellTypesInFamily ;
 149       _geometricType = new medGeometryElement[numberOfCellTypesInFamily] ;
 150       _geometricTypeNumber = new int[numberOfCellTypesInFamily] ;
 151       _isOnAllElts = false ;
 152       _numberOfEntities = new int[numberOfCellTypesInFamily] ;
 153       _totalNumberOfEntities=0;
 154       for (int i=0; i<numberOfCellTypesInFamily; i++) {
 155         _geometricType[i]=tmp_CellsTypes[i] ;
 156         _geometricTypeNumber[i]=GeometricTypeNumber[i];
 157         _numberOfEntities[i]=numberOfCellsInFamily[i] ;
 158         _totalNumberOfEntities+=numberOfCellsInFamily[i] ;
 159       }
 160       delete[] numberOfCellsInFamily;
 161       delete[] tmp_CellsTypes;
 162       delete[] GeometricTypeNumber;
 163
 164       // family on all CELL ?
 165       if (_totalNumberOfEntities==Mesh->getNumberOfElements(MED_CELL,MED_ALL_ELEMENTS)) {
 166         _isOnAllElts = true ;
 167         delete[] _numberOfEntities ;
 168         _numberOfEntities=(int*)NULL;
 169       } else {
 170         _number=new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities);
 171         int *NumberValue=_number->getValue();
 172         int *NumberIndex=_number->getIndex();
 173         NumberIndex[0]=1;
 174         for (int i=0; i<_numberOfGeometricType; i++) {
 175           NumberIndex[i+1]=NumberIndex[i]+_numberOfEntities[i];
 176           for (int j=NumberIndex[i]; j<NumberIndex[i+1]; j++)
 177             NumberValue[j-1]=tmp_CellsLists[i][j-NumberIndex[i]];
 178           delete[] tmp_CellsLists[i];
 179         }
 180         delete[] tmp_CellsLists;
 181       }
 182     }
 183   }
 184   // on face ?
 185   if (!Find)
 186     if ((_mesh->existConnectivity(MED_NODAL,MED_FACE))|(_mesh->existConnectivity(MED_DESCENDING,MED_FACE))) {
 187       int NumberOfFacesType = _mesh->getNumberOfTypes(MED_FACE) ;
 188       medGeometryElement * FacesType = _mesh->getTypes(MED_FACE) ;
 189       int * NumberOfFacesInFamily = new int[NumberOfFacesType] ;
 190       int NumberOfFacesTypeInFamily = 0 ;
 191       medGeometryElement * tmp_FacesTypes = new medGeometryElement[NumberOfFacesType];
 192       int ** tmp_FacesLists = new int*[NumberOfFacesType] ;
 193       int * GeometricTypeNumber = new int[NumberOfFacesType] ;
 194       int ** FaceFamilyNumber = _mesh->getMEDArrayFaceFamily();
 195       int * GlobalNumberingIndex = _mesh->getGlobalNumberingIndex(MED_FACE);
 196       // we search all face in this family
 197       for (int FaceTypeNumber=0; FaceTypeNumber<NumberOfFacesType; FaceTypeNumber++) {
 198         int NumberOfThisFaces = _mesh->getNumberOfElements(MED_FACE,FacesType[FaceTypeNumber]) ;
 199         int NumberOfFacesInThisFamily = 0 ;
 200         int * FaceOfThisFamilyNumber = FaceFamilyNumber[FaceTypeNumber];
 201         int * tmp_FacesList = new int[NumberOfThisFaces];
 202         for (int i=0; i<NumberOfThisFaces; i++)
 203           if (_identifier == FaceOfThisFamilyNumber[i]) {
 204             tmp_FacesList[NumberOfFacesInThisFamily]=i+GlobalNumberingIndex[FaceTypeNumber] ;
 205             NumberOfFacesInThisFamily++;
 206
 207             SCRUTE(i);
 208             SCRUTE(NumberOfFacesInThisFamily);
 209
 210           }
 211         if (NumberOfFacesInThisFamily>0) {// we have found some faces
 212           NumberOfFacesInFamily[NumberOfFacesTypeInFamily]=NumberOfFacesInThisFamily;
 213           int * FacesList=new int[NumberOfFacesInThisFamily] ;
 214           for (int i=0;i<NumberOfFacesInThisFamily;i++)
 215             FacesList[i]=tmp_FacesList[i] ;
 216           tmp_FacesLists[NumberOfFacesTypeInFamily]=FacesList ;
 217           tmp_FacesTypes[NumberOfFacesTypeInFamily]=FacesType[FaceTypeNumber];
 218           GeometricTypeNumber[NumberOfFacesTypeInFamily]=FaceTypeNumber+1;
 219           NumberOfFacesTypeInFamily++;
 220         }
 221         delete[] tmp_FacesList ;
 222       }
 223       // we define all attribut in SUPPORT :
 224       if (NumberOfFacesTypeInFamily>0) { // we have found faces
 225         Find = true ;
 226         _entity = MED_FACE ;
 227         _numberOfGeometricType = NumberOfFacesTypeInFamily ;
 228         _geometricType = new medGeometryElement[NumberOfFacesTypeInFamily] ;
 229         _geometricTypeNumber = new int[NumberOfFacesTypeInFamily] ;
 230         _isOnAllElts = false ;
 231         _numberOfEntities = new int[NumberOfFacesTypeInFamily] ;
 232         _totalNumberOfEntities=0;
 233         for (int i=0; i<NumberOfFacesTypeInFamily; i++) {
 234           _geometricType[i]=tmp_FacesTypes[i] ;
 235           _geometricTypeNumber[i]=GeometricTypeNumber[i];
 236           _numberOfEntities[i]=NumberOfFacesInFamily[i] ;
 237           _totalNumberOfEntities+=NumberOfFacesInFamily[i] ;
 238         }
 239         delete[] NumberOfFacesInFamily;
 240         delete[] tmp_FacesTypes;
 241         delete[] GeometricTypeNumber;
 242
 243         // family on all FACE ?
 244
 245         // we suppose family is never on all face !!!!!!!!!
 246         // in all case, family is only on boundary and connectivity is partial
 247
 248 //      if (_totalNumberOfEntities==Mesh->getNumberOfElements(MED_FACE,MED_ALL_ELEMENTS)) {
 249 //        _isOnAllElts = true ;
 250 //        delete[] _numberOfEntities ;
 251 //        _numberOfEntities=(int*)NULL;
 252 //      } else {
 253           _number=new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities);
 254           int *NumberValue=_number->getValue();
 255           int *NumberIndex=_number->getIndex();
 256           NumberIndex[0]=1;
 257           for (int i=0; i<_numberOfGeometricType; i++) {
 258             NumberIndex[i+1]=NumberIndex[i]+_numberOfEntities[i];
 259             for (int j=NumberIndex[i]; j<NumberIndex[i+1]; j++)
 260               NumberValue[j-1]=tmp_FacesLists[i][j-NumberIndex[i]];
 261             delete[] tmp_FacesLists[i];
 262           }
 263           delete[] tmp_FacesLists;
 264 //      }
 265       }
 266     }
 267
 268   // on edge ?
 269   if (!Find)
 270     if ((_mesh->existConnectivity(MED_NODAL,MED_EDGE))|(_mesh->existConnectivity(MED_DESCENDING,MED_EDGE))) {
 271       int NumberOfEdgesType = _mesh->getNumberOfTypes(MED_EDGE) ;
 272       medGeometryElement * EdgesType = _mesh->getTypes(MED_EDGE) ;
 273       int * NumberOfEdgesInFamily = new int[NumberOfEdgesType] ;
 274       int NumberOfEdgesTypeInFamily = 0 ;
 275       medGeometryElement * tmp_EdgesTypes = new medGeometryElement[NumberOfEdgesType];
 276       int ** tmp_EdgesLists = new int*[NumberOfEdgesType] ;
 277       int * GeometricTypeNumber = new int[NumberOfEdgesType] ;
 278       int ** EdgeFamilyNumber = _mesh->getMEDArrayEdgeFamily();
 279       int * GlobalNumberingIndex = _mesh->getGlobalNumberingIndex(MED_EDGE);
 280       // we search all edge in this family
 281       for (int EdgeTypeNumber=0; EdgeTypeNumber<NumberOfEdgesType; EdgeTypeNumber++) {
 282         int NumberOfThisEdges = _mesh->getNumberOfElements(MED_EDGE,EdgesType[EdgeTypeNumber]) ;
 283         int NumberOfEdgesInThisFamily = 0 ;
 284         int * EdgeOfThisFamilyNumber = EdgeFamilyNumber[EdgeTypeNumber];
 285         int * tmp_EdgesList = new int[NumberOfThisEdges];
 286         for (int i=0; i<NumberOfThisEdges; i++)
 287           if (_identifier == EdgeOfThisFamilyNumber[i]) {
 288             tmp_EdgesList[NumberOfEdgesInThisFamily]=i+GlobalNumberingIndex[EdgeTypeNumber] ;
 289             NumberOfEdgesInThisFamily++;
 290           }
 291         if (NumberOfEdgesInThisFamily>0) {// we have found some edges
 292           NumberOfEdgesInFamily[NumberOfEdgesTypeInFamily]=NumberOfEdgesInThisFamily;
 293           int * EdgesList=new int[NumberOfEdgesInThisFamily] ;
 294           for (int i=0;i<NumberOfEdgesInThisFamily;i++)
 295             EdgesList[i]=tmp_EdgesList[i] ;
 296           tmp_EdgesLists[NumberOfEdgesTypeInFamily]=EdgesList ;
 297           tmp_EdgesTypes[NumberOfEdgesTypeInFamily]=EdgesType[EdgeTypeNumber];
 298           GeometricTypeNumber[NumberOfEdgesTypeInFamily]=EdgeTypeNumber+1;
 299           NumberOfEdgesTypeInFamily++;
 300         }
 301         delete[] tmp_EdgesList ;
 302       }
 303       // we define all attribut in SUPPORT :
 304       if (NumberOfEdgesTypeInFamily>0) { // we have found edges
 305         Find = true ;
 306         _entity = MED_EDGE ;
 307         _numberOfGeometricType = NumberOfEdgesTypeInFamily ;
 308         _geometricType = new medGeometryElement[NumberOfEdgesTypeInFamily] ;
 309         _geometricTypeNumber = new int[NumberOfEdgesTypeInFamily] ;
 310         _isOnAllElts = false ;
 311         _numberOfEntities = new int[NumberOfEdgesTypeInFamily] ;
 312         _totalNumberOfEntities=0;
 313         for (int i=0; i<NumberOfEdgesTypeInFamily; i++) {
 314           _geometricType[i]=tmp_EdgesTypes[i] ;
 315           _geometricTypeNumber[i]=GeometricTypeNumber[i];
 316           _numberOfEntities[i]=NumberOfEdgesInFamily[i] ;
 317           _totalNumberOfEntities+=NumberOfEdgesInFamily[i] ;
 318         }
 319         delete[] NumberOfEdgesInFamily;
 320         delete[] tmp_EdgesTypes;
 321         delete[] GeometricTypeNumber;
 322
 323         // family on all EDGE ?
 324
 325         // we suppose family is never on all edge !!!!!!!!!
 326         // in all case, family is only on boundary and connectivity is partial
 327
 328 //      if (_totalNumberOfEntities==Mesh->getNumberOfElements(MED_EDGE,MED_ALL_ELEMENTS)) {
 329 //        _isOnAllElts = true ;
 330 //        delete[] _numberOfEntities ;
 331 //        _numberOfEntities=(int*)NULL;
 332 //      } else {
 333           _number=new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities);
 334           int *NumberValue=_number->getValue();
 335           int *NumberIndex=_number->getIndex();
 336           NumberIndex[0]=1;
 337           for (int i=0; i<_numberOfGeometricType; i++) {
 338             NumberIndex[i+1]=NumberIndex[i]+_numberOfEntities[i];
 339             for (int j=NumberIndex[i]; j<NumberIndex[i+1]; j++)
 340               NumberValue[j-1]=tmp_EdgesLists[i][j-NumberIndex[i]];
 341             delete[] tmp_EdgesLists[i];
 342           }
 343           delete[] tmp_EdgesLists;
 344 //      }
 345       }
 346     }
 347   // That's all !
 348
 349   // if not find : no entity in familly !!!
 350   if (!Find) {
 351     _numberOfGeometricType = 0 ;
 352     _isOnAllElts = false ;
 353     MESSAGE ("FAMILY() : No entity found !") ;
 354   } else { // set gauss point number to be equal one !
 355     _numberOfGaussPoint = new int[_numberOfGeometricType] ;
 356     for (int i=0; i<_numberOfGeometricType; i++)
 357       _numberOfGaussPoint[i]=1 ;
 358   }
 359 };
 360
 361 FAMILY::~FAMILY()
 362 {
 363     MESSAGE("~FAMILY()");
 364     if(_attributeIdentifier!=NULL)
 365        delete[] _attributeIdentifier;
 366     if(_attributeValue!=NULL)
 367        delete[] _attributeValue;
 368     if(_attributeDescription!=NULL)
 369        delete[] _attributeDescription;
 370     if(_groupName!=NULL)
 371        delete[] _groupName;
 372 };
 373
 374 FAMILY & FAMILY::operator=(const FAMILY &fam)
 375 {
 376     MESSAGE("FAMILY::operator=");
 377     _identifier = fam._identifier;
 378     _numberOfAttribute = fam._numberOfAttribute;
 379     _attributeIdentifier = fam._attributeIdentifier;
 380     _attributeValue = fam._attributeValue;
 381     _attributeDescription = fam._attributeDescription;
 382     _numberOfGroup = fam._numberOfGroup;
 383     _groupName = fam._groupName;
 384     return *this;
 385 };