src/MEDMEM/MEDMEM_TypeMeshDriver.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_TypeMeshDriver.hxx"
  23 #include "MEDMEM_DriversDef.hxx"
  24
  25 #include "MEDMEM_Family.hxx"
  26 #include "MEDMEM_Group.hxx"
  27 #include "MEDMEM_Coordinate.hxx"
  28 #include "MEDMEM_Connectivity.hxx"
  29 #include "MEDMEM_Mesh.hxx"
  30 #include "MEDMEM_CellModel.hxx"
  31
  32 using namespace std;
  33 using namespace MEDMEM;
  34
  35 // Every memory allocation made in the MedDriver members function are desallocated in the Mesh destructor
  36
  37 TYPE_MESH_DRIVER::TYPE_MESH_DRIVER():
  38   GENDRIVER(),
  39   _ptrMesh(( MESH *)MED_NULL),
  40   // A VOIR _medIdt(MED_INVALID),
  41   _meshName("")
  42 {
  43 }
  44
  45 TYPE_MESH_DRIVER::TYPE_MESH_DRIVER(const std::string & fileName,
  46                                    MESH * ptrMesh,
  47                                    MED_EN::med_mode_acces accessMode):
  48   GENDRIVER(fileName,accessMode),
  49   _ptrMesh(ptrMesh),
  50   // A VOIR _medIdt(MED_INVALID),
  51   _meshName("")
  52 {
  53 }
  54
  55 TYPE_MESH_DRIVER::TYPE_MESH_DRIVER(const TYPE_MESH_DRIVER & driver):
  56   GENDRIVER(driver),
  57   _ptrMesh(driver._ptrMesh),
  58   // A VOIR _medIdt(MED_INVALID),
  59   _meshName(driver._meshName)
  60 {
  61 }
  62
  63 TYPE_MESH_DRIVER::~TYPE_MESH_DRIVER()
  64 {
  65 }
  66
  67 void TYPE_MESH_DRIVER::open()
  68   throw (MEDEXCEPTION)
  69 {
  70   const char * LOC = "TYPE_MESH_DRIVER::open()" ;
  71   BEGIN_OF_MED(LOC);
  72
  73 //   if (_medIdt > 0)
  74 //     _status = MED_OPENED;
  75 //   else {
  76 //     _medIdt = MED_INVALID;
  77 //     _status = MED_CLOSED;
  78 //     throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<" Could not open file "<<_fileName<<" in mode "<<_accessMode));
  79 //   }
  80
  81   END_OF_MED(LOC);
  82 }
  83
  84 void TYPE_MESH_DRIVER::close()
  85   throw (MEDEXCEPTION)
  86 {
  87   const char * LOC = "TYPE_MESH_DRIVER::close() " ;
  88   BEGIN_OF_MED(LOC);
  89
  90 //   int err = 0;
  91 //   if ( _status == MED_OPENED) {
  92 //     err=MED_FR::MEDfermer(_medIdt);
  93 //     H5close(); // If we call H5close() all the files are closed.
  94 //     if (err != 0)
  95 //       throw MEDEXCEPTION( LOCALIZED(STRING(LOC)
  96 //                                  <<" Error when closing file !"
  97 //                                  )
  98 //                        );
  99 //     _status = MED_CLOSED;
 100 //     _medIdt = MED_INVALID;
 101 //   }
 102
 103   END_OF_MED(LOC);
 104 }
 105
 106 void    TYPE_MESH_DRIVER::setMeshName(const string & meshName) { _meshName = meshName; };
 107 string  TYPE_MESH_DRIVER::getMeshName() const { return _meshName; };
 108
 109
 110 //---------------------------------- RDONLY PART -------------------------------------------------------------
 111
 112 TYPE_MESH_RDONLY_DRIVER::TYPE_MESH_RDONLY_DRIVER(): TYPE_MESH_DRIVER()
 113 {
 114 }
 115
 116 TYPE_MESH_RDONLY_DRIVER::TYPE_MESH_RDONLY_DRIVER(const string & fileName,
 117                                                  MESH * ptrMesh):
 118   TYPE_MESH_DRIVER(fileName,ptrMesh,MED_RDONLY)
 119 {
 120   MESSAGE_MED("TYPE_MESH_RDONLY_DRIVER::TYPE_MESH_RDONLY_DRIVER(const string & fileName, MESH * ptrMesh) has been created");
 121 }
 122
 123 TYPE_MESH_RDONLY_DRIVER::TYPE_MESH_RDONLY_DRIVER(const TYPE_MESH_RDONLY_DRIVER & driver):
 124   TYPE_MESH_DRIVER(driver)
 125 {
 126 }
 127
 128 TYPE_MESH_RDONLY_DRIVER::~TYPE_MESH_RDONLY_DRIVER()
 129 {
 130   //MESSAGE_MED("TYPE_MESH_RDONLY_DRIVER::~TYPE_MESH_RDONLY_DRIVER() has been destroyed");
 131 }
 132
 133 GENDRIVER * TYPE_MESH_RDONLY_DRIVER::copy(void) const
 134 {
 135   return new TYPE_MESH_RDONLY_DRIVER(*this);
 136 }
 137
 138 void TYPE_MESH_RDONLY_DRIVER::read(void)
 139   throw (MEDEXCEPTION)
 140 {
 141   const char * LOC = "TYPE_MESH_RDONLY_DRIVER::read() : " ;
 142   BEGIN_OF_MED(LOC);
 143
 144   if (_status!=MED_OPENED)
 145     throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << "The _idt of file " << _fileName << " is : "  <<  " (the file is not opened)." )) ;
 146
 147   _ptrMesh->_name =  _meshName;
 148
 149
 150   END_OF_MED(LOC);
 151 }
 152
 153 void TYPE_MESH_RDONLY_DRIVER::write( void ) const
 154   throw (MEDEXCEPTION)
 155 {
 156   throw MEDEXCEPTION("TYPE_MESH_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
 157 }
 158
 159
 160 /*--------------------- WRONLY PART -------------------------------*/
 161
 162 TYPE_MESH_WRONLY_DRIVER::TYPE_MESH_WRONLY_DRIVER():TYPE_MESH_DRIVER()
 163 {
 164 }
 165
 166 TYPE_MESH_WRONLY_DRIVER::TYPE_MESH_WRONLY_DRIVER(const string & fileName,
 167                                                  MESH * ptrMesh):
 168   TYPE_MESH_DRIVER(fileName,ptrMesh,MED_WRONLY)
 169 {
 170   MESSAGE_MED("TYPE_MESH_WRONLY_DRIVER::TYPE_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh) has been created");
 171 }
 172
 173 TYPE_MESH_WRONLY_DRIVER::TYPE_MESH_WRONLY_DRIVER(const TYPE_MESH_WRONLY_DRIVER & driver):
 174   TYPE_MESH_DRIVER(driver)
 175 {
 176 }
 177
 178 TYPE_MESH_WRONLY_DRIVER::~TYPE_MESH_WRONLY_DRIVER()
 179 {
 180   //MESSAGE_MED("TYPE_MESH_WRONLY_DRIVER::TYPE_MESH_WRONLY_DRIVER(const string & fileName, MESH * ptrMesh) has been destroyed");
 181 }
 182
 183 GENDRIVER * TYPE_MESH_WRONLY_DRIVER::copy(void) const
 184 {
 185   return new TYPE_MESH_WRONLY_DRIVER(*this);
 186 }
 187
 188 void TYPE_MESH_WRONLY_DRIVER::read (void)
 189   throw (MEDEXCEPTION)
 190 {
 191   throw MEDEXCEPTION("TYPE_MESH_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
 192 }
 193
 194 void TYPE_MESH_WRONLY_DRIVER::write(void) const
 195   throw (MEDEXCEPTION)
 196 {
 197   const char * LOC = "void TYPE_MESH_WRONLY_DRIVER::write(void) const : ";
 198   BEGIN_OF_MED(LOC);
 199
 200   throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<< "Write Driver isn\'t implemented"));
 201
 202   END_OF_MED(LOC);
 203 }
 204
 205
 206
 207 /*--------------------- RDWR PART -------------------------------*/
 208
 209 TYPE_MESH_RDWR_DRIVER::TYPE_MESH_RDWR_DRIVER():TYPE_MESH_DRIVER()
 210 {
 211 }
 212
 213 TYPE_MESH_RDWR_DRIVER::TYPE_MESH_RDWR_DRIVER(const string & fileName,
 214                                            MESH * ptrMesh):
 215   TYPE_MESH_DRIVER(fileName,ptrMesh,MED_RDWR)
 216 {
 217   MESSAGE_MED("TYPE_MESH_RDWR_DRIVER::TYPE_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh) has been created");
 218 }
 219
 220 TYPE_MESH_RDWR_DRIVER::TYPE_MESH_RDWR_DRIVER(const TYPE_MESH_RDWR_DRIVER & driver):
 221   TYPE_MESH_RDONLY_DRIVER::TYPE_MESH_DRIVER(driver)
 222 {
 223 }
 224
 225 TYPE_MESH_RDWR_DRIVER::~TYPE_MESH_RDWR_DRIVER() {
 226   //MESSAGE_MED("TYPE_MESH_RDWR_DRIVER::TYPE_MESH_RDWR_DRIVER(const string & fileName, MESH * ptrMesh) has been destroyed");
 227 }
 228
 229 GENDRIVER * TYPE_MESH_RDWR_DRIVER::copy(void) const
 230 {
 231   return new TYPE_MESH_RDWR_DRIVER(*this);
 232 }
 233
 234 void TYPE_MESH_RDWR_DRIVER::write(void) const
 235   throw (MEDEXCEPTION)
 236 {
 237   TYPE_MESH_WRONLY_DRIVER::write();
 238 }
 239 void TYPE_MESH_RDWR_DRIVER::read (void)
 240   throw (MEDEXCEPTION)
 241 {
 242   TYPE_MESH_RDONLY_DRIVER::read();
 243 }