src/MEDMEM/MEDMEM_Med.cxx

   1 using namespace std;
   2 # include <string>
   3
   4 # include "MEDMEM_Med.hxx"
   5
   6 # include "MEDMEM_STRING.hxx"
   7
   8 # include "MEDMEM_Mesh.hxx"
   9 # include "MEDMEM_Grid.hxx"
  10 # include "MEDMEM_Field.hxx"
  11
  12 # include "MEDMEM_Exception.hxx"
  13 # include "utilities.h"
  14 using namespace MEDMEM;
  15
  16 /*!
  17   Constructor.
  18 */
  19 MED::MED() {
  20   MESSAGE("MED::MED()");
  21 };
  22
  23 /*!
  24   Constructor.
  25 */
  26 MED::MED(driverTypes driverType, const string & fileName)
  27 {
  28   const char * LOC = "MED::MED(driverTypes driverType, const string & fileName) : ";
  29   BEGIN_OF(LOC);
  30
  31   MESSAGE(LOC << "driverType = " << driverType);
  32
  33   MED_MED_RDONLY_DRIVER * myDriver = new MED_MED_RDONLY_DRIVER(fileName,this) ;
  34   int current = addDriver(*myDriver);
  35   //int current= addDriver(driverType,fileName);
  36
  37   _drivers[current]->open();
  38   _drivers[current]->readFileStruct();
  39   _drivers[current]->close();
  40
  41   END_OF(LOC);
  42 };
  43
  44 /*!
  45   Destructor.
  46 */
  47 MED::~MED()
  48 {
  49   const char * LOC = "MED::~MED() : ";
  50   BEGIN_OF(LOC);
  51
  52   // Analysis of the object MED
  53
  54   int index;
  55
  56   map<FIELD_ *, MESH_NAME_>::const_iterator currentField;
  57   index = 0;
  58   for ( currentField=_meshName.begin();currentField != _meshName.end(); currentField++ ) {
  59     if ( (*currentField).first != NULL) index++;
  60   }
  61
  62   MESSAGE(LOC << " there is(are) " << index << " field(s):");
  63   for ( currentField=_meshName.begin();currentField != _meshName.end(); currentField++ ) {
  64     if ( (*currentField).first != NULL) MESSAGE("             " << ((*currentField).first)->getName().c_str());
  65   }
  66
  67   map<MESH_NAME_, map<MED_FR::med_entite_maillage,SUPPORT *> >::iterator itSupportOnMesh ;
  68   index = 0;
  69   for ( itSupportOnMesh=_support.begin();itSupportOnMesh != _support.end(); itSupportOnMesh++ ) {
  70     map<MED_FR::med_entite_maillage,SUPPORT *>::iterator itSupport ;
  71     for ( itSupport=(*itSupportOnMesh).second.begin();itSupport!=(*itSupportOnMesh).second.end();itSupport++)
  72       index++;
  73   }
  74
  75   MESSAGE(LOC << " there is(are) " << index << " support(s):");
  76
  77   map<MESH_NAME_,MESH*>::const_iterator  currentMesh;
  78   index =0;
  79   for ( currentMesh=_meshes.begin();currentMesh != _meshes.end(); currentMesh++ ) {
  80     if ( (*currentMesh).second != NULL)
  81       index++;
  82   }
  83
  84   MESSAGE(LOC << " there is(are) " << index << " meshe(s):");
  85 //   for ( currentMesh=_meshes.begin();currentMesh != _meshes.end(); currentMesh++ ) {
  86 //     if ( (*currentMesh).second != NULL)
  87 //       {
  88 //      SCRUTE((*currentMesh).second);
  89
  90 //      string meshName = ((*currentMesh).second)->getName();
  91
  92 //      MESSAGE("             " << meshName);
  93 //       }
  94 //   }
  95
  96   // delete all ? : PG : YES !
  97   //  map<FIELD_ *, MESH_NAME_>::const_iterator currentField;
  98   for ( currentField=_meshName.begin();currentField != _meshName.end(); currentField++ ) {
  99     if ( (*currentField).first != NULL) {
 100       // cast in right type to delete it !
 101       switch ((*currentField).first->getValueType()) {
 102       case MED_INT32 :
 103         delete (FIELD<int>*) (*currentField).first ;
 104         break ;
 105       case MED_REEL64 :
 106         delete (FIELD<double>*) (*currentField).first ;
 107         break ;
 108       default :
 109         MESSAGE(LOC << "Field has type different of int or double, could not destroy its values array !") ;
 110         delete (*currentField).first;
 111       }
 112     }
 113   }
 114   //  map<MESH_NAME_, map<MED_FR::med_entite_maillage,SUPPORT *> >::iterator itSupportOnMesh ;
 115   for ( itSupportOnMesh=_support.begin();itSupportOnMesh != _support.end(); itSupportOnMesh++ ) {
 116     map<MED_FR::med_entite_maillage,SUPPORT *>::iterator itSupport ;
 117     for ( itSupport=(*itSupportOnMesh).second.begin();itSupport!=(*itSupportOnMesh).second.end();itSupport++)
 118         delete (*itSupport).second ;
 119   }
 120
 121   //  map<MESH_NAME_,MESH*>::const_iterator  currentMesh;
 122   for ( currentMesh=_meshes.begin();currentMesh != _meshes.end(); currentMesh++ ) {
 123     if ( (*currentMesh).second != NULL)
 124       {
 125         if (!((*currentMesh).second)->getIsAGrid())
 126           delete (*currentMesh).second;
 127         else
 128           delete (GRID *) (*currentMesh).second;
 129       }
 130   }
 131
 132   index =_drivers.size();
 133
 134   MESSAGE(LOC << "In this object MED there is(are) " << index << " driver(s):");
 135
 136   for (unsigned int ind=0; ind < _drivers.size(); ind++ )
 137     {
 138       SCRUTE(_drivers[ind]);
 139       if ( _drivers[ind] != NULL) delete _drivers[ind];
 140     }
 141
 142
 143
 144   END_OF(LOC);
 145 } ;
 146
 147 // ------- Drivers Management Part
 148
 149 // Add your new driver instance declaration here (step 3-1)
 150 MED::INSTANCE_DE<MED_MED_RDWR_DRIVER> MED::inst_med ;
 151 MED::INSTANCE_DE<VTK_MED_DRIVER> MED::inst_vtk ;
 152
 153 // Add your new driver instance in the MED instance list (step 3-2)
 154 const MED::INSTANCE * const MED::instances[] = { &MED::inst_med, &MED::inst_vtk };
 155
 156 /*!
 157   Create the specified driver and return its index reference to path to
 158   read or write methods.
 159 */
 160 int MED::addDriver(driverTypes driverType, const string & fileName="Default File Name.med") {
 161
 162   const char * LOC = "MED::addDriver(driverTypes driverType, const string & fileName=\"Default File Name.med\") : ";
 163   GENDRIVER * driver;
 164   int current;
 165   int itDriver = (int) NO_DRIVER;
 166
 167   BEGIN_OF(LOC);
 168
 169   MESSAGE(LOC << " the file name is " << fileName);
 170
 171   SCRUTE(driverType);
 172
 173   SCRUTE(instances[driverType]);
 174
 175   switch(driverType)
 176     {
 177     case MED_DRIVER : {
 178       itDriver = (int) driverType ;
 179       break ;
 180     }
 181
 182     case VTK_DRIVER : {
 183       itDriver = 1 ;
 184       break ;
 185     }
 186
 187     case GIBI_DRIVER : {
 188       throw MED_EXCEPTION (LOCALIZED(STRING(LOC)<< "GIBI_DRIVER has been specified to the method which is not allowed because there is no GIBI driver for the MED object"));
 189       break;
 190     }
 191
 192     case NO_DRIVER : {
 193       throw MED_EXCEPTION (LOCALIZED(STRING(LOC)<< "NO_DRIVER has been specified to the method which is not allowed"));
 194       break;
 195     }
 196     }
 197
 198   if (itDriver == ((int) NO_DRIVER))
 199     throw MED_EXCEPTION (LOCALIZED(STRING(LOC)<< "NO_DRIVER has been specified to the method which is not allowed"));
 200
 201   driver = instances[itDriver]->run(fileName, this) ;
 202
 203   current = _drivers.size()-1;
 204
 205   driver->setId(current);
 206
 207   END_OF(LOC);
 208
 209   return current;
 210 }
 211
 212 /*!
 213   Duplicate the given driver and return its index reference to path to
 214   read or write methods.
 215 */
 216 int  MED::addDriver(GENDRIVER & driver) {
 217   const char * LOC = "MED::addDriver(GENDRIVER &) : ";
 218   int current;
 219
 220   BEGIN_OF(LOC);
 221
 222   SCRUTE(_drivers.size());
 223
 224   _drivers.push_back(&driver);
 225
 226   SCRUTE(_drivers.size());
 227
 228   SCRUTE(_drivers[0]);
 229   SCRUTE(driver);
 230
 231   current = _drivers.size()-1;
 232   driver.setId(current);
 233
 234   END_OF(LOC);
 235   return current;
 236
 237 }
 238
 239 /*!
 240   Remove the driver referenced by its index.
 241 */
 242 void MED::rmDriver (int index/*=0*/)
 243   throw (MED_EXCEPTION)
 244 {
 245   const char * LOC = "MED::rmDriver (int index=0): ";
 246   BEGIN_OF(LOC);
 247
 248   if (_drivers[index])
 249     //_drivers.erase(&_drivers[index]);
 250     {}
 251   else
 252     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 253                                      << "The index given is invalid, index must be between 0 and |"
 254                                      << _drivers.size()
 255                                      )
 256                           );
 257   END_OF(LOC);
 258 }
 259
 260 /*!
 261   ??? to do comment ???
 262 */
 263 void MED::writeFrom (int index/*=0*/)
 264   throw (MED_EXCEPTION)
 265 {
 266   const char * LOC = "MED::write (int index=0): ";
 267   BEGIN_OF(LOC);
 268
 269   if (_drivers[index]) {
 270     // open and close are made by all objects !
 271     _drivers[index]->writeFrom();
 272   }
 273   throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 274                                    << "The index given is invalid, index must be between 0 and |"
 275                                    << _drivers.size()
 276                                    )
 277                         );
 278   END_OF(LOC);
 279 };
 280
 281 /*!
 282   Write all objects with the driver given by its index.
 283 */
 284 void MED::write (int index/*=0*/)
 285   throw (MED_EXCEPTION)
 286 {
 287   const char * LOC = "MED::write (int index=0): ";
 288   BEGIN_OF(LOC);
 289
 290   if (_drivers[index]) {
 291     // open and close are made by the subsequent objects !
 292     _drivers[index]->write();
 293   }
 294   else
 295     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 296                                      << "The index given is invalid, index must be between  0 and |"
 297                                      << _drivers.size()
 298                                      )
 299                           );
 300   END_OF(LOC);
 301 };
 302
 303 /*!
 304   Parse all the file and generate empty object.
 305
 306   All object must be read explicitly later with their own method read
 307   or use MED::read to read all.
 308
 309   This method is automaticaly call by constructor with driver information.
 310 */
 311 void MED::readFileStruct (int index/*=0*/)
 312   throw (MED_EXCEPTION)
 313 {
 314   const char * LOC = "MED::readFileStruct (int index=0): ";
 315   BEGIN_OF(LOC);
 316
 317   if (_drivers[index]) {
 318     _drivers[index]->open();
 319     _drivers[index]->readFileStruct();
 320     _drivers[index]->close();
 321   }
 322   else
 323     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 324                                      << "The index given is invalid, index must be between 0 and |"
 325                                      << _drivers.size()
 326                                      )
 327                           );
 328   END_OF(LOC);
 329 }
 330
 331 /*!
 332   Read all objects in the file specified in the driver given by its index.
 333 */
 334 void MED::read  (int index/*=0*/)
 335   throw (MED_EXCEPTION)
 336 {
 337   const char * LOC = "MED::read (int index=0): ";
 338   BEGIN_OF(LOC);
 339
 340   if (_drivers[index]) {
 341     // open and close are made by all objects !
 342     SCRUTE(index);
 343     SCRUTE(_drivers[index]);
 344     SCRUTE(&_drivers[index]);
 345     //    _drivers[index]->open();
 346     _drivers[index]->read();
 347     //    _drivers[index]->close();
 348   }
 349   else
 350     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 351                                      << "The index given is invalid, index must be between  >0 and < |"
 352                                      << _drivers.size()-1
 353                                      )
 354                           );
 355   END_OF(LOC);
 356
 357 };
 358
 359 // ------- End Of Drivers Management Part
 360
 361 /*!
 362   Get the number of MESH objects.
 363 */
 364 int      MED::getNumberOfMeshes ( void ) const {
 365
 366   const char * LOC = "MED::getNumberOfMeshes ( void ) const : ";
 367   BEGIN_OF(LOC);
 368
 369   int size = _meshes.size();
 370
 371   SCRUTE(size);
 372
 373   END_OF(LOC);
 374
 375   return size;
 376 };
 377
 378 /*!
 379   Get the number of FIELD objects.
 380 */
 381 int      MED::getNumberOfFields ( void ) const {
 382
 383   const char * LOC = "MED::getNumberOfFields ( void ) const : ";
 384   BEGIN_OF(LOC);
 385
 386   return _fields.size(); // we get number of field with different name
 387
 388   END_OF(LOC);
 389 };
 390
 391 /*!
 392   Get the names of all MESH objects.
 393
 394   meshNames is an in/out argument.
 395
 396   It is a string array of size the
 397   number of MESH objects. It must be allocated before calling
 398   this method. All names are put in it.
 399 */
 400 void MED::getMeshNames      ( string * meshNames ) const
 401   throw (MED_EXCEPTION)
 402 {
 403   const char * LOC = "MED::getMeshNames ( string * ) const : ";
 404   BEGIN_OF(LOC);
 405   unsigned int meshNamesSize;
 406
 407   if (  ( meshNamesSize = sizeof(meshNames) / sizeof(string *) )
 408        != _meshes.size() )
 409     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 410                                      << "Size of parameter meshNames is |"
 411                                      << meshNamesSize    << "| and should be |"
 412                                      << _meshes.size() << "| and should be |"
 413                                      )
 414                           );
 415
 416   // REM : ALLOCATION D'UN TABLEAU DE POINTEURS SUR STRING FAITE PAR LE CLIENT
 417   map<MESH_NAME_,MESH*>::const_iterator  currentMesh; // ??ITERATEUR CONST SUR UN OBJET NON CONST ??
 418
 419   int meshNamesIndex = 0;
 420
 421   for ( currentMesh=_meshes.begin();currentMesh != _meshes.end(); currentMesh++ ) {
 422     meshNames[meshNamesIndex]=(*currentMesh).first;
 423     meshNamesIndex++;                               // CF OPTIMISATION
 424   }
 425
 426   END_OF(LOC);
 427 };
 428
 429 /*!
 430   Get the names of all MESH objects.
 431
 432   Return a deque<string> object which contain the name of all MESH objects.
 433 */
 434 deque<string> MED::getMeshNames      () const {
 435
 436   const char * LOC = "MED::getMeshNames () const : ";
 437   BEGIN_OF(LOC);
 438
 439   deque<string> meshNames(_meshes.size());
 440
 441   map<MESH_NAME_,MESH*>::const_iterator  currentMesh; // ??ITERATEUR CONST SUR UN OBJET NON CONST ??
 442
 443   int meshNamesIndex = 0;
 444
 445   for ( currentMesh=_meshes.begin();currentMesh != _meshes.end(); currentMesh++ ) {
 446     meshNames[meshNamesIndex]=(*currentMesh).first;
 447     meshNamesIndex++;                               // CF OPTIMISATION
 448   }
 449
 450   END_OF(LOC);
 451   return meshNames ;
 452 };
 453
 454
 455 /*!
 456   Return a reference to the MESH object named meshName.
 457 */
 458 MESH   * MED::getMesh           ( const string & meshName )  const
 459   throw (MED_EXCEPTION)
 460 {
 461   const char * LOC = "MED::getMesh ( const string & meshName ) const : ";
 462   BEGIN_OF(LOC);
 463
 464   SCRUTE(meshName);
 465
 466   map<MESH_NAME_,MESH*>::const_iterator itMeshes =  _meshes.find(meshName);
 467
 468   if ( itMeshes == _meshes.end() )
 469     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 470                                      << "There is no known mesh named |"
 471                                      << meshName << "|"
 472                                      )
 473                           );
 474
 475   return (*itMeshes).second;
 476
 477   END_OF(LOC);
 478 }
 479
 480 /*!
 481  \internal Return a reference to the MESH object associated with
 482  field argument.
 483 */
 484 MESH   * MED::getMesh           (const FIELD_ * const field ) const
 485   throw (MED_EXCEPTION)
 486 {
 487
 488   const char * LOC = "MED::getMesh ( const FIELD * field ) const : ";
 489   BEGIN_OF(LOC);
 490
 491   FIELD_ * f = const_cast< FIELD_* > (field);     //  Comment faire mieux ?
 492   map<FIELD_ *, MESH_NAME_>::const_iterator itMeshName = _meshName.find(f);
 493
 494   if ( itMeshName  == _meshName.end() )
 495     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 496                                      << "There is no known mesh associated with |"
 497                                      << field << "| pointer"
 498                                      )
 499                           );
 500
 501   string meshName = (*itMeshName).second;
 502   map<MESH_NAME_,MESH*>::const_iterator itMeshes =  _meshes.find(meshName);
 503   if ( itMeshes == _meshes.end() )
 504     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 505                                      << "There is no known mesh named |"
 506                                      << meshName << " while it's associated with the found field |"
 507                                      << field << "| pointer"
 508                                      )
 509                           );
 510
 511   return (*itMeshes).second;
 512
 513   END_OF(LOC);
 514 };
 515
 516
 517 /*!
 518   Get the names of all FIELD objects.
 519
 520   fieldNames is an in/out argument.
 521
 522   It is an array of string of size the
 523   number of FIELD objects. It must be allocated before calling
 524   this method. All names are put in it.
 525 */
 526 void MED::getFieldNames     ( string * fieldNames ) const
 527   throw (MED_EXCEPTION)
 528 {
 529   const char * LOC = "MED::getFieldNames ( string * ) const : ";
 530   BEGIN_OF(LOC);
 531
 532   unsigned int fieldNamesSize =  sizeof(fieldNames) / sizeof(string *);
 533
 534   if ( fieldNamesSize != _fields.size() )
 535     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 536                                      << "Size of parameter fieldNames is |"
 537                                      << fieldNamesSize     << "| and should be |"
 538                                      << _fields.size() << "| and should be |"
 539                                      )
 540                           );
 541
 542   // REM : ALLOCATION D'UN TABLEAU DE POINTEURS SUR STRING FAITE PAR LE CLIENT
 543   map<FIELD_NAME_,MAP_DT_IT_>::const_iterator  currentField;
 544
 545   int fieldNamesIndex = 0;
 546   for ( currentField=_fields.begin();currentField != _fields.end(); currentField++ ) {
 547     fieldNames[fieldNamesIndex]=(*currentField).first;
 548     fieldNamesIndex++;                               // CF OPTIMISATION
 549   }
 550
 551   END_OF(LOC);
 552
 553 };
 554
 555 /*!
 556   Get the names of all FIELD objects.
 557
 558   Return a deque<string> object which contain the name of all FIELD objects.
 559 */
 560 deque<string> MED::getFieldNames     () const {
 561
 562   const char * LOC = "MED::getFieldNames ( ) const : ";
 563   BEGIN_OF(LOC);
 564
 565   deque<string> fieldNames(_fields.size());
 566
 567   map<FIELD_NAME_,MAP_DT_IT_>::const_iterator  currentField;
 568
 569   int fieldNamesIndex = 0;
 570
 571   for ( currentField=_fields.begin();currentField != _fields.end(); currentField++ ) {
 572     fieldNames[fieldNamesIndex]=(*currentField).first;
 573     fieldNamesIndex++;                               // CF OPTIMISATION
 574   }
 575
 576   END_OF(LOC);
 577   return fieldNames ;
 578 };
 579
 580 /*!
 581   Return a deque<DT_IT_> which contain all iteration step for the FIELD
 582   identified by its name.
 583 */
 584 deque<DT_IT_> MED::getFieldIteration (const string & fieldName) const
 585   throw (MED_EXCEPTION)
 586 {
 587
 588   const char * LOC = "MED::getFieldIteration ( const string & ) const : ";
 589   BEGIN_OF(LOC);
 590
 591   map<FIELD_NAME_,MAP_DT_IT_>::const_iterator itFields = _fields.find(fieldName);
 592
 593   if ( itFields == _fields.end() )
 594     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 595                                      << "There is no known field named |"
 596                                      << fieldName << "|"
 597                                      )
 598                           );
 599   //  const MAP_DT_IT_ & myIterationMap =  const_cast<const MAP_DT_IT_ & > ((*itFields).second);
 600   const MAP_DT_IT_ & myIterationMap =  (*itFields).second ;
 601   MAP_DT_IT_::const_iterator currentIterator ;
 602
 603   deque<DT_IT_> Iteration(myIterationMap.size());
 604
 605   int iterationIndex = 0;
 606
 607   for ( currentIterator=myIterationMap.begin();currentIterator != myIterationMap.end(); currentIterator++ ) {
 608     Iteration[iterationIndex]=(*currentIterator).first;
 609     iterationIndex++;                               // CF OPTIMISATION
 610   }
 611
 612   END_OF(LOC);
 613   return Iteration ;
 614 };
 615
 616 /*!
 617  Return a reference to the FIELD object named fieldName with
 618  time step number dt and order number it.
 619 */
 620 FIELD_  * MED::getField          ( const string & fieldName, const int dt=MED_NOPDT, const int it=MED_NOPDT ) const
 621   throw (MED_EXCEPTION)
 622 {
 623
 624   const char * LOC = "MED::getField ( const string &, const int, const int ) const : ";
 625   BEGIN_OF(LOC);
 626
 627   MESSAGE(LOC << "fieldName = "<<fieldName<<", dt ="<<dt<<", it = "<<it);
 628
 629   DT_IT_ dtIt;
 630
 631   dtIt.dt= dt;
 632   dtIt.it= it;
 633
 634   map<FIELD_NAME_,MAP_DT_IT_>::const_iterator itFields = _fields.find(fieldName);
 635
 636   if ( itFields == _fields.end() )
 637     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 638                                      << "There is no known field named |"
 639                                      << fieldName << "|"
 640                                      )
 641                           );
 642
 643   const MAP_DT_IT_ & map_dtIt =  const_cast<const MAP_DT_IT_ & > ((*itFields).second);
 644   MAP_DT_IT_::const_iterator itMap_dtIt =  map_dtIt.find(dtIt);
 645
 646   if ( itMap_dtIt == map_dtIt.end() )
 647     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 648                                      << "There is no (dt,it) |("
 649                                      << dt << "," << it << ")| associated with the found field |"
 650                                      << fieldName << "|"
 651                                      )
 652                           );
 653
 654   END_OF(LOC);
 655
 656   //return _fields[fieldName][dtIt];
 657   return (*itMap_dtIt).second;
 658
 659 };
 660
 661
 662 // fiend ostream & MED::operator<<(ostream &os,const MED & med) const {
 663 //   return os;
 664 // };
 665
 666 /*!
 667   Return a map<MED_FR::med_entite_maillage,SUPPORT*> which contain
 668   foreach entity, a reference to the SUPPORT on all elements.
 669 */
 670 const map<MED_FR::med_entite_maillage,SUPPORT*> & MED::getSupports(const string & meshName) const
 671   throw (MED_EXCEPTION)
 672 {
 673   const char * LOC = "MED::getSupports ( const string ) const : ";
 674   BEGIN_OF(LOC);
 675
 676   map<MESH_NAME_, map<MED_FR::med_entite_maillage,SUPPORT *> >::const_iterator itSupportOnMesh = _support.find(meshName) ;
 677
 678   if ( itSupportOnMesh == _support.end() )
 679     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 680                                      << "There is no support on mesh named |"
 681                                      << meshName << "|"
 682                                      )
 683                           );
 684   END_OF(LOC);
 685   return (*itSupportOnMesh).second ;
 686 }
 687
 688 /*!
 689   Return a reference to the SUPPORT object on all elements of entity
 690   for the MESH named meshName.
 691 */
 692 SUPPORT *  MED::getSupport (const string & meshName,MED_FR::med_entite_maillage entity) const
 693   throw (MED_EXCEPTION)
 694 {
 695   const char * LOC = "MED::getSupport ( const string, MED_FR::med_entite_maillage ) const : ";
 696   BEGIN_OF(LOC);
 697
 698   int index = 0;
 699   for (map<MESH_NAME_, map<MED_FR::med_entite_maillage,SUPPORT *> >::const_iterator const_itSupportOnMesh=_support.begin(); const_itSupportOnMesh != _support.end();
 700        const_itSupportOnMesh++ )
 701     {
 702       map<MED_FR::med_entite_maillage,SUPPORT *>::const_iterator const_itSupport ;
 703       for (const_itSupport=(*const_itSupportOnMesh).second.begin();
 704            const_itSupport!=(*const_itSupportOnMesh).second.end();const_itSupport++) index++;
 705     }
 706
 707   MESSAGE(LOC << "In this MED object there is(are) " << index << " support(s):");
 708
 709   for (map<MESH_NAME_, map<MED_FR::med_entite_maillage,SUPPORT *> >::const_iterator const_itSupportOnMesh=_support.begin();const_itSupportOnMesh != _support.end(); const_itSupportOnMesh++ )
 710     {
 711       map<MED_FR::med_entite_maillage,SUPPORT *>::const_iterator const_itSupport ;
 712       for (const_itSupport=(*const_itSupportOnMesh).second.begin();
 713            const_itSupport!=(*const_itSupportOnMesh).second.end();const_itSupport++)
 714         {
 715           MESSAGE(LOC << "Support on mesh " << (*const_itSupportOnMesh).first << " on entity " << (*const_itSupport).first << " : " << *((*const_itSupport).second));
 716         }
 717   }
 718
 719
 720   map<MESH_NAME_, map<MED_FR::med_entite_maillage,SUPPORT *> >::const_iterator const_itSupportOnMesh = _support.find(meshName) ;
 721
 722   if ( const_itSupportOnMesh == _support.end() )
 723     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 724                                      << "There is no support on mesh named |"
 725                                      << meshName << "|"
 726                                      )
 727                           );
 728
 729 //   map<MED_FR::med_entite_maillage,SUPPORT *> & SupportOnMesh = (map<MED_FR::med_entite_maillage,SUPPORT *>&) ((*itSupportOnMesh).second) ;
 730 //   map<MED_FR::med_entite_maillage,SUPPORT *>::const_iterator itSupport = SupportOnMesh.find(entity) ;
 731
 732 //   if (itSupport == SupportOnMesh.end() )
 733 //     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 734 //                                      << "There is no support on entity "
 735 //                                   << entity << " in mesh named |"
 736 //                                      << meshName << "|"
 737 //                                      )
 738 //                           );
 739
 740
 741   map<MED_FR::med_entite_maillage,SUPPORT *> SupportOnMesh = ((*const_itSupportOnMesh).second);
 742
 743   map<MED_FR::med_entite_maillage,SUPPORT *>::const_iterator itSupport = SupportOnMesh.find(entity) ;
 744
 745   if (itSupport == SupportOnMesh.end() )
 746     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 747                                      << "There is no support on entity "
 748                                      << entity << " in mesh named |"
 749                                      << meshName << "|"
 750                                      )
 751                           );
 752   END_OF(LOC);
 753   return (*itSupport).second ;
 754 };
 755
 756 /*!
 757   Temporary method : when all MESH objects are read, this methods
 758   update all SUPPORT objects with the rigth dimension.
 759 */
 760 void MED::updateSupport ()
 761 {
 762
 763   const char * LOC = "MED::updateSupport () : ";
 764   BEGIN_OF(LOC);
 765
 766   map<MESH_NAME_, map<MED_FR::med_entite_maillage,SUPPORT *> >::iterator itSupportOnMesh ;
 767   for ( itSupportOnMesh=_support.begin();itSupportOnMesh != _support.end(); itSupportOnMesh++ ) {
 768     map<MED_FR::med_entite_maillage,SUPPORT *>::iterator itSupport ;
 769     for ( itSupport=(*itSupportOnMesh).second.begin();itSupport!=(*itSupportOnMesh).second.end();itSupport++)
 770       try {
 771         (*itSupport).second->update() ;
 772       }
 773       catch (MEDEXCEPTION & ex) {
 774         // entity not defined in mesh -> we remove support on it !
 775         MESSAGE(LOC<<ex.what());
 776         delete (*itSupport).second ;
 777         (*itSupportOnMesh).second.erase(itSupport) ; // that's rigth ????
 778         itSupport-- ;
 779       }
 780   }
 781
 782   END_OF(LOC);
 783 }
 784
 785 /*!
 786   Add the given MESH object. MED object control it,
 787   and destroy it, so you must not destroy it after.
 788
 789   The meshName is given by the MESH object.
 790 */
 791 void MED::addMesh( MESH * const ptrMesh)
 792   throw (MED_EXCEPTION)
 793 {
 794   const char * LOC = "MED::addMesh(const MESH * ptrMesh): ";
 795   BEGIN_OF(LOC);
 796
 797   if ( ! ptrMesh )
 798     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "ptrMesh must not be NULL !"));
 799
 800   string meshName;
 801   if ( ! ( meshName = ptrMesh->getName()).size() )
 802     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "ptrMesh->_name must not be NULL !"));
 803
 804 //   MESH * meshToMed = new MESH(*ptrMesh); DO WE HAVE TO COPY THE ENTRY MESH OR NOT ????? (NB)
 805
 806   _meshes[meshName] = ptrMesh; // if ptrMesh->meshName already exists it is modified
 807
 808 //   _meshes[meshName] = meshToMed;
 809
 810   END_OF(LOC);
 811 }
 812
 813 /*!
 814   Add the given FIELD object. MED object control it,
 815   and destroy it, so you must not destroy it after.
 816
 817   The fieldName is given by the FIELD object.
 818 */
 819 void MED::addField( FIELD_ * const ptrField)
 820   throw (MED_EXCEPTION)
 821 {
 822   const char * LOC = "MED::addField(const FIELD_ * const ptrField): ";
 823   BEGIN_OF(LOC);
 824
 825   if ( ! ptrField )
 826     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "ptrField must not be NULL !"));
 827
 828   string fieldName;
 829   if ( ! (fieldName = ptrField->getName()).size() )
 830     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "ptrField->_name must not be NULL !"));
 831
 832   SUPPORT * ptrSupport;
 833   if ( ! ( ptrSupport = (SUPPORT * ) ptrField->getSupport()) )
 834     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "ptrField->_support must not be NULL !"));
 835
 836   MESH * ptrMesh;
 837   if ( ! ( ptrMesh = ptrSupport->getMesh()) )
 838     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "ptrField->_support->_mesh must not be NULL !"));
 839
 840   string meshName;
 841   if ( ! ( meshName = ptrMesh->getName()).size() )
 842     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "ptrField->_support->_mesh->_name must not be NULL !"));
 843
 844   DT_IT_ dtIt;
 845   dtIt.dt  = ptrField->getIterationNumber();
 846   dtIt.it  = ptrField->getOrderNumber();
 847
 848   _fields   [fieldName][dtIt] = ptrField; // if it already exists it is replaced
 849   _meshName [ptrField]        = meshName; // if it already exists it is replaced
 850   _meshes   [meshName]        = ptrMesh;  // if it already exists it is replaced
 851
 852   //  int  numberOfTypes = ptrSupport->getNumberOfTypes(); !! UNUSED VARIABLE !!
 853   _support  [meshName][ (MED_FR::med_entite_maillage) ptrSupport->getEntity()] = ptrSupport;// if it already exists it is replaced
 854
 855
 856   END_OF(LOC);
 857 }