src/MEDMEM/MEDMEM_Family.cxx

   1 using namespace std;
   2 /*
   3  File MEDMEM_Family.cxx
   4  $Header$
   5 */
   6
   7 #include "MEDMEM_Mesh.hxx"
   8 #include "MEDMEM_Family.hxx"
   9
  10 FAMILY::FAMILY():_identifier(0), _numberOfAttribute(0),
  11                  _attributeIdentifier((int*)NULL),_attributeValue((int*)NULL), _attributeDescription((string*)NULL),
  12                  _numberOfGroup(0), _groupName((string*)NULL)
  13 {
  14     MESSAGE("FAMILY::FAMILY()");
  15 };
  16
  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)
  26 {
  27   MESSAGE("FAMILY(int Identifier, string Name, int NumberOfAttribute,int *AttributeIdentifier,int *AttributeValue,string AttributeDescription,int NumberOfGroup,string GroupName, int ** Number) : "<<Identifier);
  28
  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]);
  34   }
  35
  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]);
  41   }
  42
  43   // well, we must set SUPPORT attribut
  44   _description = "FAMILY" ;
  45   // on which geometric type :
  46   bool Find = false ;
  47
  48
  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++;
  60     }
  61
  62   // If we found nodes set the family attributes adequatly
  63   if (NumberOfNodesInFamily>0) {
  64
  65     Find = true ;
  66
  67     _entity = MED_NODE ;
  68     _numberOfGeometricType = 1 ;
  69     _geometricType = new medGeometryElement[1] ;
  70     _geometricType[0]=MED_NONE ;
  71
  72     // family on all NODE
  73     if (NumberOfNodesInFamily==NumberOfNodes)
  74       _isOnAllElts = true ;
  75     else {
  76       _isOnAllElts= false ;
  77       _numberOfEntities = new int[1] ;
  78       _numberOfEntities[0]=NumberOfNodesInFamily ;
  79       _totalNumberOfEntities=NumberOfNodesInFamily;
  80
  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 !
  89     }
  90   }
  91   delete[] tmp_NodesList ;
  92
  93
  94
  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>
 100   if (!Find) {
 101
 102     // Get cell types information from <_mesh>
 103     int    numberOfCellTypes             = _mesh->getNumberOfTypes(MED_CELL) ;
 104     medGeometryElement * cellTypes       = _mesh->getTypes(MED_CELL) ;
 105
 106     int *  numberOfCellsInFamily         = new int[numberOfCellTypes] ;
 107     int    numberOfCellTypesInFamily     = 0 ;
 108
 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);
 114
 115     // we search for all cell in this family
 116     for (int cellTypeNumber=0; cellTypeNumber < numberOfCellTypes; cellTypeNumber++) {
 117
 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];
 122
 123       for (int i=0; i<NumberOfCells; i++)
 124         if (_identifier == CellsOfThisFamilyNumber[i]) {
 125           tmp_CellsList[NumberOfCellsInThisFamily]=i+GlobalNumberingIndex[cellTypeNumber] ;
 126           NumberOfCellsInThisFamily++;
 127         }
 128
 129       if (NumberOfCellsInThisFamily>0) {// we have found some cells
 130         numberOfCellsInFamily[numberOfCellTypesInFamily]=NumberOfCellsInThisFamily;
 131         int * CellsList=new int[NumberOfCellsInThisFamily] ;
 132
 133         for (int i=0;i<NumberOfCellsInThisFamily;i++)
 134           CellsList[i]=tmp_CellsList[i] ;                         // RESIZE de tmp_NodesList serait plus efficace !!!!!!!!
 135
 136         tmp_CellsLists[numberOfCellTypesInFamily]=CellsList ;
 137         tmp_CellsTypes[numberOfCellTypesInFamily]=cellTypes[cellTypeNumber];
 138         GeometricTypeNumber[numberOfCellTypesInFamily]=cellTypeNumber+1;
 139         numberOfCellTypesInFamily++;
 140       }
 141
 142       delete[] tmp_CellsList ;
 143     }
 144
 145     // we define all attribut in SUPPORT :
 146     if (numberOfCellTypesInFamily>0) { // we have found cells
 147       Find = true ;
 148       _entity = MED_CELL ;
 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] ;
 160       }
 161       delete[] numberOfCellsInFamily;
 162       delete[] tmp_CellsTypes;
 163       delete[] GeometricTypeNumber;
 164
 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;
 170       } else {
 171         _number=new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities);
 172         int *NumberValue=_number->getValue();
 173         int *NumberIndex=_number->getIndex();
 174         NumberIndex[0]=1;
 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];
 180         }
 181         delete[] tmp_CellsLists;
 182       }
 183     }
 184   }
 185   // on face ?
 186   if (!Find)
 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++;
 207
 208             SCRUTE(i);
 209             SCRUTE(NumberOfFacesInThisFamily);
 210
 211           }
 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++;
 221         }
 222         delete[] tmp_FacesList ;
 223       }
 224       // we define all attribut in SUPPORT :
 225       if (NumberOfFacesTypeInFamily>0) { // we have found faces
 226         Find = true ;
 227         _entity = MED_FACE ;
 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] ;
 239         }
 240         delete[] NumberOfFacesInFamily;
 241         delete[] tmp_FacesTypes;
 242         delete[] GeometricTypeNumber;
 243
 244         // family on all FACE ?
 245
 246         // we suppose family is never on all face !!!!!!!!!
 247         // in all case, family is only on boundary and connectivity is partial
 248
 249 //      if (_totalNumberOfEntities==Mesh->getNumberOfElements(MED_FACE,MED_ALL_ELEMENTS)) {
 250 //        _isOnAllElts = true ;
 251 //        delete[] _numberOfEntities ;
 252 //        _numberOfEntities=(int*)NULL;
 253 //      } else {
 254           _number=new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities);
 255           int *NumberValue=_number->getValue();
 256           int *NumberIndex=_number->getIndex();
 257           NumberIndex[0]=1;
 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];
 263           }
 264           delete[] tmp_FacesLists;
 265 //      }
 266       }
 267     }
 268
 269   // on edge ?
 270   if (!Find)
 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++;
 291           }
 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++;
 301         }
 302         delete[] tmp_EdgesList ;
 303       }
 304       // we define all attribut in SUPPORT :
 305       if (NumberOfEdgesTypeInFamily>0) { // we have found edges
 306         Find = true ;
 307         _entity = MED_EDGE ;
 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] ;
 319         }
 320         delete[] NumberOfEdgesInFamily;
 321         delete[] tmp_EdgesTypes;
 322         delete[] GeometricTypeNumber;
 323
 324         // family on all EDGE ?
 325
 326         // we suppose family is never on all edge !!!!!!!!!
 327         // in all case, family is only on boundary and connectivity is partial
 328
 329 //      if (_totalNumberOfEntities==Mesh->getNumberOfElements(MED_EDGE,MED_ALL_ELEMENTS)) {
 330 //        _isOnAllElts = true ;
 331 //        delete[] _numberOfEntities ;
 332 //        _numberOfEntities=(int*)NULL;
 333 //      } else {
 334           _number=new MEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities);
 335           int *NumberValue=_number->getValue();
 336           int *NumberIndex=_number->getIndex();
 337           NumberIndex[0]=1;
 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];
 343           }
 344           delete[] tmp_EdgesLists;
 345 //      }
 346       }
 347     }
 348   // That's all !
 349
 350   // if not find : no entity in familly !!!
 351   if (!Find) {
 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 ;
 359   }
 360 };
 361
 362 FAMILY::FAMILY(FAMILY & m):SUPPORT(m)
 363 {
 364   _identifier = m._identifier;
 365   _numberOfAttribute = m._numberOfAttribute;
 366   if (m._attributeIdentifier != NULL)
 367     {
 368       _attributeIdentifier = new int[m._numberOfAttribute];
 369       memcpy(_attributeIdentifier,m._attributeIdentifier,m._numberOfAttribute*sizeof(int));
 370     }
 371   else
 372     _attributeIdentifier = (int *) NULL;
 373   if (m._attributeValue != NULL)
 374     {
 375       _attributeValue = new int[m._numberOfAttribute];
 376       memcpy(_attributeValue,m._attributeValue,m._numberOfAttribute*sizeof(int));
 377     }
 378   else
 379     _attributeValue = (int *) NULL;
 380   if (m._attributeDescription != NULL)
 381     {
 382       _attributeDescription = new string[m._numberOfAttribute];
 383       for (int i=0;i<m._numberOfAttribute;i++)
 384         _attributeDescription[i] = m._attributeDescription[i];
 385     }
 386   else
 387     _attributeDescription = (string *) NULL;
 388   _numberOfGroup = m._numberOfGroup;
 389   if (m._groupName != NULL)
 390     {
 391       _groupName = new string[m._numberOfGroup];
 392       for (int i=0;i<m._numberOfGroup;i++)
 393         _groupName[i]=m._groupName[i];
 394     }
 395   else
 396     _groupName = (string *) NULL;
 397 };
 398
 399 FAMILY::~FAMILY()
 400 {
 401     MESSAGE("~FAMILY()");
 402     if(_attributeIdentifier!=NULL)
 403        delete[] _attributeIdentifier;
 404     if(_attributeValue!=NULL)
 405        delete[] _attributeValue;
 406     if(_attributeDescription!=NULL)
 407        delete[] _attributeDescription;
 408     if(_groupName!=NULL)
 409        delete[] _groupName;
 410 };
 411
 412 FAMILY & FAMILY::operator=(const FAMILY &fam)
 413 {
 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;
 422     return *this;
 423 };