src/MEDMEM/MEDMEM_MedFieldDriver22.hxx

   1 #ifndef MED_FIELD_DRIVER22_HXX
   2 #define MED_FIELD_DRIVER22_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_DRIVER22 : public virtual MED_FIELD_DRIVER<T>
  32 {
  33 protected:
  34
  35   med_2_2::med_idt        _medIdt;
  36
  37   void search_field() ;
  38
  39 public :
  40
  41   // all MED cell type ?? Classe de Définition ??
  42   //   static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
  43
  44   //   static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
  45
  46   /*!
  47     Constructor.
  48   */
  49   MED_FIELD_DRIVER22():MED_FIELD_DRIVER<T>(),_medIdt(MED_INVALID)
  50   {}
  51   /*!
  52     Constructor.
  53   */
  54   MED_FIELD_DRIVER22(const string & fileName, FIELD<T> * ptrField,
  55                      MED_EN::med_mode_acces accessMode)
  56     : MED_FIELD_DRIVER<T>(fileName,ptrField,accessMode),_medIdt(MED_INVALID)
  57   {
  58   }
  59
  60   /*!
  61     Copy constructor.
  62   */
  63   MED_FIELD_DRIVER22(const MED_FIELD_DRIVER22 & fieldDriver):
  64     MED_FIELD_DRIVER<T>(fieldDriver),
  65     _medIdt(fieldDriver._medIdt)
  66   {
  67   }
  68
  69   /*!
  70     Destructor.
  71   */
  72   virtual ~MED_FIELD_DRIVER22() {
  73   }
  74
  75   void open() throw (MEDEXCEPTION)
  76   {
  77     const char * LOC = "MED_FIELD_DRIVER22::open() ";
  78     BEGIN_OF(LOC);
  79
  80     // we must set fieldname before open, because we must find field number in file (if it exist !!!)
  81     if ( MED_FIELD_DRIVER<T>::_fileName == "" )
  82       throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
  83                                        << "_fileName is |\"\"|, please set a correct fileName before calling open()"
  84                                        )
  85                             );
  86
  87     MESSAGE(LOC<<"_fileName.c_str : "<< MED_FIELD_DRIVER<T>::_fileName.c_str()<<",mode : "<< MED_FIELD_DRIVER<T>::_accessMode);
  88     _medIdt = med_2_2::MEDouvrir( (const_cast <char *> (MED_FIELD_DRIVER<T>::_fileName.c_str())),(med_2_2::med_mode_acces) MED_FIELD_DRIVER<T>::_accessMode);
  89     MESSAGE(LOC<<"_medIdt : "<< _medIdt );
  90     if (_medIdt > 0)
  91       MED_FIELD_DRIVER<T>::_status=MED_OPENED;
  92     else {
  93       MED_FIELD_DRIVER<T>::_status = MED_INVALID;
  94       _medIdt = MED_INVALID;
  95       throw MED_EXCEPTION (LOCALIZED( STRING(LOC)
  96                                       << "Can't open |"  << MED_FIELD_DRIVER<T>::_fileName
  97                                       << "|, _medIdt : " << _medIdt
  98                                       )
  99                            );
 100     }
 101
 102     END_OF(LOC);
 103   }
 104
 105   void close() {
 106     BEGIN_OF("MED_FIELD_DRIVER22::close()");
 107     med_2_2::med_int err = 0;
 108     if (MED_FIELD_DRIVER<T>::_status == MED_OPENED) {
 109       err=med_2_2::MEDfermer(_medIdt);
 110       //H5close(); // If we call H5close() all the files are closed.
 111       MED_FIELD_DRIVER<T>::_status = MED_CLOSED;
 112       _medIdt = MED_INVALID;
 113       MESSAGE(" MED_FIELD_DRIVER22::close() : MEDfermer : _medIdt= " << _medIdt );
 114       MESSAGE(" MED_FIELD_DRIVER22::close() : MEDfermer : err    = " << err );
 115     }
 116     END_OF("MED_FIELD_DRIVER22::close()");
 117   }
 118
 119 };
 120
 121 /*!
 122
 123   Driver Med for FIELD : Read only.
 124
 125   Implement read method.
 126
 127 */
 128
 129   template <class T> class MED_FIELD_RDONLY_DRIVER22 : public virtual MED_FIELD_DRIVER22<T>, public virtual IMED_FIELD_RDONLY_DRIVER<T>
 130 {
 131
 132 public :
 133
 134   /*!
 135     Constructor.
 136   */
 137   MED_FIELD_RDONLY_DRIVER22():MED_FIELD_DRIVER<T>() {};
 138
 139   /*!
 140     Constructor.
 141   */
 142   MED_FIELD_RDONLY_DRIVER22(const string & fileName,  FIELD<T> * ptrField):
 143     IMED_FIELD_RDONLY_DRIVER<T>(fileName,ptrField),
 144     MED_FIELD_DRIVER22<T>(fileName,ptrField,MED_EN::MED_RDONLY),
 145     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_RDONLY)
 146   {
 147     BEGIN_OF("MED_FIELD_RDONLY_DRIVER22::MED_FIELD_RDONLY_DRIVER22(const string & fileName, const FIELD<T> * ptrField)");
 148     END_OF("MED_FIELD_RDONLY_DRIVER22::MED_FIELD_RDONLY_DRIVER22(const string & fileName, const FIELD<T> * ptrField)");
 149   }
 150
 151   /*!
 152     Copy constructor.
 153   */
 154   MED_FIELD_RDONLY_DRIVER22(const MED_FIELD_RDONLY_DRIVER22 & fieldDriver):
 155     IMED_FIELD_RDONLY_DRIVER<T>(fieldDriver),
 156     MED_FIELD_DRIVER22<T>(fieldDriver),
 157     MED_FIELD_DRIVER<T>(fieldDriver)
 158   {};
 159
 160   /*!
 161     Destructor.
 162   */
 163   virtual ~MED_FIELD_RDONLY_DRIVER22() {};
 164
 165   // CREER UNE METHODE POUR LIRE LA LISTE DES MAILLAGES .....
 166
 167   /*!
 168     Return a MEDEXCEPTION : it is the read-only driver.
 169   */
 170   void write( void ) const throw (MEDEXCEPTION) ;
 171   /*!
 172     Read FIELD in the specified file.
 173   */
 174   void read ( void ) throw (MEDEXCEPTION) ;
 175
 176 private:
 177   GENDRIVER * copy( void ) const ;
 178
 179 };
 180
 181 /*!
 182
 183   Driver Med for FIELD : Write only.
 184
 185   Implement write method.
 186
 187 */
 188
 189 template <class T> class MED_FIELD_WRONLY_DRIVER22 : public virtual MED_FIELD_DRIVER22<T>, public virtual IMED_FIELD_WRONLY_DRIVER<T> {
 190
 191 public :
 192
 193   /*!
 194     Constructor.
 195   */
 196   MED_FIELD_WRONLY_DRIVER22():MED_FIELD_DRIVER<T>() {}
 197
 198   /*!
 199     Constructor.
 200   */
 201   MED_FIELD_WRONLY_DRIVER22(const string & fileName, FIELD<T> * ptrField):
 202     IMED_FIELD_WRONLY_DRIVER<T>(fileName,ptrField),
 203     MED_FIELD_DRIVER22<T>(fileName,ptrField,MED_EN::MED_WRONLY),
 204     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_WRONLY)
 205   {
 206     BEGIN_OF("MED_FIELD_WRONLY_DRIVER22::MED_FIELD_WRONLY_DRIVER22(const string & fileName, const FIELD<T> * ptrField)");
 207     END_OF("MED_FIELD_WRONLY_DRIVER22::MED_FIELD_WRONLY_DRIVER22(const string & fileName, const FIELD<T> * ptrField)");
 208   };
 209
 210   /*!
 211     Copy constructor.
 212   */
 213   MED_FIELD_WRONLY_DRIVER22(const MED_FIELD_WRONLY_DRIVER22 & fieldDriver):
 214     IMED_FIELD_WRONLY_DRIVER<T>(fieldDriver),
 215     MED_FIELD_DRIVER22<T>(fieldDriver),
 216     MED_FIELD_DRIVER<T>(fieldDriver)
 217   {};
 218
 219   /*!
 220     Destructor.
 221   */
 222   virtual ~MED_FIELD_WRONLY_DRIVER22() {};
 223
 224   /*!
 225     Write FIELD in the specified file.
 226   */
 227   void write( void ) const throw (MEDEXCEPTION) ;
 228   /*!
 229     Return a MEDEXCEPTION : it is the write-only driver.
 230   */
 231   void read ( void ) throw (MEDEXCEPTION) ;
 232
 233 private:
 234   GENDRIVER * copy( void ) const ;
 235
 236 };
 237
 238
 239 /*!
 240
 241   Driver Med for FIELD : Read write.
 242   - Use read method from MED_FIELD_RDONLY_DRIVER
 243   - Use write method from MED_FIELD_WDONLY_DRIVER
 244
 245 */
 246
 247 template <class T> class MED_FIELD_RDWR_DRIVER22 : public MED_FIELD_RDONLY_DRIVER22<T>, public MED_FIELD_WRONLY_DRIVER22<T>, public IMED_FIELD_RDWR_DRIVER<T> {
 248
 249 public :
 250
 251   /*!
 252     Constructor.
 253   */
 254   MED_FIELD_RDWR_DRIVER22():MED_FIELD_DRIVER22<T>() {}
 255
 256   /*!
 257     Constructor.
 258   */
 259   MED_FIELD_RDWR_DRIVER22(const string & fileName, FIELD<T> * ptrField):
 260     MED_FIELD_WRONLY_DRIVER22<T>(fileName,ptrField),
 261     MED_FIELD_RDONLY_DRIVER22<T>(fileName,ptrField),
 262     IMED_FIELD_RDONLY_DRIVER<T>(fileName,ptrField),
 263     IMED_FIELD_WRONLY_DRIVER<T>(fileName,ptrField),
 264     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::MED_RDWR),
 265     IMED_FIELD_RDWR_DRIVER<T>(fileName,ptrField)
 266   {
 267     BEGIN_OF("MED_FIELD_RDWR_DRIVER22::MED_FIELD_RDWR_DRIVER22(const string & fileName, const FIELD<T> * ptrField)");
 268     //_accessMode = MED_RDWR ;
 269     END_OF("MED_FIELD_RDWR_DRIVER22::MED_FIELD_RDWR_DRIVER22(const string & fileName, const FIELD<T> * ptrField)");
 270   };
 271
 272   /*!
 273     Copy constructor.
 274   */
 275   MED_FIELD_RDWR_DRIVER22(const MED_FIELD_RDWR_DRIVER22 & fieldDriver):
 276     MED_FIELD_WRONLY_DRIVER22<T>(fieldDriver),
 277     MED_FIELD_RDONLY_DRIVER22<T>(fieldDriver),
 278     IMED_FIELD_RDWR_DRIVER<T>(fieldDriver),
 279     IMED_FIELD_RDONLY_DRIVER<T>(fieldDriver),
 280     IMED_FIELD_WRONLY_DRIVER<T>(fieldDriver),
 281     MED_FIELD_DRIVER<T>(fieldDriver)
 282   {};
 283
 284   /*!
 285     Destructor.
 286   */
 287   ~MED_FIELD_RDWR_DRIVER22() {};
 288
 289   /*!
 290     Write FIELD in the specified file.
 291   */
 292   void write(void) const throw (MEDEXCEPTION) ;
 293   /*!
 294     Read FIELD in the specified file.
 295   */
 296   void read (void) throw (MEDEXCEPTION) ;
 297
 298 private:
 299   GENDRIVER * copy( void ) const ;
 300
 301 };
 302
 303
 304 /*-------------------------*/
 305 /* template implementation */
 306 /*-------------------------*/
 307
 308 /*--------------------- DRIVER PART -------------------------------*/
 309
 310 //  template <class T> void MED_FIELD_DRIVER<T>::search_field() {
 311 //    const char * LOC = "template <class T> class MED_FIELD_DRIVER::search_field() :";
 312
 313 //    // we search the field number !!!!
 314 //    if (_status==MED_OPENED)
 315 //      if (_fieldNum==MED_INVALID) {
 316 //        int err ;
 317 //        int    numberOfFields              = 0;      //MED_INVALID
 318 //        //    char   fieldName[MED_TAILLE_NOM+1] = "";
 319 //        char   fieldName[MED_TAILLE_NOM+1] ;
 320 //        int    numberOfComponents          = 0;
 321 //        char * componentName               = (char *) MED_NULL;
 322 //        char * unitName                    = (char *) MED_NULL;
 323 //        med_2_2::med_type_champ type ;
 324 //        numberOfFields = med_2_2::MEDnChamp(_medIdt,0) ;
 325 //        if ( numberOfFields <= 0 )
 326 //      throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
 327 //        for (int i=1;i<=numberOfFields;i++) {
 328
 329 //      numberOfComponents = med_2_2::MEDnChamp(_medIdt,i) ;
 330 //      if ( numberOfComponents <= 0 )
 331 //        throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 332 //                                         <<  "Be careful there is no compound for field n°"
 333 //                                         << i << "in file |"<<_fileName<<"| !"));
 334
 335 //      componentName = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
 336 //      unitName      = new char[numberOfComponents*MED_TAILLE_PNOM+1] ;
 337
 338 //      err = med_2_2::MEDchampInfo(_medIdt, i, fieldName, &type, componentName,
 339 //                                 unitName, numberOfComponents) ;
 340
 341 //      delete[] componentName ;
 342 //      delete[] unitName ;
 343 //      MESSAGE("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<_fieldName.c_str()<<"#");
 344 //      if ( !strcmp(fieldName,_fieldName.c_str()) ) {
 345 //        MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
 346 //        _fieldNum = i ;
 347 //        break ;
 348 //      }
 349 //        }
 350 //      }
 351 //  }
 352
 353 /*--------------------- RDONLY PART -------------------------------*/
 354
 355 template <class T> GENDRIVER * MED_FIELD_RDONLY_DRIVER22<T>::copy(void) const
 356 {
 357   return new MED_FIELD_RDONLY_DRIVER22<T>(*this);
 358 }
 359
 360 template <class T> void MED_FIELD_RDONLY_DRIVER22<T>::read(void)
 361   throw (MEDEXCEPTION)
 362 {
 363   const char * LOC = " MED_FIELD_RDONLY_DRIVER22::read() " ;
 364   BEGIN_OF(LOC);
 365
 366   if (MED_FIELD_DRIVER<T>::_ptrField->_name=="")
 367     MED_FIELD_DRIVER<T>::_ptrField->_name = MED_FIELD_DRIVER<T>::_fieldName ;
 368   else
 369     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 !!!!!
 370
 371   MESSAGE("###### "<<LOC<<" fieldNameDRIVER : "<<MED_FIELD_DRIVER<T>::_fieldName<<" fieldName : "<<MED_FIELD_DRIVER<T>::_ptrField->_name);
 372
 373   string MeshName =  MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getMesh()->getName() ;
 374
 375   if (MED_FIELD_DRIVER<T>::_status==MED_OPENED)
 376     {
 377
 378       //        search_field() ;
 379
 380       char *  fieldName ;
 381       fieldName = new char[MED_TAILLE_NOM+1] ;
 382       int err ;
 383       int    numberOfComponents          = 0;
 384       char * componentName               = (char *) MED_NULL;
 385       char * unitName                    = (char *) MED_NULL;
 386       med_2_2::med_type_champ type ;
 387
 388       // we search the field number !!!!
 389       if (MED_FIELD_DRIVER<T>::_fieldNum==MED_INVALID) {
 390         int    numberOfFields              = 0;      //MED_INVALID
 391         numberOfFields = med_2_2::MEDnChamp(MED_FIELD_DRIVER22<T>::_medIdt,0) ;
 392         if ( numberOfFields <= 0 )
 393           throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
 394         for (int i=1;i<=numberOfFields;i++) {
 395
 396           numberOfComponents = med_2_2::MEDnChamp(MED_FIELD_DRIVER22<T>::_medIdt,i) ;
 397           if ( numberOfComponents <= 0 )
 398             //                throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 399             //                                                 <<  "Be careful there is no compound for field n°"
 400             //                                                 << i << "in file |"<<_fileName<<"| !"));
 401             MESSAGE(LOC<<"Be careful there is no compound for field n°"<<i<<"in file |"<<MED_FIELD_DRIVER<T>::_fileName<<"| !");
 402
 403           componentName = new char[numberOfComponents*MED_TAILLE_PNOM22+1] ;
 404           unitName      = new char[numberOfComponents*MED_TAILLE_PNOM22+1] ;
 405
 406           err = med_2_2::MEDchampInfo(MED_FIELD_DRIVER22<T>::_medIdt, i, fieldName, &type, componentName,
 407                                      unitName, numberOfComponents) ;
 408
 409           MESSAGE("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<MED_FIELD_DRIVER<T>::_fieldName.c_str()<<"#");
 410           if ( !strcmp(fieldName,MED_FIELD_DRIVER<T>::_fieldName.c_str()) ) {
 411             MESSAGE("FOUND FIELD "<< fieldName <<" : "<<i);
 412             MED_FIELD_DRIVER<T>::_fieldNum = i ;
 413             break ;
 414           }
 415           // not found : release memory and search next field !
 416           delete[] componentName ;
 417           delete[] unitName ;
 418         }
 419       }
 420
 421       delete[] fieldName ;
 422
 423       if (MED_FIELD_DRIVER<T>::_fieldNum==MED_INVALID)
 424         throw MEDEXCEPTION(LOCALIZED( STRING(LOC) << ": Field "<<MED_FIELD_DRIVER<T>::_fieldName << " not found in file " << MED_FIELD_DRIVER<T>::_fileName ) );
 425       MESSAGE ("FieldNum : "<<MED_FIELD_DRIVER<T>::_fieldNum);
 426
 427       //        int err ;
 428       //        int NumberOfComponents = med_2_2::MEDnChamp(MED_FIELD_DRIVER<T>::_medIdt,MED_FIELD_DRIVER<T>::_fieldNum) ;
 429       if (numberOfComponents < 1)
 430         throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"no component")) ; // use iostring !
 431       // test type to check if it is rigth !!!???
 432       MED_FIELD_DRIVER<T>::_ptrField->_numberOfComponents = numberOfComponents ;
 433       MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes = new int[numberOfComponents] ;
 434       MED_FIELD_DRIVER<T>::_ptrField->_componentsNames = new string[numberOfComponents] ;
 435       MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits = new UNIT[numberOfComponents] ;
 436       MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions = new string[numberOfComponents] ;
 437       MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits = new string[numberOfComponents] ;
 438       for (int i=0; i<numberOfComponents; i++) {
 439         MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes[i] = 1 ;
 440
 441         // PG : what about space !!!
 442         MED_FIELD_DRIVER<T>::_ptrField->_componentsNames[i] = string(componentName,i*MED_TAILLE_PNOM22,MED_TAILLE_PNOM22) ;
 443         SCRUTE(MED_FIELD_DRIVER<T>::_ptrField->_componentsNames[i]);
 444         MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits[i] = string(unitName,i*MED_TAILLE_PNOM22,MED_TAILLE_PNOM22) ;
 445         SCRUTE(MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits[i]);
 446       }
 447       delete[] componentName;
 448       delete[] unitName;
 449
 450       // read values for each geometric type in _support
 451       int NumberOfTypes = MED_FIELD_DRIVER<T>::_ptrField->_support->getNumberOfTypes() ;
 452       const MED_EN::medGeometryElement *Types = MED_FIELD_DRIVER<T>::_ptrField->_support->getTypes() ;
 453       T ** myValues = new T*[NumberOfTypes] ;
 454       int * NumberOfValues = new int[NumberOfTypes] ;
 455       int TotalNumberOfValues = 0 ;
 456       MESSAGE ("NumberOfTypes :"<< NumberOfTypes);
 457       MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues=0 ;
 458       for (int i=0; i<NumberOfTypes; i++) {
 459         MESSAGE ("Type["<<i+1<<"] :"<< Types[i]);
 460         MESSAGE ("Entity :"<<MED_FIELD_DRIVER<T>::_ptrField->_support->getEntity());
 461 //      NumberOfValues[i] =
 462 //        MEDnVal(_medIdt,
 463 //                const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
 464 //                (med_2_2::med_entite_maillage)_ptrField->_support->getEntity(),
 465 //                (med_2_2::med_geometrie_element)Types[i],
 466 //                _ptrField->_iterationNumber,
 467 //                _ptrField->_orderNumber) ; // no time step ! prend en compte le nbre de pt de gauss
 468         // test if NumberOfValues is the same in _support !!! TODO that !!
 469         // we suppose it is
 470         // we could allocate array
 471         // Be really carefull about the profil; especially the last arg of
 472         // MEDnVal
 473
 474         NumberOfValues[i] =
 475           MEDnVal(MED_FIELD_DRIVER22<T>::_medIdt,
 476                   const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
 477                   (med_2_2::med_entite_maillage)MED_FIELD_DRIVER<T>::_ptrField->_support->getEntity(),
 478                   (med_2_2::med_geometrie_element) Types[i],
 479                   MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber, MED_FIELD_DRIVER<T>::_ptrField->_orderNumber,
 480                   const_cast <char*> (MED_FIELD_DRIVER<T>::_ptrField->_support->getMesh()->getName().c_str()),
 481                   med_2_2::MED_COMPACT) ;
 482
 483         myValues[i] = new T[ NumberOfValues[i]*numberOfComponents ] ;
 484         TotalNumberOfValues+=NumberOfValues[i] ;// diviser par le nombre de point de gauss
 485         char * ProfilName = new char[MED_TAILLE_NOM+1];
 486         char * LocalGaussName = new char[MED_TAILLE_NOM+1];
 487         MESSAGE ("NumberOfValues :"<< NumberOfValues[i]);
 488         MESSAGE ("NumberOfComponents :"<< numberOfComponents);
 489         MESSAGE ("MESH_NAME :"<< MeshName.c_str());
 490         MESSAGE ("FIELD_NAME :"<< MED_FIELD_DRIVER<T>::_fieldName.c_str());
 491         MESSAGE ("MED_ENTITE :"<< (med_2_2::med_entite_maillage) MED_FIELD_DRIVER<T>::_ptrField->_support->getEntity());
 492         MESSAGE("MED_GEOM :"<<(med_2_2::med_geometrie_element)Types[i]);
 493         MESSAGE("Iteration :"<<MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
 494         MESSAGE("Order :"<<MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber());
 495         MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues+=NumberOfValues[i]; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
 496
 497         err = MEDchampLire(MED_FIELD_DRIVER22<T>::_medIdt,const_cast <char*> (MeshName.c_str()),
 498                            const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
 499                                   (unsigned char*) myValues[i],
 500                            med_2_2::MED_NO_INTERLACE,MED_ALL,
 501                            LocalGaussName,ProfilName,
 502                            med_2_2::MED_NO_PFLMOD,
 503                            (med_2_2::med_entite_maillage) MED_FIELD_DRIVER<T>::_ptrField->_support->getEntity(),(med_2_2::med_geometrie_element)Types[i],
 504                            MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
 505                            MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber());
 506
 507         if ( err < 0) {
 508           // we must do some delete !!!
 509           for(int j=0; j<=i;j++)
 510             delete[] myValues[j];
 511           delete[] myValues;
 512           delete[] NumberOfValues ;
 513           delete[] ProfilName;
 514           delete[] LocalGaussName;
 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         // At this time ProfilName should be med_2_2::MED_NOPFL and
 530         // LocalGaussName should be med_2_2::MED_NOGAUSS
 531         delete[] ProfilName ;
 532         delete[] LocalGaussName ;
 533       }
 534       // allocate _value
 535       // probleme avec les points de gauss : voir lorsqu-il y en a (!= 1)
 536       //      MEDARRAY<T> * Values = new MEDARRAY<T>(MED_FIELD_DRIVER<T>::_ptrField->getNumberOfComponents(),TotalNumberOfValues/MED_FIELD_DRIVER<T>::_ptrField->getNumberOfComponents(),MED_EN::MED_NO_INTERLACE);
 537
 538       if (MED_FIELD_DRIVER<T>::_ptrField->_value==NULL)
 539         MED_FIELD_DRIVER<T>::_ptrField->_value=new MEDARRAY<T>(numberOfComponents,TotalNumberOfValues,MED_EN::MED_NO_INTERLACE);
 540
 541       MEDARRAY<T> * Values = MED_FIELD_DRIVER<T>::_ptrField->_value ; // create by constructor ???
 542       // check if dimensions are right : inutile : c'est dans le constructeur !!!
 543       //if (Values->getLeadingValue() != numberOfComponents)
 544       //  throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": leading dimension are false : "<<Values->getLeadingValue()<<" and "<<numberOfComponents) ) ;
 545       //if (Values->getLengthValue() != TotalNumberOfValues)
 546       //  throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": length dimension are false : "<<Values->getLengthValue()<<" and "<<TotalNumberOfValues) ) ;
 547
 548       for (int i=0; i<numberOfComponents; i++) {
 549         //T * ValuesT = Values->getRow(i+1) ;
 550         int Count = 1 ;
 551         for (int j=0; j<NumberOfTypes; j++) {
 552           T * myValue = myValues[j] ;
 553           int NumberOf = NumberOfValues[j] ;
 554 //        MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues+=NumberOf; // problem with gauss point : _numberOfValues != TotalNumberOfValues !!!!!!!
 555           int offset = NumberOf*i ;
 556           for (int k=0 ; k<NumberOf; k++) {
 557             //ValuesT[Count]=myValue[k+offset] ;
 558             Values->setIJ(Count,i+1,myValue[k+offset]);
 559             SCRUTE(Count);
 560             SCRUTE(Values->getIJ(Count,i+1));
 561             Count++;
 562           }
 563         }
 564       }
 565
 566       for (int j=0; j<NumberOfTypes; j++)
 567         delete[] myValues[j] ;
 568       delete[] myValues ;
 569       delete[] NumberOfValues ;
 570
 571       MED_FIELD_DRIVER<T>::_ptrField->_isRead = true ;
 572     }
 573
 574   END_OF(LOC);
 575 }
 576
 577 template <class T> void MED_FIELD_RDONLY_DRIVER22<T>::write( void ) const
 578   throw (MEDEXCEPTION)
 579 {
 580   throw MEDEXCEPTION("MED_FIELD_RDONLY_DRIVER22::write : Can't write with a RDONLY driver !");
 581 }
 582
 583 /*--------------------- WRONLY PART -------------------------------*/
 584
 585 template <class T> GENDRIVER * MED_FIELD_WRONLY_DRIVER22<T>::copy(void) const
 586 {
 587   return new MED_FIELD_WRONLY_DRIVER22<T>(*this);
 588 }
 589
 590 template <class T> void MED_FIELD_WRONLY_DRIVER22<T>::read (void)
 591   throw (MEDEXCEPTION)
 592 {
 593   throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER22::read : Can't read with a WRONLY driver !");
 594 }
 595
 596 template <class T> void MED_FIELD_WRONLY_DRIVER22<T>::write(void) const
 597   throw (MEDEXCEPTION)
 598 {
 599   const char * LOC = "MED_FIELD_WRONLY_DRIVER22::write(void) const " ;
 600   BEGIN_OF(LOC);
 601   if (MED_FIELD_DRIVER<T>::_status==MED_OPENED)
 602     {
 603       int err ;
 604
 605       int component_count=MED_FIELD_DRIVER<T>::_ptrField->getNumberOfComponents();
 606       string   component_name(component_count*MED_TAILLE_PNOM22,' ') ;
 607       string   component_unit(component_count*MED_TAILLE_PNOM22,' ') ;
 608
 609       const string * listcomponent_name=MED_FIELD_DRIVER<T>::_ptrField->getComponentsNames() ;
 610       const string * listcomponent_unit=MED_FIELD_DRIVER<T>::_ptrField->getMEDComponentsUnits() ;
 611       int length ;
 612       for (int i=0; i < component_count ; i++) {
 613         length = min(MED_TAILLE_PNOM22,(int)listcomponent_name[i].size());
 614         component_name.replace(i*MED_TAILLE_PNOM22,length,
 615                                listcomponent_name[i],0,length);
 616         length = min(MED_TAILLE_PNOM22,(int)listcomponent_unit[i].size());
 617         component_unit.replace(i*MED_TAILLE_PNOM22,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=MED_FIELD_DRIVER<T>::_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_2_2::med_type_champ type ;
 631       char * compName ;
 632       char * compUnit ;
 633       bool Find = false ;
 634       int n = med_2_2::MEDnChamp(MED_FIELD_DRIVER22<T>::_medIdt,0);
 635       int nbComp ;
 636       for (int i=1; i<=n; i++) {
 637         nbComp = med_2_2::MEDnChamp(MED_FIELD_DRIVER22<T>::_medIdt,i);
 638         compName = new char[MED_TAILLE_PNOM22*nbComp+1];
 639         compUnit = new char[MED_TAILLE_PNOM22*nbComp+1];
 640         err = med_2_2::MEDchampInfo(MED_FIELD_DRIVER22<T>::_medIdt,i,champName,&type,compName,compUnit,nbComp);
 641         if (err == 0)
 642           if (strcmp(champName,MED_FIELD_DRIVER<T>::_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        += MED_FIELD_DRIVER<T>::_ptrField->getName();
 670         MESSAGE(LOC << "|" << dataGroupName << "|" );
 671         med_2_2::med_idt gid =  H5Gopen(MED_FIELD_DRIVER22<T>::_medIdt, dataGroupName.c_str() );
 672
 673         if ( gid < 0 ) {
 674           // create field :
 675           err=med_2_2::MEDchampCr(MED_FIELD_DRIVER22<T>::_medIdt,
 676                                  const_cast <char*> ((MED_FIELD_DRIVER<T>::_ptrField->getName()).c_str()),
 677                                  (med_2_2::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 = MED_FIELD_DRIVER<T>::_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 = MED_FIELD_DRIVER<T>::_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 MED_EN::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 = MED_FIELD_DRIVER<T>::_ptrField->getValueI(MED_EN::MED_FULL_INTERLACE,Index) ;
 710
 711         MESSAGE("MED_FIELD_DRIVER<T>22::_medIdt                         : "<<MED_FIELD_DRIVER22<T>::_medIdt);
 712         MESSAGE("MeshName.c_str()                : "<<MeshName.c_str());
 713         MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getName()            : "<<MED_FIELD_DRIVER<T>::_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("MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber() : "<<MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
 720         MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getTime()            : "<<MED_FIELD_DRIVER<T>::_ptrField->getTime());
 721         MESSAGE("MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()     : "<<MED_FIELD_DRIVER<T>::_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_2_2::med_type_champ chatype;
 727         med_int chancomp=1;
 728
 729         err=med_2_2::MEDchampInfo(MED_FIELD_DRIVER<T>::_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_2_2::MED_REEL64 = "<<med_2_2::MED_REEL64<<endl;
 741 */
 742
 743 //      err=med_2_2::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_2_2::MED_FULL_INTERLACE,
 748 //                              NumberOfElements,
 749 //                              NumberOfGaussPoint[i],
 750 //                              MED_ALL,
 751 //                              MED_NOPFL,
 752 //                              med_2_2::MED_REMP,  // PROFIL NON GERE, mode de remplacement non géré
 753 //                              (med_2_2::med_entite_maillage)mySupport->getEntity(),
 754 //                              (med_2_2::med_geometrie_element)Types[i],
 755 //                              _ptrField->getIterationNumber(),
 756 //                              "        ",
 757 //                              _ptrField->getTime(),
 758 //                              _ptrField->getOrderNumber()
 759 //                              );
 760
 761         err=med_2_2::MEDchampEcr(MED_FIELD_DRIVER22<T>::_medIdt,
 762                                 const_cast <char*> ( MeshName.c_str()) ,                         //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
 763                                 const_cast <char*> ( (MED_FIELD_DRIVER<T>::_ptrField->getName()).c_str()),
 764                                 (unsigned char*)value,
 765                                 med_2_2::MED_FULL_INTERLACE,
 766                                 NumberOfElements*NumberOfGaussPoint[i],
 767                                 MED_NOGAUSS, MED_ALL, MED_NOPFL,
 768                                 med_2_2::MED_NO_PFLMOD, // PROFIL NON GERE, mode de remplacement non géré
 769                                 (med_2_2::med_entite_maillage)mySupport->getEntity(),
 770                                 (med_2_2::med_geometrie_element)Types[i],
 771                                 MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
 772                                 "        ",
 773                                 MED_FIELD_DRIVER<T>::_ptrField->getTime(),
 774                                 MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
 775                                 );
 776
 777         if (err < MED_VALID )
 778           throw MEDEXCEPTION(LOCALIZED( STRING(LOC)
 779                                         <<": Error in writing Field "<< MED_FIELD_DRIVER<T>::_ptrField->getName() <<", type "<<Types[i]
 780                                         )
 781                              );
 782
 783         Index += NumberOfElements ;
 784
 785       }
 786     }
 787
 788   END_OF(LOC);
 789 }
 790
 791 /*--------------------- RDWR PART -------------------------------*/
 792
 793 template <class T> GENDRIVER * MED_FIELD_RDWR_DRIVER22<T>::copy(void) const
 794 {
 795   return new MED_FIELD_RDWR_DRIVER22<T>(*this);
 796 }
 797
 798 template <class T> void MED_FIELD_RDWR_DRIVER22<T>::write(void) const
 799   throw (MEDEXCEPTION)
 800 {
 801   BEGIN_OF("MED_FIELD_RDWR_DRIVER22::write(void)");
 802   MED_FIELD_WRONLY_DRIVER22<T>::write();
 803   END_OF("MED_FIELD_RDWR_DRIVER22::write(void)");
 804 }
 805
 806 template <class T> void MED_FIELD_RDWR_DRIVER22<T>::read (void)
 807   throw (MEDEXCEPTION)
 808 {
 809   BEGIN_OF("MED_FIELD_RDWR_DRIVER22::read(void)");
 810   MED_FIELD_RDONLY_DRIVER22<T>::read();
 811   END_OF("MED_FIELD_RDWR_DRIVER22::read(void)");
 812 }
 813
 814 }
 815 /*-----------------------------------------------------------------*/
 816
 817 #endif /* MED_FIELD_DRIVER_HXX */
 818