src/MEDMEM/MEDMEM_VtkMedDriver.cxx

   1 #include "MEDMEM_VtkMedDriver.hxx"
   2
   3 #include "MEDMEM_Med.hxx"
   4
   5 VTK_MED_DRIVER::VTK_MED_DRIVER(): GENDRIVER(),
   6                                   _ptrMed((MED * const)MED_NULL),
   7                                   _vtkFile(MED_INVALID)
   8 {
   9   // What about _id in Gendriver ?
  10   // _driverType ???
  11 }
  12
  13
  14 VTK_MED_DRIVER::VTK_MED_DRIVER(const string & fileName,  MED * const ptrMed):
  15   GENDRIVER(fileName,MED_EN::MED_RDWR), _ptrMed(ptrMed), _vtkFile(MED_INVALID)
  16 {
  17   // What about _id in Gendriver ?
  18   // _driverType ???
  19 }
  20
  21 //REM :  As t'on besoin du champ _status :  _vtkFile <-> _status  ?  Oui
  22
  23
  24 void VTK_MED_DRIVER::open() {
  25
  26   const char * LOC ="VTK_MED_DRIVER::open() : ";
  27   BEGIN_OF(LOC);
  28
  29   // REFLECHIR SUR CE TEST PAR RAPPORT A L'OUVERTURE/FERMETURE
  30 //    if ( _vtkFile != MED_INVALID )
  31 //      throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
  32 //                                       << "_vtkFile is already in use, please close the file |"
  33 //                                       << _fileName << "| before calling open()"
  34 //                                       )
  35 //                            );
  36
  37   if ( _status != MED_CLOSED )
  38     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
  39                                      << "_status is not closed, please close the file |"
  40                                      << _fileName << "| before calling open()"
  41                                      )
  42                           );
  43
  44   if ( _fileName == "" )
  45     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
  46                                      << "_fileName is |\"\"|, please set a correct fileName before calling open()"
  47                                      )
  48                           );
  49   _vtkFile.open(filename.c_str()) ; // ? if error ????
  50   _status = MED_OPENED ;
  51
  52 //    if (_vtkFile > 0) _status=MED_OPENED;
  53 //    else {
  54 //      _status = MED_CLOSED;
  55 //      _vtkFile = MED_INVALID;
  56 //      throw MED_EXCEPTION (LOCALIZED( STRING(LOC)
  57 //                                      << "Can't open |"  << _fileName
  58 //                                      << "|, _vtkFile : " << _vtkFile
  59 //                                      )
  60 //                           );
  61 //  }
  62
  63   END_OF(LOC);
  64 }
  65
  66
  67 void VTK_MED_DRIVER::close() {
  68
  69   const char * LOC = "MED_MED_DRIVER::close() : ";
  70   BEGIN_OF(LOC);
  71
  72   if ( _status == MED_CLOSED)
  73     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << ": the file |"
  74                                      << _fileName << "| is already closed"
  75                                      )
  76                           );
  77
  78   //    if ( _vtkFile == MED_INVALID )
  79 //      throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "_vtkFile invalid, but the file |"
  80 //                                       << _fileName << "| seems to be openned !"
  81 //                                       )
  82 //                            );
  83   vtkFile_.close();
  84
  85   _status = MED_CLOSED;
  86   //  _vtkFile = MED_INVALID;
  87
  88 //    if (err != MED_VALID)
  89 //      throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "the file |"
  90 //                                       << _fileName << "| couldn't be closed"
  91 //                                       )
  92 //                            );
  93
  94   END_OF(LOC);
  95 }
  96
  97
  98 void VTK_MED_DRIVER::write() {
  99
 100   const char * LOC = "MED_MED_DRIVER::write() : ";
 101   BEGIN_OF(LOC);
 102
 103   // could we put more than one Mesh ?????
 104   _vtkFile << "# vtk DataFile Version 2.0" << endl
 105            << "maillage SALOLME"  << endl ;
 106   // only ASCII for the moment (binary came latest :-)
 107   _vtkFile << "ASCII" << endl ;
 108
 109   int NumberOfMeshes = _ptrMED->getNumberOfMeshes() ;
 110   string * MeshName = new string[NumberOfMeshes] ;
 111   _ptrMED->getMeshNames(MeshName) ;
 112   // In fact, we must take care of all supports
 113   // We restrict Field on all nodes or cells
 114   for (int i=0; i<NumberOfMeshes; i++) {
 115     MESH * myMesh = _ptrMED->getMesh(MeshName[i]) ;
 116     writeMesh(myMesh) ;
 117     // get all field which values are on this mesh => revoir api de Med !!!
 118     _vtkFile << "NODE" << endl ;
 119     // first : field on node
 120     for (int j=0; j<NumberOfFields; j++) {
 121       FIELD_ * myField = _ptrMED->getField() ;
 122       if (myField->getSupport()->getEntity()!=MED_NODE)
 123         if (myField->getSupport()->isOnAllElements())
 124           writeField(myField) ;
 125
 126     }
 127     _vtkFile << "CELL" << endl ;
 128     // second : field on cell
 129     for (int j=0; j<NumberOfFields; j++) {
 130       FIELD_ * myField = _ptrMED->getField() ;
 131       if (myField->getSupport()->getEntity()!=MED_CELL)
 132         if (myField->getSupport()->isOnAllElements())
 133           writeField(myField) ;
 134
 135     }
 136
 137   }
 138
 139   END_OF(LOC);
 140 }
 141
 142 void VTK_MED_DRIVER::writeMesh(MESH * myMesh) {
 143
 144   const char * LOC = "MED_MED_DRIVER::writeMesh() : ";
 145   BEGIN_OF(LOC);
 146
 147   _vtkFile << "DATASET UNSTRUCTURED_GRID" << endl ;
 148   // put points (all point are in 3D, so if we are in 1D or 2D, we complete by zero !
 149   int SpaceDimension = myMesh->getSpaceDimension() ;
 150   int NumberOfNodes = myMesh->getNumberOfNodes() ;
 151   _vtkFile << "POINTS " << NumberOfNodes << " float" << endl ;
 152   double *coordinate = myMesh->getCoordinates(MED_FULL_ENTERLACE) ;
 153   if (SpaceDimension<3) { // 1D or 2D
 154     coordinate_z = new double[NumberOfNodes] ;
 155     // we put zero :
 156     for (int i=0;i<NumberOfNodes;i++)
 157       coordinate_z[i] = 0.0 ;
 158     if (SpaceDimension==1)
 159       coordinate_y = coordinate_z ; // only one array of zero !
 160     else
 161       coordinate_y = coordinate_x + NumberOfNodes ;
 162   } else {
 163     coordinate_y = coordinate_x + NumberOfNodes ;
 164     coordinate_z = coordinate_y + NumberOfNodes ;
 165   }
 166   for (int i=0;i<NumberOfNodes;i++)
 167     for (int j=0;j<SpaceDimension;j++)
 168       _vtkFile << coordinate[i*SpaceDimension+j] << " " ;
 169   if (SpaceDimension==1)
 170     _vtkFile << "0 0" ;
 171   if (SpaceDimension==2)
 172     _vtkFile << "0" ;
 173   _vtkFile << endl ;
 174
 175   // we put connectivity
 176   // how many cells and how many value in connectivity :
 177   int cells_types_count = myMesh->getNumberOfTypes(MED_CELL) ;
 178   int * cells_count = myMesh->get_cells_count() ;
 179   int cells_sum = cells_count[cells_types_count] ;
 180   CellModel * cells_type = myMesh->get_cells_type() ;
 181   int connectivity_sum = 0 ;
 182
 183   int * connectivity = myMesh->getConnectivity(MED_FULL_ENTERLACE,MED_CELL,MED_ALL_ELEMENTS) ;
 184   int * connectivityIndex = myMesh->getConnectivityIndex(MED_CELL) ;
 185
 186   for (int i=0;i<cells_types_count;i++) {
 187     int nodes_cell = cells_type[i].getNumberOfNodes();
 188     connectivity_sum+= (cells_count[i+1]-cells_count[i])*(nodes_cell + 1);
 189     // we add 1 because we put nodes count in vtk file !
 190   }
 191   _vtkFile << "CELLS " << cells_sum << " " << connectivity_sum << endl ;
 192   // we put connectivity
 193   for (int i=0;i<cells_types_count;i++) {
 194     int *filter = (int*) NULL ; // index in vtk connectivity
 195     switch (cells_type[i].get_type())
 196       {
 197       case MED_POINT1  : {
 198         filter = new int[1] ;
 199         filter[0] = 0 ;
 200         break ;
 201       }
 202       case MED_SEG2    : {
 203         filter = new int[2] ;
 204         filter[0] = 0 ;
 205         filter[1] = 1 ;
 206         break ;
 207       }
 208       case MED_SEG3    : {
 209         break ;
 210       }
 211       case MED_TRIA3   : {
 212         filter = new int[3] ;
 213         filter[0] = 0 ;
 214         filter[1] = 1 ;
 215         filter[2] = 2 ;
 216         break ;
 217       }
 218       case MED_QUAD4   : {
 219         filter = new int[4] ;
 220         filter[0] = 0 ;
 221         filter[1] = 1 ;
 222         filter[2] = 2 ;
 223         filter[3] = 3 ;
 224         break ;
 225       }
 226       case MED_TRIA6   : {
 227         break ;
 228       }
 229       case MED_QUAD8   : {
 230         break ;
 231       }
 232       case MED_TETRA4  : {
 233         filter = new int[4] ;
 234         filter[0] = 0 ;
 235         filter[1] = 1 ;
 236         filter[2] = 3 ;  // 3td element in med are 4th in vtk (array begin at 0 !)
 237         filter[3] = 2 ;  // 4th element in med are 3rd in vtk (array begin at 0 !)
 238         break ;
 239       }
 240       case MED_PYRA5   : {
 241         filter = new int[5] ;
 242         filter[0] = 0 ;
 243         filter[1] = 3 ;  // 2nd element in med are 4th in vtk (array begin at 0 !)
 244         filter[2] = 2 ;
 245         filter[3] = 1 ;  // 4th element in med are 2nd in vtk (array begin at 0 !)
 246         filter[4] = 4 ;
 247         break ;
 248       }
 249       case MED_PENTA6  : {
 250         filter = new int[6] ;
 251         filter[0] = 0 ;
 252         filter[1] = 1 ;
 253         filter[2] = 2 ;
 254         filter[3] = 3 ;
 255         filter[4] = 4 ;
 256         filter[5] = 5 ;
 257         break ;
 258       }
 259       case MED_HEXA8   : {
 260         filter = new int[8] ;
 261         filter[0] = 0 ;
 262         filter[1] = 3 ;
 263         filter[2] = 2 ;
 264         filter[3] = 1 ;
 265         filter[4] = 4 ;
 266         filter[5] = 7 ;
 267         filter[6] = 6 ;
 268         filter[7] = 5 ;
 269         break ;
 270       }
 271       case MED_TETRA10 : {
 272         break ;
 273       }
 274       case MED_PYRA13  : {
 275         break ;
 276       }
 277       case MED_PENTA15 : {
 278         break ;
 279       }
 280       case MED_HEXA20  : {
 281         break ;
 282       }
 283       default : {
 284         break ;
 285       }
 286       }
 287     if (filter==NULL)
 288       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": MED element type not supported yet : " << cells_type[i].get_type() ) ) ;
 289     int nodes_cell = cells_type[i].get_NumberOfNodes();
 290     for (int j=0;j<cells_count[i+1]-cells_count[i];j++) {
 291       _vtkFile << nodes_cell << " " ;
 292       for (int k=0;k<nodes_cell;k++)
 293         _vtkFile << (myMesh->get_nodal_connectivity(i+1))[j*nodes_cell+filter[k]] - 1 << " " ;
 294       _vtkFile << endl ;
 295     }
 296   }
 297   _vtkFile << endl ;
 298   // we put cells type
 299   _vtkFile << "CELL_TYPES " << cells_sum << endl ;
 300   for (int i=0;i<cells_types_count;i++) {
 301     int vtkType = 0 ;
 302     switch (cells_type[i].get_type())
 303       {
 304       case MED_POINT1  : {
 305         vtkType = 1 ;
 306         break ;
 307       }
 308       case MED_SEG2    : {
 309         vtkType = 3 ;
 310         break ;
 311       }
 312       case MED_SEG3    : {
 313         vtkType = 0 ;
 314         break ;
 315       }
 316       case MED_TRIA3   : {
 317         vtkType = 5 ;
 318         break ;
 319       }
 320       case MED_QUAD4   : {
 321         vtkType = 9 ;
 322         break ;
 323       }
 324       case MED_TRIA6   : {
 325         vtkType = 0 ;
 326         break ;
 327       }
 328       case MED_QUAD8   : {
 329         vtkType = 0 ;
 330         break ;
 331       }
 332       case MED_TETRA4  : {
 333         vtkType = 10 ;
 334         break ;
 335       }
 336       case MED_PYRA5   : {
 337         vtkType = 14 ;
 338         break ;
 339       }
 340       case MED_PENTA6  : {
 341         vtkType = 13 ;
 342         break ;
 343       }
 344       case MED_HEXA8   : {
 345         vtkType = 12 ;
 346         break ;
 347       }
 348       case MED_TETRA10 : {
 349         vtkType = 0 ;
 350         break ;
 351       }
 352       case MED_PYRA13  : {
 353         vtkType = 0 ;
 354         break ;
 355       }
 356       case MED_PENTA15 : {
 357         vtkType = 0 ;
 358         break ;
 359       }
 360       case MED_HEXA20  : {
 361         vtkType = 0 ;
 362         break ;
 363       }
 364       default : {
 365         vtkType = 0 ;
 366         break ;
 367       }
 368       }
 369     if (vtkType == 0)
 370       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": MED element type not supported yet : " << cells_type[i].get_type() ) ) ;
 371     for (int j=0;j<cells_count[i+1]-cells_count[i];j++)
 372       _vtkFile << vtkType << endl ;
 373     if (filter != NULL)
 374       delete[] filter ;
 375   }
 376
 377   // add a constant field on all node to test !
 378   //    _vtkFile << "POINT_DATA " << NumberOfNodes << endl ;
 379   //    _vtkFile << "SCALARS example_scalaire float 1" << endl ;
 380   //    _vtkFile << "LOOKUP_TABLE default" << endl ;
 381   //    for (int i=0;i<NumberOfNodes;i++)
 382   //      _vtkFile << i << endl ;
 383
 384   return 1 ;
 385
 386
 387   END_OF(LOC);
 388 }
 389
 390 void VTK_MED_DRIVER::writeField(FIELD * myField) {
 391
 392   const char * LOC = "MED_MED_DRIVER::writeField() : ";
 393   BEGIN_OF(LOC);
 394
 395
 396
 397   END_OF(LOC);
 398 }