22 #include <pugixml.hpp>
23 #include "boost/lexical_cast.hpp"
43 data_stream.read(
reinterpret_cast<char *
>(&val),
sizeof(val));
101 }
catch(ExcWrongType &e) {
102 e << EI_SectionTypeName(
"base parameter header_type");
110 THROW( ExcWrongType() << EI_ErrMessage(
"Forbidden") << EI_SectionTypeName(
"base parameter header_type")
111 << EI_VTKFile(
tok_.f_name()));
113 std::string compressor = vtk_node.attribute(
"compressor").as_string();
114 if (compressor ==
"vtkZLibDataCompressor")
120 pugi::xml_node piece_node = vtk_node.child(
"UnstructuredGrid").child(
"Piece");
121 n_nodes = piece_node.attribute(
"NumberOfPoints").as_uint();
122 n_elements = piece_node.attribute(
"NumberOfCells").as_uint();
128 Tokenizer::Position appended_pos;
132 tok_.set_position( Tokenizer::Position() );
133 if (!
tok_.skip_to(
"AppendedData"))
134 THROW(ExcMissingTag() << EI_TagType(
"tag") << EI_TagName(
"AppendedData") << EI_VTKFile(
tok_.f_name()) );
136 appended_pos =
tok_.get_position();
147 appended_pos.line_counter_++;
151 data_stream_ =
new std::ifstream(
tok_.f_name(), std::ios_base::in | std::ios_base::binary );
161 header.
field_name = node.attribute(
"Name").as_string();
165 }
catch(ExcWrongType &e) {
166 e << EI_SectionTypeName(
"DataArray " + header.
field_name);
169 if (disc == OutputTime::DiscreteSpace::NATIVE_DATA) {
170 header.
n_components = node.attribute(
"n_dofs_per_element").as_uint();
173 header.
n_components = node.attribute(
"NumberOfComponents").as_uint(1);
176 std::string
format = node.attribute(
"format").as_string();
179 THROW(ExcInvalidFormat() << EI_FieldName(header.
field_name) << EI_ExpectedFormat(
"ascii") << EI_VTKFile(
tok_.f_name()) );
180 std::streampos file_pos = pos.file_position_;
181 file_pos += node.attribute(
"offset").as_uint();
182 header.
position = Tokenizer::Position( file_pos, pos.line_counter_, pos.line_position_ );
183 }
else if (
format==
"ascii") {
185 THROW(ExcInvalidFormat() << EI_FieldName(header.
field_name) << EI_ExpectedFormat(
"appended") << EI_VTKFile(
tok_.f_name()) );
187 tok_.set_position( Tokenizer::Position() );
189 std::string found_str = (is_point) ?
"<Points>" :
"Name=\"" + header.
field_name +
"\"";
190 if (!
tok_.skip_to(found_str))
191 THROW(ExcMissingTag() << EI_TagType(
"DataArray tag") << EI_TagName(header.
field_name) << EI_VTKFile(
tok_.f_name()) );
193 if (is_point)
tok_.skip_to(
"DataArray");
197 THROW(ExcUnknownFormat() << EI_FieldName(header.
field_name) << EI_VTKFile(
tok_.f_name()) );
206 pugi::xml_document doc;
207 doc.load_file(
tok_.f_name().c_str() );
208 unsigned int n_nodes, n_elements;
215 Tokenizer::Position appended_pos;
222 pugi::xml_node node = doc.child(
"VTKFile").child(
"UnstructuredGrid").child(
"Piece");
227 auto points_header =
create_header( node.child(
"Points").child(
"DataArray"), n_nodes, appended_pos,
228 OutputTime::DiscreteSpace::MESH_DEFINITION );
229 points_header.field_name =
"Points";
230 header_table_.insert( std::pair<std::string, MeshDataHeader>(
"Points", points_header) );
231 auto con_header =
create_header( node.child(
"Cells").find_child_by_attribute(
"DataArray",
"Name",
"connectivity"),
232 n_elements, appended_pos, OutputTime::DiscreteSpace::MESH_DEFINITION );
233 header_table_.insert( std::pair<std::string, MeshDataHeader>(
"connectivity", con_header) );
234 auto offsets_header =
create_header( node.child(
"Cells").find_child_by_attribute(
"DataArray",
"Name",
"offsets"),
235 n_elements, appended_pos, OutputTime::DiscreteSpace::MESH_DEFINITION );
236 header_table_.insert( std::pair<std::string, MeshDataHeader>(
"offsets", offsets_header) );
237 auto types_header =
create_header( node.child(
"Cells").find_child_by_attribute(
"DataArray",
"Name",
"types"), n_elements,
238 appended_pos, OutputTime::DiscreteSpace::MESH_DEFINITION );
239 header_table_.insert( std::pair<std::string, MeshDataHeader>(
"types", types_header) );
241 pugi::xml_node point_node = node.child(
"PointData");
242 for (pugi::xml_node subnode = point_node.child(
"DataArray"); subnode; subnode = subnode.next_sibling(
"DataArray")) {
243 auto header =
create_header( subnode, n_nodes, appended_pos, OutputTime::DiscreteSpace::NODE_DATA );
244 header_table_.insert( std::pair<std::string, MeshDataHeader>(header.field_name, header) );
247 pugi::xml_node cell_node = node.child(
"CellData");
248 for (pugi::xml_node subnode = cell_node.child(
"DataArray"); subnode; subnode = subnode.next_sibling(
"DataArray")) {
249 auto header =
create_header( subnode, n_elements, appended_pos, OutputTime::DiscreteSpace::ELEM_DATA );
250 header_table_.insert( std::pair<std::string, MeshDataHeader>(header.field_name, header) );
253 pugi::xml_node native_node = node.child(
"Flow123dData");
254 for (pugi::xml_node subnode = native_node.child(
"DataArray"); subnode; subnode = subnode.next_sibling(
"DataArray")) {
255 auto header =
create_header( subnode, n_elements, appended_pos, OutputTime::DiscreteSpace::NATIVE_DATA );
256 header_table_.insert( std::pair<std::string, MeshDataHeader>(header.field_name, header) );
267 THROW( ExcFieldNameNotFound() << EI_FieldName(header_query.
field_name) << EI_MeshFile(
tok_.f_name()));
268 }
else if (count == 1) {
272 if (header_query.
discretization != table_it->second.discretization) {
273 if (header_query.
discretization != OutputTime::DiscreteSpace::UNDEFINED) {
275 "Invalid value of 'input_discretization' for field '{}', time: {}.\nCorrect discretization type will be used.\n",
281 if (header_query.
discretization == OutputTime::DiscreteSpace::NATIVE_DATA)
283 THROW(ExcInvalidDofHandler() << EI_FieldName(header_query.
field_name) << EI_VTKFile(
tok_.f_name()) );
285 return table_it->second;
294 THROW( ExcMissingFieldDiscretization() << EI_FieldName(header_query.
field_name) << EI_Time(header_query.
time) << EI_MeshFile(
tok_.f_name()));
317 if (
it != types.end()) {
320 THROW( ExcWrongType() << EI_ErrMessage(
"Unknown") << EI_VTKFile(
tok_.f_name()));
330 static const std::vector<unsigned int> sizes = { 1, 1, 2, 2, 4, 4, 8, 8, 4, 8, 0 };
332 return sizes[data_type];
340 case DataFormat::ascii: {
344 case DataFormat::binary_uncompressed: {
349 case DataFormat::binary_zlib: {
360 LogOut().fmt(
"time: {}; {} entities of field {} read.\n",
366 Tokenizer::Position pos)
370 tok_.set_position( pos );
373 for (
unsigned int i_row = 0; i_row < n_entities; ++i_row) {
377 }
catch (boost::bad_lexical_cast &) {
378 THROW(ExcWrongFormat() << EI_Type(
"DataArray tag") << EI_TokenizerMsg(
tok_.position_msg())
379 << EI_MeshFile(
tok_.f_name()) );
385 Tokenizer::Position pos)
392 for (
unsigned int i_row = 0; i_row < n_entities; ++i_row) {
400 Tokenizer::Position pos)
408 block_sizes.reserve(n_blocks);
409 for (uint64_t i = 0; i < n_blocks; ++i) {
413 stringstream decompressed_data;
414 uint64_t decompressed_data_size = 0;
415 for (uint64_t i = 0; i < n_blocks; ++i) {
416 uint64_t decompressed_block_size = (i==n_blocks-1 && p_size>0) ? p_size : u_size;
417 uint64_t compressed_block_size = block_sizes[i];
420 data_stream_->read(&data_block[0], compressed_block_size);
428 strm.next_in = (Bytef *)(&data_block[0]);
429 strm.avail_in = compressed_block_size;
430 strm.next_out = (Bytef *)(&buffer[0]);
431 strm.avail_out = decompressed_block_size;
435 inflate(&strm, Z_NO_FLUSH);
439 decompressed_data << std::string(buffer.begin(), buffer.end());
440 decompressed_data_size += decompressed_block_size;
445 for (
unsigned int i_row = 0; i_row < n_entities; ++i_row) {
466 unsigned int n_nodes = vect.size()/3;
469 for (
unsigned int i=0, ivec=0; i<n_nodes; ++i) {
470 point(0)=vect[ivec]; ++ivec;
471 point(1)=vect[ivec]; ++ivec;
472 point(2)=vect[ivec]; ++ivec;
483 ASSERT(offset_it !=
element_data_values_->end()).error(
"Missing cache of offsets section. Did you call create_node_element_caches()?\n");
488 ASSERT(conn_it !=
element_data_values_->end()).error(
"Missing cache of offsets section. Did you call create_node_element_caches()?\n");
496 unsigned int i_con = 0, last_offset=0, dim;
498 for (
unsigned int i=0; i<offsets_vec.size(); ++i) {
499 dim = offsets_vec[i] - last_offset - 1;
500 for ( ; i_con<offsets_vec[i]; ++i_con ) {
501 node_list.push_back( connectivity_vec[i_con] );
506 last_offset = offsets_vec[i];
521 HeaderQuery header_params(
"Points", 0.0, OutputTime::DiscreteSpace::MESH_DEFINITION);
522 auto point_header = this->
find_header(header_params);
523 this->get_element_data<double>(point_header, point_header.n_entities, point_header.n_components, point_header.n_entities);
526 HeaderQuery offsets_params(
"offsets", 0.0, OutputTime::DiscreteSpace::MESH_DEFINITION);
527 auto offset_header = this->
find_header(offsets_params);
528 std::vector<unsigned int> &offsets_vec = *( this->get_element_data<unsigned int>(offset_header, offset_header.n_entities, offset_header.n_components, offset_header.n_entities) );
531 HeaderQuery con_params(
"connectivity", 0.0, OutputTime::DiscreteSpace::MESH_DEFINITION);
533 con_header.n_entities = offsets_vec[offsets_vec.size()-1];
534 this->get_element_data<unsigned int>(con_header, con_header.n_entities, con_header.n_components, con_header.n_entities);
#define ASSERT_PERMANENT(expr)
Allow use shorter versions of macro names if these names is not used with external library.
#define ASSERT_PTR(ptr)
Definition of assert macro checking non-null pointer (PTR) only for debug mode.
vector< LongIdx > bulk_elements_id_
Tokenizer tok_
Tokenizer used for reading ASCII file format.
std::string data_section_name_
Store name of field data section specify for type of mesh file.
bool has_compatible_mesh_
std::shared_ptr< ElementDataFieldMap > element_data_values_
Cache with last read element data.
virtual void read_ascii_data(Tokenizer &tok, unsigned int n_components, unsigned int i_row)=0
virtual void read_binary_data(std::istream &data_stream, unsigned int n_components, unsigned int i_row)=0
CacheData get_data()
Return underlying vector of element data.
Dedicated class for storing path to input and output files.
void init_element_vector(unsigned int size)
Initialize element_vec_, set size and reset counters of boundary and bulk elements.
void init_node_vector(unsigned int size)
Initialize node_vec_, set size.
void add_node(unsigned int node_id, arma::vec3 coords)
Add new node of given id and coordinates to mesh.
void add_element(unsigned int elm_id, unsigned int dim, unsigned int region_id, unsigned int partition_id, std::vector< unsigned int > node_ids)
Add new element of given id to mesh.
void read_element_data(ElementDataCacheBase &data_cache, MeshDataHeader header) override
VtkMeshReader(const FilePath &file_name)
void parse_binary_data(ElementDataCacheBase &data_cache, unsigned int n_components, unsigned int n_entities, Tokenizer::Position pos)
Parse binary data to data cache.
virtual ~VtkMeshReader()
Destructor.
DataFormat data_format_
variants of data format (ascii, appended, compressed appended)
Tokenizer::Position get_appended_position()
Get position of AppendedData tag in VTK file.
void read_elements(Mesh *mesh)
MeshDataHeader create_header(pugi::xml_node node, unsigned int n_entities, Tokenizer::Position pos, OutputTime::DiscreteSpace disc)
Helper method that create DataArray header of given xml node (used from make_header_table)
HeaderTable header_table_
Table with data of DataArray headers.
static const double point_tolerance
Tolerance during comparison point data with GMSH nodes.
double time_step_
time of VTK file (getting only during initialization from PVD reader)
std::istream * data_stream_
input stream allow read appended data, used only if this tag exists
void parse_ascii_data(ElementDataCacheBase &data_cache, unsigned int n_components, unsigned int n_entities, Tokenizer::Position pos)
Parse ascii data to data cache.
void parse_compressed_data(ElementDataCacheBase &data_cache, unsigned int n_components, unsigned int n_entities, Tokenizer::Position pos)
Uncompress and parse binary compressed data to data cache.
unsigned int type_value_size(DataType data_type)
Return size of value of data_type.
void make_header_table() override
Reads table of DataArray headers through pugixml interface.
DataType get_data_type(std::string type_str)
Get DataType by value of string.
unsigned int n_read_
store count of read entities
DataType header_type_
header type of VTK file (only for appended data)
void read_nodes(Mesh *mesh)
void read_base_vtk_attributes(pugi::xml_node vtk_node, unsigned int &n_nodes, unsigned int &n_elements)
Set base attributes of VTK and get count of nodes and elements.
void create_node_element_caches()
void read_physical_names(Mesh *mesh) override
MeshDataHeader & find_header(HeaderQuery &header_query) override
#define THROW(whole_exception_expr)
Wrapper for throw. Saves the throwing point.
int LongIdx
Define type that represents indices of large arrays (elements, nodes, dofs etc.)
#define WarningOut()
Macro defining 'warning' record of log.
#define LogOut()
Macro defining 'log' record of log.
manipulators::Array< T, Delim > format(T const &deduce, Delim delim=", ")
DataType
Types of VTK data (value 'undefined' for empty value)
template uint64_t read_binary_value< uint64_t >(std::istream &data_stream)
template unsigned int read_binary_value< unsigned int >(std::istream &data_stream)
uint64_t read_header_type(DataType data_header_type, std::istream &data_stream)
T read_binary_value(std::istream &data_stream)