diff --git a/src/iohelper_common.hh b/src/iohelper_common.hh index 779d2b5..90e9282 100644 --- a/src/iohelper_common.hh +++ b/src/iohelper_common.hh @@ -1,297 +1,300 @@ /** * @file iohelper_common.hh * * @author Guillaume Anciaux * @author David Simon Kammer * @author Nicolas Richart * * @date creation: Thu Mar 11 2010 * @date last modification: Thu Oct 10 2013 * * @brief header for common types * * @section LICENSE * * Copyright (©) 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne) * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides) * * IOHelper is free software: you can redistribute it and/or modify it under the * terms of the GNU Lesser General Public License as published by the Free * Software Foundation, either version 3 of the License, or (at your option) any * later version. * * IOHelper is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. * * You should have received a copy of the GNU Lesser General Public License * along with IOHelper. If not, see . * */ /* -------------------------------------------------------------------------- */ #ifndef __IOHELPER_COMMON_H__ #define __IOHELPER_COMMON_H__ /* -------------------------------------------------------------------------- */ #define USING_ZLIB #include #include #include #define __BEGIN_IOHELPER__ namespace iohelper { #define __END_IOHELPER__ } #include #include /* -------------------------------------------------------------------------- */ __BEGIN_IOHELPER__ typedef unsigned int UInt; typedef int Int; typedef double Real; /* -------------------------------------------------------------------------- */ enum DataType { _bool, _uint, _int, _float, _double, _int64, _uint64, }; enum IndexingMode{ C_MODE = 0, FORTRAN_MODE = 1 }; /* -------------------------------------------------------------------------- */ #if __cplusplus <= 199711L enum ElemType { #else enum ElemType : unsigned int { #endif TRIANGLE1 , TRIANGLE2 , TETRA1 , TETRA2 , POINT_SET , LINE1 , LINE2 , QUAD1 , QUAD2 , HEX1 , HEX2 , BEAM2 , BEAM3 , PRISM1 , PRISM2 , COH2D4 , COH2D6 , COH3D6 , COH3D12 , COH3D8 , + COH3D16 , MAX_ELEM_TYPE }; /* -------------------------------------------------------------------------- */ enum FileStorageMode{ TEXT = 0, BASE64 = 1, COMPRESSED = 2 }; enum TextDumpMode { _tdm_space, _tdm_csv, }; /* -------------------------------------------------------------------------- */ static UInt nb_node_per_elem[MAX_ELEM_TYPE] __attribute__((unused)) = { 3, // TRIANGLE1 6, // TRIANGLE2 4, // TETRA1 10, // TETRA2 1, // POINT_SET 2, // LINE1 3, // LINE2 4, // QUAD1 8, // QUAD2 8, // HEX1 20, // HEX2 2, // BEAM2 2, // BEAM3 6, // PRISM1 15, // PRISM2 4, // COH2D4 6, // COH2D6 6, // COH3D6 12, // COH3D12 - 8 // COH3D8 + 8, // COH3D8 + 16 // COH3D16 }; /* -------------------------------------------------------------------------- */ static UInt nb_quad_points[MAX_ELEM_TYPE] __attribute__((unused)) = { 1, // TRIANGLE1 3, // TRIANGLE2 1, // TETRA1 4, // TETRA2 0, // POINT_SET 1, // LINE1 2, // LINE2 4, // QUAD1 9, // QUAD2 8, // HEX1 27, // HEX2 2, // BEAM2 3, // BEAM3 6, // PRISM1 8, // PRISM2 1, // COH2D4 2, // COH2D6 1, // COH3D6 3, // COH3D12 - 1 // COH3D8 + 1, // COH3D8 + 8 // COH3D16 }; /* -------------------------------------------------------------------------- */ template class IOHelperVector { public: virtual ~IOHelperVector() {} inline IOHelperVector(T * ptr, UInt size){ this->ptr = ptr; this->_size = size; }; inline UInt size() const {return _size;}; inline const T & operator[] (UInt i) const { return ptr[i]; }; inline const T * getPtr() const { return ptr; }; private: T* ptr; UInt _size; }; /* -------------------------------------------------------------------------- */ /* Iterator interface */ /* -------------------------------------------------------------------------- */ template< typename T, class daughter, class ret_cont = IOHelperVector > class iterator { public: typedef ret_cont type; virtual ~iterator() {} virtual bool operator!=(const daughter & it) const = 0; virtual daughter & operator++() = 0; virtual ret_cont operator*() = 0; //! This function is only for the element iterators virtual ElemType element_type() { return MAX_ELEM_TYPE; } }; /* -------------------------------------------------------------------------- */ class IOHelperException : public std::exception { public: enum ErrorType { _et_non_homogeneous_data, _et_unknown_visitor_stage, _et_file_error, _et_missing_field, _et_data_type, _et_options_error }; public: IOHelperException(const std::string & message, const ErrorType type) throw() { this->message = message; this->type = type; }; ~IOHelperException() throw(){}; virtual const char* what() const throw(){ return message.c_str(); }; private: std::string message; ErrorType type; }; /* -------------------------------------------------------------------------- */ #define IOHELPER_THROW(x,type) { \ std::stringstream ioh_throw_sstr; \ ioh_throw_sstr << __FILE__ << ":" << __LINE__ << ":" \ << __PRETTY_FUNCTION__ << ": " << x; \ std::string ioh_message(ioh_throw_sstr.str()); \ throw ::iohelper::IOHelperException(ioh_message, \ ::iohelper::IOHelperException::type); \ } /* -------------------------------------------------------------------------- */ template DataType getDataType(); #define DEFINE_GET_DATA_TYPE(type, data_type ) \ template <> inline DataType getDataType() { return data_type; } DEFINE_GET_DATA_TYPE(bool, _bool) DEFINE_GET_DATA_TYPE(ElemType, _int) DEFINE_GET_DATA_TYPE(int, _int) DEFINE_GET_DATA_TYPE(unsigned int, _uint) DEFINE_GET_DATA_TYPE(float, _float) DEFINE_GET_DATA_TYPE(double, _double) DEFINE_GET_DATA_TYPE(long int, _int64) DEFINE_GET_DATA_TYPE(unsigned long int, _uint64) #undef DEFINE_GET_DATA_TYPE inline std::ostream & operator <<(std::ostream & stream, DataType type) { switch(type) { case _bool : stream << "bool" ; break; case _uint : stream << "uint32" ; break; case _int : stream << "int32" ; break; case _float : stream << "float32" ; break; case _double : stream << "float64" ; break; case _uint64 : stream << "uint64" ; break; case _int64 : stream << "int64" ; break; } return stream; } inline std::ostream & operator <<(std::ostream & stream, TextDumpMode mode) { switch(mode) { case _tdm_space : stream << "space" ; break; case _tdm_csv : stream << "csv" ; break; } return stream; } __END_IOHELPER__ #endif /* __IOHELPER_COMMON_H__ */ diff --git a/src/paraview_helper.cc b/src/paraview_helper.cc index 5a8f53a..97bf709 100644 --- a/src/paraview_helper.cc +++ b/src/paraview_helper.cc @@ -1,298 +1,299 @@ /** * @file paraview_helper.cc * * @author Guillaume Anciaux * @author Nicolas Richart * * @date creation: Fri Oct 12 2012 * @date last modification: Wed Jun 05 2013 * * @brief implementation of paraview helper * * @section LICENSE * * Copyright (©) 2010-2012, 2014 EPFL (Ecole Polytechnique Fédérale de Lausanne) * Laboratory (LSMS - Laboratoire de Simulation en Mécanique des Solides) * * IOHelper is free software: you can redistribute it and/or modify it under the * terms of the GNU Lesser General Public License as published by the Free * Software Foundation, either version 3 of the License, or (at your option) any * later version. * * IOHelper is distributed in the hope that it will be useful, but WITHOUT ANY * WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR * A PARTICULAR PURPOSE. See the GNU Lesser General Public License for more * details. * * You should have received a copy of the GNU Lesser General Public License * along with IOHelper. If not, see . * */ #include "paraview_helper.hh" #include /* -------------------------------------------------------------------------- */ #if defined(__INTEL_COMPILER) /// remark #981: operands are evaluated in unspecified order #pragma warning ( disable : 981 ) /// remark #383: value copied to temporary, reference to temporary used #pragma warning ( disable : 383 ) #endif //defined(__INTEL_COMPILER) __BEGIN_IOHELPER__ /* -------------------------------------------------------------------------- */ ParaviewHelper::ParaviewHelper(File & f, UInt mode): b64(f), file(f), position_flag(false) { bflag = BASE64; compteur = 0; setMode(mode); this->paraview_code_type[TRIANGLE1] = VTK_TRIANGLE; this->paraview_code_type[TRIANGLE2] = VTK_QUADRATIC_TRIANGLE; this->paraview_code_type[TETRA1 ] = VTK_TETRA; this->paraview_code_type[TETRA2 ] = VTK_QUADRATIC_TETRA; this->paraview_code_type[POINT_SET] = VTK_POLY_VERTEX; this->paraview_code_type[LINE1 ] = VTK_LINE; this->paraview_code_type[LINE2 ] = VTK_QUADRATIC_EDGE; this->paraview_code_type[QUAD1 ] = VTK_QUAD; this->paraview_code_type[QUAD2 ] = VTK_QUADRATIC_QUAD; this->paraview_code_type[HEX1 ] = VTK_HEXAHEDRON; this->paraview_code_type[HEX2 ] = VTK_QUADRATIC_HEXAHEDRON; this->paraview_code_type[BEAM2 ] = VTK_LINE; this->paraview_code_type[BEAM3 ] = VTK_LINE; this->paraview_code_type[PRISM1 ] = VTK_WEDGE; this->paraview_code_type[PRISM2 ] = VTK_QUADRATIC_WEDGE; this->paraview_code_type[COH2D4 ] = VTK_POLYGON; this->paraview_code_type[COH2D6 ] = VTK_POLYGON; this->paraview_code_type[COH3D6 ] = VTK_WEDGE; this->paraview_code_type[COH3D12 ] = VTK_QUADRATIC_LINEAR_WEDGE; this->paraview_code_type[COH3D8 ] = VTK_HEXAHEDRON; + this->paraview_code_type[COH3D16 ] = VTK_QUADRATIC_LINEAR_HEXAHEDRON; std::map::iterator it; for(it = paraview_code_type.begin(); it != paraview_code_type.end(); ++it) { UInt nb_nodes = nb_node_per_elem[it->first]; UInt * tmp = new UInt[nb_nodes]; for (UInt i = 0; i < nb_nodes; ++i) { tmp[i] = i; } switch(it->first) { case COH2D6: tmp[0] = 0; tmp[1] = 2; tmp[2] = 1; tmp[3] = 4; tmp[4] = 5; tmp[5] = 3; break; case COH2D4: tmp[0] = 0; tmp[1] = 1; tmp[2] = 3; tmp[3] = 2; break; case HEX2: tmp[12] = 16; tmp[13] = 17; tmp[14] = 18; tmp[15] = 19; tmp[16] = 12; tmp[17] = 13; tmp[18] = 14; tmp[19] = 15; break; case PRISM2: tmp[ 0] = 0; tmp[ 1] = 1; tmp[ 2] = 2; tmp[ 3] = 3; tmp[ 4] = 4; tmp[ 5] = 5; tmp[ 6] = 6; tmp[ 7] = 7; tmp[ 8] = 8; tmp[ 9] = 12; tmp[10] = 13; tmp[11] = 14; tmp[12] = 9; tmp[13] = 10; tmp[14] = 11; break; default: //nothing to change break; } this->write_reorder[it->first] = tmp; } } /* -------------------------------------------------------------------------- */ ParaviewHelper::~ParaviewHelper(){ std::map::iterator it; for(it = this->paraview_code_type.begin(); it != this->paraview_code_type.end(); ++it) { delete [] this->write_reorder[it->first]; } } /* -------------------------------------------------------------------------- */ void ParaviewHelper::writeTimePVD(const std::string & filename, const std::vector< std::pair > & pvtus) { std::ofstream pvd_file; pvd_file.open(filename.c_str()); if(!pvd_file.good()) { IOHELPER_THROW("DumperParaview was not able to open the file \"" << filename, _et_file_error); } pvd_file << "" << std::endl << "" << std::endl << " " << std::endl; std::vector< std::pair >::const_iterator it = pvtus.begin(); std::vector< std::pair >::const_iterator end = pvtus.end(); for (;it != end; ++it) { pvd_file << " first << "\" group=\"\" part=\"0\" file=\"" << it->second << "\"/>" << std::endl; } pvd_file << " " << std::endl << "" << std::endl; pvd_file.close(); } /* -------------------------------------------------------------------------- */ void ParaviewHelper::writeHeader(int nb_nodes,int nb_elems){ file << "" << std::endl; file << " " << std::endl << " " << std::endl; } /* -------------------------------------------------------------------------- */ void ParaviewHelper::PDataArray(const std::string & name, int nb_components, const std::string & type){ file << " " << std::endl; } /* -------------------------------------------------------------------------- */ void ParaviewHelper::write_conclusion(){ file << " " << std::endl; file << " " << std::endl; file << "" << std::endl; } /* -------------------------------------------------------------------------- */ void ParaviewHelper::startData(const std::string & name, int nb_components, const std::string & type){ file << " " << std::endl; if (bflag == BASE64) b64.CreateHeader(); } /* -------------------------------------------------------------------------- */ void ParaviewHelper::endData(){ if (bflag == BASE64) b64.WriteHeader(); file << std::endl << " " << std::endl; } /* -------------------------------------------------------------------------- */ void ParaviewHelper::startDofList(int dimension){ file << " " << std::endl; startData("positions", dimension, "Float64"); } /* -------------------------------------------------------------------------- */ void ParaviewHelper::endDofList(){ endData(); file << " " << std::endl; } /* -------------------------------------------------------------------------- */ void ParaviewHelper::startCells(){ file << " " << std::endl; } /* -------------------------------------------------------------------------- */ void ParaviewHelper::endCells(){ file << " " << std::endl; } /* -------------------------------------------------------------------------- */ void ParaviewHelper::startCellsConnectivityList(){ startData("connectivity",0,"Int32"); } /* -------------------------------------------------------------------------- */ void ParaviewHelper::endCellsConnectivityList(){ endData(); } /* -------------------------------------------------------------------------- */ void ParaviewHelper::startCellsoffsetsList(){ startData("offsets",0,"Int32"); } /* -------------------------------------------------------------------------- */ void ParaviewHelper::endCellsoffsetsList(){ endData(); } /* -------------------------------------------------------------------------- */ void ParaviewHelper::startCellstypesList(){ startData("types",0,"UInt32"); } /* -------------------------------------------------------------------------- */ void ParaviewHelper::endCellstypesList(){ endData(); } /* -------------------------------------------------------------------------- */ void ParaviewHelper::startPointDataList(){ file << " " << std::endl; } /* -------------------------------------------------------------------------- */ void ParaviewHelper::endPointDataList(){ file << " " << std::endl; } /* -------------------------------------------------------------------------- */ void ParaviewHelper::startCellDataList(){ file << " " << std::endl; } /* -------------------------------------------------------------------------- */ void ParaviewHelper::endCellDataList(){ file << " " << std::endl; } /* -------------------------------------------------------------------------- */ __END_IOHELPER__