src/MEDMEM/MEDMEM_VtkMeshDriver.cxx

   1 using namespace std;
   2 #include "MEDMEM_VtkMeshDriver.hxx"
   3
   4 #include "MEDMEM_DriversDef.hxx"
   5
   6 #include "MEDMEM_Family.hxx"
   7 #include "MEDMEM_Group.hxx"
   8 #include "MEDMEM_Coordinate.hxx"
   9 #include "MEDMEM_Connectivity.hxx"
  10 #include "MEDMEM_Mesh.hxx"
  11 #include "MEDMEM_CellModel.hxx"
  12 #include "MEDMEM_Grid.hxx"
  13
  14 #include <sstream>
  15
  16 VTK_MESH_DRIVER::VTK_MESH_DRIVER(): GENDRIVER(),
  17                                     _ptrMesh((MESH * const)MED_NULL)
  18 {
  19   _vtkFile = new ofstream();
  20   // What about _id in Gendriver ?
  21   // _driverType ???
  22 }
  23
  24 VTK_MESH_DRIVER::VTK_MESH_DRIVER(const string & fileName,
  25                                  MESH * ptrMesh) :
  26   GENDRIVER(fileName,MED_WRONLY),
  27   _ptrMesh(ptrMesh)
  28 {
  29   const char * LOC = "VTK_MESH_DRIVER::VTK_MESH_DRIVER(const string & fileName, MESH * ptrMesh) : " ;
  30
  31   // Send an exception because a VTK_MESH_DRIVER object cannot be instantied
  32   // from a file and there is no read for that kind of driver
  33
  34   //  throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << "This driver is only used to write in VTK format So thie object can not be instantied using a file!"));
  35
  36   //  _ptrMesh->addDriver(*this); // OU RECUPERER L'ID.
  37   MESSAGE(LOC << "WARNING this driver is only used to write in VTK format So the object can not be instantied using a file!");
  38
  39   _vtkFile = new ofstream();
  40 }
  41
  42 VTK_MESH_DRIVER::VTK_MESH_DRIVER(const VTK_MESH_DRIVER & driver):
  43   GENDRIVER(driver),
  44   _ptrMesh(driver._ptrMesh),
  45   _meshName(driver._meshName)
  46 {
  47   _ptrMesh->addDriver(*this);
  48   _vtkFile = new ofstream();
  49 }
  50
  51 VTK_MESH_DRIVER::~VTK_MESH_DRIVER()
  52 {
  53   const char * LOC ="VTK_MESH_DRIVER::~VTK_MESH_DRIVER()";
  54   BEGIN_OF(LOC);
  55
  56   close();
  57
  58   SCRUTE(_vtkFile);
  59
  60   delete _vtkFile ;
  61
  62   SCRUTE(_vtkFile);
  63
  64   END_OF(LOC);
  65 }
  66
  67 void VTK_MESH_DRIVER::openConst() const throw (MEDEXCEPTION)
  68 {
  69   const char * LOC = "VTK_MESH_DRIVER::openConst()" ;
  70   BEGIN_OF(LOC);
  71
  72   MESSAGE(LOC<<" : _fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
  73
  74   if ( _fileName == "" )
  75     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
  76                                      << "_fileName is |\"\"|, please set a correct fileName before calling open()"
  77                                      )
  78                           );
  79
  80   if (!(*_vtkFile).is_open())
  81     (*_vtkFile).open(_fileName.c_str()) ;
  82 //    if (*_vtkFile)
  83 //      _status = MED_OPENED ;
  84 //    else
  85
  86
  87   SCRUTE((*_vtkFile).is_open());
  88   SCRUTE(_vtkFile);
  89
  90
  91
  92   if (!(*_vtkFile))
  93     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not open file "
  94                                      << _fileName)
  95                           );
  96   END_OF(LOC);
  97 }
  98
  99 void VTK_MESH_DRIVER::open() {
 100   openConst() ;
 101 }
 102
 103 void VTK_MESH_DRIVER::closeConst() const throw (MEDEXCEPTION)
 104 {
 105   const char * LOC = "VTK_MESH_DRIVER::closeConst() " ;
 106   BEGIN_OF(LOC);
 107
 108   SCRUTE(_vtkFile);
 109   SCRUTE(*_vtkFile);
 110
 111
 112   if ((*_vtkFile).is_open())
 113     (*_vtkFile).close();
 114
 115 //    if (*_vtkFile)
 116 //      _status = MED_CLOSED ;
 117 //    else
 118
 119   SCRUTE(_vtkFile);
 120   SCRUTE(*_vtkFile);
 121
 122   if (!(*_vtkFile))
 123     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not close file "
 124                                      << _fileName)
 125                           );
 126
 127   END_OF(LOC);
 128 }
 129
 130 void VTK_MESH_DRIVER::close() {
 131   closeConst() ;
 132 }
 133
 134 void    VTK_MESH_DRIVER::setMeshName(const string & meshName) { _meshName = meshName; };
 135 string  VTK_MESH_DRIVER::getMeshName() const { return _meshName; };
 136
 137 void VTK_MESH_DRIVER::read(void) throw (MEDEXCEPTION)
 138 {
 139   const char * LOC = "VTK_MESH_DRIVER::read() : " ;
 140   BEGIN_OF(LOC);
 141
 142   // Send an exception
 143
 144   throw MEDEXCEPTION(LOCALIZED(STRING(LOC) << "This driver is only used to write in VTK format !"));
 145
 146   END_OF(LOC);
 147 }
 148
 149
 150 void VTK_MESH_DRIVER::write(void) const
 151   throw (MEDEXCEPTION)
 152 {
 153   const char * LOC = "void VTK_MESH_DRIVER::write(void) const : ";
 154   BEGIN_OF(LOC);
 155
 156   // Well we must open vtk file first, because there are
 157   // no other driver than MED for VTK that do it !
 158
 159   openConst();
 160
 161   (*_vtkFile) << "# vtk DataFile Version 2.0" << endl
 162            << "maillage from MedMemory"  << endl ;
 163   // only ASCII for the moment (binary came later :-)
 164   (*_vtkFile) << "ASCII" << endl ;
 165
 166
 167   (*_vtkFile) << "DATASET UNSTRUCTURED_GRID" << endl ;
 168   // put points (all point are in 3D, so if we are in 1D or 2D, we complete by zero !
 169   int SpaceDimension = _ptrMesh->getSpaceDimension() ;
 170   int NumberOfNodes = _ptrMesh->getNumberOfNodes() ;
 171   (*_vtkFile) << "POINTS " << NumberOfNodes << " float" << endl ;
 172   const double *coordinate = _ptrMesh->getCoordinates(MED_FULL_INTERLACE) ;
 173   for (int i=0;i<NumberOfNodes;i++) {
 174     for (int j=0;j<SpaceDimension;j++)
 175       (*_vtkFile) << coordinate[i*SpaceDimension+j] << " " ;
 176     if (SpaceDimension==1)
 177       (*_vtkFile) << "0 0" ;
 178     if (SpaceDimension==2)
 179       (*_vtkFile) << "0" ;
 180     (*_vtkFile) << endl ;
 181   }
 182
 183   // we put connectivity
 184   // how many cells and how many value in connectivity :
 185   int cells_types_count = _ptrMesh->getNumberOfTypes(MED_CELL) ;
 186   //  int * cells_count = _ptrMesh->get_cells_count() ;
 187   //  int cells_sum = cells_count[cells_types_count] ;
 188   int cells_sum = _ptrMesh->getNumberOfElements(MED_CELL,MED_ALL_ELEMENTS) ;
 189   const CELLMODEL * cells_type = _ptrMesh->getCellsTypes(MED_CELL) ;
 190   //  int connectivity_sum = 0 ;
 191
 192   //const int * connectivity = _ptrMesh->getConnectivity(MED_FULL_INTERLACE,MED_NODAL,MED_CELL,MED_ALL_ELEMENTS) ; !! UNUSED VARIABLE !!
 193   const int * connectivityIndex = _ptrMesh->getConnectivityIndex(MED_NODAL,MED_CELL) ;
 194
 195   int connectivity_sum =  connectivityIndex[cells_sum]-1 ;
 196
 197   (*_vtkFile) << "CELLS " << cells_sum << " " << connectivity_sum+cells_sum << endl ;
 198   // we put connectivity
 199   for (int i=0;i<cells_types_count;i++) {
 200     int *filter = (int*) NULL ; // index in vtk connectivity
 201     switch (cells_type[i].getType())
 202       {
 203       case MED_POINT1  : {
 204         filter = new int[1] ;
 205         filter[0] = 0 ;
 206         break ;
 207       }
 208       case MED_SEG2    : {
 209         filter = new int[2] ;
 210         filter[0] = 0 ;
 211         filter[1] = 1 ;
 212         break ;
 213       }
 214       case MED_SEG3    : {
 215         break ;
 216       }
 217       case MED_TRIA3   : {
 218         filter = new int[3] ;
 219         filter[0] = 0 ;
 220         filter[1] = 1 ;
 221         filter[2] = 2 ;
 222         break ;
 223       }
 224       case MED_QUAD4   : {
 225         filter = new int[4] ;
 226         filter[0] = 0 ;
 227         filter[1] = 1 ;
 228         filter[2] = 2 ;
 229         filter[3] = 3 ;
 230         break ;
 231       }
 232       case MED_TRIA6   : {
 233         break ;
 234       }
 235       case MED_QUAD8   : {
 236         break ;
 237       }
 238       case MED_TETRA4  : {
 239         filter = new int[4] ;
 240         filter[0] = 0 ;
 241         filter[1] = 1 ;
 242         filter[2] = 3 ;  // 3td element in med are 4th in vtk (array begin at 0 !)
 243         filter[3] = 2 ;  // 4th element in med are 3rd in vtk (array begin at 0 !)
 244         break ;
 245       }
 246       case MED_PYRA5   : {
 247         filter = new int[5] ;
 248         filter[0] = 0 ;
 249         filter[1] = 3 ;  // 2nd element in med are 4th in vtk (array begin at 0 !)
 250         filter[2] = 2 ;
 251         filter[3] = 1 ;  // 4th element in med are 2nd in vtk (array begin at 0 !)
 252         filter[4] = 4 ;
 253         break ;
 254       }
 255       case MED_PENTA6  : {
 256         filter = new int[6] ;
 257         filter[0] = 0 ;
 258         filter[1] = 1 ;
 259         filter[2] = 2 ;
 260         filter[3] = 3 ;
 261         filter[4] = 4 ;
 262         filter[5] = 5 ;
 263         break ;
 264       }
 265       case MED_HEXA8   : {
 266         filter = new int[8] ;
 267         filter[0] = 0 ;
 268         filter[1] = 3 ;
 269         filter[2] = 2 ;
 270         filter[3] = 1 ;
 271         filter[4] = 4 ;
 272         filter[5] = 7 ;
 273         filter[6] = 6 ;
 274         filter[7] = 5 ;
 275         break ;
 276       }
 277       case MED_TETRA10 : {
 278         break ;
 279       }
 280       case MED_PYRA13  : {
 281         break ;
 282       }
 283       case MED_PENTA15 : {
 284         break ;
 285       }
 286       case MED_HEXA20  : {
 287         break ;
 288       }
 289       default : {
 290         break ;
 291       }
 292       }
 293     if (filter==NULL)
 294       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": MED element type not supported yet : " << cells_type[i].getName() ) ) ;
 295     int nodes_cell = cells_type[i].getNumberOfNodes();
 296     int numberOfCell = _ptrMesh->getNumberOfElements(MED_CELL,cells_type[i].getType()) ;
 297     const int * connectivityArray = _ptrMesh->getConnectivity(MED_FULL_INTERLACE,MED_NODAL,MED_CELL,cells_type[i].getType());
 298     for (int j=0;j<numberOfCell;j++) {
 299       (*_vtkFile) << nodes_cell << " " ;
 300       for (int k=0;k<nodes_cell;k++)
 301         (*_vtkFile) << connectivityArray[j*nodes_cell+filter[k]] - 1 << " " ;
 302       (*_vtkFile) << endl ;
 303     }
 304     if (filter != NULL)
 305       delete[] filter ;
 306   }
 307   (*_vtkFile) << endl ;
 308   // we put cells type
 309   (*_vtkFile) << "CELL_TYPES " << cells_sum << endl ;
 310   for (int i=0;i<cells_types_count;i++) {
 311     int vtkType = 0 ;
 312     switch (cells_type[i].getType())
 313       {
 314       case MED_POINT1  : {
 315         vtkType = 1 ;
 316         break ;
 317       }
 318       case MED_SEG2    : {
 319         vtkType = 3 ;
 320         break ;
 321       }
 322       case MED_SEG3    : {
 323         vtkType = 0 ;
 324         break ;
 325       }
 326       case MED_TRIA3   : {
 327         vtkType = 5 ;
 328         break ;
 329       }
 330       case MED_QUAD4   : {
 331         vtkType = 9 ;
 332         break ;
 333       }
 334       case MED_TRIA6   : {
 335         vtkType = 0 ;
 336         break ;
 337       }
 338       case MED_QUAD8   : {
 339         vtkType = 0 ;
 340         break ;
 341       }
 342       case MED_TETRA4  : {
 343         vtkType = 10 ;
 344         break ;
 345       }
 346       case MED_PYRA5   : {
 347         vtkType = 14 ;
 348         break ;
 349       }
 350       case MED_PENTA6  : {
 351         vtkType = 13 ;
 352         break ;
 353       }
 354       case MED_HEXA8   : {
 355         vtkType = 12 ;
 356         break ;
 357       }
 358       case MED_TETRA10 : {
 359         vtkType = 0 ;
 360         break ;
 361       }
 362       case MED_PYRA13  : {
 363         vtkType = 0 ;
 364         break ;
 365       }
 366       case MED_PENTA15 : {
 367         vtkType = 0 ;
 368         break ;
 369       }
 370       case MED_HEXA20  : {
 371         vtkType = 0 ;
 372         break ;
 373       }
 374       default : {
 375         vtkType = 0 ;
 376         break ;
 377       }
 378       }
 379     if (vtkType == 0)
 380       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": MED element type not supported yet : " << cells_type[i].getType() ) ) ;
 381     int numberOfCell = _ptrMesh->getNumberOfElements(MED_CELL,cells_type[i].getType()) ;
 382     for (int j=0;j<numberOfCell;j++)
 383       (*_vtkFile) << vtkType << endl ;
 384   }
 385
 386
 387   END_OF(LOC);
 388 }
 389
 390 GENDRIVER * VTK_MESH_DRIVER::copy(void) const
 391 {
 392   return new VTK_MESH_DRIVER(*this);
 393 }