src/MEDMEM/MEDMEM_Support.cxx

   1 using namespace std;
   2 /*
   3  File Support.cxx
   4  $Header$
   5 */
   6
   7 #include <set>
   8 #include <list>
   9
  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"
  17
  18 using namespace MED_EN;
  19
  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 //--------------------------------------------------------------------------
  30 {
  31     MESSAGE("Constructeur SUPPORT sans parametre");
  32 };
  33
  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 //--------------------------------------------------------------------------
  45 {
  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 ;
  51   }
  52 };
  53
  54 //--------------------------------------------------------------------------
  55 SUPPORT::SUPPORT(SUPPORT & m)
  56 //--------------------------------------------------------------------------
  57 {
  58   const char * LOC = "SUPPORT::SUPPORT(SUPPORT & m) : " ;
  59   BEGIN_OF(LOC) ;
  60
  61   _name = m._name;
  62   _description = m._description;
  63   _mesh = m._mesh; // on recopie uniquement l'adresse
  64   _entity = m._entity;
  65   _numberOfGeometricType = m._numberOfGeometricType;
  66   if (m._geometricType != NULL)
  67     {
  68       _geometricType = new medGeometryElement[m._numberOfGeometricType];
  69       memcpy(_geometricType,m._geometricType,m._numberOfGeometricType*sizeof(medGeometryElement));
  70     }
  71   else
  72     _geometricType = (medGeometryElement *) NULL;
  73   if (m._numberOfGaussPoint != NULL)
  74     {
  75       _numberOfGaussPoint = new int[m._numberOfGeometricType];
  76       memcpy(_numberOfGaussPoint,m._numberOfGaussPoint,m._numberOfGeometricType*sizeof(int));
  77     }
  78   else
  79     _numberOfGaussPoint = (int *) NULL;
  80   if (m._geometricTypeNumber != NULL)
  81     {
  82       _geometricTypeNumber = new int[m._numberOfGeometricType];
  83       memcpy(_geometricTypeNumber,m._geometricTypeNumber,m._numberOfGeometricType*sizeof(int));
  84     }
  85   else
  86     _geometricTypeNumber = (int *) NULL;
  87   _isOnAllElts = m._isOnAllElts;
  88   if (m._numberOfEntities != NULL)
  89     {
  90       _numberOfEntities = new int[m._numberOfGeometricType];
  91       memcpy(_numberOfEntities,m._numberOfEntities,m._numberOfGeometricType*sizeof(int));
  92     }
  93   else
  94     _numberOfEntities = (int *) NULL;
  95   _totalNumberOfEntities = m._totalNumberOfEntities;
  96   if (m._isOnAllElts == false)
  97     _number = new MEDSKYLINEARRAY(* m._number);
  98   else
  99     _number = (MEDSKYLINEARRAY *) NULL;
 100
 101   END_OF(LOC) ;
 102 };
 103
 104 //-----------------
 105 SUPPORT::~SUPPORT()
 106 //-----------------
 107 {
 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 ;
 117     if (_number!=NULL)
 118                 delete _number ;
 119 }
 120
 121 //--------------------------------------------------
 122 ostream & operator<<(ostream &os, const SUPPORT &my)
 123 //--------------------------------------------------
 124 {
 125   os << "Name : "<<my._name<< endl ;
 126   os << "Description : "<< my._description << endl ;
 127   os << "Mesh name : ";
 128   if (my._mesh==NULL)
 129     os << "ERROR : Mesh not defined !" << endl ;
 130   else
 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] << " ";
 144       os << endl ;
 145     }
 146   } else
 147     os << "Is on all entities !"<< endl;
 148
 149   return os ;
 150 }
 151
 152 /*! A DOCUMENTER */
 153 //-------------------
 154 void SUPPORT::update()
 155 //-------------------
 156 {
 157   const char * LOC = "SUPPORT::update() : " ;
 158   BEGIN_OF(LOC) ;
 159
 160   if (_isOnAllElts)
 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 ;
 168     }
 169   if (_entity == MED_NODE)
 170     _totalNumberOfEntities = _mesh->getNumberOfNodes();
 171
 172   END_OF(LOC);
 173 };
 174
 175 /*! A DOCUMENTER */
 176 //-------------------
 177 void SUPPORT::blending(SUPPORT * mySupport)
 178 //-------------------
 179 {
 180   const char * LOC = "SUPPORT::blending() : " ;
 181   BEGIN_OF(LOC) ;
 182
 183   MESSAGE(LOC<< "SUPPORT entry : " << *mySupport) ;
 184
 185   // on same entity :
 186   if ( _entity != mySupport->getEntity() )
 187     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Entities are different !"));
 188
 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 ;
 194   int it=0 ;
 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;
 197     whereIsType[it]=0 ;
 198     try {
 199       tmp_NumberOfElementsInType[it]+=getNumberOfElements((medGeometryElement)(*listIt)) ;
 200       whereIsType[it]+=1 ;
 201     }
 202     catch (const MEDEXCEPTION & ex) {};
 203     try {
 204       tmp_NumberOfElementsInType[it]+=mySupport->getNumberOfElements((medGeometryElement)(*listIt)) ;
 205       whereIsType[it]+=2 ;
 206     }
 207     catch (const MEDEXCEPTION & ex) {};
 208     if (whereIsType[it]!=0) {
 209       myType[it]=(medGeometryElement)(*listIt) ;
 210       it++;
 211     }
 212   }
 213   // set new value :
 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 ;
 231       int i1 = 0 ;
 232       int i2 = 0 ;
 233       int ii = 0 ;
 234       int * number1 = getNumber(myType[i]) ;
 235       int * number2 = mySupport->getNumber(myType[i]) ;
 236
 237       SCRUTE(number1);
 238       SCRUTE(number2);
 239
 240       int numberOfElements1 = numberOfEntities[i] ;
 241       int numberOfElements2 = mySupport->getNumberOfElements(myType[i]) ;
 242
 243       SCRUTE(numberOfElements1);
 244       SCRUTE(numberOfElements2);
 245
 246       for(int j=0;j<numberOfElements1;j++){
 247         elementList.insert(number1[j]) ;
 248       }
 249
 250       for(int j=0;j<numberOfElements2;j++){
 251         SCRUTE(number2[j]);
 252         elementList.insert(number2[j]) ;
 253       }
 254
 255       //create the array !
 256       int newNumberOfEntities = elementList.size() ;
 257       _numberOfEntities[i] = newNumberOfEntities ;
 258       int * tmp_arrayNew = new int[newNumberOfEntities];
 259
 260       set<int>::iterator its ;
 261       for(its=elementList.begin();its!=elementList.end(); its++) {
 262         tmp_arrayNew[ii]=*its ;
 263         ii++;
 264       }
 265
 266       delete[] tmp_array[i] ;
 267       tmp_array[i] = tmp_arrayNew ;
 268       _totalNumberOfEntities-=(numberOfElementsInType-newNumberOfEntities) ;
 269
 270     } else
 271       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"ERROR")) ;
 272   }
 273   delete[] whereIsType ;
 274   delete[] tmp_NumberOfElementsInType ;
 275
 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] ;
 283
 284   MEDSKYLINEARRAY* numberNew = new MEDSKYLINEARRAY(it,_totalNumberOfEntities);
 285   int * numberIndex = numberNew->getIndex() ;
 286   numberIndex[0]=1;
 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] ;
 291
 292     _geometricType[i]=myType[i] ;
 293     _numberOfGaussPoint[i]=1 ;
 294     _geometricTypeNumber[i]=0 ;
 295
 296   }
 297   delete _number ;
 298   _number = numberNew ;
 299
 300   delete[] myType ;
 301   delete[] tmp_array ;
 302
 303   delete[] geometricType ;
 304   delete[] numberOfGaussPoint ;
 305   delete[] geometricTypeNumber ;
 306   delete[] numberOfEntities ;
 307
 308   END_OF(LOC);
 309 };
 310
 311 /*!
 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.
 318  */
 319
 320 //-------------------
 321 void SUPPORT::setpartial(string Description, int NumberOfGeometricType,
 322                          int TotalNumberOfEntity,
 323                          medGeometryElement *GeometricType,
 324                          int *NumberOfEntity, int *NumberValue)
 325 //-------------------
 326 {
 327   const char * LOC = "SUPPORT::setpartial(string , int , int , medGeometryElement * , int * , int *) : " ;
 328   BEGIN_OF(LOC) ;
 329
 330   _description=Description;
 331
 332   _numberOfGeometricType=NumberOfGeometricType;
 333
 334   _totalNumberOfEntities=TotalNumberOfEntity;
 335
 336   _geometricType = new medGeometryElement[NumberOfGeometricType];
 337   _geometricType = GeometricType;
 338
 339   // attributes initialised at 0 because not really useful but it has to be
 340   // allocated !! WARNING !!
 341
 342   _geometricTypeNumber = new int[NumberOfGeometricType] ;
 343   for (int i=0;i<NumberOfGeometricType;i++) _geometricTypeNumber[i] = 0;
 344
 345   //_numberOfEntities = new int[NumberOfGeometricType] ;
 346   _numberOfEntities = NumberOfEntity;
 347
 348   MEDSKYLINEARRAY * number = new MEDSKYLINEARRAY();
 349
 350   int * index = new int[_numberOfGeometricType+1];
 351   index[0]=1;
 352
 353   for (int i=0;i<_numberOfGeometricType;i++)
 354     index[i+1] = index[i]+_numberOfEntities[i] ;
 355
 356   number->setMEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities,index,NumberValue);
 357
 358   if (_number!=NULL) delete _number ;
 359   _number = number;
 360
 361   update();
 362
 363   END_OF(LOC);
 364 };