src/MEDMEM/MEDMEM_MedFieldDriver.hxx

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