src/MEDMEM/MEDMEM_Group.cxx

   1 using namespace std;
   2 /*
   3  File Group.cxx
   4  $Header$
   5 */
   6 #include <list>
   7
   8 #include "MEDMEM_Group.hxx"
   9 #include "MEDMEM_Family.hxx"
  10 using namespace MEDMEM;
  11
  12 GROUP::GROUP():_numberOfFamilies(0),_family()
  13 {
  14   MESSAGE("GROUP()");
  15 };
  16
  17 GROUP::~GROUP()
  18 {
  19   MESSAGE("~GROUP()");
  20 };
  21
  22 GROUP & GROUP::operator=(const GROUP &group)
  23 {
  24   MESSAGE("GROUP::operator=");
  25   _numberOfFamilies = group._numberOfFamilies ;
  26   _family           = group._family ;
  27   return *this;
  28 };
  29
  30 ostream & MEDMEM::operator<<(ostream &os, GROUP &myGroup)
  31 {
  32   os << (SUPPORT) myGroup;
  33
  34   int numberoffamilies = myGroup.getNumberOfFamilies();
  35   os << "  - Families ("<<numberoffamilies<<") :"<<endl;
  36   for (int j=1;j<numberoffamilies+1;j++)
  37     os << "    * "<<myGroup.getFamily(j)->getName().c_str()<<endl ;
  38
  39   return os;
  40 };
  41
  42 GROUP::GROUP(const string & name, const list<FAMILY*> & families) throw (MEDEXCEPTION)
  43 {
  44   const char * LOC = "GROUP( const string & , const list<FAMILY*> & ) : " ;
  45
  46   BEGIN_OF(LOC);
  47
  48   MESSAGE(LOC<<name);
  49
  50   int numberOfFamilies = families.size();
  51   _name = name ;
  52   _description = "GROUP";
  53   // description : none !
  54   // first FAMILY to set all !
  55   FAMILY * myFamily = families.front() ;
  56   _mesh =  myFamily->getMesh() ;
  57   _entity = myFamily->getEntity() ;
  58   bool isOnAllElts = myFamily->isOnAllElements() ;
  59
  60   SCRUTE(isOnAllElts);
  61   SCRUTE(numberOfFamilies);
  62
  63
  64   if ((numberOfFamilies==1)&(isOnAllElts))
  65     {
  66       _numberOfFamilies = numberOfFamilies;
  67       _isOnAllElts = isOnAllElts ;
  68       _family.resize(_numberOfFamilies) ;
  69       _family[0] = myFamily;
  70       update();
  71       return;
  72     }
  73   else if ((!(numberOfFamilies==1))&(isOnAllElts))
  74     throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << "building of a GROUP object from several FAMILY, and one of them is on all entities"  )) ;
  75
  76   _numberOfGeometricType = myFamily->getNumberOfTypes() ;
  77   _geometricType = new medGeometryElement[_numberOfGeometricType];
  78   //_geometricTypeNumber = new int[_numberOfGeometricType] ;
  79   _numberOfGaussPoint = new int[_numberOfGeometricType] ;
  80   _numberOfElements = new int[_numberOfGeometricType] ;
  81   const medGeometryElement * geometricType = myFamily->getTypes() ;
  82   //int * geometricTypeNumber = myFamily->getGeometricTypeNumber() ;
  83   const int * numberOfGaussPoint = myFamily->getNumberOfGaussPoint() ;
  84
  85   SCRUTE(_numberOfGeometricType);
  86
  87   for (int i=0 ; i<_numberOfGeometricType; i++) {
  88     _geometricType[i]= geometricType[i] ;
  89     // _geometricTypeNumber[i] = geometricTypeNumber[i] ;
  90     _numberOfGaussPoint[i] = numberOfGaussPoint[i] ;
  91     _numberOfElements[i]=myFamily->getNumberOfElements(geometricType[i]);
  92     MESSAGE(LOC << " Type : " << _geometricType[i] << " number of element(s) " << _numberOfElements[i]);
  93   }
  94   _isOnAllElts = false ;
  95   //_totalNumberOfEntities = myFamily->getNumberOfElements(MED_ALL_ELEMENTS) ;
  96
  97
  98   MEDSKYLINEARRAY * famNumber = myFamily->getnumber();
  99
 100   const int * famNumberValue = myFamily->getNumber(MED_ALL_ELEMENTS);
 101
 102   const int * famNumberIndex = myFamily->getNumberIndex();
 103
 104   int famNumberCount = famNumber->getNumberOf();
 105   int famNumberLength = famNumber->getLength();
 106
 107   SCRUTE(famNumber);
 108   SCRUTE(famNumberCount);
 109   SCRUTE(famNumberLength);
 110   SCRUTE(famNumberValue);
 111   SCRUTE(famNumberIndex);
 112
 113 //   _number = new MEDSKYLINEARRAY(*famNumber) ;
 114   _number = new MEDSKYLINEARRAY(famNumberCount,famNumberLength,
 115                                 famNumberIndex,famNumberValue) ;
 116
 117   SCRUTE(_number);
 118
 119   _numberOfFamilies = families.size();
 120
 121   SCRUTE(numberOfFamilies);
 122
 123   //SCRUTE(_numberOfFamilies);
 124
 125   _family.resize(_numberOfFamilies) ;
 126   list<FAMILY*>::const_iterator li ;
 127
 128   // MESSAGE(LOC<<"Printing of the object GROUP built right before the blending"<< (SUPPORT) *this);
 129
 130
 131   int it = 0 ;
 132   for (li=families.begin();li!=families.end();li++) {
 133     blending(*li);
 134     _family[it] = (*li) ;
 135     it++ ;
 136   }
 137
 138   //MESSAGE(LOC<<"Printing of the object GROUP built "<< (GROUP)*this);
 139
 140   END_OF(LOC);
 141 };
 142
 143 GROUP::GROUP(const GROUP & m):SUPPORT(m)
 144 {
 145   _numberOfFamilies = m._numberOfFamilies;
 146   _family = m._family;
 147 };
 148
 149 // void GROUP::init(const list<FAMILY*> & families)
 150 // {
 151 //   const char * LOC = "GROUP::init( const list<FAMILY*> & ) : " ;
 152
 153 //   BEGIN_OF(LOC);
 154
 155 //   FAMILY * myFamily = families.front() ;
 156 //   _mesh =  myFamily->getMesh() ;
 157
 158 //   _isOnAllElts = myFamily->isOnAllElements() ;
 159
 160 //   SCRUTE(_mesh);
 161
 162 //   SCRUTE(_isOnAllElts);
 163
 164 //   _entity = myFamily->getEntity() ;
 165
 166 //   SCRUTE(_mesh->getNumberOfTypes(_entity));
 167
 168 //   _numberOfGeometricType = myFamily->getNumberOfTypes() ;
 169 //   _geometricType = new medGeometryElement[_numberOfGeometricType];
 170 //   //_geometricTypeNumber = new int[_numberOfGeometricType] ;
 171 //   _numberOfGaussPoint = new int[_numberOfGeometricType] ;
 172 //   _numberOfElements = new int[_numberOfGeometricType] ;
 173 //   medGeometryElement * geometricType = myFamily->getTypes() ;
 174 //   //int * geometricTypeNumber = myFamily->getGeometricTypeNumber() ;
 175 //   int * numberOfGaussPoint = myFamily->getNumberOfGaussPoint() ;
 176 //   for (int i=0 ; i<_numberOfGeometricType; i++) {
 177 //     _geometricType[i]= geometricType[i] ;
 178 //     // _geometricTypeNumber[i] = geometricTypeNumber[i] ;
 179 //     _numberOfGaussPoint[i] = numberOfGaussPoint[i] ;
 180 //     _numberOfElements[i]=myFamily->getNumberOfElements(geometricType[i]);
 181 //   }
 182 //   _isOnAllElts = false ;
 183 //   _totalNumberOfEntities = myFamily->getNumberOfElements(MED_ALL_ELEMENTS) ;
 184 //   _number = new MEDSKYLINEARRAY(*myFamily->getnumber()) ;
 185
 186 //   _numberOfFamilies = families.size();
 187 //   _family.resize(_numberOfFamilies) ;
 188 //   list<FAMILY*>::const_iterator liIni = families.begin() ;
 189 //   _family[0]=(*liIni);
 190 //   liIni++;
 191 //   list<FAMILY*>::const_iterator li ;
 192 //   int it = 1 ;
 193 //   for (li=liIni;li!=families.end();li++) {
 194 //     blending(*li);
 195 //     _family[it] = (*li) ;
 196 //     it++ ;
 197 //   }
 198
 199 //   END_OF(LOC);
 200 // };
 201