src/MEDMEM/MEDMEM_EnsightMedDriver.cxx

   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 #include "MEDMEM_define.hxx"
  23 #include "MEDMEM_Med.hxx"
  24 #include "MEDMEM_Support.hxx"
  25 #include "MEDMEM_Mesh.hxx"
  26
  27 #include "MEDMEM_EnsightMedDriver.hxx"
  28 #include "MEDMEM_EnsightFieldDriver.hxx"
  29 #include "MEDMEM_EnsightMeshDriver.hxx"
  30
  31 using namespace std;
  32 //using namespace MEDMEM;
  33 using namespace MED_EN;
  34 using namespace MEDMEM_ENSIGHT;
  35
  36 // ================================================================================
  37 // ENSIGHT_MED_DRIVER
  38 // ================================================================================
  39 namespace MEDMEM {
  40
  41 ENSIGHT_MED_DRIVER::ENSIGHT_MED_DRIVER():
  42   _CaseFileDriver_User(),_ptrMed((MED *)MED_NULL)
  43 {}
  44
  45 ENSIGHT_MED_DRIVER::ENSIGHT_MED_DRIVER(const string & fileName,  MED * ptrMed):
  46   _CaseFileDriver_User(fileName,RDONLY), _ptrMed(ptrMed)
  47 {
  48 }
  49
  50 ENSIGHT_MED_DRIVER::ENSIGHT_MED_DRIVER(const string & fileName,
  51                                        MED *          ptrMed,
  52                                        med_mode_acces accessMode):
  53   _CaseFileDriver_User(fileName,accessMode), _ptrMed(ptrMed)
  54 {
  55 }
  56
  57 ENSIGHT_MED_DRIVER::ENSIGHT_MED_DRIVER(const ENSIGHT_MED_DRIVER & driver):
  58   _CaseFileDriver_User(driver), _ptrMed(driver._ptrMed)
  59 {
  60 }
  61
  62 void ENSIGHT_MED_DRIVER::openConst() const
  63 {
  64   const char * LOC ="ENSIGHT_MED_DRIVER::open() : ";
  65   BEGIN_OF_MED(LOC);
  66
  67   if ( _fileName.empty() )
  68     throw MED_EXCEPTION
  69       ( LOCALIZED( STRING(LOC) << "_fileName is empty, "
  70                    "please set a correct fileName before calling open()"));
  71
  72   if (!canOpenFile( _fileName, getAccessMode() ))
  73     throw MED_EXCEPTION
  74       ( LOCALIZED( STRING(LOC) << "Can not open main Ensight file " << _fileName));
  75
  76   END_OF_MED(LOC);
  77 }
  78
  79 void ENSIGHT_MED_DRIVER::open() {
  80   openConst();
  81 }
  82 void ENSIGHT_MED_DRIVER::close() {
  83 }
  84
  85 ENSIGHT_MED_DRIVER::~ENSIGHT_MED_DRIVER()
  86 {
  87   MESSAGE_MED("ENSIGHT_MED_DRIVER::~ENSIGHT_MED_DRIVER() has been destroyed");
  88 }
  89
  90 // ================================================================================
  91 // WRONLY
  92 // ================================================================================
  93
  94 ENSIGHT_MED_WRONLY_DRIVER::ENSIGHT_MED_WRONLY_DRIVER() : ENSIGHT_MED_DRIVER()
  95 {
  96 }
  97
  98 ENSIGHT_MED_WRONLY_DRIVER::ENSIGHT_MED_WRONLY_DRIVER(const string & fileName,  MED * ptrMed)
  99   : ENSIGHT_MED_DRIVER(fileName, ptrMed, MED_EN::WRONLY )
 100 {
 101 }
 102
 103 ENSIGHT_MED_WRONLY_DRIVER::ENSIGHT_MED_WRONLY_DRIVER(const ENSIGHT_MED_WRONLY_DRIVER & driver)
 104   : ENSIGHT_MED_DRIVER(driver)
 105 {
 106 }
 107
 108 ENSIGHT_MED_WRONLY_DRIVER::~ENSIGHT_MED_WRONLY_DRIVER()
 109 {
 110 }
 111
 112 GENDRIVER * ENSIGHT_MED_WRONLY_DRIVER::copy() const
 113 {
 114   return new ENSIGHT_MED_WRONLY_DRIVER(*this) ;
 115 }
 116
 117 void ENSIGHT_MED_WRONLY_DRIVER::read() throw (MEDEXCEPTION) {
 118   throw MEDEXCEPTION("ENSIGHT_MED_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
 119 }
 120
 121 void ENSIGHT_MED_WRONLY_DRIVER::write() const throw (MEDEXCEPTION)
 122 {
 123   const char * LOC = "ENSIGHT_MED_WRONLY_DRIVER::write() : ";
 124   BEGIN_OF_MED(LOC);
 125
 126   openConst(); // check if can open the case file
 127
 128   _CaseFileDriver caseFile( getCaseFileName(), this );
 129
 130   int NumberOfMeshes = _ptrMed->getNumberOfMeshes() ;
 131   deque<string> MeshNames = _ptrMed->getMeshNames() ;
 132
 133   int NumberOfFields = _ptrMed->getNumberOfFields() ;
 134   deque<string> FieldNames = _ptrMed->getFieldNames() ;
 135
 136   // Create drivers for all meshes and fields
 137   // and add them to be written to Case file
 138
 139   list< GENDRIVER* > drivers;
 140   ENSIGHT_MESH_WRONLY_DRIVER *  meshDriver;
 141   ENSIGHT_FIELD_WRONLY_DRIVER * fieldDriver;
 142
 143   for (int i=0; i<NumberOfMeshes; i++)
 144   {
 145     MESH * mesh = _ptrMed->getMesh(MeshNames[i]) ;
 146     meshDriver = new ENSIGHT_MESH_WRONLY_DRIVER( _fileName, mesh );
 147     caseFile.addMesh( meshDriver );
 148     drivers.push_back( meshDriver );
 149
 150     // get all fields on this mesh
 151     for (int j=0; j<NumberOfFields; j++)
 152     {
 153       deque<DT_IT_> timeSteps = _ptrMed->getFieldIteration(FieldNames[j]) ;
 154       deque<DT_IT_>::const_iterator dtit = timeSteps.begin();
 155       for ( ; dtit!=timeSteps.end(); dtit++)
 156       {
 157         FIELD_ * field = _ptrMed->getField( FieldNames[j], dtit->dt, dtit->it );
 158         MESH* supMesh = field->getSupport()->getMesh();
 159         if ( supMesh == mesh || mesh->getName() == field->getSupport()->getMeshName() ) {
 160           fieldDriver = new ENSIGHT_FIELD_WRONLY_DRIVER( _fileName, field );
 161           caseFile.addField( fieldDriver );
 162           drivers.push_back( fieldDriver );
 163         }
 164       }
 165     }
 166   }
 167
 168   // Write
 169
 170   // case file
 171   caseFile.write();// necessary data is passed to the drivers by this method
 172
 173   // meshes and fields
 174   list< GENDRIVER* >::iterator drv = drivers.begin();
 175   for ( ; drv != drivers.end(); ++drv ) {
 176     GENDRIVER* driver = *drv;
 177     driver->write();
 178     delete driver;
 179   }
 180
 181   END_OF_MED(LOC);
 182 }
 183
 184 // ================================================================================
 185 // RDONLY
 186 // ================================================================================
 187
 188 ENSIGHT_MED_RDONLY_DRIVER::ENSIGHT_MED_RDONLY_DRIVER() :
 189   ENSIGHT_MED_DRIVER(), _isFileStructRead(false)
 190 {
 191 }
 192
 193 ENSIGHT_MED_RDONLY_DRIVER::ENSIGHT_MED_RDONLY_DRIVER(const string & fileName,  MED * ptrMed)
 194   : ENSIGHT_MED_DRIVER( fileName, ptrMed, MED_EN::RDONLY), _isFileStructRead(false)
 195 {
 196 }
 197
 198 ENSIGHT_MED_RDONLY_DRIVER::ENSIGHT_MED_RDONLY_DRIVER(const ENSIGHT_MED_RDONLY_DRIVER & driver)
 199   : ENSIGHT_MED_DRIVER(driver), _isFileStructRead(false)
 200 {
 201 }
 202
 203 ENSIGHT_MED_RDONLY_DRIVER::~ENSIGHT_MED_RDONLY_DRIVER()
 204 {
 205 }
 206
 207 GENDRIVER * ENSIGHT_MED_RDONLY_DRIVER::copy() const
 208 {
 209   return new ENSIGHT_MED_RDONLY_DRIVER(*this) ;
 210 }
 211
 212 void ENSIGHT_MED_RDONLY_DRIVER::write() const throw (MEDEXCEPTION) {
 213   throw MEDEXCEPTION("ENSIGHT_MED_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
 214 }
 215
 216 void ENSIGHT_MED_RDONLY_DRIVER::read()
 217 {
 218   const char * LOC = "ENSIGHT_MED_RDONLY_DRIVER::read() : " ;
 219   BEGIN_OF_MED(LOC);
 220
 221   if ( _isFileStructRead ) {
 222
 223     int NumberOfMeshes = _ptrMed->getNumberOfMeshes() ;
 224     deque<string> MeshNames = _ptrMed->getMeshNames() ;
 225
 226     int NumberOfFields = _ptrMed->getNumberOfFields() ;
 227     deque<string> FieldNames = _ptrMed->getFieldNames() ;
 228
 229     for (int i=0; i<NumberOfMeshes; i++)
 230     {
 231       MESH * mesh = _ptrMed->getMesh(MeshNames[i]) ;
 232       mesh->read( getId() );
 233     }
 234     // read fields
 235     for (int j=0; j<NumberOfFields; j++)
 236     {
 237       deque<DT_IT_> timeSteps = _ptrMed->getFieldIteration(FieldNames[j]) ;
 238       deque<DT_IT_>::const_iterator dtit = timeSteps.begin();
 239       for ( ; dtit!=timeSteps.end(); dtit++)
 240       {
 241         FIELD_ * field = _ptrMed->getField( FieldNames[j], dtit->dt, dtit->it );
 242         field->read( getId() );
 243       }
 244     }
 245   }
 246   else {
 247
 248     open(); // check if can open the case file
 249
 250     _CaseFileDriver caseFile( getCaseFileName(), this );
 251
 252     caseFile.read();
 253
 254     int nbOfMeshes = caseFile.getNbMeshes();
 255     for ( int i = 1; i <= nbOfMeshes; ++i )
 256     {
 257       MESH* mesh = new MESH;
 258       ENSIGHT_MESH_RDONLY_DRIVER meshDriver(_fileName, mesh);
 259       caseFile.setDataFileName( i, &meshDriver );
 260       meshDriver.open();
 261       meshDriver.read();
 262       _ptrMed->addMesh( mesh );
 263     }
 264
 265     int nbOfFields = caseFile.getNbVariables();
 266     for ( int i = 1; i <= nbOfFields; i++ )
 267     {
 268       int nbSteps = caseFile.getNbVarSteps( i );
 269       for ( int step = 1; step <= nbSteps; ++step )
 270       {
 271         FIELD_* field = new FIELD<double>;
 272         ENSIGHT_FIELD_RDONLY_DRIVER fieldDriver( _fileName, field );
 273         caseFile.setDataFileName( i, step, &fieldDriver );
 274         fieldDriver.open();
 275         fieldDriver.read();
 276         _ptrMed->addField( field );
 277       }
 278     }
 279   }
 280 }
 281 //================================================================================
 282 /*!
 283  * \brief Create all meshes and fields but not read them
 284  */
 285 //================================================================================
 286
 287 void ENSIGHT_MED_RDONLY_DRIVER::readFileStruct()
 288 {
 289   const char * LOC = "ENSIGHT_MED_RDONLY_DRIVER::read() : " ;
 290   BEGIN_OF_MED(LOC);
 291
 292   open(); // check if can open the case file
 293
 294   _CaseFileDriver caseFile( getCaseFileName(), this );
 295
 296   caseFile.read();
 297
 298   int nbOfMeshes = caseFile.getNbMeshes();
 299   vector<MESH*> meshes( nbOfMeshes+1, (MESH*)0 );
 300   for ( int i = 1; i <= nbOfMeshes; ++i )
 301   {
 302     MESH* mesh = meshes[ i ] = new MESH;
 303     ENSIGHT_MESH_RDONLY_DRIVER meshDriver(_fileName, mesh, i);
 304     caseFile.setDataFileName( i, &meshDriver ); // retrieve mesh name
 305     setId( mesh->addDriver( meshDriver ));
 306     _ptrMed->addMesh( mesh );
 307   }
 308   _isFileStructRead = true;
 309
 310   int nbOfFields = caseFile.getNbVariables();
 311   for ( int i = 1; i <= nbOfFields; i++ )
 312   {
 313     int nbSteps = caseFile.getNbVarSteps( i );
 314     for ( int step = 1; step <= nbSteps; ++step )
 315     {
 316       FIELD<double>* field = new FIELD<double>;
 317       ENSIGHT_FIELD_RDONLY_DRIVER fieldDriver( _fileName, field, step );
 318       int meshIndex = caseFile.setDataFileName( i, step, &fieldDriver ); // retrieve field name
 319       field->addDriver( fieldDriver );
 320       if ( const SUPPORT* sup = field->getSupport() ) {
 321         if ( meshIndex > nbOfMeshes || !meshes[ meshIndex ])
 322           meshIndex = 1;
 323         ((SUPPORT*) sup)->setMesh( meshes[ meshIndex ]);
 324       }
 325       _ptrMed->addField( field );
 326     }
 327   }
 328 }
 329 }