src/MEDMEM/MEDMEM_MedFieldDriver21.hxx

   1 //  Copyright (C) 2007-2008  CEA/DEN, EDF R&D, OPEN CASCADE
   2 //
   3 //  Copyright (C) 2003-2007  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   4 //  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   5 //
   6 //  This library is free software; you can redistribute it and/or
   7 //  modify it under the terms of the GNU Lesser General Public
   8 //  License as published by the Free Software Foundation; either
   9 //  version 2.1 of the License.
  10 //
  11 //  This library is distributed in the hope that it will be useful,
  12 //  but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 //  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14 //  Lesser General Public License for more details.
  15 //
  16 //  You should have received a copy of the GNU Lesser General Public
  17 //  License along with this library; if not, write to the Free Software
  18 //  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  19 //
  20 //  See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  21 //
  22 #ifndef MED_FIELD_DRIVER21_HXX
  23 #define MED_FIELD_DRIVER21_HXX
  24
  25 #include <string>
  26
  27 #include "MEDMEM_define.hxx"
  28
  29 #include "MEDMEM_DriversDef.hxx"
  30 #include "MEDMEM_Utilities.hxx"
  31 #include "MEDMEM_MedFieldDriver.hxx"
  32 #include "MEDMEM_STRING.hxx"
  33 #include "MEDMEM_Exception.hxx"
  34 #include "MEDMEM_Unit.hxx"
  35
  36 #include "MEDMEM_ArrayInterface.hxx"
  37 #include "MEDMEM_ArrayConvert.hxx"
  38
  39 #include "MEDMEM_Support.hxx"
  40 #include "MEDMEM_Mesh.hxx"
  41 #include "MEDMEM_GaussLocalization.hxx"
  42
  43 namespace MEDMEM {
  44
  45 /*!
  46
  47   Driver Med for FIELD.
  48
  49   Generic part : implement open and close methods.
  50
  51 */
  52
  53 template <class T> class MED_FIELD_DRIVER21 : public virtual MED_FIELD_DRIVER<T>
  54 {
  55 protected:
  56   med_2_1::med_idt        _medIdt;
  57
  58   bool createFieldSupport(med_2_1::med_idt id,
  59                           string & fieldName,
  60                           med_2_1::med_int ndt,
  61                           med_2_1::med_int od,
  62                           SUPPORT & support,
  63                           vector<int> & numberOfGaussPoint,
  64                           string & meshName) const throw (MEDEXCEPTION);
  65
  66   void getMeshGeometricType(med_2_1::med_idt id,
  67                             string & meshName,
  68                             MED_EN::medEntityMesh  entite,
  69                             vector<MED_EN::medGeometryElement> & geoType,
  70                             vector<int> &nbOfElOfType) const;
  71
  72 public :
  73
  74   /*!
  75     Constructor.
  76   */
  77   MED_FIELD_DRIVER21():MED_FIELD_DRIVER<T>(),_medIdt(MED_INVALID)
  78   {}
  79   /*!
  80     Constructor.
  81   */
  82   template <class INTERLACING_TAG>
  83   MED_FIELD_DRIVER21(const string & fileName,
  84                      FIELD<T, INTERLACING_TAG> * ptrField,
  85                      MED_EN::med_mode_acces accessMode)
  86     : MED_FIELD_DRIVER<T>(fileName,ptrField,accessMode),_medIdt(MED_INVALID)
  87   {
  88   }
  89
  90   /*!
  91     Copy constructor.
  92   */
  93   MED_FIELD_DRIVER21(const MED_FIELD_DRIVER21 & fieldDriver):
  94     MED_FIELD_DRIVER<T>(fieldDriver), _medIdt(fieldDriver._medIdt)
  95   {
  96   }
  97
  98   /*!
  99     Destructor.
 100   */
 101   virtual ~MED_FIELD_DRIVER21() {
 102   }
 103
 104   void open() throw (MEDEXCEPTION)
 105   {
 106     const char * LOC = "MED_FIELD_DRIVER21::open() ";
 107     BEGIN_OF_MED(LOC);
 108
 109     // we must set fieldname before open, because we must find field number in file (if it exist !!!)
 110     if ( MED_FIELD_DRIVER<T>::_fileName == "" ) {
 111       throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 112                                        << "_fileName is |\"\"|, please set a correct fileName before calling open()"
 113                                        )
 114                             );
 115     }
 116     if ( MED_FIELD_DRIVER<T>::_status==MED_OPENED )
 117       return;
 118
 119     MED_EN::med_mode_acces mode = dynamic_cast<GENDRIVER*>(this)->getAccessMode();
 120     med_2_1::med_mode_acces m21mode = (med_2_1::med_mode_acces)getMedAccessMode(mode,MED_EN::V21);
 121     MESSAGE_MED(LOC<<"_fileName.c_str : "<< MED_FIELD_DRIVER<T>::_fileName.c_str()<<",mode : "<< MED_FIELD_DRIVER<T>::_accessMode);
 122     _medIdt = med_2_1::MEDouvrir( (const_cast <char *> (MED_FIELD_DRIVER<T>::_fileName.c_str())),
 123                                   //(med_2_1::med_mode_acces) MED_FIELD_DRIVER<T>::_accessMode);
 124                                   m21mode);
 125     //                             (med_2_1::med_mode_acces) mode);
 126     MESSAGE_MED(LOC<<"_medIdt : "<< _medIdt );
 127     if (_medIdt > 0)
 128       MED_FIELD_DRIVER<T>::_status=MED_OPENED;
 129     else {
 130       MED_FIELD_DRIVER<T>::_status = MED_INVALID;
 131       MED_FIELD_DRIVER21<T>::_medIdt = MED_INVALID;
 132       throw MED_EXCEPTION (LOCALIZED( STRING(LOC)
 133                                       << "Can't open |"  << MED_FIELD_DRIVER<T>::_fileName
 134                                       << "|, _medIdt : " << MED_FIELD_DRIVER21<T>::_medIdt
 135                                       )
 136                            );
 137     }
 138
 139   END_OF_MED(LOC);
 140   }
 141
 142   void close() {
 143   const char* LOC = "MED_FIELD_DRIVER21::close()";
 144   BEGIN_OF_MED(LOC);
 145     med_2_1::med_int err = 0;
 146     if (MED_FIELD_DRIVER<T>::_status == MED_OPENED) {
 147       err=med_2_1::MEDfermer(MED_FIELD_DRIVER21<T>::_medIdt);
 148       //H5close(); // If we call H5close() all the files are closed.
 149       MED_FIELD_DRIVER<T>::_status = MED_CLOSED;
 150       MED_FIELD_DRIVER21<T>::_medIdt = MED_INVALID;
 151       MESSAGE_MED(" MED_FIELD_DRIVER21::close() : MEDfermer : MED_FIELD_DRIVER21<T>::_medIdt= " << _medIdt );
 152       MESSAGE_MED(" MED_FIELD_DRIVER21::close() : MEDfermer : err    = " << err );
 153     }
 154   END_OF_MED(LOC);
 155   }
 156
 157
 158 };
 159
 160 /*!
 161
 162   Driver Med for FIELD : Read only.
 163
 164   Implement read method.
 165
 166 */
 167
 168   template <class T> class MED_FIELD_RDONLY_DRIVER21 : public virtual MED_FIELD_DRIVER21<T>, public virtual IMED_FIELD_RDONLY_DRIVER<T>
 169 {
 170
 171 public :
 172
 173   /*!
 174     Constructor.
 175   */
 176   MED_FIELD_RDONLY_DRIVER21():MED_FIELD_DRIVER<T>()
 177   {
 178     this->GENDRIVER::_accessMode = MED_EN::RDONLY;
 179   };
 180
 181   /*!
 182     Constructor.
 183   */
 184   template <class INTERLACING_TAG>
 185   MED_FIELD_RDONLY_DRIVER21(const string & fileName,
 186                             FIELD<T, INTERLACING_TAG> * ptrField):
 187     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::RDONLY),
 188     MED_FIELD_DRIVER21<T>(fileName,ptrField,MED_EN::RDONLY),
 189     IMED_FIELD_RDONLY_DRIVER<T>(fileName,ptrField)
 190   {
 191   const char* LOC = "MED_FIELD_RDONLY_DRIVER21::MED_FIELD_RDONLY_DRIVER21(const string & fileName, const FIELD<T,INTERLACING_TAG> * ptrField)";
 192   BEGIN_OF_MED(LOC);
 193   END_OF_MED(LOC);
 194   }
 195
 196   /*!
 197     Copy constructor.
 198   */
 199   MED_FIELD_RDONLY_DRIVER21(const MED_FIELD_RDONLY_DRIVER21 & fieldDriver):
 200     IMED_FIELD_RDONLY_DRIVER<T>(fieldDriver),
 201     MED_FIELD_DRIVER21<T>(fieldDriver),
 202     MED_FIELD_DRIVER<T>(fieldDriver)
 203   {};
 204
 205   /*!
 206     Destructor.
 207   */
 208   virtual ~MED_FIELD_RDONLY_DRIVER21() {};
 209
 210   // CREER UNE METHODE POUR LIRE LA LISTE DES MAILLAGES .....
 211
 212   /*!
 213     Return a MEDEXCEPTION : it is the read-only driver.
 214   */
 215   void write( void ) const throw (MEDEXCEPTION) ;
 216   /*!
 217     Read FIELD in the specified file.
 218   */
 219   void read ( void ) throw (MEDEXCEPTION) ;
 220
 221 private:
 222   GENDRIVER * copy( void ) const ;
 223
 224 };
 225
 226 /*!
 227
 228   Driver Med for FIELD : Write only.
 229
 230   Implement write method.
 231
 232 */
 233
 234 template <class T> class MED_FIELD_WRONLY_DRIVER21 : public virtual MED_FIELD_DRIVER21<T>, public virtual IMED_FIELD_WRONLY_DRIVER<T> {
 235
 236 public :
 237
 238   /*!
 239     Constructor.
 240   */
 241   MED_FIELD_WRONLY_DRIVER21():MED_FIELD_DRIVER<T>()
 242   {
 243     this->GENDRIVER::_accessMode = MED_EN::WRONLY;
 244   }
 245
 246   /*!
 247     Constructor.
 248   */
 249   template <class INTERLACING_TAG>
 250   MED_FIELD_WRONLY_DRIVER21(const string & fileName,
 251                             FIELD<T, INTERLACING_TAG> * ptrField):
 252     IMED_FIELD_WRONLY_DRIVER<T>(fileName,ptrField),
 253     MED_FIELD_DRIVER21<T>(fileName,ptrField,MED_EN::WRONLY),
 254     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::WRONLY)
 255   {
 256   const char* LOC = "MED_FIELD_WRONLY_DRIVER21::MED_FIELD_WRONLY_DRIVER21(const string & fileName, const FIELD<T,INTERLACING_TAG> * ptrField)";
 257   BEGIN_OF_MED(LOC);
 258   END_OF_MED(LOC);
 259   }
 260
 261   /*!
 262     Copy constructor.
 263   */
 264   MED_FIELD_WRONLY_DRIVER21(const MED_FIELD_WRONLY_DRIVER21 & fieldDriver):
 265     IMED_FIELD_WRONLY_DRIVER<T>(fieldDriver),
 266     MED_FIELD_DRIVER21<T>(fieldDriver),
 267     MED_FIELD_DRIVER<T>(fieldDriver)
 268   {}
 269
 270   /*!
 271     Destructor.
 272   */
 273   virtual ~MED_FIELD_WRONLY_DRIVER21() {};
 274
 275   /*!
 276     Write FIELD in the specified file.
 277   */
 278   void write( void ) const throw (MEDEXCEPTION) ;
 279   /*!
 280     Return a MEDEXCEPTION : it is the write-only driver.
 281   */
 282   void read ( void ) throw (MEDEXCEPTION) ;
 283
 284 private:
 285   GENDRIVER * copy( void ) const ;
 286
 287 };
 288
 289
 290 /*!
 291
 292   Driver Med for FIELD : Read write.
 293   - Use read method from MED_FIELD_RDONLY_DRIVER
 294   - Use write method from MED_FIELD_WDONLY_DRIVER
 295
 296 */
 297
 298 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> {
 299
 300 public :
 301
 302   /*!
 303     Constructor.
 304   */
 305   MED_FIELD_RDWR_DRIVER21():MED_FIELD_DRIVER21<T>()
 306   {
 307     this->GENDRIVER::_accessMode = MED_EN::RDWR;
 308   }
 309
 310   /*!
 311     Constructor.
 312   */
 313   template <class INTERLACING_TAG>
 314   MED_FIELD_RDWR_DRIVER21(const string & fileName,
 315                           FIELD<T, INTERLACING_TAG> * ptrField):
 316     MED_FIELD_WRONLY_DRIVER21<T>(fileName,ptrField),
 317     MED_FIELD_RDONLY_DRIVER21<T>(fileName,ptrField),
 318     IMED_FIELD_RDONLY_DRIVER<T>(fileName,ptrField),
 319     IMED_FIELD_WRONLY_DRIVER<T>(fileName,ptrField),
 320     MED_FIELD_DRIVER<T>(fileName,ptrField,MED_EN::RDWR),
 321     IMED_FIELD_RDWR_DRIVER<T>(fileName,ptrField)
 322   {
 323   const char* LOC = "MED_FIELD_RDWR_DRIVER21::MED_FIELD_RDWR_DRIVER21(const string & fileName, const FIELD<T> * ptrField)";
 324   BEGIN_OF_MED(LOC);
 325     //_accessMode = MED_RDWR ;
 326   END_OF_MED(LOC);
 327   }
 328
 329   /*!
 330     Copy constructor.
 331   */
 332   MED_FIELD_RDWR_DRIVER21(const MED_FIELD_RDWR_DRIVER21 & fieldDriver):
 333     MED_FIELD_WRONLY_DRIVER21<T>(fieldDriver),
 334     MED_FIELD_RDONLY_DRIVER21<T>(fieldDriver),
 335     IMED_FIELD_RDWR_DRIVER<T>(fieldDriver),
 336     IMED_FIELD_RDONLY_DRIVER<T>(fieldDriver),
 337     IMED_FIELD_WRONLY_DRIVER<T>(fieldDriver),
 338     MED_FIELD_DRIVER<T>(fieldDriver)
 339   {};
 340
 341   /*!
 342     Destructor.
 343   */
 344   ~MED_FIELD_RDWR_DRIVER21() {};
 345
 346   /*!
 347     Write FIELD in the specified file.
 348   */
 349   void write(void) const throw (MEDEXCEPTION) ;
 350   /*!
 351     Read FIELD in the specified file.
 352   */
 353   void read (void) throw (MEDEXCEPTION) ;
 354
 355 private:
 356   GENDRIVER * copy( void ) const ;
 357
 358 };
 359
 360 /*--------------------- DRIVER PART -------------------------------*/
 361
 362 template <class T> bool
 363 MED_FIELD_DRIVER21<T>::createFieldSupport(med_2_1::med_idt id,
 364                                           string & fieldName,
 365                                           med_2_1::med_int ndt,
 366                                           med_2_1::med_int od,
 367                                           SUPPORT & support,
 368                                           vector<int> & numberOfGaussPoints,
 369                                           string & meshName) const throw (MEDEXCEPTION)
 370 {
 371
 372   //EF : Gérer le meshName pour le driver 2.2
 373   const char * LOC="MED_FIELD_DRIVER<T>::search_field(...)";
 374
 375   BEGIN_OF_MED(LOC);
 376
 377   map<int, list<MED_EN::medGeometryElement> > CellAndNodeEntities;
 378   map<int, list<MED_EN::medGeometryElement> >::iterator currentEntity;
 379   CellAndNodeEntities[MED_EN::MED_CELL]  = MED_EN::meshEntities[MED_EN::MED_CELL];
 380   CellAndNodeEntities[MED_EN::MED_NODE] = MED_EN::meshEntities[MED_EN::MED_NODE];
 381   list< MED_EN::medGeometryElement >::const_iterator currentGeometry;
 382
 383   MED_EN::medEntityMesh entityCurrent;
 384   MED_EN::medGeometryElement geometryCurrent;
 385
 386   //med_2_1::med_entite_maillage
 387   MED_EN::medEntityMesh entity;
 388   bool alreadyFoundAnEntity=false, alreadyFoundPdtIt = false/*, anyGauss=false*/;
 389   int  numberOfElements = 0, numberOfElements1 = 0,numberOfElements2 = 0;
 390   int  numberOfGeometricType = 0;
 391   //med_2_1::med_geometrie_element..
 392   MED_EN::medGeometryElement geometricType[MED_NBR_GEOMETRIE_MAILLE];
 393   int numberOfElementsOfType[MED_NBR_GEOMETRIE_MAILLE];
 394   //int numberOfGaussPoints[MED_NBR_GEOMETRIE_MAILLE];
 395   numberOfGaussPoints.resize(MED_NBR_GEOMETRIE_MAILLE, 1);
 396
 397   med_2_1::med_int ngauss=0, numdt=-1, numo=-1, nbPdtIt=0; //nmaa=0
 398   char dtunit[MED_TAILLE_PNOM21+1], maa[MED_TAILLE_NOM+1];
 399   med_2_1::med_float   dt=-1.0;
 400   //med_2_1::med_booleen local;
 401   med_2_1::med_err     ret=1;
 402
 403   for (currentEntity = CellAndNodeEntities.begin();
 404        currentEntity != CellAndNodeEntities.end(); currentEntity++) {
 405     for (currentGeometry  = (*currentEntity).second.begin();
 406          currentGeometry != (*currentEntity).second.end(); currentGeometry++) {
 407
 408       entityCurrent = (*currentEntity).first ;
 409       geometryCurrent = (*currentGeometry) ;
 410
 411       // That is a difference between Med File and Med Memory (NB)
 412
 413       if (geometryCurrent == MED_EN::MED_SEG2 || geometryCurrent == MED_EN::MED_SEG3)
 414         entityCurrent = MED_EN::MED_EDGE;
 415
 416       if (geometryCurrent == MED_EN::MED_TRIA3 || geometryCurrent == MED_EN::MED_QUAD4 ||
 417           geometryCurrent == MED_EN::MED_TRIA6 || geometryCurrent == MED_EN::MED_QUAD8)
 418         entityCurrent = MED_EN::MED_FACE;
 419
 420       numberOfElements1 =  med_2_1::MEDnVal(id, const_cast <char*> ( fieldName.c_str() ),
 421                                             (med_2_1::med_entite_maillage)   (*currentEntity).first,
 422                                             (med_2_1::med_geometrie_element) *currentGeometry,
 423                                             ndt, od);
 424
 425       numberOfElements2 =  med_2_1::MEDnVal(id, const_cast <char*> ( fieldName.c_str() ),
 426                                             (med_2_1::med_entite_maillage) entityCurrent,
 427                                             (med_2_1::med_geometrie_element) *currentGeometry,
 428                                             ndt, od);
 429       if (numberOfElements2 < numberOfElements1) entityCurrent = (*currentEntity).first ;
 430
 431       numberOfElements = (numberOfElements1>numberOfElements2)?numberOfElements1:numberOfElements2;
 432
 433       SCRUTE_MED(numberOfElements);
 434
 435       if ( numberOfElements <=  0 )
 436         continue;
 437
 438       if ( alreadyFoundAnEntity ) {
 439         if (entity != entityCurrent)
 440           throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Field |"  << fieldName
 441                                        << "| with (ndt,or) = (" << ndt << ","
 442                                        << od << ") must not be defined on nodes and cells" ));
 443
 444       } else { entity=entityCurrent; alreadyFoundAnEntity = true; };
 445
 446       nbPdtIt = med_2_1::MEDnPasdetemps(id, const_cast <char*> ( fieldName.c_str() ),
 447                                         (med_2_1::med_entite_maillage) entityCurrent,
 448                                         (med_2_1::med_geometrie_element)  *currentGeometry );
 449
 450       SCRUTE_MED(nbPdtIt);
 451       SCRUTE_MED(numberOfElements);
 452
 453       if ( nbPdtIt < 0 )
 454         throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Field |" << fieldName << "| with (ndt,or) = ("
 455                                      << ndt << "," << od << ") should be defined for (entityType,geometricType)=("
 456                                      << MED_EN::entNames[entityCurrent] << ","
 457                                      << MED_EN::geoNames[*currentGeometry] << ")" ));
 458
 459       ret = 0; alreadyFoundPdtIt = false; ngauss =0;
 460       for ( med_2_1::med_int j=1; j <= nbPdtIt; j++ ) {
 461
 462         // Search how many <ngauss> (<fieldName>,<ndt>,<ot>) has
 463         ret = med_2_1::MEDpasdetempsInfo(id, const_cast <char*> ( fieldName.c_str() ),
 464                                          (med_2_1::med_entite_maillage) entityCurrent,
 465                                          (med_2_1::med_geometrie_element)  *currentGeometry,
 466                                          j,maa,&ngauss,&numdt,dtunit,&dt,&numo);
 467
 468         MED_FIELD_DRIVER<T>::_ptrField->setTime(dt); // PAL12664
 469
 470         //          ret = med_2_2::MEDpasdetempsInfo(id, const_cast <char*> ( fieldName.c_str() ),
 471         //                                  (med_2_1::med_entite_maillage)   (*currentEntity).first,
 472         //                                  (med_2_1::med_geometrie_element)  *currentGeometry,
 473         //                                  j, &ngauss,  &numdt,  &numo, &dtunit, &dt, &maa, &local, &nmaa)
 474
 475         if ( ndt == numdt && numo == od ) {
 476           alreadyFoundPdtIt = true;
 477           if ( ! meshName.empty() )
 478             if ( meshName != maa ) {
 479
 480               //                  if ( nmaa > 1 )
 481               {
 482                 //EF : Gérer le meshName pour le driver 2.2
 483                 //                    MESSAGE_MED(STRING(LOC)<<" Field |" << fieldName << "| with (ndt,or) = (" << ndt << ","
 484                 //                            << ot << ") is  defined on " << nmaa << " meshes, using mesh |"
 485                 //                            << maa << "|");
 486                 //                  }
 487                 throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Field |" << fieldName << "| with (ndt,or) = ("
 488                                              << ndt << "," << od << ") for (entityType,geometricType)=("
 489                                              << MED_EN::entNames[entityCurrent] << ","
 490                                              << MED_EN::geoNames[*currentGeometry] << ")"
 491                                              << "is defined on mesh |" << maa << "| not on mesh |" << meshName ));
 492               }
 493             }
 494           break;
 495         }
 496       }
 497
 498       MESSAGE_MED(LOC << " a (dt,it) is found ?? " << alreadyFoundPdtIt);
 499
 500       if ( !alreadyFoundPdtIt )
 501         throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Field |" << fieldName << "| with (ndt,or) = ("
 502                                      << ndt << "," << od << ") should be defined for (entityType,geometricType)=("
 503                                      << MED_EN::entNames[entityCurrent] << ","
 504                                      << MED_EN::geoNames[*currentGeometry] << ")" ));
 505
 506       if ( (ret != 0)  || (ngauss < 1 ) )
 507         throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Error in MEDpasdetempsInfo for  Field |" << fieldName
 508                                      << "| with (ndt,or) = ("
 509                                      << ndt << "," << od << ") for (entityType,geometricType)=("
 510                                      << MED_EN::entNames[entityCurrent] << ","
 511                                      << MED_EN::geoNames[*currentGeometry] << ")" ));
 512       if ( ngauss > 1000 ) { // some gabage
 513         INFOS_MED( "Set to 1 invalid nb of Gauss points " << ngauss << " for  Field |" << fieldName
 514                << "| with (ndt,or) = (" << ndt << "," << od << ") for (entityType,geometricType)=("
 515                << MED_EN::entNames[entityCurrent] << ","
 516                << MED_EN::geoNames[*currentGeometry] << ")" );
 517         ngauss = 1;
 518       }
 519
 520       //totalNumberOfElements+=numberOfElements;
 521       numberOfElementsOfType[numberOfGeometricType] = numberOfElements/ngauss;
 522       numberOfGaussPoints[numberOfGeometricType] = ngauss;
 523       //anyGauss = (anyGauss || (ngauss-1) );
 524       geometricType[numberOfGeometricType]= *currentGeometry;
 525       numberOfGeometricType++;
 526
 527     } // End Second For
 528
 529   } // End Premier For
 530
 531   if ( alreadyFoundAnEntity) {
 532     support.setName(fieldName+"Support");
 533     support.setMeshName(string(maa)); // Vérifier que les différents noms de maillages lus soient identiques
 534     support.setEntity(entity);
 535     // REM : Signification précédente erronée pour un champ qui ne repose pas sur toutes les entités géométriques
 536     // du maillage mais dont le SUPPORT a été crée à partir des informations d'un maillage, comme
 537     // celà fût la plupart du temps.
 538     support.setNumberOfGeometricType(numberOfGeometricType);
 539     support.setGeometricType(geometricType); // Utile uniquement si setAll == false
 540     support.setNumberOfElements(numberOfElementsOfType);    //setNumberOfElements effectue une copie
 541     support.setAll(true);
 542
 543   END_OF_MED(LOC);
 544
 545     return alreadyFoundAnEntity;
 546   } else
 547     {
 548   END_OF_MED(LOC);
 549
 550       return false;
 551     }
 552 }
 553
 554 template <class T> void
 555 MED_FIELD_DRIVER21<T>::getMeshGeometricType(med_2_1::med_idt id,
 556                                           string & meshName,
 557                                           MED_EN::medEntityMesh  entity,
 558                                           vector<MED_EN::medGeometryElement> & geoType,
 559                                           vector<int> &nbOfElOfType) const
 560 {
 561   //const char LOC[] = "MED_FIELD_DRIVER<T>::getMeshGeometricType(...)";
 562
 563   int numberOfGeometricType=0;
 564   MED_EN::medGeometryElement geometricType[MED_NBR_GEOMETRIE_MAILLE];
 565   int numberOfElementsOfType[MED_NBR_GEOMETRIE_MAILLE];
 566   med_2_1::med_int   numberOfElements=0;
 567   med_2_1::med_table quoi;
 568   if (entity == MED_EN::MED_CELL) quoi=med_2_1::MED_CONN;
 569   else
 570     if (entity == MED_EN::MED_NODE) quoi=med_2_1::MED_COOR;
 571     else
 572       MESSAGE_MED("MED_FIELD_DRIVER<T>::getMeshGeometricType(...)"<<" Support Creation from Mesh |"  << meshName
 573                                    << "| on entity " << MED_EN::entNames[entity]
 574                                    << "| is impossible,  must be  on MED_NODE or MED_CELL");
 575
 576 //       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Support Creation from Mesh |"  << meshName
 577 //                                 << "| on entity " << MED_EN::entNames[entity]
 578 //                                 << "| is impossible,  must be  on MED_NODE or MED_CELL" ));
 579
 580   list<MED_EN::medGeometryElement>::const_iterator currentGeometry;
 581   bool alreadyFoundAnEntity = false;
 582
 583   for (currentGeometry  = (MED_EN::meshEntities[entity]).begin();
 584        currentGeometry != (MED_EN::meshEntities[entity]).end(); currentGeometry++) {
 585
 586
 587     if ( (numberOfElements =
 588           med_2_1::MEDnEntMaa(id,
 589                               const_cast<char*> (meshName.c_str()),
 590                               quoi,
 591                               (med_2_1::med_entite_maillage)   entity,
 592                               (med_2_1::med_geometrie_element)  *currentGeometry,
 593                               med_2_1::MED_NOD) ) <= 0)
 594       continue;
 595
 596     alreadyFoundAnEntity = true;
 597     numberOfElementsOfType[numberOfGeometricType] = numberOfElements;
 598     geometricType[numberOfGeometricType] = *currentGeometry;
 599     numberOfGeometricType++;
 600
 601   }
 602
 603   geoType = vector<MED_EN::medGeometryElement>(geometricType,geometricType+numberOfGeometricType);
 604   nbOfElOfType = vector<int> (numberOfElementsOfType,numberOfElementsOfType+numberOfGeometricType);
 605
 606 }
 607
 608 /*--------------------- RDONLY PART -------------------------------*/
 609
 610 template <class T> GENDRIVER * MED_FIELD_RDONLY_DRIVER21<T>::copy(void) const
 611 {
 612   return new MED_FIELD_RDONLY_DRIVER21<T>(*this);
 613 }
 614
 615 template <class T> void MED_FIELD_RDONLY_DRIVER21<T>::read(void)
 616   throw (MEDEXCEPTION)
 617 {
 618   const char * LOC = " MED_FIELD_RDONLY_DRIVER21::read() " ;
 619   BEGIN_OF_MED(LOC);
 620
 621   typedef typename MEDMEM_ArrayInterface<T,NoInterlace,NoGauss>::Array       ArrayNo;
 622   typedef typename MEDMEM_ArrayInterface<T,NoInterlace,Gauss>::Array         ArrayNoWg;
 623   typedef typename MEDMEM_ArrayInterface<T,FullInterlace,NoGauss>::Array     ArrayFull;
 624   typedef typename MEDMEM_ArrayInterface<T,FullInterlace,Gauss>::Array       ArrayFullWg;
 625   typedef typename MEDMEM_ArrayInterface<T,NoInterlaceByType,NoGauss>::Array ArrayByType;
 626   typedef typename MEDMEM_ArrayInterface<T,NoInterlaceByType,Gauss>::Array   ArrayByTypeWg;
 627
 628   if ( ( MED_FIELD_DRIVER<T>::_fieldName.empty()       ) &&
 629        ( MED_FIELD_DRIVER<T>::_ptrField->_name.empty() )    )
 630     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)
 631                                  <<" neither <fieldName> is set in driver nor in object FIELD.")) ;
 632
 633   // If _fieldName is not set in driver, try to use _ptrfield->_fieldName
 634   if ( ( MED_FIELD_DRIVER<T>::_fieldName.empty()       ) &&
 635        ( !MED_FIELD_DRIVER<T>::_ptrField->_name.empty() )    )
 636     MED_FIELD_DRIVER<T>::_fieldName=MED_FIELD_DRIVER<T>::_ptrField->_name;
 637
 638   if ( MED_FIELD_DRIVER<T>::_fieldName.size() > MED_TAILLE_NOM )
 639     MESSAGE_MED(LOC << "Warning <fieldName> size in object driver FIELD is > MED_TAILLE_NOM .");
 640
 641 //     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)
 642 //                               <<" <fieldName> size in object driver FIELD is > MED_TAILLE_NOM ."));
 643
 644
 645   MESSAGE_MED("###### "<<LOC<<" fieldNameDRIVER : "<< MED_FIELD_DRIVER<T>::_fieldName <<
 646           " fieldName : "<<MED_FIELD_DRIVER<T>::_fieldName);
 647
 648
 649   if (MED_FIELD_DRIVER<T>::_status!=MED_OPENED)
 650     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": Method open must be called before method read.")) ;
 651
 652 // EF :
 653 //   Si un support a été donnée au champ, pour des raisons de compatibilité avec
 654 //   les versions précédentes, ce support sera utilisé pour
 655 //   - Obtenir le nom du maillage sur lequel on veut lire le champ
 656 //     (eventuellement on pourrait l'utiliser pour selectionner un champ qui
 657 //      repose sur plusieurs maillages cf HOMARD-ASTER)
 658 //   -  vérifier le type d'entité (MED_NOEUD xor  MED_MAILLE xor MED_FACE xor MED_ARETE ) sur lequel
 659 //      il faut lire le champ qui est également  retouvé.
 660 //   - Si le support défini une liste d'entité ( différente de MED_ALL_ELEMENTS), celle-ci est ignorée
 661 //     à la lecture et écrasé par les listes de profils lus s'il en existe
 662
 663 //   Si aucun support n'a été donné au champ :
 664 //   - A la lecture : Un support est crée et le type d'entité unique est lu
 665 //                    (cf decision gt MED qu'un champ repose sur une entité unique ?),
 666 //                    l'ensemble des types géométriques est lu,
 667 //                    l'ensemble des profils par type géométrique est lu
 668 //                    Le nom du maillage associé est lu mais le pointeur SUPPORT-MESH non initialisé
 669
 670   char fieldName[MED_TAILLE_NOM+1] ;
 671
 672   int err ;
 673   int    numberOfComponents          = 0;
 674   char * componentName               = (char *) MED_NULL;
 675   char * unitName                    = (char *) MED_NULL;
 676   med_2_1::med_type_champ type ;
 677   med_2_1::med_idt id = MED_FIELD_DRIVER21<T>::_medIdt;
 678
 679   // we search for the field med number of <fieldName>
 680   // Having found <fieldName> variables <numberOfComponents>,
 681   // <componentName>, <unitname>, <type> and attribute <_fieldNum> are set.
 682   if (MED_FIELD_DRIVER<T>::_fieldNum==MED_INVALID)
 683     {
 684       int    numberOfFields              = 0;      //MED_INVALID
 685       numberOfFields = med_2_1::MEDnChamp(id,0) ;
 686       if ( numberOfFields <= 0 )
 687         throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": No Field found !"));
 688
 689       for (int i=1;i<=numberOfFields;i++)
 690         {
 691           numberOfComponents = med_2_1::MEDnChamp(id,i) ;
 692           if ( numberOfComponents <= 0 )
 693             //                throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 694             //                                                 <<  "Be careful there is no compound for field n°"
 695             //                                                 << i << "in file |"<<_fileName<<"| !"));
 696             MESSAGE_MED(LOC<<"Be careful there is no compound for field n°"<<i<<"in file |"<<MED_FIELD_DRIVER<T>::_fileName<<"| !");
 697
 698           componentName = new char[numberOfComponents*MED_TAILLE_PNOM21+1] ;
 699           unitName      = new char[numberOfComponents*MED_TAILLE_PNOM21+1] ;
 700
 701           err = med_2_1::MEDchampInfo(id, i, fieldName, &type, componentName,
 702                                       unitName, numberOfComponents) ;
 703
 704           MESSAGE_MED("Champ "<<i<<" : #" << fieldName <<"# et recherche #"<<MED_FIELD_DRIVER<T>::_fieldName.c_str()<<"#");
 705           if ( !strcmp(fieldName,MED_FIELD_DRIVER<T>::_fieldName.c_str()) )
 706             {
 707               MESSAGE_MED("FOUND FIELD "<< fieldName <<" : "<<i);
 708               MED_FIELD_DRIVER<T>::_fieldNum = i ;
 709               break ;
 710             }
 711           // not found : release memory and search next field !
 712           delete[] componentName ;
 713           delete[] unitName ;
 714         }
 715     }
 716
 717   //delete[] fieldName ;
 718
 719   if (MED_FIELD_DRIVER<T>::_fieldNum==MED_INVALID)
 720     throw MEDEXCEPTION(LOCALIZED( STRING(LOC) << ": Field "<<MED_FIELD_DRIVER<T>::_fieldName << " not found in file " << MED_FIELD_DRIVER<T>::_fileName ) );
 721
 722   MESSAGE_MED ("FieldNum : "<<MED_FIELD_DRIVER<T>::_fieldNum);
 723
 724   if (numberOfComponents < 1)
 725     {
 726       delete[] componentName; delete[] unitName;
 727       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"no component found for field "
 728                                    << MED_FIELD_DRIVER<T>::_fieldName)) ;
 729     }
 730
 731   // Pourquoi _ptrField est toujour null et non MED_FIELD_DRIVER<T>::_ptrField
 732   switch ( (med_2_1::med_type_champ) MED_FIELD_DRIVER<T>::_ptrField->_valueType ) {
 733   case  med_2_1::MED_INT :
 734   case  med_2_1::MED_INT32 :
 735   case  med_2_1::MED_INT64 :
 736     if ( type == ( med_2_1::MED_REEL64 ) ) {
 737       delete[] componentName; delete[] unitName;
 738       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Field Type in file (" << type
 739                                    <<") differs from FIELD object type (" <<
 740                                    MED_FIELD_DRIVER<T>::_ptrField->_valueType << ")" )) ;
 741     }
 742     break;
 743   default:
 744     break;
 745   }
 746
 747
 748   string meshName="";
 749   bool   haveSupport = false;
 750   if ( MED_FIELD_DRIVER<T>::_ptrField->getSupport() ) {
 751     // Verif sur la taille du meshName
 752     meshName =  MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getMesh()->getName() ;
 753     haveSupport = true;
 754   }
 755
 756   // Cherche le type d'entité, le nombre d'entité  par type géométrique sur le type d'entité
 757   // (MED_MAILLE ou MED_NOEUD uniquement car MEDMEMOIRE ne gère pas la connectivité descendante).
 758   // et crée le support correspondant.
 759   SUPPORT * mySupport = new SUPPORT();
 760   vector<int> numberOfGaussPoints;
 761   bool found = createFieldSupport(id,MED_FIELD_DRIVER<T>::_fieldName,
 762                                   MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber,
 763                                   MED_FIELD_DRIVER<T>::_ptrField->_orderNumber,
 764                                   *mySupport, numberOfGaussPoints, meshName) ;
 765   if ( !found ) {
 766     delete mySupport; delete[] componentName; delete[] unitName;
 767     MED_FIELD_DRIVER<T>::_fieldNum = MED_INVALID ;
 768      throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"  Can't find any entity for field |"
 769                                  << MED_FIELD_DRIVER<T>::_fieldName
 770                                  << "| with (it,or) = ("
 771                                   << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
 772                                  << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << "), on mesh "
 773                                  << meshName << "|" ));
 774   }
 775
 776   if (! haveSupport)
 777     meshName = mySupport->getMeshName();
 778   else {
 779     if ( mySupport->getEntity() != MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getEntity() ) {
 780       MED_EN::medEntityMesh ent = mySupport->getEntity();
 781       delete mySupport; delete[] componentName; delete[] unitName;
 782       MED_FIELD_DRIVER<T>::_fieldNum = MED_INVALID ;
 783       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"  Given entity |"
 784                                    << MED_EN::entNames[MED_FIELD_DRIVER<T>::_ptrField->
 785                                                        getSupport()->getEntity()]
 786                                    << "| for field |"
 787                                    << MED_FIELD_DRIVER<T>::_fieldName
 788                                    << "| with (it,or) = ("
 789                                    << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
 790                                    << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << "), on mesh "
 791                                    << meshName << "| differs from found entity |"
 792                                    << MED_EN::entNames[ent] << "|."
 793                                    ));
 794     }
 795     mySupport->setName( MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getName() );
 796     mySupport->setMesh( MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getMesh() );
 797     mySupport->setDescription(MED_FIELD_DRIVER<T>::_ptrField->getSupport()->getDescription());
 798   }
 799
 800   // Test si le Support du Champ repose ou non sur toutes les entités géométriques du maillage.
 801   // Pour tester les profils aussi ?
 802   vector< MED_EN::medGeometryElement >  meshGeoType;
 803   vector< int >  meshNbOfElOfType;
 804   MED_FIELD_DRIVER21<T>::getMeshGeometricType(id,meshName,mySupport->getEntity(),meshGeoType,meshNbOfElOfType);
 805   vector<MED_EN::medGeometryElement> supGeoType(mySupport->getTypes(),
 806                                                 mySupport->getTypes()+mySupport->getNumberOfTypes());
 807   vector < int > supNbOfElOfType(mySupport->getNumberOfElements(),
 808                                  mySupport->getNumberOfElements()+mySupport->getNumberOfTypes() );
 809   if ( ( meshGeoType != supGeoType )  || meshNbOfElOfType != supNbOfElOfType  ) {
 810     mySupport->setAll(false);
 811   }
 812
 813   //??support->setNumber(MEDSKYLINEARRAY * Number);
 814   //??support->setNumber(const int * index, const int* value, bool shallowCopy=false);
 815
 816   // If an error occurs while reading the field, these allocated FIELD member will be deleted
 817   MED_FIELD_DRIVER<T>::_ptrField->_name =  MED_FIELD_DRIVER<T>::_fieldName;
 818   MED_FIELD_DRIVER<T>::_ptrField->_numberOfComponents = numberOfComponents ;
 819   //MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes = new int[numberOfComponents] ;
 820   //MED_FIELD_DRIVER<T>::_ptrField->_componentsNames = new string[numberOfComponents] ;
 821   //MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits = new UNIT[numberOfComponents] ;
 822   //MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions = new string[numberOfComponents] ;
 823   //MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits = new string[numberOfComponents] ;
 824   MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes.resize(numberOfComponents);
 825   MED_FIELD_DRIVER<T>::_ptrField->_componentsNames.resize(numberOfComponents);
 826   MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits.resize(numberOfComponents);
 827   MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions.resize(numberOfComponents);
 828   MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits.resize(numberOfComponents);
 829
 830   for (int i=0; i<numberOfComponents; i++)
 831     {
 832       MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes[i] = 1 ;
 833       MED_FIELD_DRIVER<T>::_ptrField->_componentsNames[i] = string(componentName+i*MED_TAILLE_PNOM21,MED_TAILLE_PNOM21) ;
 834       SCRUTE_MED(MED_FIELD_DRIVER<T>::_ptrField->_componentsNames[i]);
 835       MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits[i] = string(unitName+i*MED_TAILLE_PNOM21,MED_TAILLE_PNOM21) ;
 836       SCRUTE_MED(MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits[i]);
 837     }
 838
 839   delete[] componentName;
 840   delete[] unitName;
 841
 842   // read values for each geometric type in _support
 843   int NumberOfTypes = mySupport->getNumberOfTypes() ;
 844   const MED_EN::medGeometryElement *Types = mySupport->getTypes() ;
 845   T ** myValues = new T*[NumberOfTypes] ;
 846   int * NumberOfValues = new int[NumberOfTypes] ;
 847   int TotalNumberOfValues = 0 ; // Profils a gerer en 2.2 Rmq from EF
 848   MESSAGE_MED ("NumberOfTypes :"<< NumberOfTypes);
 849   MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues=0 ;
 850   bool anyGauss=false;
 851
 852   MED_EN::medModeSwitch interlacingType = MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType();
 853   bool isFullInterlace     = ( interlacingType == MED_EN::MED_FULL_INTERLACE );
 854   bool isNoInterlaceByType = ( interlacingType == MED_EN::MED_NO_INTERLACE_BY_TYPE );//PAL17011
 855
 856   // PAL16681 (Read no interlace field from file) ->
 857   // use medModeSwitch of a field in MEDMEMchampLire() if there is one geometric type
 858   // to exclude array conversion
 859   med_2_1::med_mode_switch modswt = med_2_1::MED_NO_INTERLACE;
 860   // NOTE: field can be either of 3 medModeSwitch'es, MED_NO_INTERLACE_BY_TYPE added (PAL17011)
 861   if ( NumberOfTypes == 1 && isFullInterlace )
 862     modswt = med_2_1::MED_FULL_INTERLACE;
 863
 864   for (int i=0; i<NumberOfTypes; i++) {
 865     MESSAGE_MED ("Type["<<i+1<<"] :"<< Types[i]);
 866     MESSAGE_MED ("Entity :"<< mySupport->getEntity());
 867
 868     int refNumberOfValues =
 869       MEDnVal(MED_FIELD_DRIVER21<T>::_medIdt,
 870               const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
 871               (med_2_1::med_entite_maillage)mySupport->getEntity(),
 872               (med_2_1::med_geometrie_element)Types[i],
 873               MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber,
 874               MED_FIELD_DRIVER<T>::_ptrField->_orderNumber);
 875
 876     NumberOfValues[i] = mySupport->getNumberOfElements(Types[i]) * numberOfGaussPoints[i];
 877       // * MED_FIELD_DRIVER<T>::_ptrField->getNumberOfGaussPoints(Types[i]);
 878
 879     // protect against spoiling memory when reading field values
 880     if ( NumberOfValues[i] < refNumberOfValues )
 881       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<< "  Too many values (" << refNumberOfValues
 882                                    << ") in field |" << MED_FIELD_DRIVER<T>::_fieldName
 883                                    << "| with (it,or) = ("
 884                                    << MED_FIELD_DRIVER<T>::_ptrField->_iterationNumber << ","
 885                                    << MED_FIELD_DRIVER<T>::_ptrField->_orderNumber << "), on mesh "
 886                                    << meshName << "| while only " << NumberOfValues[i]
 887                                    << " values expected"));
 888
 889     myValues[i] = new T[ NumberOfValues[i]*numberOfComponents ] ;
 890     TotalNumberOfValues+=NumberOfValues[i] ;
 891     char * ProfilName = new char[MED_TAILLE_NOM+1];
 892     MESSAGE_MED ("NumberOfValues :"<< NumberOfValues[i]);
 893     MESSAGE_MED ("NumberOfComponents :"<< numberOfComponents);
 894     MESSAGE_MED ("MESH_NAME :"<< meshName.c_str());
 895     MESSAGE_MED ("FIELD_NAME :"<< MED_FIELD_DRIVER<T>::_fieldName.c_str());
 896     MESSAGE_MED ("MED_ENTITE :"<< (med_2_1::med_entite_maillage) mySupport->getEntity());
 897     MESSAGE_MED("MED_GEOM :"<<(med_2_1::med_geometrie_element)Types[i]);
 898     MESSAGE_MED("Iteration :"<<MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
 899     MESSAGE_MED("Order :"<<MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber());
 900     MED_FIELD_DRIVER<T>::_ptrField->_numberOfValues+=mySupport->getNumberOfElements(Types[i]); // Ne doit pas prendre en compte les points de Gauss
 901
 902     med_2_1::med_err ret;
 903 #if defined(IRIX64) || defined(OSF1) || defined(VPP5000) || defined(PCLINUX64) || defined(PCLINUX64_32)
 904     int lgth2=NumberOfValues[i]*numberOfComponents;
 905     if(MED_FIELD_DRIVER<T>::_ptrField->getValueType()==MED_EN::MED_INT32)
 906       {
 907         med_2_1::med_int *temp=new med_2_1::med_int[lgth2];
 908         ret=med_2_1::MEDchampLire(id,const_cast <char*> (meshName.c_str()),
 909                                   const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
 910                                   (unsigned char*) temp,
 911                                   modswt /*med_2_1::MED_NO_INTERLACE*/, // PAL16681,17011
 912                                   MED_ALL,
 913                                   ProfilName,
 914                                   (med_2_1::med_entite_maillage) mySupport->getEntity(),
 915                                   (med_2_1::med_geometrie_element) Types[i],
 916                                   MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
 917                                   MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
 918                                   );
 919         for(int i2=0;i2<lgth2;i2++)
 920           myValues[i][i2]=(int)(temp[i2]);
 921         delete [] temp;
 922       }
 923     else
 924 #endif
 925       ret=med_2_1::MEDchampLire(id,const_cast <char*> (meshName.c_str()),
 926                                 const_cast <char*> (MED_FIELD_DRIVER<T>::_fieldName.c_str()),
 927                                 (unsigned char*) myValues[i],
 928                                 modswt /*med_2_1::MED_NO_INTERLACE*/, // PAL16681,17011
 929                                 MED_ALL,
 930                                 ProfilName,
 931                                 (med_2_1::med_entite_maillage) mySupport->getEntity()
 932                                 ,(med_2_1::med_geometrie_element)Types[i],
 933                                 MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
 934                                 MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
 935                                 );
 936     if (ret < 0)
 937       {
 938       // The Field can't be read then we must delete all previously allocated members in FIELD
 939         for(int j=0; j<=i;j++)
 940           delete[] myValues[j];
 941         delete[] myValues;
 942         delete[] NumberOfValues ;
 943         delete[] ProfilName;
 944         //delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes ;
 945         //delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsNames ;
 946         //delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits ;
 947         //delete[] MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions ;
 948         //delete[] MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits ;
 949         //MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes = NULL ;
 950         //MED_FIELD_DRIVER<T>::_ptrField->_componentsNames = NULL ;
 951         //MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits = NULL ;
 952         //MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions = NULL ;
 953         //MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits = NULL ;
 954         MED_FIELD_DRIVER<T>::_ptrField->_componentsTypes.clear();
 955         MED_FIELD_DRIVER<T>::_ptrField->_componentsNames.clear();
 956         MED_FIELD_DRIVER<T>::_ptrField->_componentsUnits.clear();
 957         MED_FIELD_DRIVER<T>::_ptrField->_componentsDescriptions.clear();
 958         MED_FIELD_DRIVER<T>::_ptrField->_MEDComponentsUnits.clear();
 959         MED_FIELD_DRIVER<T>::_fieldNum = MED_INVALID ; // we have not found right field, so reset the field number
 960         throw MEDEXCEPTION( LOCALIZED( STRING(LOC) <<": ERROR when read value")) ;
 961       }
 962
 963     delete[] ProfilName ;
 964
 965   }
 966   // allocate _value
 967   MEDMEM_Array_ * Values;
 968   if ( anyGauss ) {
 969     vector<int> nbelgeoc( supNbOfElOfType.size()+1, 0 ), nbgaussgeo( supNbOfElOfType.size()+1, 0);
 970     for ( int t = 0; t < NumberOfTypes; t++ ) {
 971       nbelgeoc  [ t+1 ] = nbelgeoc  [ t ] + supNbOfElOfType    [ t ];
 972       nbgaussgeo[ t+1 ] = /*nbgaussgeo[ t ] +*/ numberOfGaussPoints[ t ];
 973     }
 974
 975     // PAL16681. If NumberOfTypes == 1 then myValues[0] is what should be
 976     // in a field value, i.e. no conversion needed
 977     if ( NumberOfTypes == 1 )
 978     {
 979       if ( isNoInterlaceByType ) // PAL17011
 980         Values = new ArrayByTypeWg(myValues[0],
 981                                    numberOfComponents,TotalNumberOfValues,NumberOfTypes,
 982                                    &nbelgeoc[0], &nbgaussgeo[0],
 983                                    true, //shallowCopy
 984                                    true); // ownershipOfValues
 985       else if ( !isFullInterlace )
 986         Values = new ArrayNoWg(myValues[0],
 987                                numberOfComponents,TotalNumberOfValues,NumberOfTypes,
 988                                &nbelgeoc[0], &nbgaussgeo[0],
 989                                true, true);
 990       else
 991         Values = new ArrayFullWg(myValues[0],
 992                                  numberOfComponents,TotalNumberOfValues,NumberOfTypes,
 993                                  &nbelgeoc[0], &nbgaussgeo[0],
 994                                  true, true);
 995     }
 996     else if ( isNoInterlaceByType )  // PAL17011
 997     {
 998       ArrayByTypeWg* aValues = new ArrayByTypeWg(numberOfComponents,TotalNumberOfValues,
 999                                                  NumberOfTypes, &nbelgeoc[0], &nbgaussgeo[0]);
1000       Values = aValues;
1001       T * myValue = new T[ aValues->getArraySize() ];
1002       int Count = 0 ;
1003       for (int t=0; t<NumberOfTypes; t++)
1004       {
1005         int nbElem  = supNbOfElOfType[ t ];
1006         int nbGauss = numberOfGaussPoints[ t ];
1007         int tSize   = nbElem * nbGauss * numberOfComponents;
1008         memcpy( myValue+Count, myValues[t], sizeof(T)*tSize );
1009         Count += tSize;
1010       }
1011       aValues->setPtr( myValue, true, true );
1012     }
1013     else
1014     {
1015       ArrayNoWg* aValues = new ArrayNoWg(numberOfComponents,TotalNumberOfValues,NumberOfTypes,
1016                                          &nbelgeoc[0], &nbgaussgeo[0]);
1017       Values = aValues;
1018       for (int j=1; j<=numberOfComponents; j++)
1019       {
1020         int Count = 1 ;
1021         for (int t=0; t<NumberOfTypes; t++)
1022         {
1023           T * myValue = myValues[t] ;
1024           int nbElem  = supNbOfElOfType[ t ];
1025           int nbGauss = numberOfGaussPoints[ t ];
1026           nbelgeoc[1] = nbElem;
1027           nbgaussgeo[1] = nbGauss;
1028           ArrayNoWg indexer( numberOfComponents, nbElem, 1, &nbelgeoc[0], &nbgaussgeo[0]);
1029           for (int i=1; i<=nbElem; i++) {
1030             for (int k=1 ; k<=nbGauss; k++)
1031               aValues->setIJK( Count, j, k, myValue[ indexer.getIndex( i, j, k )]);
1032             Count++;
1033           }
1034         }
1035       }
1036     }
1037   }
1038   else { // if ( anyGauss )
1039
1040     // PAL16681. If NumberOfTypes == 1 then myValues[0] is what should be
1041     // in a field value, i.e. no conversion needed
1042     vector<int> nbelgeoc( supNbOfElOfType.size()+1, 0 );
1043     for ( int t = 0; t < NumberOfTypes; t++ )
1044       nbelgeoc[ t+1 ] = nbelgeoc[ t ] + supNbOfElOfType[ t ];
1045     if ( NumberOfTypes == 1 ) {
1046       if ( isNoInterlaceByType ) // PAL17011
1047         Values = new ArrayByType(myValues[0],numberOfComponents,TotalNumberOfValues,
1048                                  NumberOfTypes, &nbelgeoc[0],
1049                                  true, //shallowCopy
1050                                  true); // ownershipOfValues
1051       else if ( !isFullInterlace )
1052         Values = new ArrayNo( myValues[0],numberOfComponents,TotalNumberOfValues,true, true);
1053       else
1054         Values = new ArrayFull( myValues[0],numberOfComponents,TotalNumberOfValues,true, true);
1055     }
1056     else if ( isNoInterlaceByType )  // PAL17011
1057     {
1058       ArrayByType* aValues = new ArrayByType(numberOfComponents,TotalNumberOfValues,
1059                                              NumberOfTypes, &nbelgeoc[0]);
1060       Values = aValues;
1061       T * myValue = new T[ aValues->getArraySize() ];
1062       int Count = 0 ;
1063       for (int t=0; t<NumberOfTypes; t++)
1064       {
1065         int nbElem  = supNbOfElOfType[ t ];
1066         int tSize   = nbElem * numberOfComponents;
1067         memcpy( myValue+Count, myValues[t], sizeof(T)*tSize );
1068         Count += tSize;
1069       }
1070       aValues->setPtr( myValue, true, true );
1071     }
1072     else {
1073       ArrayNo* aValues = new ArrayNo(numberOfComponents,TotalNumberOfValues);
1074       Values = aValues;
1075
1076       for (int i=0; i<numberOfComponents; i++)
1077       {
1078         //T * ValuesT = Values->getRow(i+1) ;
1079         int Count = 1 ;
1080         for (int j=0; j<NumberOfTypes; j++)
1081         {
1082           T * myValue = myValues[j] ;
1083           int NumberOf = NumberOfValues[j] ;
1084           int offset = NumberOf*i ;
1085           for (int k=0 ; k<NumberOf; k++) {
1086             //ValuesT[Count]=myValue[k+offset] ;
1087             aValues->setIJ(Count,i+1,myValue[k+offset]);
1088             Count++;
1089           }
1090         }
1091       }
1092     }
1093   }
1094
1095   // PAL16681. If NumberOfTypes == 1 then myValues[0] is used in field value
1096   if ( NumberOfTypes != 1 )
1097     for (int j=0; j<NumberOfTypes; j++)
1098       delete[] myValues[j] ;
1099   delete[] myValues ;
1100   delete[] NumberOfValues ;
1101
1102   if (MED_FIELD_DRIVER<T>::_ptrField->_value != NULL)
1103     delete MED_FIELD_DRIVER<T>::_ptrField->_value;
1104
1105   if ( NumberOfTypes != 1 &&  // PAL16681
1106        isFullInterlace )
1107   {
1108     // Convert MED_NO_INTERLACE -> MED_FULL_INTERLACE
1109     if (Values->getGaussPresence())
1110       MED_FIELD_DRIVER<T>::_ptrField->_value=ArrayConvert(*static_cast<ArrayNoWg*>(Values));
1111     else
1112       MED_FIELD_DRIVER<T>::_ptrField->_value=ArrayConvert(*static_cast<ArrayNo*  >(Values));
1113     delete Values;
1114   }
1115   else
1116   {
1117     MED_FIELD_DRIVER<T>::_ptrField->_value=Values;
1118   }
1119   MED_FIELD_DRIVER<T>::_ptrField->_isRead = true ;
1120
1121   MED_FIELD_DRIVER<T>::_ptrField->_support=mySupport; //Prévenir l'utilisateur ?
1122
1123   // check support entity and isOnAllElements
1124   if ( haveSupport && mySupport->getEntity() != MED_EN::MED_NODE ) {
1125     // check if support geometry corresponds to support entity in mesh
1126     MESH* mesh = mySupport->getMesh();
1127     const MED_EN::medGeometryElement *meshGeoms, *endGeom, *foundGeom;
1128     meshGeoms = mesh->getTypesWithPoly( mySupport->getEntity() );
1129     endGeom = meshGeoms + mesh->getNumberOfTypesWithPoly( mySupport->getEntity() );
1130     foundGeom = std::find( meshGeoms, endGeom, mySupport->getTypes()[ 0 ]);
1131     bool geomFound = ( foundGeom != endGeom );
1132     if ( !geomFound ) // support geom type is missing in types of the entity in mesh
1133     { // find entity corresponding to support geom type in the mesh
1134       MED_EN::MESH_ENTITIES::const_iterator ent_geoms = MED_EN::meshEntities.begin();
1135       for ( ; ent_geoms != MED_EN::meshEntities.end(); ++ent_geoms ) {
1136         if ( ent_geoms->first == mySupport->getEntity() )
1137           continue;
1138         if ( mesh->getNumberOfElementsWithPoly( ent_geoms->first, MED_EN::MED_ALL_ELEMENTS)) {
1139           meshGeoms = mesh->getTypesWithPoly( ent_geoms->first );
1140           endGeom = meshGeoms + mesh->getNumberOfTypesWithPoly( ent_geoms->first );
1141           foundGeom = std::find( meshGeoms, endGeom, mySupport->getTypes()[ 0 ]);
1142           if ( foundGeom != endGeom ) { // geom type found
1143             mySupport->setEntity( ent_geoms->first );
1144             break;
1145           }
1146         }
1147       }
1148     }
1149     if ( !mySupport->isOnAllElements() ) {
1150       // recheck isAll
1151       meshGeoType = vector<MED_EN::medGeometryElement>(meshGeoms, endGeom);
1152       bool isAll = ( meshGeoType == supGeoType );
1153       for ( int i = 0; ( isAll && i < supGeoType.size()); ++i )
1154         isAll = ( supNbOfElOfType[ i ] ==
1155                   mesh->getNumberOfElementsWithPoly( mySupport->getEntity(), supGeoType[ i ]));
1156       mySupport->setAll( isAll );
1157     }
1158     if ( !geomFound ) { // initial entity was wrong
1159       // update support name
1160       string supportName;
1161       if ( mySupport->isOnAllElements() )
1162         supportName = "SupportOnAll_" + MED_EN::entNames[ mySupport->getEntity() ];
1163       else
1164         supportName = MED_FIELD_DRIVER<T>::_fieldName + "_Support";
1165       mySupport->setName( supportName );
1166     }
1167   }
1168
1169   //  END_OF_MED();
1170 }
1171
1172 template <class T> void MED_FIELD_RDONLY_DRIVER21<T>::write( void ) const
1173   throw (MEDEXCEPTION)
1174 {
1175   throw MEDEXCEPTION("MED_FIELD_RDONLY_DRIVER21::write : Can't write with a RDONLY driver !");
1176 }
1177
1178 /*--------------------- WRONLY PART -------------------------------*/
1179
1180 template <class T> GENDRIVER * MED_FIELD_WRONLY_DRIVER21<T>::copy(void) const
1181 {
1182   return new MED_FIELD_WRONLY_DRIVER21<T>(*this);
1183 }
1184
1185 template <class T> void MED_FIELD_WRONLY_DRIVER21<T>::read (void)
1186   throw (MEDEXCEPTION)
1187 {
1188   throw MEDEXCEPTION("MED_FIELD_WRONLY_DRIVER21::read : Can't read with a WRONLY driver !");
1189 }
1190
1191 template <class T> void MED_FIELD_WRONLY_DRIVER21<T>::write(void) const
1192   throw (MEDEXCEPTION)
1193 {
1194   const char * LOC = "MED_FIELD_WRONLY_DRIVER21::write(void) const " ;
1195   BEGIN_OF_MED(LOC);
1196
1197   typedef typename MEDMEM_ArrayInterface<T,NoInterlace,NoGauss>::Array ArrayNo;
1198   typedef typename MEDMEM_ArrayInterface<T,FullInterlace,NoGauss>::Array ArrayFull;
1199   typedef typename MEDMEM_ArrayInterface<T,NoInterlaceByType,NoGauss>::Array ArrayNoByType;
1200
1201   //if (MED_FIELD_DRIVER<T>::_status==MED_OPENED &&
1202   //    MED_FIELD_DRIVER<T>::_ptrField->_isRead )
1203         if (MED_FIELD_DRIVER<T>::_status!=MED_OPENED)
1204                 throw MEDEXCEPTION ("MEDMEM_MedFieldDriver21: Trying to write before opening");
1205   else {
1206       int err ;
1207
1208       const SUPPORT * mySupport = MED_FIELD_DRIVER<T>::_ptrField->getSupport() ;
1209       if (! mySupport->isOnAllElements())
1210         throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
1211                                        <<": Field must be on all entity"
1212                                        )
1213                             );
1214 //       MESH * myMesh = mySupport->getMesh() ;
1215 //       if(!myMesh)
1216 //      throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
1217 //                                     <<": Mesh in support is null"
1218 //                                     )
1219 //                             );
1220
1221       int component_count=MED_FIELD_DRIVER<T>::_ptrField->getNumberOfComponents();
1222       string   component_name(component_count*MED_TAILLE_PNOM21,' ') ;
1223       string   component_unit(component_count*MED_TAILLE_PNOM21,' ') ;
1224
1225       const string * listcomponent_name=MED_FIELD_DRIVER<T>::_ptrField->getComponentsNames() ;
1226       const string * listcomponent_unit=MED_FIELD_DRIVER<T>::_ptrField->getMEDComponentsUnits();
1227       if ( ! listcomponent_name || ! listcomponent_unit )
1228         throw MEDEXCEPTION(LOCALIZED(STRING(LOC) <<" Udefined components of FIELD : "
1229                                      << MED_FIELD_DRIVER<T>::_ptrField->getName() << "."));
1230
1231       int length ;
1232       for (int i=0; i < component_count ; i++) {
1233         length = min(MED_TAILLE_PNOM21,(int)listcomponent_name[i].size());
1234         component_name.replace(i*MED_TAILLE_PNOM21,length,
1235                                listcomponent_name[i],0,length);
1236         length = min(MED_TAILLE_PNOM21,(int)listcomponent_unit[i].size());
1237         component_unit.replace(i*MED_TAILLE_PNOM21,length,
1238                                listcomponent_unit[i],0,length);
1239       }
1240
1241       MESSAGE_MED("component_name=|"<<component_name<<"|");
1242       MESSAGE_MED("component_unit=|"<<component_unit<<"|");
1243
1244       MED_EN::med_type_champ ValueType=MED_FIELD_DRIVER<T>::_ptrField->getValueType() ;
1245
1246       MESSAGE_MED("Template Type =|"<<ValueType<<"|");
1247
1248       // le champ existe deja ???
1249       char * champName = new char[MED_TAILLE_NOM+1] ;
1250       med_2_1::med_type_champ type ;
1251       char * compName ;
1252       char * compUnit ;
1253       bool Find = false ;
1254       int n = med_2_1::MEDnChamp(MED_FIELD_DRIVER21<T>::_medIdt,0);
1255       int nbComp ;
1256       for (int i=1; i<=n; i++) {
1257         nbComp = med_2_1::MEDnChamp(MED_FIELD_DRIVER21<T>::_medIdt,i);
1258         if ( nbComp < 1 ) continue; // nbComp can be -1
1259         compName = new char[MED_TAILLE_PNOM21*nbComp+1];
1260         compUnit = new char[MED_TAILLE_PNOM21*nbComp+1];
1261         err = med_2_1::MEDchampInfo(MED_FIELD_DRIVER21<T>::_medIdt,i,champName,&type,compName,compUnit,nbComp);
1262         if (err == 0)
1263           if (strcmp(champName,MED_FIELD_DRIVER<T>::_ptrField->getName().c_str())==0) { // Found !
1264             Find = true ;
1265             break ;
1266           }
1267         delete[] compName ;
1268         delete[] compUnit ;
1269       }
1270       delete[] champName ;
1271       if (Find) {
1272         // the same ?
1273         if (nbComp != component_count)
1274           throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
1275                                          <<": Field exist in file, but number of component are different : "<<nbComp<<" in file and "<<component_count<<" in memory."
1276                                          )
1277                               );
1278         // component name and unit
1279         MESSAGE_MED(LOC<<" Component name in file : "<<compName);
1280         MESSAGE_MED(LOC<<" Component name in memory : "<<component_name);
1281         MESSAGE_MED(LOC<<" Component unit in file : "<<compUnit);
1282         MESSAGE_MED(LOC<<" Component unit in memory : "<<component_unit);
1283         delete[] compName ;
1284         delete[] compUnit ;
1285
1286       } else {
1287         // Verify the field doesn't exist
1288
1289         string dataGroupName =  "/CHA/";
1290         dataGroupName        += MED_FIELD_DRIVER<T>::_ptrField->getName();
1291         MESSAGE_MED(LOC << "|" << dataGroupName << "|" );
1292         med_2_1::med_idt gid =  H5Gopen(MED_FIELD_DRIVER21<T>::_medIdt, dataGroupName.c_str() );
1293
1294         if ( gid < 0 ) {
1295           // create field :
1296           err=med_2_1::MEDchampCr(MED_FIELD_DRIVER21<T>::_medIdt,
1297                                  const_cast <char*> ((MED_FIELD_DRIVER<T>::_ptrField->getName()).c_str()),
1298                                  (med_2_1::med_type_champ) ValueType,
1299                                  const_cast <char*> ( component_name.c_str() ),
1300                                  const_cast <char*> ( component_unit.c_str() ),
1301                                  component_count);
1302           if ( err < 0 )
1303             throw MEDEXCEPTION( LOCALIZED (STRING(LOC)
1304                                            << ": Error MEDchampCr : "<<err
1305                                            )
1306                                 );
1307         }
1308         else H5Gclose(gid);
1309       }
1310
1311       MESH * myMesh = mySupport->getMesh();
1312       string MeshName = myMesh ? myMesh->getName() : mySupport->getMeshName();
1313       //MED_EN::medModeSwitch Mode = MED_FIELD_DRIVER<T>::_ptrField->_value->getMode() ;
1314       // on boucle sur tout les types pour ecrire les tableaux de valeur
1315       int NumberOfType = mySupport->getNumberOfTypes() ;
1316       int Index = 1 ;
1317       const MED_EN::medGeometryElement * Types = mySupport->getTypes() ;
1318
1319       const T * value     = NULL;
1320       ArrayFull * myArray = NULL;
1321
1322       med_2_1::med_mode_switch       modswt = med_2_1::MED_FULL_INTERLACE;
1323       MED_EN::medModeSwitch interlacingType = MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType();
1324
1325       if ( interlacingType == MED_EN::MED_FULL_INTERLACE ) {
1326         myArray = MED_FIELD_DRIVER<T>::_ptrField->getArrayNoGauss();
1327       }
1328       else if ( interlacingType == MED_EN::MED_NO_INTERLACE_BY_TYPE ) { //PAL17011
1329         // no need to convert, that is what this improvement is needed for
1330         modswt = med_2_1::MED_NO_INTERLACE;
1331       }
1332       else {
1333         // En attendant la convertion de FIELD, on utilise le ArrayConvert
1334         // ( les infos _ptrField-> sont les mêmes )
1335         myArray = ArrayConvert( *( dynamic_cast< ArrayNo * >
1336                                    (MED_FIELD_DRIVER<T>::_ptrField->getArrayNoGauss()
1337                                     ))
1338                                 );
1339       }
1340       for (int i=0;i<NumberOfType;i++) {
1341         int NumberOfElements = mySupport->getNumberOfElements(Types[i]) ;
1342         int NumberOfGaussPoints = MED_FIELD_DRIVER<T>::_ptrField->getNumberOfGaussPoints(Types[i]) ;
1343
1344 //      const T * value = MED_FIELD_DRIVER<T>::_ptrField->getValueI(MED_EN::MED_FULL_INTERLACE,Index) ;
1345
1346         if ( interlacingType == MED_EN::MED_NO_INTERLACE_BY_TYPE ) { //PAL17011
1347           value = MED_FIELD_DRIVER<T>::_ptrField->getValueByType(i+1);
1348         }
1349         else {
1350           value = myArray->getRow(Index) ;
1351         }
1352         MESSAGE_MED("MED_FIELD_DRIVER21<T>::_medIdt                         : "<<MED_FIELD_DRIVER21<T>::_medIdt);
1353         MESSAGE_MED("MeshName.c_str()                : "<<MeshName.c_str());
1354         MESSAGE_MED("MED_FIELD_DRIVER<T>::_ptrField->getName()            : "<<MED_FIELD_DRIVER<T>::_ptrField->getName());
1355         MESSAGE_MED("value                           : "<<value);
1356         MESSAGE_MED("NumberOfElements                : "<<NumberOfElements);
1357         MESSAGE_MED("NumberOfGaussPoints             : "<<NumberOfGaussPoints);
1358         MESSAGE_MED("mySupport->getEntity()          : "<<mySupport->getEntity());
1359         MESSAGE_MED("Types[i]                        : "<<Types[i]);
1360         MESSAGE_MED("MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber() : "<<MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber());
1361         MESSAGE_MED("MED_FIELD_DRIVER<T>::_ptrField->getTime()            : "<<MED_FIELD_DRIVER<T>::_ptrField->getTime());
1362         MESSAGE_MED("MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()     : "<<MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber());
1363
1364 /*      char chanom[MED_TAILLE_NOM+1];
1365         char chacomp[MED_TAILLE_NOM+1];
1366         char chaunit[MED_TAILLE_NOM+1];
1367         med_2_1::med_type_champ chatype;
1368         med_int chancomp=1;
1369
1370         err=med_2_1::MEDchampInfo(MED_FIELD_DRIVER<T>::_medIdt,1,chanom,&chatype,chacomp,chaunit,chancomp);
1371
1372         if (err<0)
1373                 {
1374                 cout<<"=======================================================================> gros probleme"<<endl;
1375                 exit(-1);
1376                 }
1377         cout<<"==================> nom lu            = "<<chanom<<endl;
1378         cout<<"==================> type lu           = "<<chatype<<endl;
1379         cout<<"==================> nom composante lu = "<<chacomp<<endl;
1380         cout<<"==================> nom unit lu       = "<<chaunit<<endl;
1381         cout<<"==================> valeur de med_2_1::MED_REEL64 = "<<med_2_1::MED_REEL64<<endl;
1382 */
1383 #if defined(IRIX64) || defined(OSF1) || defined(VPP5000) || defined(PCLINUX64) || defined(PCLINUX64_32)
1384         if(MED_FIELD_DRIVER<T>::_ptrField->getValueType()==MED_EN::MED_INT32)
1385           {
1386             int lgth2=MED_FIELD_DRIVER<T>::_ptrField->getValueLength();
1387             T *temp=new T[lgth2];
1388             for(int i2=0;i2<lgth2;i2++)
1389               temp[i2]=(T)(value[i2]);
1390             err=med_2_1::MEDchampEcr(MED_FIELD_DRIVER21<T>::_medIdt,
1391                                     const_cast <char*> ( MeshName.c_str()) ,                         //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
1392                                     const_cast <char*> ( (MED_FIELD_DRIVER<T>::_ptrField->getName()).c_str()),
1393                                     (unsigned char*)temp,
1394                                     modswt /*med_2_1::MED_FULL_INTERLACE*/, //PAL17011
1395                                     NumberOfElements,
1396                                     NumberOfGaussPoints,
1397                                     MED_ALL,
1398                                     MED_NOPFL,
1399                                     med_2_1::MED_REMP,  // PROFIL NON GERE, mode de remplacement non géré
1400                                     (med_2_1::med_entite_maillage)mySupport->getEntity(),
1401                                     (med_2_1::med_geometrie_element)Types[i],
1402                                     MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
1403                                     "        ",
1404                                     MED_FIELD_DRIVER<T>::_ptrField->getTime(),
1405                                     MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
1406                                     );
1407             delete [] temp;
1408           }
1409         else
1410 #endif
1411         err=med_2_1::MEDchampEcr(MED_FIELD_DRIVER21<T>::_medIdt,
1412                                 const_cast <char*> ( MeshName.c_str()) ,                         //( string(mesh_name).resize(MED_TAILLE_NOM).c_str())
1413                                 const_cast <char*> ( (MED_FIELD_DRIVER<T>::_ptrField->getName()).c_str()),
1414                                 (unsigned char*)value,
1415                                 modswt /*med_2_1::MED_FULL_INTERLACE*/, //PAL17011
1416                                 NumberOfElements,
1417                                 NumberOfGaussPoints,
1418                                 MED_ALL,
1419                                  (char *)MED_NOPFL,
1420                                 med_2_1::MED_REMP,  // PROFIL NON GERE, mode de remplacement non géré
1421                                 (med_2_1::med_entite_maillage)mySupport->getEntity(),
1422                                 (med_2_1::med_geometrie_element)Types[i],
1423                                 MED_FIELD_DRIVER<T>::_ptrField->getIterationNumber(),
1424                                  (char *) "        ",
1425                                 MED_FIELD_DRIVER<T>::_ptrField->getTime(),
1426                                 MED_FIELD_DRIVER<T>::_ptrField->getOrderNumber()
1427                                 );
1428         if (err < MED_VALID )
1429           {
1430             if ( MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType() == MED_EN::MED_NO_INTERLACE ) delete myArray;
1431
1432             throw MEDEXCEPTION(LOCALIZED( STRING(LOC)
1433                                           <<": Error in writing Field "<< MED_FIELD_DRIVER<T>::_ptrField->getName() <<", type "<<Types[i]
1434                                           )
1435                                );
1436           }
1437
1438         Index += NumberOfElements ;
1439
1440       }
1441       if ( MED_FIELD_DRIVER<T>::_ptrField->getInterlacingType() == MED_EN::MED_NO_INTERLACE ) delete myArray;
1442
1443     }
1444
1445   END_OF_MED(LOC);
1446 }
1447
1448 /*--------------------- RDWR PART -------------------------------*/
1449
1450 template <class T> GENDRIVER * MED_FIELD_RDWR_DRIVER21<T>::copy(void) const
1451 {
1452   return new MED_FIELD_RDWR_DRIVER21<T>(*this);
1453 }
1454
1455 template <class T> void MED_FIELD_RDWR_DRIVER21<T>::write(void) const
1456   throw (MEDEXCEPTION)
1457 {
1458   const char* LOC = "MED_FIELD_RDWR_DRIVER21::write(void)";
1459   BEGIN_OF_MED(LOC);
1460   MED_FIELD_WRONLY_DRIVER21<T>::write();
1461   END_OF_MED(LOC);
1462 }
1463
1464 template <class T> void MED_FIELD_RDWR_DRIVER21<T>::read (void)
1465   throw (MEDEXCEPTION)
1466 {
1467   const char* LOC = "MED_FIELD_RDWR_DRIVER21::read(void)";
1468   BEGIN_OF_MED(LOC);
1469   MED_FIELD_RDONLY_DRIVER21<T>::read();
1470   END_OF_MED(LOC);
1471 }
1472 }//End namespace MEDMEM
1473 /*-----------------------------------------------------------------*/
1474
1475 #endif /* MED_FIELD_DRIVER_HXX */
1476