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