src/MEDMEM/MEDMEM_TypeMeshDriver.cxx

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