src/MEDMEM/MEDMEM_VtkFieldDriver.hxx

   1 #ifndef VTK_FIELD_DRIVER_HXX
   2 #define VTK_FIELD_DRIVER_HXX
   3
   4 #include <string>
   5 #include <fstream>
   6 #include <sstream>
   7
   8 #include "MEDMEM_define.hxx"
   9
  10 #include "MEDMEM_GenDriver.hxx"
  11 #include "utilities.h"
  12
  13 #include "MEDMEM_STRING.hxx"
  14 #include "MEDMEM_Exception.hxx"
  15 #include "MEDMEM_Unit.hxx"
  16 #include "MEDMEM_Array.hxx"
  17 #include "MEDMEM_Support.hxx"
  18 //#include "MEDMEM_Field.hxx"
  19 #include "MEDMEM_Mesh.hxx"
  20 #include "MEDMEM_CellModel.hxx"
  21
  22
  23 /*!
  24
  25   Driver Med for FIELD.
  26
  27   Generic part : implement open and close methods.
  28
  29 */
  30
  31 namespace MEDMEM {
  32 template <class T> class FIELD;
  33 template <class T> class VTK_FIELD_DRIVER : public GENDRIVER
  34 {
  35 protected:
  36
  37   FIELD<T> *     _ptrField;
  38   mutable ofstream *        _vtkFile ;
  39   string         _fieldName;
  40   int            _fieldNum;
  41
  42 public :
  43
  44   // all MED cell type ?? Classe de Définition ??
  45   //   static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
  46
  47   //   static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
  48
  49   /*!
  50     Constructor.
  51   */
  52   VTK_FIELD_DRIVER():GENDRIVER(),
  53                      _ptrField((FIELD<T> *)MED_NULL), _fieldName(""),
  54                      _fieldNum(MED_INVALID)
  55   {
  56     const char * LOC = "VTK_FIELD_DRIVER::VTK_FIELD_DRIVER() ";
  57     BEGIN_OF(LOC);
  58
  59     _vtkFile = new ofstream();
  60
  61     END_OF(LOC);
  62   }
  63   /*!
  64     Constructor.
  65   */
  66   VTK_FIELD_DRIVER(const string & fileName, FIELD<T> * ptrField)
  67     : GENDRIVER(fileName,MED_EN::MED_WRONLY),
  68       _ptrField((FIELD<T> *) ptrField),
  69       _fieldName(fileName),_fieldNum(MED_INVALID)
  70   {
  71     const char * LOC = "VTK_FIELD_DRIVER::VTK_FIELD_DRIVER(const string & fileName, FIELD<T> * ptrField) ";
  72     BEGIN_OF(LOC);
  73
  74     _vtkFile = new ofstream();
  75
  76     END_OF(LOC);
  77   }
  78
  79   /*!
  80     Copy constructor.
  81   */
  82   VTK_FIELD_DRIVER(const VTK_FIELD_DRIVER & fieldDriver):
  83     GENDRIVER(fieldDriver),
  84     _ptrField(fieldDriver._ptrField),
  85     _fieldName(fieldDriver._fieldName),
  86     _fieldNum(fieldDriver._fieldNum)
  87   {
  88     _ptrField->addDriver(*this);
  89     _vtkFile = new ofstream();
  90   }
  91
  92   /*!
  93     Destructor.
  94   */
  95   ~VTK_FIELD_DRIVER()
  96   {
  97   const char * LOC ="VTK_FIELD_DRIVER::~VTK_FIELD_DRIVER()";
  98   BEGIN_OF(LOC);
  99
 100   close();
 101
 102   SCRUTE(_vtkFile);
 103
 104   delete _vtkFile ;
 105
 106   SCRUTE(_vtkFile);
 107
 108   END_OF(LOC);
 109   }
 110
 111   void openConst() const throw (MEDEXCEPTION)
 112   {
 113     const char * LOC = "VTK_FIELD_DRIVER::openConst()" ;
 114     BEGIN_OF(LOC);
 115
 116     MESSAGE(LOC<<" : _fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
 117
 118     if ( _fileName == "" )
 119       throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 120                                        << "_fileName is |\"\"|, please set a correct fileName before calling open()"
 121                                        )
 122                             );
 123
 124     if (!(*_vtkFile).is_open())
 125       (*_vtkFile).open(_fileName.c_str()) ;
 126 //    if (*_vtkFile)
 127 //      _status = MED_OPENED ;
 128 //    else
 129
 130
 131     SCRUTE((*_vtkFile).is_open());
 132     SCRUTE(_vtkFile);
 133
 134
 135
 136     if (!(*_vtkFile))
 137       throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not open file "
 138                                        << _fileName)
 139                             );
 140     END_OF(LOC);
 141   }
 142
 143   void openConstAppend() const throw (MEDEXCEPTION)
 144   {
 145     const char * LOC = "VTK_FIELD_DRIVER::openConstAppend()" ;
 146     BEGIN_OF(LOC);
 147
 148     MESSAGE(LOC<<" : _fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
 149
 150     if ( _fileName == "" )
 151       throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
 152                                        << "_fileName is |\"\"|, please set a correct fileName before calling open()"
 153                                        )
 154                             );
 155
 156     SCRUTE((*_vtkFile).is_open());
 157
 158     if (!(*_vtkFile).is_open())
 159       {
 160         MESSAGE(LOC<<"The file is already close and it is opened with the right option");
 161         (*_vtkFile).open(_fileName.c_str(), ofstream::out | ofstream::app) ;
 162       }
 163     else
 164       {
 165         MESSAGE(LOC<<"The file is still open, it is closed to make sure that it will be opened with the right option");
 166         //      closeConst();
 167
 168
 169         (*_vtkFile).close() ;
 170
 171         _vtkFile->open(_fileName.c_str(), ofstream::out | ofstream::app) ;
 172       }
 173 //    if (*_vtkFile)
 174 //      _status = MED_OPENED ;
 175 //    else
 176
 177
 178     SCRUTE((*_vtkFile).is_open());
 179     SCRUTE(_vtkFile);
 180
 181
 182
 183     if (!(*_vtkFile))
 184       throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not open file "
 185                                        << _fileName)
 186                             );
 187     END_OF(LOC);
 188   }
 189
 190   void open() throw (MEDEXCEPTION)
 191   {
 192     openConst() ;
 193   }
 194
 195   void openAppend() throw (MEDEXCEPTION)
 196   {
 197     openConstAppend() ;
 198   }
 199
 200   void closeConst() const throw (MEDEXCEPTION)
 201   {
 202     const char * LOC = "VTK_FIELD_DRIVER::closeConst() " ;
 203     BEGIN_OF(LOC);
 204
 205     SCRUTE(_vtkFile);
 206     SCRUTE(*_vtkFile);
 207
 208
 209     if ((*_vtkFile).is_open())
 210       (*_vtkFile).close();
 211
 212 //    if (*_vtkFile)
 213 //      _status = MED_CLOSED ;
 214 //    else
 215
 216     SCRUTE(_vtkFile);
 217     SCRUTE(*_vtkFile);
 218
 219     if (!(*_vtkFile))
 220       throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not close file "
 221                                        << _fileName)
 222                             );
 223
 224     END_OF(LOC);
 225   }
 226
 227   void close() {
 228     closeConst() ;
 229   }
 230
 231   /*!
 232     Set the name of the FIELD asked in file.
 233
 234     It could be different than the name of the FIELD object.
 235   */
 236   void   setFieldName(const string & fieldName) ;
 237
 238   /*!
 239     Get the name of the FIELD asked in file.
 240   */
 241   string getFieldName() const ;
 242
 243   /*!
 244     Return a MEDEXCEPTION : it is the write-only driver.
 245   */
 246   void read ( void ) throw (MEDEXCEPTION) ;
 247
 248   /*!
 249     Write FIELD in the specified file, with its mesh through its support
 250     which has to be on all entities (excluding the faces in 3d and edges
 251     in 2d).
 252   */
 253   void write( void ) const throw (MEDEXCEPTION) ;
 254
 255   /*!
 256     Write FIELD in the specified file, the mesh is supposed to be
 257     written in this file. The field support has to be on all entities
 258     (excluding the faces in 3d and edges in 2d).
 259   */
 260   void writeAppend( void ) const throw (MEDEXCEPTION);
 261
 262 private:
 263   GENDRIVER * copy ( void ) const ;
 264
 265 };
 266
 267 /*-------------------------*/
 268 /* template implementation */
 269 /*-------------------------*/
 270
 271 /*--------------------- DRIVER PART -------------------------------*/
 272
 273 template <class T> void VTK_FIELD_DRIVER<T>::setFieldName(const string & fieldName)
 274 {
 275   _fieldName = fieldName;
 276 }
 277
 278 template <class T> string  VTK_FIELD_DRIVER<T>::getFieldName() const
 279 {
 280   return _fieldName;
 281 }
 282
 283 template <class T> GENDRIVER * VTK_FIELD_DRIVER<T>::copy(void) const
 284 {
 285   VTK_FIELD_DRIVER<T> * myDriver = new VTK_FIELD_DRIVER<T>(*this);
 286
 287   return myDriver ;
 288 }
 289
 290 template <class T> void VTK_FIELD_DRIVER<T>::read (void)
 291   throw (MEDEXCEPTION)
 292 {
 293   throw MEDEXCEPTION("VTK_FIELD_DRIVER::read : Can't read with a VTK driver because it is write only driver !");
 294 }
 295
 296 template <class T> void VTK_FIELD_DRIVER<T>::write(void) const
 297   throw (MEDEXCEPTION)
 298 {
 299   const char * LOC = "VTK_FIELD_DRIVER::write(void) const " ;
 300   BEGIN_OF(LOC);
 301
 302   // we get the Support and its associated Mesh
 303
 304   const SUPPORT * supportField = _ptrField->getSupport();
 305   MESH * meshField = supportField->getMesh();
 306
 307   // Well we must open vtk file first, because there are
 308   // no other driver than MED for VTK that do it !
 309   openConst() ;
 310
 311   // could we put more than one Mesh ?????
 312   (*_vtkFile) << "# vtk DataFile Version 2.0" << endl
 313            << "maillage from MedMemory"  << endl ;
 314   // only ASCII for the moment (binary came later :-)
 315   (*_vtkFile) << "ASCII" << endl ;
 316
 317   (*_vtkFile) << "DATASET UNSTRUCTURED_GRID" << endl ;
 318   // put points (all point are in 3D, so if we are in 1D or 2D, we complete by zero !
 319   int SpaceDimension = meshField->getSpaceDimension() ;
 320   int NumberOfNodes = meshField->getNumberOfNodes() ;
 321   (*_vtkFile) << "POINTS " << NumberOfNodes << " float" << endl ;
 322   const double *coordinate = meshField->getCoordinates(MED_EN::MED_FULL_INTERLACE) ;
 323   for (int i=0;i<NumberOfNodes;i++) {
 324     for (int j=0;j<SpaceDimension;j++)
 325       (*_vtkFile) << coordinate[i*SpaceDimension+j] << " " ;
 326     if (SpaceDimension==1)
 327       (*_vtkFile) << "0 0" ;
 328     if (SpaceDimension==2)
 329       (*_vtkFile) << "0" ;
 330     (*_vtkFile) << endl ;
 331   }
 332
 333   // we put connectivity
 334   // how many cells and how many value in connectivity :
 335   int cells_types_count = meshField->getNumberOfTypes(MED_EN::MED_CELL) ;
 336   //  int * cells_count = meshField->get_cells_count() ;
 337   //  int cells_sum = cells_count[cells_types_count] ;
 338   int cells_sum = meshField->getNumberOfElements(MED_EN::MED_CELL,MED_EN::MED_ALL_ELEMENTS) ;
 339   const CELLMODEL * cells_type = meshField->getCellsTypes(MED_EN::MED_CELL) ;
 340   //  int connectivity_sum = 0 ;
 341
 342   //const int * connectivity = meshField->getConnectivity(MED_FULL_INTERLACE,MED_NODAL,MED_CELL,MED_ALL_ELEMENTS) ; !! UNUSED VARIABLE !!
 343   const int * connectivityIndex = meshField->getConnectivityIndex(MED_EN::MED_NODAL,MED_EN::MED_CELL) ;
 344
 345   int connectivity_sum =  connectivityIndex[cells_sum]-1 ;
 346
 347   (*_vtkFile) << "CELLS " << cells_sum << " " << connectivity_sum+cells_sum << endl ;
 348   // we put connectivity
 349   for (int i=0;i<cells_types_count;i++) {
 350     int *filter = (int*) NULL ; // index in vtk connectivity
 351     switch (cells_type[i].getType())
 352       {
 353       case MED_EN::MED_POINT1  : {
 354         filter = new int[1] ;
 355         filter[0] = 0 ;
 356         break ;
 357       }
 358       case MED_EN::MED_SEG2    : {
 359         filter = new int[2] ;
 360         filter[0] = 0 ;
 361         filter[1] = 1 ;
 362         break ;
 363       }
 364       case MED_EN::MED_SEG3    : {
 365         break ;
 366       }
 367       case MED_EN::MED_TRIA3   : {
 368         filter = new int[3] ;
 369         filter[0] = 0 ;
 370         filter[1] = 1 ;
 371         filter[2] = 2 ;
 372         break ;
 373       }
 374       case MED_EN::MED_QUAD4   : {
 375         filter = new int[4] ;
 376         filter[0] = 0 ;
 377         filter[1] = 1 ;
 378         filter[2] = 2 ;
 379         filter[3] = 3 ;
 380         break ;
 381       }
 382       case MED_EN::MED_TRIA6   : {
 383         break ;
 384       }
 385       case MED_EN::MED_QUAD8   : {
 386         break ;
 387       }
 388       case MED_EN::MED_TETRA4  : {
 389         filter = new int[4] ;
 390         filter[0] = 0 ;
 391         filter[1] = 1 ;
 392         filter[2] = 3 ;  // 3td element in med are 4th in vtk (array begin at 0 !)
 393         filter[3] = 2 ;  // 4th element in med are 3rd in vtk (array begin at 0 !)
 394         break ;
 395       }
 396       case MED_EN::MED_PYRA5   : {
 397         filter = new int[5] ;
 398         filter[0] = 0 ;
 399         filter[1] = 3 ;  // 2nd element in med are 4th in vtk (array begin at 0 !)
 400         filter[2] = 2 ;
 401         filter[3] = 1 ;  // 4th element in med are 2nd in vtk (array begin at 0 !)
 402         filter[4] = 4 ;
 403         break ;
 404       }
 405       case MED_EN::MED_PENTA6  : {
 406         filter = new int[6] ;
 407         filter[0] = 0 ;
 408         filter[1] = 1 ;
 409         filter[2] = 2 ;
 410         filter[3] = 3 ;
 411         filter[4] = 4 ;
 412         filter[5] = 5 ;
 413         break ;
 414       }
 415       case MED_EN::MED_HEXA8   : {
 416         filter = new int[8] ;
 417         filter[0] = 0 ;
 418         filter[1] = 3 ;
 419         filter[2] = 2 ;
 420         filter[3] = 1 ;
 421         filter[4] = 4 ;
 422         filter[5] = 7 ;
 423         filter[6] = 6 ;
 424         filter[7] = 5 ;
 425         break ;
 426       }
 427       case MED_EN::MED_TETRA10 : {
 428         break ;
 429       }
 430       case MED_EN::MED_PYRA13  : {
 431         break ;
 432       }
 433       case MED_EN::MED_PENTA15 : {
 434         break ;
 435       }
 436       case MED_EN::MED_HEXA20  : {
 437         break ;
 438       }
 439       default : {
 440         break ;
 441       }
 442       }
 443     if (filter==NULL)
 444       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": MED element type not supported yet : " << cells_type[i].getName() ) ) ;
 445     int nodes_cell = cells_type[i].getNumberOfNodes();
 446     int numberOfCell = meshField->getNumberOfElements(MED_EN::MED_CELL,cells_type[i].getType()) ;
 447     const int * connectivityArray = meshField->getConnectivity(MED_EN::MED_FULL_INTERLACE,MED_EN::MED_NODAL,MED_EN::MED_CELL,cells_type[i].getType());
 448     for (int j=0;j<numberOfCell;j++) {
 449       (*_vtkFile) << nodes_cell << " " ;
 450       for (int k=0;k<nodes_cell;k++)
 451         (*_vtkFile) << connectivityArray[j*nodes_cell+filter[k]] - 1 << " " ;
 452       (*_vtkFile) << endl ;
 453     }
 454     if (filter != NULL)
 455       delete[] filter ;
 456   }
 457   (*_vtkFile) << endl ;
 458   // we put cells type
 459   (*_vtkFile) << "CELL_TYPES " << cells_sum << endl ;
 460   for (int i=0;i<cells_types_count;i++) {
 461     int vtkType = 0 ;
 462     switch (cells_type[i].getType())
 463       {
 464       case MED_EN::MED_POINT1  : {
 465         vtkType = 1 ;
 466         break ;
 467       }
 468       case MED_EN::MED_SEG2    : {
 469         vtkType = 3 ;
 470         break ;
 471       }
 472       case MED_EN::MED_SEG3    : {
 473         vtkType = 0 ;
 474         break ;
 475       }
 476       case MED_EN::MED_TRIA3   : {
 477         vtkType = 5 ;
 478         break ;
 479       }
 480       case MED_EN::MED_QUAD4   : {
 481         vtkType = 9 ;
 482         break ;
 483       }
 484       case MED_EN::MED_TRIA6   : {
 485         vtkType = 0 ;
 486         break ;
 487       }
 488       case MED_EN::MED_QUAD8   : {
 489         vtkType = 0 ;
 490         break ;
 491       }
 492       case MED_EN::MED_TETRA4  : {
 493         vtkType = 10 ;
 494         break ;
 495       }
 496       case MED_EN::MED_PYRA5   : {
 497         vtkType = 14 ;
 498         break ;
 499       }
 500       case MED_EN::MED_PENTA6  : {
 501         vtkType = 13 ;
 502         break ;
 503       }
 504       case MED_EN::MED_HEXA8   : {
 505         vtkType = 12 ;
 506         break ;
 507       }
 508       case MED_EN::MED_TETRA10 : {
 509         vtkType = 0 ;
 510         break ;
 511       }
 512       case MED_EN::MED_PYRA13  : {
 513         vtkType = 0 ;
 514         break ;
 515       }
 516       case MED_EN::MED_PENTA15 : {
 517         vtkType = 0 ;
 518         break ;
 519       }
 520       case MED_EN::MED_HEXA20  : {
 521         vtkType = 0 ;
 522         break ;
 523       }
 524       default : {
 525         vtkType = 0 ;
 526         break ;
 527       }
 528       }
 529     if (vtkType == 0)
 530       throw MEDEXCEPTION(LOCALIZED(STRING(LOC)<<": MED element type not supported yet : " << cells_type[i].getType() ) ) ;
 531     int numberOfCell = meshField->getNumberOfElements(MED_EN::MED_CELL,cells_type[i].getType()) ;
 532     for (int j=0;j<numberOfCell;j++)
 533       (*_vtkFile) << vtkType << endl ;
 534   }
 535
 536   // first : field on node
 537   // fields is on all node !
 538
 539   // second : field on cell
 540   // fields is on all cell !
 541
 542   int dt = _ptrField->getIterationNumber();
 543   int it = _ptrField->getOrderNumber();
 544
 545   ostringstream name ;
 546   string nameField = _ptrField->getName();
 547   MED_EN::medEntityMesh entitySupport = supportField->getEntity();
 548   name << nameField << "_" << dt << "_" << it ;
 549
 550   if (!(supportField->isOnAllElements()))
 551     throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<<_ptrField->getName()<<" which is not on all entities of the mesh !" << entitySupport));
 552
 553   if (entitySupport == MED_EN::MED_NODE)
 554     (*_vtkFile) << "POINT_DATA " << meshField->getNumberOfNodes() << endl ;
 555   else if (entitySupport == MED_EN::MED_CELL)
 556     (*_vtkFile) << "CELL_DATA " << meshField->getNumberOfElements(MED_EN::MED_CELL,MED_EN::MED_ALL_ELEMENTS) << endl ;
 557   else
 558     throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<<_ptrField->getName()<<" which is not on all nodes or cells but it's on !" << entitySupport));
 559
 560   int NomberOfValue = supportField->getNumberOfElements(MED_EN::MED_ALL_ELEMENTS) ;
 561   int NomberOfComponents =  _ptrField->getNumberOfComponents() ;
 562
 563   MED_EN::med_type_champ fieldType = _ptrField->getValueType() ;
 564
 565   SCRUTE(name.str());
 566   SCRUTE(fieldType);
 567
 568   switch (fieldType)
 569     {
 570     case MED_EN::MED_INT32 :
 571       {
 572         break ;
 573       }
 574     case MED_EN::MED_REEL64 :
 575       {
 576         break ;
 577       }
 578     default :
 579       {
 580         throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<< name.str() <<" the type is not int or double !"));
 581       }
 582     }
 583
 584   if (NomberOfComponents==3)
 585     (*_vtkFile) << "VECTORS " << name.str() << " int" << endl ;
 586   else if (NomberOfComponents<=4)
 587     {
 588       (*_vtkFile) << "SCALARS " << name.str() << " int " << NomberOfComponents << endl ;
 589       (*_vtkFile) << "LOOKUP_TABLE default" << endl ;
 590     }
 591   else
 592     throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<<_ptrField->getName()<<" there are more than 4 components !"));
 593
 594   const T * value = _ptrField->getValue(MED_EN::MED_NO_INTERLACE) ;
 595
 596   for (int i=0; i<NomberOfValue; i++)
 597     {
 598       for(int j=0; j<NomberOfComponents; j++)
 599         (*_vtkFile) << value[j*NomberOfValue+i] << " " ;
 600       (*_vtkFile) << endl ;
 601     }
 602   END_OF(LOC);
 603 }
 604
 605 template <class T> void VTK_FIELD_DRIVER<T>::writeAppend(void) const
 606   throw (MEDEXCEPTION)
 607 {
 608   const char * LOC = "VTK_FIELD_DRIVER::writeAppend(void) const " ;
 609   BEGIN_OF(LOC);
 610
 611   // we get the Support and its associated Mesh
 612
 613   const SUPPORT * supportField = _ptrField->getSupport();
 614   MESH * meshField = supportField->getMesh();
 615
 616   // Well we must open vtk file first, because there are
 617   // no other driver than MED for VTK that do it !
 618   openConstAppend() ;
 619
 620   // first : field on node
 621   // fields is on all node !
 622
 623   // second : field on cell
 624   // fields is on all cell !
 625
 626   int dt = _ptrField->getIterationNumber();
 627   int it = _ptrField->getOrderNumber();
 628
 629   ostringstream name ;
 630   string nameField = _ptrField->getName();
 631   MED_EN::medEntityMesh entitySupport = supportField->getEntity();
 632   name << nameField << "_" << dt << "_" << it ;
 633
 634   if (!(supportField->isOnAllElements()))
 635     throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<<_ptrField->getName()<<" which is not on all entities of the mesh !" << entitySupport));
 636
 637   if (entitySupport == MED_EN::MED_NODE)
 638     (*_vtkFile) << "POINT_DATA " << meshField->getNumberOfNodes() << endl ;
 639   else if (entitySupport == MED_EN::MED_CELL)
 640     (*_vtkFile) << "CELL_DATA " << meshField->getNumberOfElements(MED_EN::MED_CELL,MED_EN::MED_ALL_ELEMENTS) << endl ;
 641   else
 642     throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<<_ptrField->getName()<<" which is not on all nodes or cells but it's on !" << entitySupport));
 643
 644   int NomberOfValue = supportField->getNumberOfElements(MED_EN::MED_ALL_ELEMENTS) ;
 645   int NomberOfComponents =  _ptrField->getNumberOfComponents() ;
 646
 647   MED_EN::med_type_champ fieldType = _ptrField->getValueType() ;
 648
 649   SCRUTE(name.str());
 650   SCRUTE(fieldType);
 651   switch (fieldType)
 652     {
 653     case MED_EN::MED_INT32 :
 654       {
 655         break ;
 656       }
 657     case MED_EN::MED_REEL64 :
 658       {
 659         break ;
 660       }
 661     default :
 662       {
 663         throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<< name.str() <<" the type is not int or double !"));
 664       }
 665     }
 666
 667   if (NomberOfComponents==3)
 668     (*_vtkFile) << "VECTORS " << name.str() << " int" << endl ;
 669   else if (NomberOfComponents<=4)
 670     {
 671       (*_vtkFile) << "SCALARS " << name.str() << " int " << NomberOfComponents << endl ;
 672       (*_vtkFile) << "LOOKUP_TABLE default" << endl ;
 673     }
 674   else
 675     throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<<_ptrField->getName()<<" there are more than 4 components !"));
 676
 677   const T * value = _ptrField->getValue(MED_EN::MED_NO_INTERLACE) ;
 678
 679   for (int i=0; i<NomberOfValue; i++)
 680     {
 681       for(int j=0; j<NomberOfComponents; j++)
 682         (*_vtkFile) << value[j*NomberOfValue+i] << " " ;
 683       (*_vtkFile) << endl ;
 684     }
 685   END_OF(LOC);
 686 }
 687 }//End namespace MEDMEM
 688
 689 #endif /* VTK_FIELD_DRIVER_HXX */