src/MEDMEM/MEDMEM_GibiMeshDriver.cxx

   1 using namespace std;
   2
   3 #include <algorithm>
   4
   5 #include "MEDMEM_GibiMeshDriver.hxx"
   6
   7 #include "MEDMEM_DriversDef.hxx"
   8
   9 #include "MEDMEM_Family.hxx"
  10 #include "MEDMEM_Group.hxx"
  11 #include "MEDMEM_Coordinate.hxx"
  12 #include "MEDMEM_Connectivity.hxx"
  13 #include "MEDMEM_Mesh.hxx"
  14 #include "MEDMEM_CellModel.hxx"
  15 #include "MEDMEM_define.hxx"
  16 #include "MEDMEM_DriverTools.hxx"
  17
  18 /////
  19 using namespace MED_EN;
  20 using namespace MEDMEM;
  21 /////
  22
  23
  24 /////
  25 const size_t GIBI_MESH_DRIVER::nb_geometrie_gibi;
  26
  27 const medGeometryElement GIBI_MESH_DRIVER::geomGIBItoMED[nb_geometrie_gibi] =
  28      {   /*1 */ MED_POINT1 ,/*2 */ MED_SEG2   ,/*3 */ MED_SEG3   ,/*4 */ MED_TRIA3  ,/*5 */ MED_NONE   ,
  29        /*6 */ MED_TRIA6  ,/*7 */ MED_NONE   ,/*8 */ MED_QUAD4  ,/*9 */ MED_NONE   ,/*10*/ MED_QUAD8  ,
  30        /*11*/ MED_NONE   ,/*12*/ MED_NONE   ,/*13*/ MED_NONE   ,/*14*/ MED_HEXA8  ,/*15*/ MED_HEXA20 ,
  31        /*16*/ MED_PENTA6 ,/*17*/ MED_PENTA15,/*18*/ MED_NONE   ,/*19*/ MED_NONE   ,/*20*/ MED_NONE   ,
  32        /*21*/ MED_NONE   ,/*22*/ MED_NONE   ,/*23*/ MED_TETRA4 ,/*24*/ MED_TETRA10,/*25*/ MED_PYRA5  ,
  33        /*26*/ MED_PYRA13 ,/*27*/ MED_NONE   ,/*28*/ MED_NONE   ,/*29*/ MED_NONE   ,/*30*/ MED_NONE   ,
  34        /*31*/ MED_NONE   ,/*32*/ MED_NONE   ,/*33*/ MED_NONE   ,/*34*/ MED_NONE   ,/*35*/ MED_NONE   ,
  35        /*36*/ MED_NONE   ,/*37*/ MED_NONE   ,/*38*/ MED_NONE   ,/*39*/ MED_NONE   ,/*40*/ MED_NONE   ,
  36        /*41*/ MED_NONE   ,/*42*/ MED_NONE   ,/*43*/ MED_NONE   ,/*44*/ MED_NONE   ,/*45*/ MED_NONE   ,
  37        /*46*/ MED_NONE   ,/*47*/ MED_NONE   };
  38 /////
  39
  40 // Every memory allocation made in the MedDriver members function are desallocated in the Mesh destructor
  41
  42 GIBI_MESH_DRIVER::GIBI_MESH_DRIVER():
  43   GENDRIVER(),
  44   _ptrMesh(( MESH *)MED_NULL),
  45   // A VOIR _medIdt(MED_INVALID),
  46   _meshName("")
  47 {
  48 }
  49
  50 GIBI_MESH_DRIVER::GIBI_MESH_DRIVER(const string & fileName,
  51                                    MESH * ptrMesh,
  52                                    MED_EN::med_mode_acces accessMode):
  53   GENDRIVER(fileName,accessMode),
  54   _ptrMesh(ptrMesh)
  55   // A VOIR _medIdt(MED_INVALID),
  56 {
  57 //   _meshName=fileName.substr(0,fileName.rfind("."));
  58     // mesh name construction from fileName
  59     const string ext=".sauve"; // expected extension
  60     string::size_type pos=fileName.find(ext,0);
  61     string::size_type pos1=fileName.rfind('/');
  62     _meshName = string(fileName,pos1+1,pos-pos1-1); //get rid of directory & extension
  63     SCRUTE(_meshName);
  64 }
  65
  66 GIBI_MESH_DRIVER::GIBI_MESH_DRIVER(const GIBI_MESH_DRIVER & driver):
  67   GENDRIVER(driver),
  68   _ptrMesh(driver._ptrMesh),
  69   // A VOIR _medIdt(MED_INVALID),
  70   _meshName(driver._meshName)
  71 {
  72 }
  73
  74 GIBI_MESH_DRIVER::~GIBI_MESH_DRIVER()
  75 {
  76 }
  77
  78 void GIBI_MESH_DRIVER::open()
  79   throw (MEDEXCEPTION)
  80 {
  81     const char * LOC = "GIBI_MESH_DRIVER::open()" ;
  82     BEGIN_OF(LOC);
  83
  84     _gibi.open(_fileName.c_str(), ios::in);
  85     if(_gibi)
  86         _status = MED_OPENED;
  87     else
  88     {
  89         _status = MED_CLOSED;
  90         throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Could not open file "<<_fileName<<" in mode ios::in"));
  91     }
  92   END_OF(LOC);
  93 }
  94
  95 void GIBI_MESH_DRIVER::close()
  96   throw (MEDEXCEPTION)
  97 {
  98     const char * LOC = "GIBI_MESH_DRIVER::close() " ;
  99     BEGIN_OF(LOC);
 100     if ( _status == MED_OPENED)
 101     {
 102         _gibi.close();
 103         _status = MED_CLOSED;
 104     }
 105     END_OF(LOC);
 106 }
 107
 108 void    GIBI_MESH_DRIVER::setMeshName(const string & meshName) { _meshName = meshName; };
 109 string  GIBI_MESH_DRIVER::getMeshName() const { return _meshName; };
 110
 111
 112 //---------------------------------- RDONLY PART -------------------------------------------------------------
 113
 114 GIBI_MESH_RDONLY_DRIVER::GIBI_MESH_RDONLY_DRIVER(): GIBI_MESH_DRIVER()
 115 {
 116 }
 117
 118 GIBI_MESH_RDONLY_DRIVER::GIBI_MESH_RDONLY_DRIVER(const string & fileName,
 119         MESH * ptrMesh):
 120 GIBI_MESH_DRIVER(fileName,ptrMesh,MED_RDONLY)
 121 {
 122     MESSAGE("GIBI_MESH_RDONLY_DRIVER::GIBI_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh) has been created");
 123 }
 124
 125     GIBI_MESH_RDONLY_DRIVER::GIBI_MESH_RDONLY_DRIVER(const GIBI_MESH_RDONLY_DRIVER & driver):
 126 GIBI_MESH_DRIVER(driver)
 127 {
 128 }
 129
 130 GIBI_MESH_RDONLY_DRIVER::~GIBI_MESH_RDONLY_DRIVER()
 131 {
 132     //MESSAGE("GIBI_MESH_RDONLY_DRIVER::~GIBI_MESH_RDONLY_DRIVER() has been destroyed");
 133 }
 134
 135 GENDRIVER * GIBI_MESH_RDONLY_DRIVER::copy(void) const
 136 {
 137     return new GIBI_MESH_RDONLY_DRIVER(*this);
 138 }
 139
 140 void GIBI_MESH_RDONLY_DRIVER::read(void) throw (MEDEXCEPTION)
 141 {
 142     const char * LOC = "GIBI_MESH_RDONLY_DRIVER::read() : " ;
 143     BEGIN_OF(LOC);
 144
 145     if (_status!=MED_OPENED)
 146         throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << "The _idt of file " << _fileName << " is : "
 147                                                  <<  " (the file is not opened)." )) ;
 148
 149     // LECTURE DES DONNEES DS FICHIER GIBI
 150
 151     _intermediateMED medi; // structure de données intermédiaire pour conversion gibi->med
 152     string buf_ligne; // pour lire une ligne
 153     const char* enregistrement_type="ENREGISTREMENT DE TYPE";
 154     std::vector<int> numero_noeuds; // tableau de travail (indices)
 155
 156
 157     while ( getline(_gibi, buf_ligne) ) // boucle externe de recherche de "ENREGISTREMENT DE TYPE"
 158     {
 159         string::size_type pos = buf_ligne.find(enregistrement_type);
 160         if ( pos==string::npos )
 161             continue; // "ENREGISTREMENT DE TYPE" non trouvé -> on lit la ligne suivante
 162
 163         // lecture du numéro d'enregistrement
 164         int numero_enregistrement;
 165         istringstream buf(buf_ligne.c_str()+strlen(enregistrement_type)+1);
 166         buf >> numero_enregistrement;
 167
 168         enum { ENREG_TYPE_2=2, ENREG_TYPE_4=4}; // énumération des types d'enregistrement traités
 169         int niveau, niveau_erreur;
 170         unsigned space_dimension,nb_reels;
 171         int numero_pile, nb_objets_nommes, nb_objets, nb_indices;
 172         string s1,s2,s3,s4,s5,s6,s7; // temporary strings
 173         int i1; //temporary int
 174         double d1; //temporary double
 175         vector<int> indices_objets_nommes;
 176         vector<string> objets_nommes;
 177
 178         switch (numero_enregistrement)
 179           {
 180           case ENREG_TYPE_4:
 181             MESSAGE(LOC << "---- Traitement enregistrement de type 4");
 182             _gibi >> s1 >> niveau >> s2 >> s3 >> niveau_erreur >> s4 >> space_dimension;
 183             if ( !_gibi || s1!="NIVEAU" || s3!="ERREUR" || s4!="DIMENSION" ) // verification mots -cles
 184               throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << " Could not read file " << _fileName
 185                                            << " : syntax error in type 4 record"));
 186             break;
 187
 188           case ENREG_TYPE_2:
 189             {
 190               MESSAGE(LOC << "---- Traitement enregistrement de type 2");
 191               _gibi >> s1 >> s2 >> numero_pile >> s3 >> s4 >> s5 >> nb_objets_nommes >> s6 >> s7 >> nb_objets;
 192               if ( !_gibi || s1!="PILE"   || s2!="NUMERO"       || s3!="NBRE"  // verification mots -cles
 193                    || s4!="OBJETS" || s5!="NOMMES"       || s6!="NBRE"
 194                    || s7!="OBJETS" || nb_objets_nommes<0 || nb_objets<0  )
 195                 {
 196                   throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << " Could not read file " << _fileName
 197                                                << " : error in type 2 record"));
 198                 }
 199
 200               // lecture des objets nommés et de leurs indices
 201               objets_nommes.resize(nb_objets_nommes);
 202               indices_objets_nommes.resize(nb_objets_nommes);
 203               for (int i=0; i!=nb_objets_nommes; ++i)
 204                 _gibi >> objets_nommes[i];
 205
 206               for (int i=0; i!=nb_objets_nommes; ++i)
 207                 _gibi >> indices_objets_nommes[i];
 208
 209               // boucle interne : lecture de la pile
 210               enum {PILE_SOUS_MAILLAGE=1, PILE_NOEUDS=32, PILE_COORDONNEES=33};
 211               switch(numero_pile)
 212                 {
 213                 case PILE_SOUS_MAILLAGE:
 214                   {
 215                     medi.groupes.reserve(nb_objets);
 216                     for (int objet=0; objet!=nb_objets; ++objet) // pour chaque groupe
 217                       {
 218                         unsigned type_geom_castem, nb_reference,nb_noeud,nb_elements, nb_sous_maillage;
 219                         _gibi >> type_geom_castem >> nb_sous_maillage >> nb_reference >> nb_noeud >> nb_elements;
 220
 221                         // le cas type_geom_castem=0 correspond aux maillages composites
 222                         if (type_geom_castem<0 || (type_geom_castem>0 && geomGIBItoMED[type_geom_castem-1]==MED_NONE) )
 223                           throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << " Error while reading file " << _fileName
 224                                                        << "\nCastem geometric type " << type_geom_castem
 225                                                        << " does not have a correspondant MED geometric type!" ));
 226
 227                         // lecture des references (non utilisé pour MED)
 228                         for( unsigned i=0; i!=nb_reference; ++i)
 229                           _gibi >> i1;
 230
 231                         // lecture des couleurs (non utilisé pour MED)
 232                         for( unsigned i=0; i!=nb_elements; ++i)
 233                           _gibi >> i1;
 234
 235                         _groupe groupe;
 236                         // si le groupe se compose de sous-maillages (ie groupe composite)
 237                         if (type_geom_castem==0 && nb_sous_maillage>0)
 238                           {
 239                             // lecture des indices des sous-maillages, stockage.
 240                             // les mailles correspondant a ces sous_maillages seront inserees a la fin du case
 241                             for (unsigned i=0; i!=nb_sous_maillage; ++i)
 242                               {
 243                                 _gibi >> i1;
 244                                 groupe.groupes.push_back(i1);
 245                               }
 246                           }
 247                         else
 248                           {
 249                             pair<set<_maille>::iterator,bool> p;
 250                             pair<map<int,_noeud>::iterator,bool> p_no;
 251                             _noeud no;
 252                             no.coord.reserve(space_dimension);
 253                             no.coord.resize(space_dimension);
 254                             _maille ma(geomGIBItoMED[type_geom_castem-1], nb_noeud);
 255                             ma.sommets.resize(nb_noeud);
 256
 257                             // lecture pour chaque maille des sommets et insertions
 258                             for( unsigned i=0; i!=nb_elements; ++i)
 259                               {
 260                                 for (unsigned n=0; n!=nb_noeud; ++n)
 261                                   {
 262                                     _gibi >> i1;
 263                                     no.number=i1;
 264                                     p_no=medi.points.insert(make_pair(i1, no));
 265                                     ma.sommets[n]=p_no.first;
 266                                   }
 267
 268                                 p=medi.maillage.insert(ma);
 269                                 groupe.mailles.insert(p.first); // on stocke dans le groupe un iterateur sur la maille
 270
 271 //                                  cout << "   " << p.second << ": ";
 272 //                                  for (unsigned n=0; n!=nb_noeud; ++n)
 273 //                                      cout <<  ma.sommets[n]->second.number << " ";
 274 //                                  cout << endl;
 275
 276                               }
 277                           }
 278                         medi.groupes.push_back(groupe);
 279                       }
 280
 281                     for (int i=0; i!=nb_objets_nommes; ++i)
 282                       medi.groupes[indices_objets_nommes[i]-1].nom=objets_nommes[i];
 283
 284                     // scanne les groupes à la recherche de groupes composites
 285                     for( std::vector<_groupe>::iterator i=medi.groupes.begin(); i!=medi.groupes.end(); ++i)
 286                       {
 287                         if( i->groupes.size() ) // le groupe i contient des sous-maillages
 288                           {
 289                             for( std::vector<int>::iterator j=i->groupes.begin(); j!=i->groupes.end(); ++j)
 290                               {
 291                                 // pour chacun des sous-maillages j, on recupere les iterateurs *k sur les  maille
 292                                 // contenues et on les insere dans le groupe i
 293                                 std::set< std::set<_maille>::iterator >::const_iterator k=medi.groupes[*j-1].mailles.begin();
 294                                 for( ; k!=medi.groupes[*j-1].mailles.end(); ++k)
 295                                   i->mailles.insert(*k);
 296                               }
 297                             i->groupes.clear(); // après avoir inséré leur mailles, on efface les groupes composites
 298                           }
 299                       }
 300
 301                     break;
 302                   }// Fin case PILE_SOUS_MAILLAGE
 303
 304                 case PILE_NOEUDS:
 305                   {
 306                     std::vector<int> place_noeuds;
 307                     _gibi >> nb_indices;
 308                     if (nb_indices != nb_objets)
 309                       {
 310                         throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << " Could not read file " << _fileName
 311                                                      << "Erreur de lecture dans enregistrement de type " << ENREG_TYPE_2
 312                                                      << " (pile " << PILE_NOEUDS << ")" ));
 313                       }
 314
 315                     place_noeuds.resize(nb_objets);
 316                     for (unsigned i=0; i!=place_noeuds.size(); ++i)
 317                       _gibi >> place_noeuds[i];
 318                     int max=(* std::max_element(place_noeuds.begin(),place_noeuds.end()));
 319
 320                     // numero_noeuds contient pour chacun des max noeuds qu'on va lire dans le case PILE_COORDONNEES
 321                     // son indice dans la connectivite du maillage. Cet indice correspond egalement a la cle du map
 322                     // medi.points ou l'on stocke les noeuds.
 323                     numero_noeuds.resize(max,-1);
 324                     for (unsigned i=0; i!=place_noeuds.size(); ++i)
 325                       numero_noeuds[place_noeuds[i]-1]=i+1;
 326                     break;
 327                   }
 328
 329                 case PILE_COORDONNEES:
 330                   _gibi >> nb_reels;
 331                   // PROVISOIRE : certains fichier gibi n'ont
 332                   if (nb_reels < numero_noeuds.size()*(space_dimension))
 333                     throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << " Could not read file " << _fileName
 334                                                  << "Erreur de lecture dans enregistrement de type " << ENREG_TYPE_2
 335                                                  << " (pile " << PILE_COORDONNEES << ")" ));
 336
 337                   for (unsigned i=0; i!=numero_noeuds.size(); ++i)
 338                     {
 339                       // si le noeud est utilisé dans le maillage, on lit ses coordonnées et on les stocke dans la structure
 340                       if ( (numero_noeuds[i] != -1) && (medi.points.find(numero_noeuds[i])!=medi.points.end()) )
 341                         {
 342                           for (unsigned j=0; j!=space_dimension; ++j)
 343                             _gibi >> medi.points[numero_noeuds[i]].coord[j];
 344                           _gibi >> d1; // on ne conserve pas la densite
 345                         }
 346                       else // sinon, on passe au noeud suivant
 347                         {
 348                           for (unsigned j=0; j!=space_dimension+1; ++j)
 349                             _gibi >> d1;
 350                         }
 351                     }
 352                   break;
 353
 354                 } // Fin switch numero_pile
 355               break;
 356             } // Fin case ENREG_TYPE_2
 357           }
 358
 359     } //  fin de la boucle while de lecture externe
 360
 361     // impression résultats
 362     MESSAGE(LOC << "GIBI_MESH_RDONLY_DRIVER::read : RESULTATS STRUCTURE INTERMEDIAIRES : ");
 363     MESSAGE(LOC <<  medi );
 364
 365             // TRANSFORMATION EN STRUCTURES MED
 366     if ( ! _ptrMesh->isEmpty() )
 367     {
 368         throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<"Mesh object not empty : can't fill it!"));
 369     }
 370     else if ( medi.maillage.size()==0 || medi.groupes.size()==0 || medi.points.size()==0)
 371     {
 372         throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << " Error while reading file " << _fileName
 373                     << " The data read are not completed " ) ) ;
 374     }
 375     else
 376     {
 377         _ptrMesh->_name = _meshName;
 378         _ptrMesh->_spaceDimension = medi.points.begin()->second.coord.size();
 379         _ptrMesh->_meshDimension = medi.maillage.rbegin()->dimension();
 380         _ptrMesh->_numberOfNodes = medi.points.size();
 381         _ptrMesh->_isAGrid = 0;
 382         _ptrMesh->_coordinate = medi.getCoordinate();
 383
 384         //Construction des groupes
 385         vector<GROUP *> groupCell, groupFace, groupEdge, groupNode;
 386         medi.getGroups(groupCell, groupFace, groupEdge, groupNode, _ptrMesh);
 387         _ptrMesh->_groupCell = groupCell;
 388         _ptrMesh->_groupFace = groupFace;
 389         _ptrMesh->_groupEdge = groupEdge;
 390         _ptrMesh->_groupNode = groupNode;
 391
 392         // appele en dernier car cette fonction detruit le maillage intermediaire!
 393         _ptrMesh->_connectivity = medi.getConnectivity();
 394
 395         // calcul de la connectivite d-1 complete, avec renumerotation des groupes
 396         //if (_ptrMesh->_spaceDimension==3)
 397         //    _ptrMesh->_connectivity->updateGroup(_ptrMesh->_groupFace) ;
 398         //else if (_ptrMesh->_spaceDimension==2)
 399         //    _ptrMesh->_connectivity->updateGroup(_ptrMesh->_groupEdge) ;
 400
 401         // Creation des familles à partir des groupes
 402         // NC : Cet appel pourra être différé quand la gestion de la cohérence famille/groupes sera assurée
 403         _ptrMesh->createFamilies();
 404     }
 405
 406
 407
 408     END_OF(LOC);
 409 }
 410
 411 void GIBI_MESH_RDONLY_DRIVER::write( void ) const
 412   throw (MEDEXCEPTION)
 413 {
 414   throw MEDEXCEPTION("GIBI_MESH_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
 415 }
 416
 417
 418 /*--------------------- WRONLY PART -------------------------------*/
 419
 420 GIBI_MESH_WRONLY_DRIVER::GIBI_MESH_WRONLY_DRIVER():GIBI_MESH_DRIVER()
 421 {
 422 }
 423
 424 GIBI_MESH_WRONLY_DRIVER::GIBI_MESH_WRONLY_DRIVER(const string & fileName,
 425                                                  MESH * ptrMesh):
 426   GIBI_MESH_DRIVER(fileName,ptrMesh,MED_WRONLY)
 427 {
 428   MESSAGE("GIBI_MESH_WRONLY_DRIVER::GIBI_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh) has been created");
 429 }
 430
 431 GIBI_MESH_WRONLY_DRIVER::GIBI_MESH_WRONLY_DRIVER(const GIBI_MESH_WRONLY_DRIVER & driver):
 432   GIBI_MESH_DRIVER(driver)
 433 {
 434 }
 435
 436 GIBI_MESH_WRONLY_DRIVER::~GIBI_MESH_WRONLY_DRIVER()
 437 {
 438   //MESSAGE("GIBI_MESH_WRONLY_DRIVER::GIBI_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh) has been destroyed");
 439 }
 440
 441 GENDRIVER * GIBI_MESH_WRONLY_DRIVER::copy(void) const
 442 {
 443   return new GIBI_MESH_WRONLY_DRIVER(*this);
 444 }
 445
 446 void GIBI_MESH_WRONLY_DRIVER::read (void)
 447   throw (MEDEXCEPTION)
 448 {
 449   throw MEDEXCEPTION("GIBI_MESH_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
 450 }
 451
 452 void GIBI_MESH_WRONLY_DRIVER::write(void) const
 453   throw (MEDEXCEPTION)
 454 {
 455   const char * LOC = "void GIBI_MESH_WRONLY_DRIVER::write(void) const : ";
 456   BEGIN_OF(LOC);
 457
 458   throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<< "Write Driver isn\'t implemented"));
 459
 460   END_OF(LOC);
 461 }
 462
 463
 464
 465 /*--------------------- RDWR PART -------------------------------*/
 466
 467 GIBI_MESH_RDWR_DRIVER::GIBI_MESH_RDWR_DRIVER():GIBI_MESH_DRIVER()
 468 {
 469 }
 470
 471 GIBI_MESH_RDWR_DRIVER::GIBI_MESH_RDWR_DRIVER(const string & fileName,
 472                                            MESH * ptrMesh):
 473   GIBI_MESH_DRIVER(fileName,ptrMesh,MED_RDWR)
 474 {
 475   MESSAGE("GIBI_MESH_RDWR_DRIVER::GIBI_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh) has been created");
 476 }
 477
 478 GIBI_MESH_RDWR_DRIVER::GIBI_MESH_RDWR_DRIVER(const GIBI_MESH_RDWR_DRIVER & driver):
 479   GIBI_MESH_RDONLY_DRIVER::GIBI_MESH_DRIVER(driver)
 480 {
 481 }
 482
 483 GIBI_MESH_RDWR_DRIVER::~GIBI_MESH_RDWR_DRIVER() {
 484   //MESSAGE("GIBI_MESH_RDWR_DRIVER::GIBI_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh) has been destroyed");
 485 }
 486
 487 GENDRIVER * GIBI_MESH_RDWR_DRIVER::copy(void) const
 488 {
 489   return new GIBI_MESH_RDWR_DRIVER(*this);
 490 }
 491
 492 void GIBI_MESH_RDWR_DRIVER::write(void) const
 493   throw (MEDEXCEPTION)
 494 {
 495   GIBI_MESH_WRONLY_DRIVER::write();
 496 }
 497 void GIBI_MESH_RDWR_DRIVER::read (void)
 498   throw (MEDEXCEPTION)
 499 {
 500   GIBI_MESH_RDONLY_DRIVER::read();
 501 }