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_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"
25 Generic part : implement open and close methods.
30 template <class T> class FIELD;
31 template <class T> class VTK_FIELD_DRIVER : public GENDRIVER
36 mutable ofstream * _vtkFile ;
42 // all MED cell type ?? Classe de Définition ??
43 // static const medGeometryElement all_cell_type[MED_NBR_GEOMETRIE_MAILLE];
45 // static const char * const all_cell_type_tab [MED_NBR_GEOMETRIE_MAILLE];
50 VTK_FIELD_DRIVER():GENDRIVER(),
51 _ptrField((FIELD<T> *) 0), _fieldName(""),
52 _fieldNum(MED_INVALID)
54 const char * LOC = "VTK_FIELD_DRIVER::VTK_FIELD_DRIVER() ";
57 _vtkFile = new ofstream();
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)
69 const char * LOC = "VTK_FIELD_DRIVER::VTK_FIELD_DRIVER(const string & fileName, FIELD<T> * ptrField) ";
72 _vtkFile = new ofstream();
80 VTK_FIELD_DRIVER(const VTK_FIELD_DRIVER & fieldDriver):
81 GENDRIVER(fieldDriver),
82 _ptrField(fieldDriver._ptrField),
83 _fieldName(fieldDriver._fieldName),
84 _fieldNum(fieldDriver._fieldNum)
86 _ptrField->addDriver(*this);
87 _vtkFile = new ofstream();
95 const char * LOC ="VTK_FIELD_DRIVER::~VTK_FIELD_DRIVER()";
109 void openConst() const throw (MEDEXCEPTION)
111 const char * LOC = "VTK_FIELD_DRIVER::openConst()" ;
114 MESSAGE(LOC<<" : _fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
116 if ( _fileName == "" )
117 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
118 << "_fileName is |\"\"|, please set a correct fileName before calling open()"
122 if (!(*_vtkFile).is_open())
123 (*_vtkFile).open(_fileName.c_str()) ;
125 // _status = MED_OPENED ;
129 SCRUTE((*_vtkFile).is_open());
135 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not open file "
141 void openConstAppend() const throw (MEDEXCEPTION)
143 const char * LOC = "VTK_FIELD_DRIVER::openConstAppend()" ;
146 MESSAGE(LOC<<" : _fileName.c_str : "<< _fileName.c_str()<<",mode : "<< _accessMode);
148 if ( _fileName == "" )
149 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC)
150 << "_fileName is |\"\"|, please set a correct fileName before calling open()"
154 SCRUTE((*_vtkFile).is_open());
156 if (!(*_vtkFile).is_open())
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) ;
163 MESSAGE(LOC<<"The file is still open, it is closed to make sure that it will be opened with the right option");
167 (*_vtkFile).close() ;
169 _vtkFile->open(_fileName.c_str(), ofstream::out | ofstream::app) ;
172 // _status = MED_OPENED ;
176 SCRUTE((*_vtkFile).is_open());
182 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not open file "
188 void open() throw (MEDEXCEPTION)
193 void openAppend() throw (MEDEXCEPTION)
198 void closeConst() const throw (MEDEXCEPTION)
200 const char * LOC = "VTK_FIELD_DRIVER::closeConst() " ;
207 if ((*_vtkFile).is_open())
211 // _status = MED_CLOSED ;
218 throw MED_EXCEPTION ( LOCALIZED( STRING(LOC) << "Could not close file "
230 Set the name of the FIELD asked in file.
232 It could be different than the name of the FIELD object.
234 void setFieldName(const string & fieldName) ;
237 Get the name of the FIELD asked in file.
239 string getFieldName() const ;
242 Return a MEDEXCEPTION : it is the write-only driver.
244 void read ( void ) throw (MEDEXCEPTION) ;
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
251 void write( void ) const throw (MEDEXCEPTION) ;
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).
258 void writeAppend( void ) const throw (MEDEXCEPTION);
261 GENDRIVER * copy ( void ) const ;
265 /*-------------------------*/
266 /* template implementation */
267 /*-------------------------*/
269 /*--------------------- DRIVER PART -------------------------------*/
271 template <class T> void VTK_FIELD_DRIVER<T>::setFieldName(const string & fieldName)
273 _fieldName = fieldName;
276 template <class T> string VTK_FIELD_DRIVER<T>::getFieldName() const
281 template <class T> GENDRIVER * VTK_FIELD_DRIVER<T>::copy(void) const
283 VTK_FIELD_DRIVER<T> * myDriver = new VTK_FIELD_DRIVER<T>(*this);
288 template <class T> void VTK_FIELD_DRIVER<T>::read (void)
291 throw MEDEXCEPTION("VTK_FIELD_DRIVER::read : Can't read with a VTK driver because it is write only driver !");
294 template <class T> void VTK_FIELD_DRIVER<T>::write(void) const
297 const char * LOC = "VTK_FIELD_DRIVER::write(void) const " ;
300 // we get the Support and its associated Mesh
302 const SUPPORT * supportField = _ptrField->getSupport();
303 MESH * meshField = supportField->getMesh();
305 // Well we must open vtk file first, because there are
306 // no other driver than MED for VTK that do it !
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 ;
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)
328 (*_vtkFile) << endl ;
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 ;
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) ;
343 int connectivity_sum = connectivityIndex[cells_sum]-1 ;
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())
351 case MED_EN::MED_POINT1 : {
352 filter = new int[1] ;
356 case MED_EN::MED_SEG2 : {
357 filter = new int[2] ;
362 case MED_EN::MED_SEG3 : {
365 case MED_EN::MED_TRIA3 : {
366 filter = new int[3] ;
372 case MED_EN::MED_QUAD4 : {
373 filter = new int[4] ;
380 case MED_EN::MED_TRIA6 : {
383 case MED_EN::MED_QUAD8 : {
386 case MED_EN::MED_TETRA4 : {
387 filter = new int[4] ;
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 !)
394 case MED_EN::MED_PYRA5 : {
395 filter = new int[5] ;
397 filter[1] = 3 ; // 2nd element in med are 4th in vtk (array begin at 0 !)
399 filter[3] = 1 ; // 4th element in med are 2nd in vtk (array begin at 0 !)
403 case MED_EN::MED_PENTA6 : {
404 filter = new int[6] ;
413 case MED_EN::MED_HEXA8 : {
414 filter = new int[8] ;
425 case MED_EN::MED_TETRA10 : {
428 case MED_EN::MED_PYRA13 : {
431 case MED_EN::MED_PENTA15 : {
434 case MED_EN::MED_HEXA20 : {
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 ;
455 (*_vtkFile) << endl ;
457 (*_vtkFile) << "CELL_TYPES " << cells_sum << endl ;
458 for (int i=0;i<cells_types_count;i++) {
460 switch (cells_type[i].getType())
462 case MED_EN::MED_POINT1 : {
466 case MED_EN::MED_SEG2 : {
470 case MED_EN::MED_SEG3 : {
474 case MED_EN::MED_TRIA3 : {
478 case MED_EN::MED_QUAD4 : {
482 case MED_EN::MED_TRIA6 : {
486 case MED_EN::MED_QUAD8 : {
490 case MED_EN::MED_TETRA4 : {
494 case MED_EN::MED_PYRA5 : {
498 case MED_EN::MED_PENTA6 : {
502 case MED_EN::MED_HEXA8 : {
506 case MED_EN::MED_TETRA10 : {
510 case MED_EN::MED_PYRA13 : {
514 case MED_EN::MED_PENTA15 : {
518 case MED_EN::MED_HEXA20 : {
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 ;
534 // first : field on node
535 // fields is on all node !
537 // second : field on cell
538 // fields is on all cell !
540 int dt = _ptrField->getIterationNumber();
541 int it = _ptrField->getOrderNumber();
544 string nameField = _ptrField->getName();
545 MED_EN::medEntityMesh entitySupport = supportField->getEntity();
546 name << nameField << "_" << dt << "_" << it ;
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));
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 ;
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));
558 int NomberOfValue = supportField->getNumberOfElements(MED_EN::MED_ALL_ELEMENTS) ;
559 int NomberOfComponents = _ptrField->getNumberOfComponents() ;
561 MED_EN::med_type_champ fieldType = _ptrField->getValueType() ;
568 case MED_EN::MED_INT32 :
572 case MED_EN::MED_REEL64 :
578 throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<< name.str() <<" the type is not int or double !"));
582 if (NomberOfComponents==3)
583 (*_vtkFile) << "VECTORS " << name.str() << " int" << endl ;
584 else if (NomberOfComponents<=4)
586 (*_vtkFile) << "SCALARS " << name.str() << " int " << NomberOfComponents << endl ;
587 (*_vtkFile) << "LOOKUP_TABLE default" << endl ;
590 throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<<_ptrField->getName()<<" there are more than 4 components !"));
592 const T * value = _ptrField->getValue(MED_EN::MED_NO_INTERLACE) ;
594 for (int i=0; i<NomberOfValue; i++)
596 for(int j=0; j<NomberOfComponents; j++)
597 (*_vtkFile) << value[j*NomberOfValue+i] << " " ;
598 (*_vtkFile) << endl ;
603 template <class T> void VTK_FIELD_DRIVER<T>::writeAppend(void) const
606 const char * LOC = "VTK_FIELD_DRIVER::writeAppend(void) const " ;
609 // we get the Support and its associated Mesh
611 const SUPPORT * supportField = _ptrField->getSupport();
612 MESH * meshField = supportField->getMesh();
614 // Well we must open vtk file first, because there are
615 // no other driver than MED for VTK that do it !
618 // first : field on node
619 // fields is on all node !
621 // second : field on cell
622 // fields is on all cell !
624 int dt = _ptrField->getIterationNumber();
625 int it = _ptrField->getOrderNumber();
628 string nameField = _ptrField->getName();
629 MED_EN::medEntityMesh entitySupport = supportField->getEntity();
630 name << nameField << "_" << dt << "_" << it ;
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));
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 ;
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));
642 int NomberOfValue = supportField->getNumberOfElements(MED_EN::MED_ALL_ELEMENTS) ;
643 int NomberOfComponents = _ptrField->getNumberOfComponents() ;
645 MED_EN::med_type_champ fieldType = _ptrField->getValueType() ;
651 case MED_EN::MED_INT32 :
655 case MED_EN::MED_REEL64 :
661 throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<< name.str() <<" the type is not int or double !"));
665 if (NomberOfComponents==3)
666 (*_vtkFile) << "VECTORS " << name.str() << " int" << endl ;
667 else if (NomberOfComponents<=4)
669 (*_vtkFile) << "SCALARS " << name.str() << " int " << NomberOfComponents << endl ;
670 (*_vtkFile) << "LOOKUP_TABLE default" << endl ;
673 throw MED_EXCEPTION(LOCALIZED(STRING(LOC) << "Could not write field "<<_ptrField->getName()<<" there are more than 4 components !"));
675 const T * value = _ptrField->getValue(MED_EN::MED_NO_INTERLACE) ;
677 for (int i=0; i<NomberOfValue; i++)
679 for(int j=0; j<NomberOfComponents; j++)
680 (*_vtkFile) << value[j*NomberOfValue+i] << " " ;
681 (*_vtkFile) << endl ;
685 }//End namespace MEDMEM
687 #endif /* VTK_FIELD_DRIVER_HXX */