1 #ifndef VTK_FIELD_DRIVER_HXX
2 #define VTK_FIELD_DRIVER_HXX
8 #include "MEDMEM_define.hxx"
10 #include "MEDMEM_GenDriver.hxx"
11 #include "utilities.h"
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"
27 Generic part : implement open and close methods.
32 template <class T> class FIELD;
33 template <class T> class VTK_FIELD_DRIVER : public GENDRIVER
38 mutable ofstream * _vtkFile ;
44 // all MED cell type ?? Classe de Définition ??
45 // static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
47 // static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
52 VTK_FIELD_DRIVER():GENDRIVER(),
53 _ptrField((FIELD<T> *)MED_NULL), _fieldName(""),
54 _fieldNum(MED_INVALID)
56 const char * LOC = "VTK_FIELD_DRIVER::VTK_FIELD_DRIVER() ";
59 _vtkFile = new ofstream();
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)
71 const char * LOC = "VTK_FIELD_DRIVER::VTK_FIELD_DRIVER(const string & fileName, FIELD<T> * ptrField) ";
74 _vtkFile = new ofstream();
82 VTK_FIELD_DRIVER(const VTK_FIELD_DRIVER & fieldDriver):
83 GENDRIVER(fieldDriver),
84 _ptrField(fieldDriver._ptrField),
85 _fieldName(fieldDriver._fieldName),
86 _fieldNum(fieldDriver._fieldNum)
88 _ptrField->addDriver(*this);
89 _vtkFile = new ofstream();
97 const char * LOC ="VTK_FIELD_DRIVER::~VTK_FIELD_DRIVER()";
111 void openConst() const throw (MEDEXCEPTION)
113 const char * LOC = "VTK_FIELD_DRIVER::openConst()" ;
116 MESSAGE(LOC<<" : _fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
118 if ( _fileName == "" )
119 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
120 << "_fileName is |\"\"|, please set a correct fileName before calling open()"
124 if (!(*_vtkFile).is_open())
125 (*_vtkFile).open(_fileName.c_str()) ;
127 // _status = MED_OPENED ;
131 SCRUTE((*_vtkFile).is_open());
137 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not open file "
143 void openConstAppend() const throw (MEDEXCEPTION)
145 const char * LOC = "VTK_FIELD_DRIVER::openConstAppend()" ;
148 MESSAGE(LOC<<" : _fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
150 if ( _fileName == "" )
151 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
152 << "_fileName is |\"\"|, please set a correct fileName before calling open()"
156 SCRUTE((*_vtkFile).is_open());
158 if (!(*_vtkFile).is_open())
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) ;
165 MESSAGE(LOC<<"The file is still open, it is closed to make sure that it will be opened with the right option");
169 (*_vtkFile).close() ;
171 _vtkFile->open(_fileName.c_str(), ofstream::out | ofstream::app) ;
174 // _status = MED_OPENED ;
178 SCRUTE((*_vtkFile).is_open());
184 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not open file "
190 void open() throw (MEDEXCEPTION)
195 void openAppend() throw (MEDEXCEPTION)
200 void closeConst() const throw (MEDEXCEPTION)
202 const char * LOC = "VTK_FIELD_DRIVER::closeConst() " ;
209 if ((*_vtkFile).is_open())
213 // _status = MED_CLOSED ;
220 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not close file "
232 Set the name of the FIELD asked in file.
234 It could be different than the name of the FIELD object.
236 void setFieldName(const string & fieldName) ;
239 Get the name of the FIELD asked in file.
241 string getFieldName() const ;
244 Return a MEDEXCEPTION : it is the write-only driver.
246 void read ( void ) throw (MEDEXCEPTION) ;
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
253 void write( void ) const throw (MEDEXCEPTION) ;
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).
260 void writeAppend( void ) const throw (MEDEXCEPTION);
263 GENDRIVER * copy ( void ) const ;
267 /*-------------------------*/
268 /* template implementation */
269 /*-------------------------*/
271 /*--------------------- DRIVER PART -------------------------------*/
273 template <class T> void VTK_FIELD_DRIVER<T>::setFieldName(const string & fieldName)
275 _fieldName = fieldName;
278 template <class T> string VTK_FIELD_DRIVER<T>::getFieldName() const
283 template <class T> GENDRIVER * VTK_FIELD_DRIVER<T>::copy(void) const
285 VTK_FIELD_DRIVER<T> * myDriver = new VTK_FIELD_DRIVER<T>(*this);
290 template <class T> void VTK_FIELD_DRIVER<T>::read (void)
293 throw MEDEXCEPTION("VTK_FIELD_DRIVER::read : Can't read with a VTK driver because it is write only driver !");
296 template <class T> void VTK_FIELD_DRIVER<T>::write(void) const
299 const char * LOC = "VTK_FIELD_DRIVER::write(void) const " ;
302 // we get the Support and its associated Mesh
304 const SUPPORT * supportField = _ptrField->getSupport();
305 MESH * meshField = supportField->getMesh();
307 // Well we must open vtk file first, because there are
308 // no other driver than MED for VTK that do it !
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 ;
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)
330 (*_vtkFile) << endl ;
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 ;
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) ;
345 int connectivity_sum = connectivityIndex[cells_sum]-1 ;
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())
353 case MED_EN::MED_POINT1 : {
354 filter = new int[1] ;
358 case MED_EN::MED_SEG2 : {
359 filter = new int[2] ;
364 case MED_EN::MED_SEG3 : {
367 case MED_EN::MED_TRIA3 : {
368 filter = new int[3] ;
374 case MED_EN::MED_QUAD4 : {
375 filter = new int[4] ;
382 case MED_EN::MED_TRIA6 : {
385 case MED_EN::MED_QUAD8 : {
388 case MED_EN::MED_TETRA4 : {
389 filter = new int[4] ;
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 !)
396 case MED_EN::MED_PYRA5 : {
397 filter = new int[5] ;
399 filter[1] = 3 ; // 2nd element in med are 4th in vtk (array begin at 0 !)
401 filter[3] = 1 ; // 4th element in med are 2nd in vtk (array begin at 0 !)
405 case MED_EN::MED_PENTA6 : {
406 filter = new int[6] ;
415 case MED_EN::MED_HEXA8 : {
416 filter = new int[8] ;
427 case MED_EN::MED_TETRA10 : {
430 case MED_EN::MED_PYRA13 : {
433 case MED_EN::MED_PENTA15 : {
436 case MED_EN::MED_HEXA20 : {
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 ;
457 (*_vtkFile) << endl ;
459 (*_vtkFile) << "CELL_TYPES " << cells_sum << endl ;
460 for (int i=0;i<cells_types_count;i++) {
462 switch (cells_type[i].getType())
464 case MED_EN::MED_POINT1 : {
468 case MED_EN::MED_SEG2 : {
472 case MED_EN::MED_SEG3 : {
476 case MED_EN::MED_TRIA3 : {
480 case MED_EN::MED_QUAD4 : {
484 case MED_EN::MED_TRIA6 : {
488 case MED_EN::MED_QUAD8 : {
492 case MED_EN::MED_TETRA4 : {
496 case MED_EN::MED_PYRA5 : {
500 case MED_EN::MED_PENTA6 : {
504 case MED_EN::MED_HEXA8 : {
508 case MED_EN::MED_TETRA10 : {
512 case MED_EN::MED_PYRA13 : {
516 case MED_EN::MED_PENTA15 : {
520 case MED_EN::MED_HEXA20 : {
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 ;
536 // first : field on node
537 // fields is on all node !
539 // second : field on cell
540 // fields is on all cell !
542 int dt = _ptrField->getIterationNumber();
543 int it = _ptrField->getOrderNumber();
546 string nameField = _ptrField->getName();
547 MED_EN::medEntityMesh entitySupport = supportField->getEntity();
548 name << nameField << "_" << dt << "_" << it ;
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));
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 ;
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));
560 int NomberOfValue = supportField->getNumberOfElements(MED_EN::MED_ALL_ELEMENTS) ;
561 int NomberOfComponents = _ptrField->getNumberOfComponents() ;
563 MED_EN::med_type_champ fieldType = _ptrField->getValueType() ;
570 case MED_EN::MED_INT32 :
574 case MED_EN::MED_REEL64 :
580 throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<< name.str() <<" the type is not int or double !"));
584 if (NomberOfComponents==3)
585 (*_vtkFile) << "VECTORS " << name.str() << " int" << endl ;
586 else if (NomberOfComponents<=4)
588 (*_vtkFile) << "SCALARS " << name.str() << " int " << NomberOfComponents << endl ;
589 (*_vtkFile) << "LOOKUP_TABLE default" << endl ;
592 throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<<_ptrField->getName()<<" there are more than 4 components !"));
594 const T * value = _ptrField->getValue(MED_EN::MED_NO_INTERLACE) ;
596 for (int i=0; i<NomberOfValue; i++)
598 for(int j=0; j<NomberOfComponents; j++)
599 (*_vtkFile) << value[j*NomberOfValue+i] << " " ;
600 (*_vtkFile) << endl ;
605 template <class T> void VTK_FIELD_DRIVER<T>::writeAppend(void) const
608 const char * LOC = "VTK_FIELD_DRIVER::writeAppend(void) const " ;
611 // we get the Support and its associated Mesh
613 const SUPPORT * supportField = _ptrField->getSupport();
614 MESH * meshField = supportField->getMesh();
616 // Well we must open vtk file first, because there are
617 // no other driver than MED for VTK that do it !
620 // first : field on node
621 // fields is on all node !
623 // second : field on cell
624 // fields is on all cell !
626 int dt = _ptrField->getIterationNumber();
627 int it = _ptrField->getOrderNumber();
630 string nameField = _ptrField->getName();
631 MED_EN::medEntityMesh entitySupport = supportField->getEntity();
632 name << nameField << "_" << dt << "_" << it ;
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));
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 ;
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));
644 int NomberOfValue = supportField->getNumberOfElements(MED_EN::MED_ALL_ELEMENTS) ;
645 int NomberOfComponents = _ptrField->getNumberOfComponents() ;
647 MED_EN::med_type_champ fieldType = _ptrField->getValueType() ;
653 case MED_EN::MED_INT32 :
657 case MED_EN::MED_REEL64 :
663 throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<< name.str() <<" the type is not int or double !"));
667 if (NomberOfComponents==3)
668 (*_vtkFile) << "VECTORS " << name.str() << " int" << endl ;
669 else if (NomberOfComponents<=4)
671 (*_vtkFile) << "SCALARS " << name.str() << " int " << NomberOfComponents << endl ;
672 (*_vtkFile) << "LOOKUP_TABLE default" << endl ;
675 throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<<_ptrField->getName()<<" there are more than 4 components !"));
677 const T * value = _ptrField->getValue(MED_EN::MED_NO_INTERLACE) ;
679 for (int i=0; i<NomberOfValue; i++)
681 for(int j=0; j<NomberOfComponents; j++)
682 (*_vtkFile) << value[j*NomberOfValue+i] << " " ;
683 (*_vtkFile) << endl ;
687 }//End namespace MEDMEM
689 #endif /* VTK_FIELD_DRIVER_HXX */