src/MEDMEM/MEDMEM_EnsightMeshDriver.cxx

   1 // Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
   2 // CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
   3 //
   4 // This library is free software; you can redistribute it and/or
   5 // modify it under the terms of the GNU Lesser General Public
   6 // License as published by the Free Software Foundation; either
   7 // version 2.1 of the License.
   8 //
   9 // This library is distributed in the hope that it will be useful
  10 // but WITHOUT ANY WARRANTY; without even the implied warranty of
  11 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  12 // Lesser General Public License for more details.
  13 //
  14 // You should have received a copy of the GNU Lesser General Public
  15 // License along with this library; if not, write to the Free Software
  16 // Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
  17 //
  18 // See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
  19 //
  20 #include "MEDMEM_EnsightMeshDriver.hxx"
  21
  22 #include <sstream>
  23 #include <strstream>
  24 #include <iomanip>
  25
  26 #include "MEDMEM_define.hxx"
  27 #include "MEDMEM_Family.hxx"
  28 #include "MEDMEM_Group.hxx"
  29 #include "MEDMEM_Coordinate.hxx"
  30 #include "MEDMEM_Connectivity.hxx"
  31 #include "MEDMEM_Mesh.hxx"
  32 #include "MEDMEM_CellModel.hxx"
  33 #include "MEDMEM_Grid.hxx"
  34
  35 #include "MEDMEM_Meshing.hxx"
  36 #include "MEDMEM_MedMeshDriver.hxx"
  37
  38 using namespace std;
  39 using namespace MEDMEM;
  40 using namespace MED_EN;
  41
  42 #define MED_NULL     NULL
  43
  44 ENSIGHT_MESH_DRIVER::ENSIGHT_MESH_DRIVER(): GENDRIVER(),
  45                                     _ptrMesh((MESH *)MED_NULL)
  46 {
  47 }
  48
  49 ENSIGHT_MESH_DRIVER::ENSIGHT_MESH_DRIVER(const string & fileName,
  50                                  MESH * ptrMesh) :
  51   GENDRIVER(fileName,MED_EN::MED_RDWR), _ptrMesh(ptrMesh)
  52 {
  53 }
  54
  55 ENSIGHT_MESH_DRIVER::ENSIGHT_MESH_DRIVER(const string & fileName,
  56                                MESH * ptrMesh,
  57                                MED_EN::med_mode_acces accessMode):
  58   GENDRIVER(fileName,accessMode), _ptrMesh(ptrMesh)
  59 {
  60 }
  61
  62 ENSIGHT_MESH_DRIVER::ENSIGHT_MESH_DRIVER(const ENSIGHT_MESH_DRIVER & driver):
  63   GENDRIVER(driver),
  64   _ptrMesh(driver._ptrMesh),
  65   _meshName(driver._meshName)
  66 {
  67 }
  68
  69 ENSIGHT_MESH_DRIVER::~ENSIGHT_MESH_DRIVER()
  70 {
  71   MESSAGE("ENSIGHT_MESH_DRIVER::~ENSIGHT_MESH_DRIVER() has been destroyed");
  72 }
  73
  74 void    ENSIGHT_MESH_DRIVER::setMeshName(const string & meshName) { _meshName = meshName; };
  75
  76 string  ENSIGHT_MESH_DRIVER::getMeshName() const { return _meshName; };
  77
  78 void ENSIGHT_MESH_DRIVER::open() {
  79   openConst() ;
  80 }
  81
  82 void ENSIGHT_MESH_DRIVER::close() {
  83   closeConst() ;
  84 }
  85
  86 ENSIGHT_MESH_WRONLY_DRIVER::ENSIGHT_MESH_WRONLY_DRIVER() : ENSIGHT_MESH_DRIVER()
  87 {
  88   _ensightFile = new ofstream();
  89 }
  90
  91 ENSIGHT_MESH_WRONLY_DRIVER::ENSIGHT_MESH_WRONLY_DRIVER(const string & fileName,  MESH * ptrMesh) : ENSIGHT_MESH_DRIVER(fileName,ptrMesh)
  92 {
  93   _ensightFile = new ofstream();
  94 }
  95
  96 ENSIGHT_MESH_WRONLY_DRIVER::ENSIGHT_MESH_WRONLY_DRIVER(const ENSIGHT_MESH_WRONLY_DRIVER & driver) : ENSIGHT_MESH_DRIVER(driver),_support(driver._support)
  97 {
  98   _ensightFile = new ofstream();
  99 }
 100
 101 ENSIGHT_MESH_WRONLY_DRIVER::~ENSIGHT_MESH_WRONLY_DRIVER()
 102 {
 103   delete _ensightFile ;
 104 }
 105
 106 GENDRIVER * ENSIGHT_MESH_WRONLY_DRIVER::copy() const
 107 {
 108   return new ENSIGHT_MESH_WRONLY_DRIVER(*this) ;
 109 }
 110
 111 void ENSIGHT_MESH_WRONLY_DRIVER::openConst() const
 112 {
 113   const char * LOC = "ENSIGHT_MESH_WRONLY_DRIVER::open()" ;
 114
 115   BEGIN_OF(LOC);
 116
 117   if ( _fileName == "" )
 118     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 119                                      << "_fileName is |\"\"|, please set a correct fileName before calling open()"
 120                                      )
 121                           );
 122
 123   if (!(*_ensightFile).is_open())
 124     (*_ensightFile).open(_fileName.c_str()) ;
 125
 126   if (!(*_ensightFile))
 127     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not open main Ensight file "
 128                                      << _fileName)
 129                           );
 130
 131   END_OF(LOC);
 132 }
 133
 134 void ENSIGHT_MESH_WRONLY_DRIVER::closeConst() const {
 135
 136   const char * LOC = "ENSIGHT_MESH_WRONLY_DRIVER::close() : ";
 137   BEGIN_OF(LOC);
 138
 139   (*_ensightFile).close();
 140
 141   if (!(*_ensightFile))
 142     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not close main Ensight file "
 143                                      << _fileName)
 144                           );
 145   END_OF(LOC);
 146 }
 147
 148 void ENSIGHT_MESH_WRONLY_DRIVER::read() throw (MEDEXCEPTION) {
 149   throw MEDEXCEPTION("ENSIGHT_MESH_WRONLY_DRIVER::read : Can't read with a WRONLY driver !");
 150 }
 151
 152 void ENSIGHT_MESH_WRONLY_DRIVER::write() const throw (MEDEXCEPTION)
 153 {
 154
 155   const char * LOC = "ENSIGHT_MESH_WRONLY_DRIVER::write() : ";
 156   BEGIN_OF(LOC);
 157
 158   // Well we must open ensight file first, because there are
 159   // no other driver than MESH for ENSIGHT that do it !
 160   openConst() ;
 161
 162   // Ensight case organization requires a main file (filename.case) which defines organization
 163   // We also need a geom file (filemane.geo) to store the meshs
 164   // We also need a data file (filemane.data) to store the fields
 165
 166   string MeshName = _ptrMesh->getName() ;
 167   // In fact, we must take care of all supports
 168   // We restrict Field on all nodes or cells
 169
 170   cout << "-> creating the Ensight case file " << _fileName <<  endl ;
 171   (*_ensightFile) << "FORMAT" << endl ;
 172   (*_ensightFile) << "type:   ensight" << endl ;
 173   (*_ensightFile) << endl ;
 174   (*_ensightFile) << "GEOMETRY" << endl ;
 175   int len       = _fileName.size() ;
 176   string prefix = _fileName.substr(0,len-5); // extraction de .case
 177   string ensight_geomf = prefix + ".geom" ;
 178   string basen = getBaseName((char*)ensight_geomf.c_str());
 179   (*_ensightFile) << "# Mesh detected with name = " << MeshName << endl ;
 180   (*_ensightFile) << "model: " << basen << endl ;
 181   (*_ensightFile) << endl ;
 182
 183   ofstream ensightGeomFile(ensight_geomf.c_str(),ios::out);
 184   cout << "-> creating the Ensight geometry file " << ensight_geomf << endl ;
 185
 186   // ------------ create the Ensight file associated to this meshe
 187   ensightGeomFile << "Ensight Geometry File : " <<  endl
 188                   << "Meshing from MedMemory"  << endl ;
 189 //   ensightGeomFile << "node id given " << endl ;
 190 //   ensightGeomFile << "element id given " << endl ;
 191   ensightGeomFile << "node id assign " << endl ;
 192   ensightGeomFile << "element id assign " << endl ;
 193   ensightGeomFile << "coordinates" << endl ;
 194   // put points (all point are in 3D, so if we are in 1D or 2D, we complete by zero !
 195   int SpaceDimension = _ptrMesh->getSpaceDimension() ;
 196   int NumberOfNodes  = _ptrMesh->getNumberOfNodes() ;
 197   ensightGeomFile << NumberOfNodes << endl ;
 198   const double *coordinate = _ptrMesh->getCoordinates(MED_FULL_INTERLACE) ;
 199   ensightGeomFile.setf(ios::scientific);
 200   ensightGeomFile.precision(5);
 201   for (int i=0;i<NumberOfNodes;i++) {
 202 //     ensightGeomFile << setw(8) << i+1 ;
 203     for (int j=0;j<SpaceDimension;j++)
 204       ensightGeomFile << setw(12) << coordinate[i*SpaceDimension+j] ;
 205     if (SpaceDimension==1)
 206       ensightGeomFile << "0       0" ;
 207     if (SpaceDimension==2)
 208       ensightGeomFile << "0" ;
 209     ensightGeomFile << endl ;
 210   }
 211
 212   // we put connectivity
 213   // how many cells and how many value in connectivity :
 214   int cells_types_count = _ptrMesh->getNumberOfTypes(MED_CELL) ;
 215   const CELLMODEL * cells_type =_ptrMesh->getCellsTypes(MED_CELL) ;
 216   ensightGeomFile << "part 1 " << endl ;
 217   ensightGeomFile << "elements are following " << endl ;
 218
 219   // we put connectivity
 220   for (int i=0;i<cells_types_count;i++) {
 221     int numberOfCell = _ptrMesh->getNumberOfElements(MED_CELL,cells_type[i].getType()) ;
 222     int *filter = (int*) NULL ;
 223     switch (cells_type[i].getType())
 224       {
 225       case MED_POINT1  : {
 226         ensightGeomFile << "point" << endl ;
 227         ensightGeomFile << setw(8) << numberOfCell << endl ;
 228         filter = new int[1] ;
 229         filter[0] = 0 ;
 230         break ;
 231       }
 232       case MED_SEG2    : {
 233         ensightGeomFile << "bar2" << endl ;
 234         ensightGeomFile << setw(8) << numberOfCell << endl ;
 235         filter = new int[2] ;
 236         filter[0] = 0 ;
 237         filter[1] = 1 ;
 238         break ;
 239       }
 240       case MED_SEG3    : {
 241         filter = new int[3] ;
 242         filter[0] = 0 ;
 243         filter[1] = 2 ;
 244         filter[2] = 1 ;
 245         break ;
 246       }
 247       case MED_TRIA3   : {
 248         ensightGeomFile << "tria3" << endl ;
 249         ensightGeomFile << setw(8) << numberOfCell << endl ;
 250         filter = new int[3] ;
 251         filter[0] = 0 ;
 252         filter[1] = 2 ;
 253         filter[2] = 1 ;
 254         break ;
 255       }
 256       case MED_QUAD4   : {
 257         ensightGeomFile << "quad4" << endl ;
 258         ensightGeomFile << setw(8) << numberOfCell << endl ;
 259         filter = new int[4] ;
 260         filter[0] = 0 ;
 261         filter[1] = 3 ;
 262         filter[2] = 2 ;
 263         filter[3] = 1 ;
 264         break ;
 265       }
 266       case MED_TRIA6   : {
 267         ensightGeomFile << "tria6" << endl ;
 268         ensightGeomFile << setw(8) << numberOfCell << endl ;
 269         filter = new int[6] ;
 270         filter[0] = 0 ;
 271         filter[1] = 2 ;
 272         filter[2] = 1 ;
 273         filter[3] = 5 ;
 274         filter[4] = 4 ;
 275         filter[5] = 3 ;
 276         break ;
 277       }
 278       case MED_QUAD8   : {
 279         ensightGeomFile << "quad8" << endl ;
 280         ensightGeomFile << setw(8) << numberOfCell << endl ;
 281         filter = new int[8] ;
 282         filter[0] = 0 ;
 283         filter[1] = 3 ;
 284         filter[2] = 2 ;
 285         filter[3] = 1 ;
 286         filter[4] = 7 ;
 287         filter[5] = 6 ;
 288         filter[6] = 5 ;
 289         filter[7] = 4 ;
 290         break ;
 291       }
 292       case MED_TETRA4  : {
 293         ensightGeomFile << "tetra4" << endl ;
 294         ensightGeomFile << setw(8) << numberOfCell << endl ;
 295         filter = new int[4] ;
 296         filter[0] = 0 ;
 297         filter[1] = 1 ;
 298         filter[2] = 3 ;  // 3td element in med are 4th in vtk (array begin at 0 !)
 299         filter[3] = 2 ;  // 4th element in med are 3rd in vtk (array begin at 0 !)
 300         break ;
 301       }
 302       case MED_PYRA5   : {
 303         ensightGeomFile << "pyramid5" << endl ;
 304         ensightGeomFile << setw(8) << numberOfCell << endl ;
 305         filter = new int[5] ;
 306         filter[0] = 0 ;
 307         filter[1] = 3 ;  // 2nd element in med are 4th in vtk (array begin at 0 !)
 308         filter[2] = 2 ;
 309         filter[3] = 1 ;  // 4th element in med are 2nd in vtk (array begin at 0 !)
 310         filter[4] = 4 ;
 311         break ;
 312       }
 313       case MED_PENTA6  : {
 314         ensightGeomFile << "penta6" << endl ;
 315         ensightGeomFile << setw(8) << numberOfCell << endl ;
 316         filter = new int[6] ;
 317         filter[0] = 0 ;
 318         filter[1] = 2 ;
 319         filter[2] = 1 ;
 320         filter[3] = 3 ;
 321         filter[4] = 4 ;
 322         filter[5] = 5 ;
 323         break ;
 324       }
 325       case MED_HEXA8   : {
 326         ensightGeomFile << "hexa8" << endl ;
 327         ensightGeomFile << setw(8) << numberOfCell << endl ;
 328         filter = new int[8] ;
 329         filter[0] = 0 ;
 330         filter[1] = 3 ;
 331         filter[2] = 2 ;
 332         filter[3] = 1 ;
 333         filter[4] = 4 ;
 334         filter[5] = 7 ;
 335         filter[6] = 6 ;
 336         filter[7] = 5 ;
 337         break ;
 338       }
 339       case MED_TETRA10 : {
 340         ensightGeomFile << "tetra10" << endl ;
 341         ensightGeomFile << setw(8) << numberOfCell << endl ;
 342         filter = new int[10] ;
 343         filter[0] = 0 ;
 344         filter[1] = 2 ;
 345         filter[2] = 1 ;
 346         filter[3] = 3 ;
 347         filter[4] = 6 ;
 348         filter[5] = 5 ;
 349         filter[6] = 4 ;
 350         filter[7] = 7 ;
 351         filter[8] = 9 ;
 352         filter[9] = 8 ;
 353         break ;
 354       }
 355       case MED_PYRA13  : {
 356         ensightGeomFile << "pyramid13" << endl ;
 357         ensightGeomFile << setw(8) << numberOfCell << endl ;
 358         break ;
 359       }
 360       case MED_PENTA15 : {
 361         ensightGeomFile << "penta15" << endl ;
 362         ensightGeomFile << setw(8) << numberOfCell << endl ;
 363         break ;
 364       }
 365       case MED_HEXA20  : {
 366         ensightGeomFile << "hexa20" << endl ;
 367         ensightGeomFile << setw(8) << numberOfCell << endl ;
 368         break ;
 369       }
 370       default : {
 371         break ;
 372       }
 373       }
 374     if (filter==NULL)
 375       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": MED element type not supported yet : " << cells_type[i].getName() ) ) ;
 376     int nodes_cell = cells_type[i].getNumberOfNodes();
 377     const int * connectivityArray = _ptrMesh->getConnectivity(MED_FULL_INTERLACE,MED_NODAL,MED_CELL,cells_type[i].getType());
 378     for (int j=0;j<numberOfCell;j++) {
 379       for (int k=0;k<nodes_cell;k++)
 380         ensightGeomFile << setw(8) << connectivityArray[j*nodes_cell+filter[k]] ;
 381       ensightGeomFile << endl ;
 382     }
 383     if (filter != NULL)
 384       delete[] filter ;
 385   }
 386
 387   for(int i=0;i<(int)_support.size();i++){
 388     // we put connectivity
 389     // how many cells and how many value in connectivity :
 390     int nbTypes = _support[i]->getNumberOfTypes() ;
 391     const medGeometryElement * geo_type = _support[i]->getTypes() ;
 392
 393     ensightGeomFile << "part " << i+2 << endl;
 394     ensightGeomFile << "connectivities description" << endl;
 395
 396     int nodes_cell;
 397     // we put connectivity
 398     for (int i=0;i<nbTypes;i++) {
 399
 400       int numberOfCell = _support[i]->getNumberOfElements(geo_type[i]) ;
 401       int *filter = (int*) NULL ; // index in ensight connectivity
 402       switch (geo_type[i]){
 403       case MED_POINT1  : {
 404         nodes_cell=1;
 405         ensightGeomFile << "point" << endl ;
 406         ensightGeomFile << setw(8) << numberOfCell << endl ;
 407         filter = new int[1] ;
 408         filter[0] = 0 ;
 409         break ;
 410       }
 411       case MED_SEG2    : {
 412         nodes_cell=2;
 413         ensightGeomFile << "bar2" << endl ;
 414         ensightGeomFile << setw(8) << numberOfCell << endl ;
 415         filter = new int[2] ;
 416         filter[0] = 0 ;
 417         filter[1] = 1 ;
 418         break ;
 419       }
 420       case MED_SEG3    : {
 421         nodes_cell=3;
 422         ensightGeomFile << "bar3" << endl ;
 423         ensightGeomFile << setw(8) << numberOfCell << endl ;
 424         filter = new int[3] ;
 425         filter[0] = 0 ;
 426         filter[1] = 2 ;
 427         filter[2] = 1 ;
 428         break ;
 429       }
 430       case MED_TRIA3   : {
 431         nodes_cell=3;
 432         ensightGeomFile << "tria3" << endl ;
 433         ensightGeomFile << setw(8) << numberOfCell << endl ;
 434         filter = new int[3] ;
 435         filter[0] = 0 ;
 436         filter[1] = 2 ;
 437         filter[2] = 1 ;
 438         break ;
 439       }
 440       case MED_QUAD4   : {
 441         nodes_cell=4;
 442         ensightGeomFile << "quad4" << endl ;
 443         ensightGeomFile << setw(8) << numberOfCell << endl ;
 444         filter = new int[4] ;
 445         filter[0] = 0 ;
 446         filter[1] = 3 ;
 447         filter[2] = 2 ;
 448         filter[3] = 1 ;
 449         break ;
 450       }
 451       case MED_TRIA6   : {
 452         nodes_cell=6;
 453         ensightGeomFile << "tria6" << endl ;
 454         ensightGeomFile << setw(8) << numberOfCell << endl ;
 455         filter = new int[6] ;
 456         filter[0] = 0 ;
 457         filter[1] = 2 ;
 458         filter[2] = 1 ;
 459         filter[3] = 5 ;
 460         filter[4] = 4 ;
 461         filter[5] = 3 ;
 462         break ;
 463       }
 464       case MED_QUAD8   : {
 465         nodes_cell=8;
 466         ensightGeomFile << "quad8" << endl ;
 467         ensightGeomFile << setw(8) << numberOfCell << endl ;
 468         filter = new int[8] ;
 469         filter[0] = 0 ;
 470         filter[1] = 3 ;
 471         filter[2] = 2 ;
 472         filter[3] = 1 ;
 473         filter[4] = 7 ;
 474         filter[5] = 6 ;
 475         filter[6] = 5 ;
 476         filter[7] = 4 ;
 477         break ;
 478       }
 479       case MED_TETRA4  : {
 480         nodes_cell=4;
 481         ensightGeomFile << "tetra4" << endl ;
 482         ensightGeomFile << setw(8) << numberOfCell << endl ;
 483         filter = new int[4] ;
 484         filter[0] = 0 ;
 485         filter[1] = 1 ;
 486         filter[2] = 3 ;  // 3td element in med are 4th in ensight (array begin at 0 !)
 487         filter[3] = 2 ;  // 4th element in med are 3rd in ensight (array begin at 0 !)
 488         break ;
 489       }
 490       case MED_PYRA5   : {
 491         nodes_cell=5;
 492         ensightGeomFile << "pyramid5" << endl ;
 493         ensightGeomFile << setw(8) << numberOfCell << endl ;
 494         filter = new int[5] ;
 495         filter[0] = 0 ;
 496         filter[1] = 3 ;  // 2nd element in med are 4th in ensight (array begin at 0 !)
 497         filter[2] = 2 ;
 498         filter[3] = 1 ;  // 4th element in med are 2nd in ensight (array begin at 0 !)
 499         filter[4] = 4 ;
 500         break ;
 501       }
 502       case MED_PENTA6  : {
 503         nodes_cell=6;
 504         ensightGeomFile << "penta6" << endl ;
 505         ensightGeomFile << setw(8) << numberOfCell << endl ;
 506         filter = new int[6] ;
 507         filter[0] = 0 ;
 508         filter[1] = 2 ;
 509         filter[2] = 1 ;
 510         filter[3] = 3 ;
 511         filter[4] = 5 ;
 512         filter[5] = 4 ;
 513         break ;
 514       }
 515       case MED_HEXA8   : {
 516         nodes_cell=8;
 517         ensightGeomFile << "hexa8" << endl ;
 518         ensightGeomFile << setw(8) << numberOfCell << endl ;
 519         filter = new int[8] ;
 520         filter[0] = 0 ;
 521         filter[1] = 3 ;
 522         filter[2] = 2 ;
 523         filter[3] = 1 ;
 524         filter[4] = 4 ;
 525         filter[5] = 7 ;
 526         filter[6] = 6 ;
 527         filter[7] = 5 ;
 528         break ;
 529       }
 530       case MED_TETRA10 : {
 531         nodes_cell=10;
 532         ensightGeomFile << "tetra10" << endl ;
 533         ensightGeomFile << setw(8) << numberOfCell << endl ;
 534         filter = new int[10] ;
 535         filter[0] = 0 ;
 536         filter[1] = 2 ;
 537         filter[2] = 1 ;
 538         filter[3] = 3 ;
 539         filter[4] = 6 ;
 540         filter[5] = 5 ;
 541         filter[6] = 4 ;
 542         filter[7] = 7 ;
 543         filter[8] = 9 ;
 544         filter[9] = 8 ;
 545         break ;
 546       }
 547       case MED_PYRA13  : {
 548         nodes_cell=13;
 549         ensightGeomFile << "pyramid13" << endl ;
 550         ensightGeomFile << setw(8) << numberOfCell << endl ;
 551         break ;
 552       }
 553       case MED_PENTA15 : {
 554         nodes_cell=15;
 555         ensightGeomFile << "penta15" << endl ;
 556         ensightGeomFile << setw(8) << numberOfCell << endl ;
 557         break ;
 558       }
 559       case MED_HEXA20  : {
 560         nodes_cell=20;
 561         ensightGeomFile << "hexa20" << endl ;
 562         ensightGeomFile << setw(8) << numberOfCell << endl ;
 563         break ;
 564       }
 565       default : {
 566         break ;
 567       }
 568       }
 569       if (filter==NULL)
 570         throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": MED element type not supported yet : " << cells_type[i].getName() ) ) ;
 571
 572       const int * connectivityArray = _ptrMesh->getConnectivity(MED_FULL_INTERLACE,MED_NODAL,_support[i]->getEntity(),geo_type[i]);
 573       const int *type = _support[i]->getNumber(geo_type[i]);
 574
 575       for (int j=0;j<numberOfCell;j++) {
 576         for (int k=0;k<nodes_cell;k++){
 577           ensightGeomFile << setw(8) << connectivityArray[(type[j]-1)*nodes_cell+filter[k]];
 578         }
 579         ensightGeomFile << endl ;
 580       }
 581       if (filter != NULL)
 582         delete[] filter ;
 583
 584     }
 585
 586   }
 587
 588   ensightGeomFile << endl ;
 589   return ;
 590
 591   END_OF(LOC);
 592 }
 593
 594 void ENSIGHT_MESH_WRONLY_DRIVER::addSupport(SUPPORT *sup)
 595 {
 596   _support.push_back(sup);
 597 }
 598
 599 // void ENSIGHT_MESH_WRONLY_DRIVER::writeSupport(SUPPORT * mySupport) const {
 600 //   const char * LOC = "ENSIGHT_MESH_WRONLY_DRIVER::writeSupport(SUPPORT *) : " ;
 601 //   BEGIN_OF(LOC) ;
 602 //   MESSAGE(LOC << "Not yet implemented, acting on the object " << *mySupport);
 603 //   END_OF(LOC) ;
 604 // }
 605
 606 ENSIGHT_MESH_RDONLY_DRIVER::ENSIGHT_MESH_RDONLY_DRIVER() : ENSIGHT_MESH_DRIVER()
 607 {
 608   _ensightFile = new ifstream();
 609 }
 610
 611 ENSIGHT_MESH_RDONLY_DRIVER::ENSIGHT_MESH_RDONLY_DRIVER(const string & fileName,  MESH * ptrMesh) : ENSIGHT_MESH_DRIVER(fileName,ptrMesh)
 612 {
 613   _ensightFile = new ifstream();
 614 }
 615
 616 ENSIGHT_MESH_RDONLY_DRIVER::ENSIGHT_MESH_RDONLY_DRIVER(const ENSIGHT_MESH_RDONLY_DRIVER & driver) : ENSIGHT_MESH_DRIVER(driver)
 617 {
 618   _ensightFile = new ifstream();
 619 }
 620
 621 ENSIGHT_MESH_RDONLY_DRIVER::~ENSIGHT_MESH_RDONLY_DRIVER()
 622 {
 623   delete _ensightFile ;
 624 }
 625
 626 GENDRIVER * ENSIGHT_MESH_RDONLY_DRIVER::copy() const
 627 {
 628   return new ENSIGHT_MESH_RDONLY_DRIVER(*this) ;
 629 }
 630
 631 void ENSIGHT_MESH_RDONLY_DRIVER::openConst() const {
 632
 633   const char * LOC ="ENSIGHT_MESH_RDONLY_DRIVER::open() : ";
 634
 635   BEGIN_OF(LOC);
 636
 637   if ( _fileName == "" )
 638     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 639                                      << "_fileName is |\"\"|, please set a correct fileName before calling open()"
 640                                      )
 641                           );
 642
 643   if (!(*_ensightFile).is_open())
 644     (*_ensightFile).open(_fileName.c_str()) ;
 645
 646   if (!(*_ensightFile))
 647     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not open main Ensight file "
 648                                      << _fileName)
 649                           );
 650   END_OF(LOC);
 651 }
 652
 653 void ENSIGHT_MESH_RDONLY_DRIVER::closeConst() const {
 654
 655   const char * LOC = "ENSIGHT_MESH_RDONLY_DRIVER::close() : ";
 656   BEGIN_OF(LOC);
 657
 658   (*_ensightFile).close();
 659
 660   if (!(*_ensightFile))
 661     throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not close main Ensight file "
 662                                      << _fileName)
 663                           );
 664   END_OF(LOC);
 665 }
 666
 667 void ENSIGHT_MESH_RDONLY_DRIVER::write() const throw (MEDEXCEPTION) {
 668   throw MEDEXCEPTION("ENSIGHT_MESH_RDONLY_DRIVER::write : Can't write with a RDONLY driver !");
 669 }
 670
 671 void ENSIGHT_MESH_RDONLY_DRIVER::read() {
 672
 673   const char * LOC = "ENSIGHT_MESH_RDONLY_DRIVER::read() : " ;
 674   BEGIN_OF(LOC);
 675
 676   openConst() ;
 677
 678   string type_Ensight[15] = {
 679     "point" , "bar2", "bar3" , "tria3" , "tria6" , "quad4" , "quad8" , "tetra4" , "tetra10" , "pyramid5" ,
 680     "pyramid13" , "hexa8" , "hexa20" , "penta6" , "penta15" };
 681   int nb_edge[15] = { 1,2,3,3,6,4,8,4,10,5,13,8,20,6,15 };
 682
 683   vector<string> type_read  ;
 684   vector<int> nbcell_read   ;
 685   vector< vector <int> > total_conn ;
 686   vector<double> var ;
 687
 688   //int number_of_geom ;
 689   string geom_namefile ;
 690   string field_namefile ;
 691   string mot_lu ;
 692   int geom_given = 0 ;
 693   int num_coordinate ;
 694   string type_cell ;
 695   int number_of_cell ;
 696   int conn ;
 697   //----- ?
 698   int SpaceDimension = 3 ;
 699   //----- ?
 700
 701   int NumberOfTypes  = 0 ;
 702   int NumberOfNodes ;
 703   int iType ;
 704
 705   string mesh_read_name = "EnsightMesh"; // defaut name for the mesh
 706
 707   // recuperation des arguments du fichier ensight case
 708   // --------------------------------------------------
 709
 710   // In this release, the following options are available :
 711   // For GEOMETRY -> model:
 712
 713   cout << "****************** READ **************** starting " << endl ;
 714
 715   ifstream ensightCaseFile(_fileName.c_str(),ios::in);
 716   cout << "Ensight case file name to read " << _fileName << endl ;
 717   string diren = getDirName((char*)_fileName.c_str());
 718
 719   if (ensightCaseFile.is_open() )
 720     {
 721       while ( ensightCaseFile >> mot_lu )
 722         {
 723           if ( mot_lu == "GEOMETRY" ) {
 724             cout << "geometry detected" << endl ;
 725             while ( ensightCaseFile >> mot_lu ){
 726               if ( mot_lu == "model:" ) {
 727 //              ensightCaseFile >> number_of_geom ;
 728 //              cout << "number of geometries " << number_of_geom << endl ;
 729                 ensightCaseFile >> mot_lu ;
 730                 geom_namefile = mot_lu;
 731                 cout << "name of geometry file : " << geom_namefile << endl ;
 732                 break ;
 733               }
 734             }
 735           }
 736         }
 737     }
 738   else
 739     {
 740       cout << "Error :  requested file " << ensightCaseFile << " not found " << endl;
 741       exit( EXIT_FAILURE );
 742     }
 743
 744   // chargement des noeuds et connectivites necessaires depuis le fichier ensight geom
 745   // ---------------------------------------------------------------------------------
 746
 747   _ptrMesh->_name = mesh_read_name ;
 748
 749   string cgeom_namefile;
 750   if( diren.length() > 0 )
 751     cgeom_namefile = diren + '/' + geom_namefile;
 752   else
 753     cgeom_namefile = geom_namefile;
 754   cout << "-> Entering into the geometry file " << geom_namefile << endl  ;
 755   ifstream ensightGeomFile(cgeom_namefile.c_str(),ios::in);
 756   if (ensightGeomFile.is_open() )
 757     {
 758       while ( ensightGeomFile >> mot_lu ){
 759         if ( mot_lu == "given" ) geom_given=1 ;
 760         if ( mot_lu == "coordinates" ) {
 761 //---------------- Nodes part --------------------------------------------------
 762           ensightGeomFile >> NumberOfNodes ;
 763           cout << "-> loading " << NumberOfNodes << " coordinates " << endl ;
 764           int NumberOfCoordinates = NumberOfNodes*SpaceDimension ;
 765           double* Coordinates = new double[NumberOfCoordinates];
 766           int iCoord = 0 ;
 767           //cout << "-> geom given " << geom_given << endl ;
 768           for ( int i=0 ; i < NumberOfNodes ; i++) {
 769             if( geom_given) ensightGeomFile >> setw(8) >> num_coordinate ;
 770             ensightGeomFile >> setw(12) >> Coordinates[iCoord]   ;
 771             ensightGeomFile >> setw(12) >> Coordinates[iCoord+1] ;
 772             ensightGeomFile >> setw(12) >> Coordinates[iCoord+2] ;
 773 //          cout << "coordinate read " << num_coordinate << " : x = " << Coordinates[iCoord] << " y = " << Coordinates[iCoord+1] << " z = " << Coordinates[iCoord+2] << endl ;
 774             iCoord+=3 ;
 775           }
 776           _ptrMesh->_spaceDimension = SpaceDimension;
 777           _ptrMesh->_numberOfNodes = NumberOfNodes;
 778           _ptrMesh->_coordinate =  new COORDINATE(SpaceDimension,NumberOfNodes,MED_EN::MED_FULL_INTERLACE);
 779           _ptrMesh->_coordinate->setCoordinates(MED_EN::MED_FULL_INTERLACE,Coordinates);
 780           _ptrMesh->_coordinate->setCoordinatesSystem("CARTESIAN");
 781           delete [] Coordinates;
 782         }
 783         else if  ( mot_lu == "part" ) {
 784 //---------------- Connectivities part --------------------------------------------
 785           while ( ensightGeomFile >> mot_lu ){
 786             for ( int j = 0 ; j < 15 ; j++){
 787               if( mot_lu == type_Ensight[j] ) {
 788                 NumberOfTypes+=1;
 789                 iType=NumberOfTypes-1 ;
 790                 total_conn.resize(NumberOfTypes) ;
 791                 type_read.push_back(mot_lu) ;
 792                 ensightGeomFile >> number_of_cell ;
 793                 nbcell_read.push_back(number_of_cell) ;
 794                 total_conn[iType].resize(nb_edge[j]*number_of_cell);
 795                 cout << "-> loading " << number_of_cell << " cells connectivities of type " << type_Ensight[j] << " (" << nb_edge[j]*number_of_cell << ") values " << endl ;
 796                 for ( int k=0 ; k < nb_edge[j]*number_of_cell ; k++ ) {
 797                   ensightGeomFile >> setw(8) >> conn ;
 798                   total_conn[iType][k]=conn ;
 799                   // cout << " connectivitie " << k << " read = " << total_conn[iType][k] << endl ;
 800                 }
 801               }
 802             }
 803           }
 804         }
 805       }
 806     }
 807     // for compilation on WNT
 808 #ifndef WNT
 809     medGeometryElement classicalTypesCell[NumberOfTypes];
 810     int nbOfClassicalTypesCell[NumberOfTypes];
 811 #else // massive with zero size can't exist on Win32
 812     medGeometryElement* classicalTypesCell = new medGeometryElement(NumberOfTypes);
 813     int* nbOfClassicalTypesCell = new int(NumberOfTypes);
 814 #endif
 815     int ind=0 ;
 816     for (int k=0 ; k<NumberOfTypes ; k++){
 817       for (int j=0 ; j<15 ; j++)
 818         if(type_read[k] == type_Ensight[j] ){
 819           switch ( j+1 )
 820             {
 821             case 1  : {classicalTypesCell[ind] = MED_EN::MED_POINT1  ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 822             case 2  : {classicalTypesCell[ind] = MED_EN::MED_SEG2    ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 823             case 3  : {classicalTypesCell[ind] = MED_EN::MED_SEG3    ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 824             case 4  : {classicalTypesCell[ind] = MED_EN::MED_TRIA3   ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 825             case 5  : {classicalTypesCell[ind] = MED_EN::MED_TRIA6   ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 826             case 6  : {classicalTypesCell[ind] = MED_EN::MED_QUAD4   ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 827             case 7  : {classicalTypesCell[ind] = MED_EN::MED_QUAD8   ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 828             case 8  : {classicalTypesCell[ind] = MED_EN::MED_TETRA4  ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 829             case 9  : {classicalTypesCell[ind] = MED_EN::MED_TETRA10 ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 830             case 10 : {classicalTypesCell[ind] = MED_EN::MED_PYRA5   ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 831             case 11 : {classicalTypesCell[ind] = MED_EN::MED_PYRA13  ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 832             case 12 : {classicalTypesCell[ind] = MED_EN::MED_HEXA8   ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 833             case 13 : {classicalTypesCell[ind] = MED_EN::MED_HEXA20  ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 834             case 14 : {classicalTypesCell[ind] = MED_EN::MED_PENTA6  ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 835             case 15 : {classicalTypesCell[ind] = MED_EN::MED_PENTA15 ; nbOfClassicalTypesCell[ind] = nbcell_read[k] ; ind++ ; break ;}
 836             default : break ;
 837             }
 838         }
 839     }
 840
 841     _ptrMesh->_connectivity = new CONNECTIVITY(NumberOfTypes,MED_EN::MED_CELL);
 842     _ptrMesh->_connectivity->setGeometricTypes(classicalTypesCell,MED_EN::MED_CELL);
 843     int * Count = new int[NumberOfTypes+1] ;
 844     Count[0]=1 ;
 845     for (int i=0; i<NumberOfTypes; i++)
 846       Count[i+1]=Count[i]+nbOfClassicalTypesCell[i] ;
 847     _ptrMesh->_connectivity->setCount(Count,MED_EN::MED_CELL) ;
 848     delete[] Count ;
 849     int MeshDimension ;
 850     MeshDimension = 2 ;
 851     for (int k=0 ; k<NumberOfTypes ; k++){
 852       for (int j=0 ; j<15 ; j++)
 853         if(type_read[k] == type_Ensight[j] && j>6 ) MeshDimension = 3 ;
 854     }
 855     _ptrMesh->_meshDimension = MeshDimension;
 856     _ptrMesh->_connectivity->setEntityDimension(MeshDimension);
 857
 858     for (int k = 0 ; k < NumberOfTypes ; k++) {
 859       int nb_connectivities = total_conn[k].size();
 860       int *connectivities = new int[nb_connectivities];
 861       for (int itab=0 ; itab < nb_connectivities ; itab++) connectivities[itab]=total_conn[k][itab] ;
 862       for (int j=0 ; j<15 ; j++) {
 863         if( type_read[k] == type_Ensight[j] ) {
 864           switch ( j+1 )
 865             {
 866             case 1  : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_POINT1)  ; break ;}
 867             case 2  : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_SEG2)    ; break ;}
 868             case 3  : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_SEG3)    ; break ;}
 869             case 4  : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_TRIA3)   ; break ;}
 870             case 5  : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_TRIA6)   ; break ;}
 871             case 6  : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_QUAD4)   ; break ;}
 872             case 7  : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_QUAD8)   ; break ;}
 873             case 8  : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_TETRA4)  ; break ;}
 874             case 9  : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_TETRA10) ; break ;}
 875             case 10 : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_PYRA5)   ; break ;}
 876             case 11 : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_PYRA13)  ; break ;}
 877             case 12 : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_HEXA8)   ; break ;}
 878             case 13 : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_HEXA20)  ; break ;}
 879             case 14 : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_PENTA6)  ; break ;}
 880             case 15 : {_ptrMesh->_connectivity->setNodal(connectivities,MED_EN::MED_CELL,MED_EN::MED_PENTA15) ; break ;}
 881             default : break ;
 882             }
 883         }
 884       }
 885       delete [] connectivities;
 886     }
 887
 888 //     cout << "Impression de _ptrmesh dans EnsightMeshDriver: " << endl;
 889 //     cout << *_ptrMesh ;
 890
 891   END_OF(LOC);
 892 }
 893