src/MEDMEM/MEDMEM_MedFieldDriver21.hxx

   1 #ifndef MED_FIELD_DRIVER21_HXX
   2 #define MED_FIELD_DRIVER21_HXX
   3
   4 #include <string>
   5
   6 #include "MEDMEM_define.hxx"
   7
   8 #include "MEDMEM_GenDriver.hxx"
   9 #include "utilities.h"
  10 #include "MEDMEM_MedFieldDriver.hxx"
  11 #include "MEDMEM_STRING.hxx"
  12 #include "MEDMEM_Exception.hxx"
  13 #include "MEDMEM_Unit.hxx"
  14 #include "MEDMEM_Array.hxx"
  15 #include "MEDMEM_Support.hxx"
  16 #include "MEDMEM_Mesh.hxx"
  17
  18 namespace MEDMEM {
  19 template <class T> class FIELD;
  20
  21 // A QD LA CLASSE MED_ALL_ELEMENTS_DRIVER.... :) pour mutualiser le open ..... avec led _medIdt...
  22
  23 /*!
  24
  25   Driver Med for FIELD.
  26
  27   Generic part : implement open and close methods.
  28
  29 */
  30
  31 template <class T> class MED_FIELD_DRIVER21 : public virtual MED_FIELD_DRIVER<T>
  32 {
  33 protected:
  34   med_2_1::med_idt        _medIdt;
  35
  36   void search_field() ;
  37 public :
  38
  39   // all MED cell type ?? Classe de Définition ??
  40   //   static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
  41
  42   //   static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
  43
  44   /*!
  45     Constructor.
  46   */
  47   MED_FIELD_DRIVER21():MED_FIELD_DRIVER<T>(),_medIdt(MED_INVALID)
  48   {}
  49   /*!
  50     Constructor.
  51   */
  52   MED_FIELD_DRIVER21(const string & fileName, FIELD<T> * ptrField,
  53                      MED_EN::med_mode_acces accessMode)
  54     : MED_FIELD_DRIVER<T>(fileName,ptrField,accessMode),_medIdt(MED_INVALID)
  55   {
  56   }
  57
  58   /*!
  59     Copy constructor.
  60   */
  61   MED_FIELD_DRIVER21(const MED_FIELD_DRIVER21 & fieldDriver):
  62     MED_FIELD_DRIVER<T>(fieldDriver), _medIdt(fieldDriver._medIdt)
  63   {
  64   }
  65
  66   /*!
  67     Destructor.
  68   */
  69   virtual ~MED_FIELD_DRIVER21() {
  70   }
  71
  72   void open() throw (MEDEXCEPTION)
  73   {
  74     const char * LOC = "MED_FIELD_DRIVER21::open() ";
  75     BEGIN_OF(LOC);
  76
  77     // we must set fieldname before open, because we must find field number in file (if it exist !!!)
  78     if ( MED_FIELD_DRIVER<T>::_fileName == "" )
  79       throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
  80                                        << "_fileName is |\"\"|, please set a correct fileName before calling open()"
  81                                        )
  82                             );
  83
  84     MESSAGE(LOC<<"_fileName.c_str : "<< MED_FIELD_DRIVER<T>::_fileName.c_str()<<",mode : "<< MED_FIELD_DRIVER<T>::_accessMode);
  85     _medIdt = med_2_1::MEDouvrir( (const_cast <char *> (MED_FIELD_DRIVER<T>::_fileName.c_str())),(med_2_1::med_mode_acces) MED_FIELD_DRIVER<T>::_accessMode);
  86     MESSAGE(LOC<<"_medIdt : "<< _medIdt );
  87     if (_medIdt > 0)
  88       MED_FIELD_DRIVER<T>::_status=MED_OPENED;
  89     else {
  90       MED_FIELD_DRIVER<T>::_status = MED_INVALID;
  91       MED_FIELD_DRIVER21<T>::_medIdt = MED_INVALID;
  92       throw MED_EXCEPTION (LOCALIZED( STRING(LOC)
  93                                       << "Can't open |"  << MED_FIELD_DRIVER<T>::_fileName
  94                                       << "|, _medIdt : " << MED_FIELD_DRIVER21<T>::_medIdt
  95                                       )
  96                            );
  97     }
  98
  99     END_OF(LOC);
 100   }
 101
 102   void close() {
 103     BEGIN_OF("MED_FIELD_DRIVER21::close()");
 104     med_2_1::med_int err = 0;
 105     if (MED_FIELD_DRIVER<T>::_status == MED_OPENED) {
 106       err=med_2_1::MEDfermer(MED_FIELD_DRIVER21<T>::_medIdt);
 107       //H5close(); // If we call H5close() all the files are closed.
 108       MED_FIELD_DRIVER<T>::_status = MED_CLOSED;
 109       MED_FIELD_DRIVER21<T>::_medIdt = MED_INVALID;
 110       MESSAGE(" MED_FIELD_DRIVER21::close() : MEDfermer : MED_FIELD_DRIVER<T>::_medIdt= " << _medIdt );
 111       MESSAGE(" MED_FIELD_DRIVER21::close() : MEDfermer : err    = " << err );
 112     }
 113     END_OF("MED_FIELD_DRIVER21::close()");
 114   }
 115
 116
 117 };
 118
 119 /*!
 120
 121   Driver Med for FIELD : Read only.
 122
 123   Implement read method.
 124
 125 */
 126
 127   template <class T> class MED_FIELD_RDONLY_DRIVER21 : public virtual MED_FIELD_DRIVER21<T>, public virtual IMED_FIELD_RDONLY_DRIVER<T>
 128 {
 129
 130 public :
 131
 132   /*!
 133     Constructor.
 134   */
 135   MED_FIELD_RDONLY_DRIVER21():MED_FIELD_DRIVER<T>() {};
 136
 137   /*!
 138     Constructor.
 139   */
 140   MED_FIELD_RDONLY_DRIVER21(const string & fileName,  FIELD<T> * ptrField):
 141     IMED_FIELD_RDONLY_DRIVER<T>(fileName,ptrField),
 142     MED_FIELD_DRIVER21<T>(fileName,ptrField,MED_EN::MED_RDONLY),
 143     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_RDONLY)
 144   {
 145     BEGIN_OF("MED_FIELD_RDONLY_DRIVER21::MED_FIELD_RDONLY_DRIVER21(const string & fileName, const FIELD<T> * ptrField)");
 146     END_OF("MED_FIELD_RDONLY_DRIVER21::MED_FIELD_RDONLY_DRIVER21(const string & fileName, const FIELD<T> * ptrField)");
 147   }
 148
 149   /*!
 150     Copy constructor.
 151   */
 152   MED_FIELD_RDONLY_DRIVER21(const MED_FIELD_RDONLY_DRIVER21 & fieldDriver):
 153     IMED_FIELD_RDONLY_DRIVER<T>(fieldDriver),
 154     MED_FIELD_DRIVER21<T>(fieldDriver),
 155     MED_FIELD_DRIVER<T>(fieldDriver)
 156   {};
 157
 158   /*!
 159     Destructor.
 160   */
 161   virtual ~MED_FIELD_RDONLY_DRIVER21() {};
 162
 163   // CREER UNE METHODE POUR LIRE LA LISTE DES MAILLAGES .....
 164
 165   /*!
 166     Return a MEDEXCEPTION : it is the read-only driver.
 167   */
 168   void write( void ) const throw (MEDEXCEPTION) ;
 169   /*!
 170     Read FIELD in the specified file.
 171   */
 172   void read ( void ) throw (MEDEXCEPTION) ;
 173
 174 private:
 175   GENDRIVER * copy( void ) const ;
 176
 177 };
 178
 179 /*!
 180
 181   Driver Med for FIELD : Write only.
 182
 183   Implement write method.
 184
 185 */
 186
 187 template <class T> class MED_FIELD_WRONLY_DRIVER21 : public virtual MED_FIELD_DRIVER21<T>, public virtual IMED_FIELD_WRONLY_DRIVER<T> {
 188
 189 public :
 190
 191   /*!
 192     Constructor.
 193   */
 194   MED_FIELD_WRONLY_DRIVER21():MED_FIELD_DRIVER<T>() {}
 195
 196   /*!
 197     Constructor.
 198   */
 199   MED_FIELD_WRONLY_DRIVER21(const string & fileName, FIELD<T> * ptrField):
 200     IMED_FIELD_WRONLY_DRIVER<T>(fileName,ptrField),
 201     MED_FIELD_DRIVER21<T>(fileName,ptrField,MED_EN::MED_WRONLY),
 202     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_WRONLY)
 203   {
 204     BEGIN_OF("MED_FIELD_WRONLY_DRIVER21::MED_FIELD_WRONLY_DRIVER21(const string & fileName, const FIELD<T> * ptrField)");
 205     END_OF("MED_FIELD_WRONLY_DRIVER21::MED_FIELD_WRONLY_DRIVER21(const string & fileName, const FIELD<T> * ptrField)");
 206   }
 207
 208   /*!
 209     Copy constructor.
 210   */
 211   MED_FIELD_WRONLY_DRIVER21(const MED_FIELD_WRONLY_DRIVER21 & fieldDriver):
 212     IMED_FIELD_WRONLY_DRIVER<T>(fieldDriver),
 213     MED_FIELD_DRIVER21<T>(fieldDriver),
 214     MED_FIELD_DRIVER<T>(fieldDriver)
 215   {}
 216
 217   /*!
 218     Destructor.
 219   */
 220   virtual ~MED_FIELD_WRONLY_DRIVER21() {};
 221
 222   /*!
 223     Write FIELD in the specified file.
 224   */
 225   void write( void ) const throw (MEDEXCEPTION) ;
 226   /*!
 227     Return a MEDEXCEPTION : it is the write-only driver.
 228   */
 229   void read ( void ) throw (MEDEXCEPTION) ;
 230
 231 private:
 232   GENDRIVER * copy( void ) const ;
 233
 234 };
 235
 236
 237 /*!
 238
 239   Driver Med for FIELD : Read write.
 240   - Use read method from MED_FIELD_RDONLY_DRIVER
 241   - Use write method from MED_FIELD_WDONLY_DRIVER
 242
 243 */
 244
 245 template <class T> class MED_FIELD_RDWR_DRIVER21 : public MED_FIELD_RDONLY_DRIVER21<T>, public MED_FIELD_WRONLY_DRIVER21<T>, public IMED_FIELD_RDWR_DRIVER<T> {
 246
 247 public :
 248
 249   /*!
 250     Constructor.
 251   */
 252   MED_FIELD_RDWR_DRIVER21():MED_FIELD_DRIVER21<T>() {}
 253
 254   /*!
 255     Constructor.
 256   */
 257   MED_FIELD_RDWR_DRIVER21(const string & fileName, FIELD<T> * ptrField):
 258     MED_FIELD_WRONLY_DRIVER21<T>(fileName,ptrField),
 259     MED_FIELD_RDONLY_DRIVER21<T>(fileName,ptrField),
 260     IMED_FIELD_RDONLY_DRIVER<T>(fileName,ptrField),
 261     IMED_FIELD_WRONLY_DRIVER<T>(fileName,ptrField),
 262     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_RDWR),
 263     IMED_FIELD_RDWR_DRIVER<T>(fileName,ptrField)
 264   {
 265     BEGIN_OF("MED_FIELD_RDWR_DRIVER21::MED_FIELD_RDWR_DRIVER21(const string & fileName, const FIELD<T> * ptrField)");
 266     //_accessMode = MED_RDWR ;
 267     END_OF("MED_FIELD_RDWR_DRIVER21::MED_FIELD_RDWR_DRIVER21(const string & fileName, const FIELD<T> * ptrField)");
 268   };
 269
 270   /*!
 271     Copy constructor.
 272   */
 273   MED_FIELD_RDWR_DRIVER21(const MED_FIELD_RDWR_DRIVER21 & fieldDriver):
 274     MED_FIELD_WRONLY_DRIVER21<T>(fieldDriver),
 275     MED_FIELD_RDONLY_DRIVER21<T>(fieldDriver),
 276     IMED_FIELD_RDWR_DRIVER<T>(fieldDriver),
 277     IMED_FIELD_RDONLY_DRIVER<T>(fieldDriver),
 278     IMED_FIELD_WRONLY_DRIVER<T>(fieldDriver),
 279     MED_FIELD_DRIVER<T>(fieldDriver)
 280   {};
 281
 282   /*!
 283     Destructor.
 284   */
 285   ~MED_FIELD_RDWR_DRIVER21() {};
 286
 287   /*!
 288     Write FIELD in the specified file.
 289   */
 290   void write(void) const throw (MEDEXCEPTION) ;
 291   /*!
 292     Read FIELD in the specified file.
 293   */
 294   void read (void) throw (MEDEXCEPTION) ;
 295
 296 private:
 297   GENDRIVER * copy( void ) const ;
 298
 299 };
 300
 301 /*--------------------- DRIVER PART -------------------------------*/
 302
 303 //  template <class T> void MED_FIELD_DRIVER<T>::search_field() {
 304 //    const char * LOC = "template <class T> class MED_FIELD_DRIVER::search_field() :";
 305
 306 //    // we search the field number !!!!
 307 //    if (_status==MED_OPENED)
 308 //      if (_fieldNum==MED_INVALID) {
 309 //        int err ;
 310 //        int    numberOfFields              = 0;      //MED_INVALID
 311 //        //    char   fieldName[MED_TAILLE_NOM+1] = "";
 312 //        char   fieldName[MED_TAILLE_NOM+1] ;
 313 //        int    numberOfComponents          = 0;
 314 //        char * componentName               = (char *) MED_NULL;
 315 //        char * unitName                    = (char *) MED_NULL;
 316 //        med_2_1::med_type_champ type ;
 317 //        numberOfFields = med_2_1::MEDnChamp(_medIdt,0) ;
 318 //        if ( numberOfFields <= 0 )
 319 //      throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
 320 //        for (int i=1;i<=numberOfFields;i++) {
 321
 322 //      numberOfComponents = med_2_1::MEDnChamp(_medIdt,i) ;
 323 //      if ( numberOfComponents <= 0 )
 324 //        throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 325 //                                         <<  "Be careful there is no compound for field n°"
 326 //                                         << i << "in file |"<<_fileName<<"| !"));
 327
 328 //      componentName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
 329 //      unitName      = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
 330
 331 //      err = med_2_1::MEDchampInfo(_medIdt, i, fieldName, &type, componentName,
 332 //                                 unitName, numberOfComponents) ;
 333
 334 //      delete[] componentName ;
 335 //      delete[] unitName ;
 336 //      MESSAGE("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<_fieldName.c_str()<<"#");
 337 //      if ( !strcmp(fieldName,_fieldName.c_str()) ) {
 338 //        MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
 339 //        _fieldNum = i ;
 340 //        break ;
 341 //      }
 342 //        }
 343 //      }Srdwr
 344 //  }
 345
 346 /*--------------------- RDONLY PART -------------------------------*/
 347
 348 template <class T> GENDRIVER * MED_FIELD_RDONLY_DRIVER21<T>::copy(void) const
 349 {
 350   return new MED_FIELD_RDONLY_DRIVER21<T>(*this);
 351 }
 352
 353 template <class T> void MED_FIELD_RDONLY_DRIVER21<T>::read(void)
 354   throw (MEDEXCEPTION)
 355 {
 356   const char * LOC = " MED_FIELD_RDONLY_DRIVER21::read() " ;
 357   BEGIN_OF(LOC);
 358
 359   if (MED_FIELD_DRIVER<T>::_ptrField->_name=="")
 360     MED_FIELD_DRIVER<T>::_ptrField->_name = MED_FIELD_DRIVER<T>::_fieldName ;
 361   else
 362     MED_FIELD_DRIVER<T>::_fieldName = MED_FIELD_DRIVER<T>::_ptrField->_name; // bug indetermine ! apres avoir fait readfilestruct, lorsque je recupere le champ, tout est bon sauf le nom du champ dans le driver !!!!!
 363
 364   MESSAGE("###### "<<LOC<<" fieldNameDRIVER : "<<MED_FIELD_DRIVER<T>::_fieldName<<" fieldName : "<<MED_FIELD_DRIVER<T>::_ptrField->_name);
 365
 366   string MeshName =  MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getMesh()->getName() ;
 367
 368   if (MED_FIELD_DRIVER<T>::_status==MED_OPENED)
 369     {
 370
 371       //        search_field() ;
 372
 373       char *  fieldName ;
 374       fieldName = new char[MED_TAILLE_NOM+1] ;
 375       int err ;
 376       int    numberOfComponents          = 0;
 377       char * componentName               = (char *) MED_NULL;
 378       char * unitName                    = (char *) MED_NULL;
 379       med_2_1::med_type_champ type ;
 380
 381       // we search the field number !!!!
 382       if (MED_FIELD_DRIVER<T>::_fieldNum==MED_INVALID) {
 383         int    numberOfFields              = 0;      //MED_INVALID
 384         numberOfFields = med_2_1::MEDnChamp(MED_FIELD_DRIVER21<T>::_medIdt,0) ;
 385         if ( numberOfFields <= 0 )
 386           throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
 387         for (int i=1;i<=numberOfFields;i++) {
 388
 389           numberOfComponents = med_2_1::MEDnChamp(MED_FIELD_DRIVER21<T>::_medIdt,i) ;
 390           if ( numberOfComponents <= 0 )
 391             //                throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 392             //                                                 <<  "Be careful there is no compound for field n°"
 393             //                                                 << i << "in file |"<<_fileName<<"| !"));
 394             MESSAGE(LOC<<"Be careful there is no compound for field n°"<<i<<"in file |"<<MED_FIELD_DRIVER<T>::_fileName<<"| !");
 395
 396           componentName = new char[numberOfComponents*MED_TAILLE_PNOM21+1] ;
 397           unitName      = new char[numberOfComponents*MED_TAILLE_PNOM21+1] ;
 398
 399           err = med_2_1::MEDchampInfo(MED_FIELD_DRIVER21<T>::_medIdt, i, fieldName, &type, componentName,
 400                                      unitName, numberOfComponents) ;
 401
 402           MESSAGE("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<MED_FIELD_DRIVER<T>::_fieldName.c_str()<<"#");
 403           if ( !strcmp(fieldName,MED_FIELD_DRIVER<T>::_fieldName.c_str()) ) {
 404             MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
 405             MED_FIELD_DRIVER<T>::_fieldNum = i ;
 406             break ;
 407           }
 408           // not found : release memory and search next field !
 409           delete[] componentName ;
 410           delete[] unitName ;
 411         }
 412       }
 413
 414       delete[] fieldName ;
 415
 416       if (MED_FIELD_DRIVER<T>::_fieldNum==MED_INVALID)
 417         throw MEDEXCEPTION(LOCALIZED( STRING(LOC) << ": Field "<<MED_FIELD_DRIVER<T>::_fieldName << " not found in file " << MED_FIELD_DRIVER<T>::_fileName ) );
 418       MESSAGE ("FieldNum : "<<MED_FIELD_DRIVER<T>::_fieldNum);
 419
 420       //        int err ;
 421       //        int NumberOfComponents = med_2_1::MEDnChamp(MED_FIELD_DRIVER21<T>::_medIdt,MED_FIELD_DRIVER<T>::_fieldNum) ;
 422       if (numberOfComponents < 1)
 423         throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"no component")) ; // use iostring !
 424       // test type to check if it is rigth !!!???
 425       MED_FIELD_DRIVER<T>::_ptrField->_numberOfComponents = numberOfComponents ;
 426       MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes = new int[numberOfComponents] ;
 427       MED_FIELD_DRIVER<T>::_ptrField->_componentsNames = new string[numberOfComponents] ;
 428       MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits = new UNIT[numberOfComponents] ;
 429       MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions = new string[numberOfComponents] ;
 430       MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits = new string[numberOfComponents] ;
 431       for (int i=0; i<numberOfComponents; i++) {
 432         MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes[i] = 1 ;
 433
 434         // PG : what about space !!!
 435         MED_FIELD_DRIVER<T>::_ptrField->_componentsNames[i] = string(componentName,i*MED_TAILLE_PNOM21,MED_TAILLE_PNOM21) ;
 436         SCRUTE(MED_FIELD_DRIVER<T>::_ptrField->_componentsNames[i]);
 437         MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits[i] = string(unitName,i*MED_TAILLE_PNOM21,MED_TAILLE_PNOM21) ;
 438         SCRUTE(MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits[i]);
 439       }
 440       delete[] componentName;
 441       delete[] unitName;
 442
 443       // read values for each geometric type in _support
 444       int NumberOfTypes = MED_FIELD_DRIVER<T>::_ptrField->_support->getNumberOfTypes() ;
 445       const MED_EN::medGeometryElement *Types = MED_FIELD_DRIVER<T>::_ptrField->_support->getTypes() ;
 446       T ** myValues = new T*[NumberOfTypes] ;
 447       int * NumberOfValues = new int[NumberOfTypes] ;
 448       int TotalNumberOfValues = 0 ;
 449       MESSAGE ("NumberOfTypes :"<< NumberOfTypes);
 450       MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues=0 ;
 451       for (int i=0; i<NumberOfTypes; i++) {
 452         MESSAGE ("Type["<<i+1<<"] :"<< Types[i]);
 453         MESSAGE ("Entity :"<<MED_FIELD_DRIVER<T>::_ptrField->_support->getEntity());
 454         NumberOfValues[i] =
 455           MEDnVal(MED_FIELD_DRIVER21<T>::_medIdt,
 456                   const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
 457                   (med_2_1::med_entite_maillage)MED_FIELD_DRIVER<T>::_ptrField->_support->getEntity(),
 458                   (med_2_1::med_geometrie_element)Types[i],
 459                   MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber,
 460                   MED_FIELD_DRIVER<T>::_ptrField->_orderNumber) ; // no time step ! prend en compte le nbre de pt de gauss
 461         // test if NumberOfValues is the same in _support !!! TODO that !!
 462         // we suppose it is
 463         // we could allocate array
 464         myValues[i] = new T[ NumberOfValues[i]*numberOfComponents ] ;
 465         TotalNumberOfValues+=NumberOfValues[i] ;// diviser par le nombre de point de gauss
 466         char * ProfilName = new char[MED_TAILLE_NOM+1];
 467         MESSAGE ("NumberOfValues :"<< NumberOfValues[i]);
 468         MESSAGE ("NumberOfComponents :"<< numberOfComponents);
 469         MESSAGE ("MESH_NAME :"<< MeshName.c_str());
 470         MESSAGE ("FIELD_NAME :"<< MED_FIELD_DRIVER<T>::_fieldName.c_str());
 471         MESSAGE ("MED_ENTITE :"<< (med_2_1::med_entite_maillage) MED_FIELD_DRIVER<T>::_ptrField->_support->getEntity());
 472         MESSAGE("MED_GEOM :"<<(med_2_1::med_geometrie_element)Types[i]);
 473         MESSAGE("Iteration :"<<MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
 474         MESSAGE("Order :"<<MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber());
 475         MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues+=NumberOfValues[i]; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
 476         med_2_1::med_err ret;
 477 #if defined(IRIX64) || defined(OSF1) || defined(VPP5000)
 478         int lgth2=NumberOfValues[i]*numberOfComponents;
 479         if(_ptrField->getValueType()==MED_EN::MED_INT32)
 480           {
 481             med_2_1::med_int *temp=new med_2_1::med_int[lgth2];
 482             ret=med_2_1::MEDchampLire(MED_FIELD_DRIVER21<T>::_medIdt,const_cast <char*> (MeshName.c_str()),
 483                                   const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
 484                                   (unsigned char*) temp,
 485                                   med_2_1::MED_NO_INTERLACE,
 486                                   MED_ALL,
 487                                   ProfilName,
 488                                   (med_2_1::med_entite_maillage) MED_FIELD_DRIVER<T>::_ptrField->_support->getEntity(),(med_2_1::med_geometrie_element)Types[i],
 489                                   MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
 490                                   MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
 491                                  );
 492             for(int i2=0;i2<lgth2;i2++)
 493               myValues[i][i2]=(int)(temp[i2]);
 494             delete [] temp;
 495           }
 496         else
 497 #endif
 498         ret=med_2_1::MEDchampLire(MED_FIELD_DRIVER21<T>::_medIdt,const_cast <char*> (MeshName.c_str()),
 499                                   const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
 500                                   (unsigned char*) myValues[i],
 501                                   med_2_1::MED_NO_INTERLACE,
 502                                   MED_ALL,
 503                                   ProfilName,
 504                                   (med_2_1::med_entite_maillage) MED_FIELD_DRIVER<T>::_ptrField->_support->getEntity(),(med_2_1::med_geometrie_element)Types[i],
 505                                   MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
 506                                   MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
 507                                  );
 508           if (ret < 0) {
 509           // we must do some delete !!!
 510           for(int j=0; j<=i;j++)
 511             delete[] myValues[j];
 512           delete[] myValues;
 513           delete[] NumberOfValues ;
 514           delete[] ProfilName;
 515           delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes ;
 516           delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsNames ;
 517           delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits ;
 518           delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions ;
 519           delete[] MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits ;
 520           MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes = NULL ;
 521           MED_FIELD_DRIVER<T>::_ptrField->_componentsNames = NULL ;
 522           MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits = NULL ;
 523           MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions = NULL ;
 524           MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits = NULL ;
 525           MED_FIELD_DRIVER<T>::_fieldNum = MED_INVALID ; // we have not found right field, so reset the field number
 526           throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": ERROR when read value")) ;
 527         }
 528
 529         delete[] ProfilName ;
 530       }
 531       // allocate _value
 532       // probleme avec les points de gauss : voir lorsqu-il y en a (!= 1)
 533       //      MEDARRAY<T> * Values = new MEDARRAY<T>(MED_FIELD_DRIVER<T>::_ptrField->getNumberOfComponents(),TotalNumberOfValues/MED_FIELD_DRIVER<T>::_ptrField->getNumberOfComponents(),MED_EN::MED_NO_INTERLACE);
 534
 535       if (MED_FIELD_DRIVER<T>::_ptrField->_value==NULL)
 536         MED_FIELD_DRIVER<T>::_ptrField->_value=new MEDARRAY<T>(numberOfComponents,TotalNumberOfValues,MED_EN::MED_NO_INTERLACE);
 537
 538       MEDARRAY<T> * Values = MED_FIELD_DRIVER<T>::_ptrField->_value ; // create by constructor ???
 539       // check if dimensions are right : inutile : c'est dans le constructeur !!!
 540       //if (Values->getLeadingValue() != numberOfComponents)
 541       //  throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": leading dimension are false : "<<Values->getLeadingValue()<<" and "<<numberOfComponents) ) ;
 542       //if (Values->getLengthValue() != TotalNumberOfValues)
 543       //  throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": length dimension are false : "<<Values->getLengthValue()<<" and "<<TotalNumberOfValues) ) ;
 544
 545       for (int i=0; i<numberOfComponents; i++) {
 546         //T * ValuesT = Values->getRow(i+1) ;
 547         int Count = 1 ;
 548         for (int j=0; j<NumberOfTypes; j++) {
 549           T * myValue = myValues[j] ;
 550           int NumberOf = NumberOfValues[j] ;
 551 //        MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues+=NumberOf; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
 552           int offset = NumberOf*i ;
 553           for (int k=0 ; k<NumberOf; k++) {
 554             //ValuesT[Count]=myValue[k+offset] ;
 555             Values->setIJ(Count,i+1,myValue[k+offset]);
 556             //jfa 22.07.2005:SCRUTE(Count);
 557             //jfa 22.07.2005:SCRUTE(Values->getIJ(Count,i+1));
 558             Count++;
 559           }
 560         }
 561       }
 562
 563       for (int j=0; j<NumberOfTypes; j++)
 564         delete[] myValues[j] ;
 565       delete[] myValues ;
 566       delete[] NumberOfValues ;
 567
 568       MED_FIELD_DRIVER<T>::_ptrField->_isRead = true ;
 569     }
 570
 571   END_OF(LOC);
 572 }
 573
 574 template <class T> void MED_FIELD_RDONLY_DRIVER21<T>::write( void ) const
 575   throw (MEDEXCEPTION)
 576 {
 577   throw MEDEXCEPTION("MED_FIELD_RDONLY_DRIVER21::write : Can't write with a RDONLY driver !");
 578 }
 579
 580 /*--------------------- WRONLY PART -------------------------------*/
 581
 582 template <class T> GENDRIVER * MED_FIELD_WRONLY_DRIVER21<T>::copy(void) const
 583 {
 584   return new MED_FIELD_WRONLY_DRIVER21<T>(*this);
 585 }
 586
 587 template <class T> void MED_FIELD_WRONLY_DRIVER21<T>::read (void)
 588   throw (MEDEXCEPTION)
 589 {
 590   throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER21::read : Can't read with a WRONLY driver !");
 591 }
 592
 593 template <class T> void MED_FIELD_WRONLY_DRIVER21<T>::write(void) const
 594   throw (MEDEXCEPTION)
 595 {
 596   const char * LOC = "MED_FIELD_WRONLY_DRIVER21::write(void) const " ;
 597   BEGIN_OF(LOC);
 598   if (MED_FIELD_DRIVER<T>::_status==MED_OPENED)
 599     {
 600       int err ;
 601
 602       int component_count=MED_FIELD_DRIVER<T>::_ptrField->getNumberOfComponents();
 603       string   component_name(component_count*MED_TAILLE_PNOM21,' ') ;
 604       string   component_unit(component_count*MED_TAILLE_PNOM21,' ') ;
 605
 606       const string * listcomponent_name=MED_FIELD_DRIVER<T>::_ptrField->getComponentsNames() ;
 607       const string * listcomponent_unit=MED_FIELD_DRIVER<T>::_ptrField->getMEDComponentsUnits() ;
 608       int length ;
 609       for (int i=0; i < component_count ; i++) {
 610         length = min(MED_TAILLE_PNOM21,(int)listcomponent_name[i].size());
 611         component_name.replace(i*MED_TAILLE_PNOM21,length,
 612                                listcomponent_name[i],0,length);
 613         length = min(MED_TAILLE_PNOM21,(int)listcomponent_unit[i].size());
 614         component_unit.replace(i*MED_TAILLE_PNOM21,length,
 615                                listcomponent_unit[i],0,length);
 616       }
 617
 618       MESSAGE("component_name=|"<<component_name<<"|");
 619       MESSAGE("component_unit=|"<<component_unit<<"|");
 620
 621       MED_EN::med_type_champ ValueType=MED_FIELD_DRIVER<T>::_ptrField->getValueType() ;
 622
 623       MESSAGE("Template Type =|"<<ValueType<<"|");
 624
 625       // le champ existe deja ???
 626       char * champName = new char[MED_TAILLE_NOM+1] ;
 627       med_2_1::med_type_champ type ;
 628       char * compName ;
 629       char * compUnit ;
 630       bool Find = false ;
 631       int n = med_2_1::MEDnChamp(MED_FIELD_DRIVER21<T>::_medIdt,0);
 632       int nbComp ;
 633       for (int i=1; i<=n; i++) {
 634         nbComp = med_2_1::MEDnChamp(MED_FIELD_DRIVER21<T>::_medIdt,i);
 635         compName = new char[MED_TAILLE_PNOM21*nbComp+1];
 636         compUnit = new char[MED_TAILLE_PNOM21*nbComp+1];
 637         err = med_2_1::MEDchampInfo(MED_FIELD_DRIVER21<T>::_medIdt,i,champName,&type,compName,compUnit,nbComp);
 638         if (err == 0)
 639           if (strcmp(champName,MED_FIELD_DRIVER<T>::_ptrField->getName().c_str())==0) { // Found !
 640             Find = true ;
 641             break ;
 642           }
 643         delete[] compName ;
 644         delete[] compUnit ;
 645       }
 646       delete[] champName ;
 647       if (Find) {
 648         // the same ?
 649         if (nbComp != component_count)
 650           throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
 651                                          <<": Field exist in file, but number of component are different : "<<nbComp<<" in file and "<<component_count<<" in memory."
 652                                          )
 653                               );
 654         // component name and unit
 655         MESSAGE(LOC<<" Component name in file : "<<compName);
 656         MESSAGE(LOC<<" Component name in memory : "<<component_name);
 657         MESSAGE(LOC<<" Component unit in file : "<<compUnit);
 658         MESSAGE(LOC<<" Component unit in memory : "<<component_unit);
 659         delete[] compName ;
 660         delete[] compUnit ;
 661
 662       } else {
 663         // Verify the field doesn't exist
 664
 665         string dataGroupName =  "/CHA/";
 666         dataGroupName        += MED_FIELD_DRIVER<T>::_ptrField->getName();
 667         MESSAGE(LOC << "|" << dataGroupName << "|" );
 668         med_2_1::med_idt gid =  H5Gopen(MED_FIELD_DRIVER21<T>::_medIdt, dataGroupName.c_str() );
 669
 670         if ( gid < 0 ) {
 671           // create field :
 672           err=med_2_1::MEDchampCr(MED_FIELD_DRIVER21<T>::_medIdt,
 673                                  const_cast <char*> ((MED_FIELD_DRIVER<T>::_ptrField->getName()).c_str()),
 674                                  (med_2_1::med_type_champ) ValueType,
 675                                  const_cast <char*> ( component_name.c_str() ),
 676                                  const_cast <char*> ( component_unit.c_str() ),
 677                                  component_count);
 678           if ( err < 0 )
 679             throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
 680                                            << ": Error MEDchampCr : "<<err
 681                                            )
 682                                 );
 683         }
 684         else H5Gclose(gid);
 685       }
 686
 687       const SUPPORT * mySupport = MED_FIELD_DRIVER<T>::_ptrField->getSupport() ;
 688
 689       if (! mySupport->isOnAllElements())
 690         throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
 691                                        <<": Field must be on all entity"
 692                                        )
 693                             );
 694
 695       MESH * myMesh = mySupport->getMesh() ;
 696       string MeshName = myMesh->getName() ;
 697       //MED_EN::medModeSwitch Mode = MED_FIELD_DRIVER<T>::_ptrField->_value->getMode() ;
 698       // on boucle sur tout les types pour ecrire les tableaux de valeur
 699       int NumberOfType = mySupport->getNumberOfTypes() ;
 700       int Index = 1 ;
 701       const MED_EN::medGeometryElement * Types = mySupport->getTypes() ;
 702       const int * NumberOfGaussPoint = mySupport->getNumberOfGaussPoint() ;
 703       for (int i=0;i<NumberOfType;i++) {
 704         int NumberOfElements = mySupport->getNumberOfElements(Types[i]) ;
 705
 706         const T * value = MED_FIELD_DRIVER<T>::_ptrField->getValueI(MED_EN::MED_FULL_INTERLACE,Index) ;
 707
 708         MESSAGE("MED_FIELD_DRIVER21<T>::_medIdt                         : "<<MED_FIELD_DRIVER21<T>::_medIdt);
 709         MESSAGE("MeshName.c_str()                : "<<MeshName.c_str());
 710         MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getName()            : "<<MED_FIELD_DRIVER<T>::_ptrField->getName());
 711         MESSAGE("value                           : "<<value);
 712         MESSAGE("NumberOfElements                : "<<NumberOfElements);
 713         MESSAGE("NumberOfGaussPoint[i]           : "<<NumberOfGaussPoint[i]);
 714         MESSAGE("mySupport->getEntity()          : "<<mySupport->getEntity());
 715         MESSAGE("Types[i]                        : "<<Types[i]);
 716         MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber() : "<<MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
 717         MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getTime()            : "<<MED_FIELD_DRIVER<T>::_ptrField->getTime());
 718         MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()     : "<<MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber());
 719
 720 /*      char chanom[MED_TAILLE_NOM+1];
 721         char chacomp[MED_TAILLE_NOM+1];
 722         char chaunit[MED_TAILLE_NOM+1];
 723         med_2_1::med_type_champ chatype;
 724         med_int chancomp=1;
 725
 726         err=med_2_1::MEDchampInfo(MED_FIELD_DRIVER<T>::_medIdt,1,chanom,&chatype,chacomp,chaunit,chancomp);
 727
 728         if (err<0)
 729                 {
 730                 cout<<"=======================================================================> gros probleme"<<endl;
 731                 exit(-1);
 732                 }
 733         cout<<"==================> nom lu            = "<<chanom<<endl;
 734         cout<<"==================> type lu           = "<<chatype<<endl;
 735         cout<<"==================> nom composante lu = "<<chacomp<<endl;
 736         cout<<"==================> nom unit lu       = "<<chaunit<<endl;
 737         cout<<"==================> valeur de med_2_1::MED_REEL64 = "<<med_2_1::MED_REEL64<<endl;
 738 */
 739 #if defined(IRIX64) || defined(OSF1) || defined(VPP5000)
 740         if(_ptrField->getValueType()==MED_EN::MED_INT32)
 741           {
 742             int lgth2=_ptrField->getNumberOfValues();
 743             med_2_1::med_int *temp=new med_2_1::med_int[lgth2];
 744             for(int i2=0;i2<lgth2;i2++)
 745               temp[i2]=(int)(value[i2]);
 746             err=med_2_1::MEDchampEcr(MED_FIELD_DRIVER21<T>::_medIdt,
 747                                     const_cast <char*> ( MeshName.c_str()) ,                         //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
 748                                     const_cast <char*> ( (MED_FIELD_DRIVER<T>::_ptrField->getName()).c_str()),
 749                                     (unsigned char*)temp,
 750                                     med_2_1::MED_FULL_INTERLACE,
 751                                     NumberOfElements,
 752                                     NumberOfGaussPoint[i],
 753                                     MED_ALL,
 754                                     MED_NOPFL,
 755                                     med_2_1::MED_REMP,  // PROFIL NON GERE, mode de remplacement non géré
 756                                     (med_2_1::med_entite_maillage)mySupport->getEntity(),
 757                                     (med_2_1::med_geometrie_element)Types[i],
 758                                     MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
 759                                     "        ",
 760                                     MED_FIELD_DRIVER<T>::_ptrField->getTime(),
 761                                     MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
 762                                     );
 763             delete [] temp;
 764           }
 765         else
 766 #endif
 767         err=med_2_1::MEDchampEcr(MED_FIELD_DRIVER21<T>::_medIdt,
 768                                 const_cast <char*> ( MeshName.c_str()) ,                         //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
 769                                 const_cast <char*> ( (MED_FIELD_DRIVER<T>::_ptrField->getName()).c_str()),
 770                                 (unsigned char*)value,
 771                                 med_2_1::MED_FULL_INTERLACE,
 772                                 NumberOfElements,
 773                                 NumberOfGaussPoint[i],
 774                                 MED_ALL,
 775                                 MED_NOPFL,
 776                                 med_2_1::MED_REMP,  // PROFIL NON GERE, mode de remplacement non géré
 777                                 (med_2_1::med_entite_maillage)mySupport->getEntity(),
 778                                 (med_2_1::med_geometrie_element)Types[i],
 779                                 MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
 780                                 "        ",
 781                                 MED_FIELD_DRIVER<T>::_ptrField->getTime(),
 782                                 MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
 783                                 );
 784         if (err < MED_VALID )
 785           throw MEDEXCEPTION(LOCALIZED( STRING(LOC)
 786                                         <<": Error in writing Field "<< MED_FIELD_DRIVER<T>::_ptrField->getName() <<", type "<<Types[i]
 787                                         )
 788                              );
 789
 790         Index += NumberOfElements ;
 791
 792       }
 793     }
 794
 795   END_OF(LOC);
 796 }
 797
 798 /*--------------------- RDWR PART -------------------------------*/
 799
 800 template <class T> GENDRIVER * MED_FIELD_RDWR_DRIVER21<T>::copy(void) const
 801 {
 802   return new MED_FIELD_RDWR_DRIVER21<T>(*this);
 803 }
 804
 805 template <class T> void MED_FIELD_RDWR_DRIVER21<T>::write(void) const
 806   throw (MEDEXCEPTION)
 807 {
 808   BEGIN_OF("MED_FIELD_RDWR_DRIVER21::write(void)");
 809   MED_FIELD_WRONLY_DRIVER21<T>::write();
 810   END_OF("MED_FIELD_RDWR_DRIVER21::write(void)");
 811 }
 812
 813 template <class T> void MED_FIELD_RDWR_DRIVER21<T>::read (void)
 814   throw (MEDEXCEPTION)
 815 {
 816   BEGIN_OF("MED_FIELD_RDWR_DRIVER21::read(void)");
 817   MED_FIELD_RDONLY_DRIVER21<T>::read();
 818   END_OF("MED_FIELD_RDWR_DRIVER21::read(void)");
 819 }
 820 }//End namespace MEDMEM
 821 /*-----------------------------------------------------------------*/
 822
 823 #endif /* MED_FIELD_DRIVER_HXX */
 824