src/MEDMEM/MEDMEM_Support.cxx

   1 /*
   2  File Support.cxx
   3  $Header$
   4 */
   5
   6 #include <set>
   7 #include <list>
   8
   9 #include "utilities.h"
  10 #include "MEDMEM_define.hxx"
  11 #include "MEDMEM_DriversDef.hxx"
  12 #include "MEDMEM_Support.hxx"
  13 #include "MEDMEM_Family.hxx"
  14 #include "MEDMEM_Group.hxx"
  15 #include "MEDMEM_Mesh.hxx"
  16
  17 using namespace MED_EN;
  18
  19 /* This class is a generic class for family and group */
  20 //--------------------------------------------------------------------------
  21 SUPPORT::SUPPORT(): _name(""),  _description(""), _mesh((MESH*)NULL),
  22                     _entity(MED_CELL), _numberOfGeometricType(0),
  23                     _geometricType((medGeometryElement*)NULL),
  24                     _numberOfGaussPoint((int*)NULL),
  25                     _geometricTypeNumber((int*)NULL), _isOnAllElts(false),
  26                     _numberOfEntities((int*)NULL), _totalNumberOfEntities(0),
  27                     _number((MEDSKYLINEARRAY*)NULL)
  28 //--------------------------------------------------------------------------
  29 {
  30     MESSAGE("Constructeur SUPPORT sans parametre");
  31 };
  32
  33 //--------------------------------------------------------------------------
  34 SUPPORT::SUPPORT(MESH* Mesh, string Name="", medEntityMesh Entity=MED_CELL):
  35                 _name(Name), _description(""), _mesh(Mesh), _entity(Entity),
  36                 _numberOfGeometricType(0),
  37                 _geometricType((medGeometryElement*)NULL),
  38                 _numberOfGaussPoint((int*)NULL),
  39                 _geometricTypeNumber((int*)NULL),
  40                 _isOnAllElts(true), _numberOfEntities((int*)NULL),
  41                 _totalNumberOfEntities(0),
  42                 _number((MEDSKYLINEARRAY*)NULL)
  43 //--------------------------------------------------------------------------
  44 {
  45   MESSAGE("Constructeur SUPPORT avec parametres MESH* Mesh,string name,medEntityMesh Entity");
  46   if ( Entity == MED_NODE) {
  47     _numberOfGeometricType=1 ;
  48     _geometricType=new medGeometryElement[1] ;
  49     _geometricType[0]=MED_NONE ;
  50   }
  51 };
  52
  53 //-----------------
  54 SUPPORT::~SUPPORT()
  55 //-----------------
  56 {
  57     MESSAGE("Destructeur ~SUPPORT()");
  58     if (_geometricType!=NULL)
  59                 delete[] _geometricType ;
  60     if (_numberOfGaussPoint!=NULL)
  61                 delete[] _numberOfGaussPoint ;
  62     if (_geometricTypeNumber!=NULL)
  63                 delete[] _geometricTypeNumber ;
  64     if (_numberOfEntities!=NULL)
  65                 delete[] _numberOfEntities ;
  66     if (_number!=NULL)
  67                 delete _number ;
  68 }
  69
  70 //--------------------------------------------------
  71 ostream & operator<<(ostream &os, const SUPPORT &my)
  72 //--------------------------------------------------
  73 {
  74   os << "Name : "<<my._name<< endl ;
  75   os << "Description : "<< my._description << endl ;
  76   os << "Mesh name : ";
  77   if (my._mesh==NULL)
  78     os << "ERROR : Mesh not defined !" << endl ;
  79   else
  80     os << my._mesh->getName() << endl ;
  81   return os ;
  82 }
  83
  84 /*! A DOCUMENTER */
  85 //-------------------
  86 void SUPPORT::update()
  87 //-------------------
  88 {
  89   const char * LOC = "SUPPORT::update() : " ;
  90   BEGIN_OF(LOC) ;
  91
  92   if (_isOnAllElts)
  93     if (_numberOfGaussPoint==NULL) {
  94       MESSAGE( "ENTITY : "<< _entity );
  95       int NumberOfTypes = _mesh->getNumberOfTypes(_entity) ;
  96       MESSAGE( "NumberOfTypes : "<< NumberOfTypes );
  97       _numberOfGaussPoint = new int[NumberOfTypes] ;
  98       for (int i=0;i<NumberOfTypes;i++)
  99         _numberOfGaussPoint[i]=1 ;
 100     }
 101   if (_entity == MED_NODE)
 102     _totalNumberOfEntities = _mesh->getNumberOfNodes();
 103
 104   END_OF(LOC);
 105 };
 106
 107 /*! A DOCUMENTER */
 108 //-------------------
 109 void SUPPORT::blending(SUPPORT * mySupport)
 110 //-------------------
 111 {
 112   const char * LOC = "SUPPORT::blending() : " ;
 113   BEGIN_OF(LOC) ;
 114
 115   // on same entity :
 116   if ( _entity != mySupport->getEntity() )
 117     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Entities are different !"));
 118
 119   int * tmp_NumberOfElementsInType = new int[MED_NBR_GEOMETRIE_MAILLE];
 120   medGeometryElement * myType = new medGeometryElement[MED_NBR_GEOMETRIE_MAILLE];
 121   int * whereIsType = new int[MED_NBR_GEOMETRIE_MAILLE];
 122   //MESH_ENTITIES myMeshEntities() ;
 123   list<MED_FR::med_geometrie_element>::const_iterator listIt ;
 124   int it=0 ;
 125   for(listIt=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).begin();listIt!=(MED_FR::meshEntities[(MED_FR::med_entite_maillage)_entity]).end();listIt++){
 126     tmp_NumberOfElementsInType[it]=0;
 127     whereIsType[it]=0 ;
 128     try {
 129       tmp_NumberOfElementsInType[it]+=getNumberOfElements((medGeometryElement)(*listIt)) ;
 130       whereIsType[it]+=1 ;
 131     }
 132     catch (const MEDEXCEPTION & ex) {};
 133     try {
 134       tmp_NumberOfElementsInType[it]+=mySupport->getNumberOfElements((medGeometryElement)(*listIt)) ;
 135       whereIsType[it]+=2 ;
 136     }
 137     catch (const MEDEXCEPTION & ex) {};
 138     if (whereIsType[it]!=0) {
 139       myType[it]=(medGeometryElement)(*listIt) ;
 140       it++;
 141     }
 142   }
 143   // set new value :
 144   int * numberOfEntities=_numberOfEntities ;
 145   _numberOfEntities = new int[it] ;
 146   _totalNumberOfEntities = 0 ;
 147   //  int totalSize = 0 ;
 148   int ** tmp_array = new (int*)[it];
 149   for (int i=0;i<it;i++) {
 150     int numberOfElementsInType = tmp_NumberOfElementsInType[i] ;
 151     _numberOfEntities[i] = numberOfElementsInType ;
 152     tmp_array[i] = new int[numberOfElementsInType] ;
 153     //totalSize+=numberOfElementsInType*(myType[i]%100) ;
 154     _totalNumberOfEntities+=numberOfElementsInType ;
 155     if (whereIsType[i] == 1) { // only first Support
 156       memcpy(tmp_array[i],getNumber(myType[i]),sizeof(int)*numberOfElementsInType);
 157     } else if (whereIsType[i] == 2) { // only second Support
 158       memcpy(tmp_array[i],mySupport->getNumber(myType[i]),sizeof(int)*numberOfElementsInType);
 159     } else if (whereIsType[i] == 3) { // more difficult :-)
 160       set<int> elementList ;
 161       int i1 = 0 ;
 162       int i2 = 0 ;
 163       int ii = 0 ;
 164       int * number1 = getNumber(myType[i]) ;
 165       int * number2 = mySupport->getNumber(myType[i]) ;
 166
 167       int numberOfElements1 = numberOfEntities[i] ;
 168       int numberOfElements2 = mySupport->getNumberOfElements(myType[i]) ;
 169
 170       for(int j=0;j<numberOfElements1;j++){
 171         elementList.insert(number1[j]) ;
 172       }
 173
 174       for(int j=0;j<numberOfElements2;j++){
 175         elementList.insert(number2[j]) ;
 176       }
 177
 178       //create the array !
 179       int newNumberOfEntities = elementList.size() ;
 180       _numberOfEntities[i] = newNumberOfEntities ;
 181       int * tmp_arrayNew = new int[newNumberOfEntities];
 182
 183       set<int>::iterator its ;
 184       for(its=elementList.begin();its!=elementList.end(); its++) {
 185         tmp_arrayNew[ii]=*its ;
 186         ii++;
 187       }
 188
 189       delete[] tmp_array[i] ;
 190       tmp_array[i] = tmp_arrayNew ;
 191       _totalNumberOfEntities-=(numberOfElementsInType-newNumberOfEntities) ;
 192
 193     } else
 194       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"ERROR")) ;
 195   }
 196   delete[] whereIsType ;
 197   delete[] tmp_NumberOfElementsInType ;
 198
 199   _numberOfGeometricType = it ;
 200   medGeometryElement * geometricType=_geometricType ;
 201   _geometricType = new medGeometryElement[it] ;
 202   int * numberOfGaussPoint=_numberOfGaussPoint ;
 203   _numberOfGaussPoint= new int[it] ;
 204   int * geometricTypeNumber=_geometricTypeNumber ;
 205   _geometricTypeNumber = new int[it] ;
 206
 207   MEDSKYLINEARRAY* numberNew = new MEDSKYLINEARRAY(it,_totalNumberOfEntities);
 208   int * numberIndex = numberNew->getIndex() ;
 209   numberIndex[0]=1;
 210   for (int i=0;i<it;i++) {
 211     memcpy(numberNew->getI(i+1),tmp_array[i],sizeof(int)*_numberOfEntities[i]) ;
 212     delete[] tmp_array[i] ;
 213     numberIndex[i+1]=numberIndex[i]+_numberOfEntities[i] ;
 214
 215     _geometricType[i]=myType[i] ;
 216     _numberOfGaussPoint[i]=1 ;
 217     _geometricTypeNumber[i]=0 ;
 218
 219   }
 220   delete _number ;
 221   _number = numberNew ;
 222
 223   delete[] myType ;
 224   delete[] tmp_array ;
 225
 226   delete[] geometricType ;
 227   delete[] numberOfGaussPoint ;
 228   delete[] geometricTypeNumber ;
 229   delete[] numberOfEntities ;
 230
 231   END_OF(LOC);
 232 };
 233
 234 /*!
 235     This function allows the user to set a support not on all entities Entity,
 236     it should be used after an initialisation with the constructor
 237     SUPPORT(MESH* Mesh, string Name="", medEntityMesh Entity=MED_CELL) and
 238     after the call to the function setAll(false).
 239     It allocates and initialises all the attributs of the class SUPPORT.;
 240     useful for the Python API.
 241  */
 242
 243 //-------------------
 244 void SUPPORT::setpartial(string Description, int NumberOfGeometricType,
 245                          int TotalNumberOfEntity,
 246                          medGeometryElement *GeometricType,
 247                          int *NumberOfEntity, int *NumberValue)
 248 //-------------------
 249 {
 250   const char * LOC = "SUPPORT::setpartial(string , int , int , medGeometryElement * , int * , int *) : " ;
 251   BEGIN_OF(LOC) ;
 252
 253   _description=Description;
 254
 255   _numberOfGeometricType=NumberOfGeometricType;
 256
 257   _totalNumberOfEntities=TotalNumberOfEntity;
 258
 259   _geometricType = new medGeometryElement[NumberOfGeometricType];
 260   _geometricType = GeometricType;
 261
 262   // attributes initialised at 0 because not really useful but it has to be
 263   // allocated !! WARNING !!
 264
 265   _geometricTypeNumber = new int[NumberOfGeometricType] ;
 266   for (int i=0;i<NumberOfGeometricType;i++) _geometricTypeNumber[i] = 0;
 267
 268   //_numberOfEntities = new int[NumberOfGeometricType] ;
 269   _numberOfEntities = NumberOfEntity;
 270
 271   MEDSKYLINEARRAY * number = new MEDSKYLINEARRAY();
 272
 273   int * index = new int[_numberOfGeometricType+1];
 274   index[0]=1;
 275
 276   for (int i=0;i<_numberOfGeometricType;i++)
 277     index[i+1] = index[i]+_numberOfEntities[i] ;
 278
 279   number->setMEDSKYLINEARRAY(_numberOfGeometricType,_totalNumberOfEntities,index,NumberValue);
 280
 281   if (_number!=NULL) delete _number ;
 282   _number = number;
 283
 284   update();
 285
 286   END_OF(LOC);
 287 };