OGS
PVTU2VTU.cpp
Go to the documentation of this file.
1
11
12#include <tclap/CmdLine.h>
13
14#include <algorithm>
15#include <boost/property_tree/ptree.hpp>
16#include <boost/property_tree/xml_parser.hpp>
17#include <filesystem>
18#include <fstream>
19#include <memory>
20#include <numeric>
21#include <range/v3/algorithm/copy.hpp>
22#include <range/v3/algorithm/transform.hpp>
23#include <range/v3/numeric/accumulate.hpp>
24#include <range/v3/range/conversion.hpp>
25#include <range/v3/view/filter.hpp>
26#include <string>
27#include <unordered_set>
28#include <vector>
29
30#include "BaseLib/FileTools.h"
31#include "BaseLib/Logging.h"
32#include "BaseLib/MPI.h"
33#include "BaseLib/RunTime.h"
35#include "GeoLib/AABB.h"
36#include "GeoLib/OctTree.h"
37#include "InfoLib/GitInfo.h"
38#include "MathLib/Point3d.h"
41#include "MeshLib/Mesh.h"
42#include "MeshLib/Node.h"
43#include "MeshLib/Properties.h"
47
49{
50 std::size_t partition_id;
51 std::size_t original_id;
52};
53
54template <typename T>
56 MeshLib::Mesh& merged_mesh,
57 std::vector<std::unique_ptr<MeshLib::Mesh>> const& partitioned_meshes,
58 MeshLib::PropertyVector<T> const* const pv,
59 MeshLib::Properties const& properties,
60 std::vector<MeshEntityMapInfo> const& merged_node_map,
61 std::vector<MeshEntityMapInfo> const& merged_element_map)
62{
63 if (pv == nullptr)
64 {
65 return false;
66 }
67
68 if (pv->getPropertyName() == "vtkGhostType")
69 {
70 // Do nothing
71 return true;
72 }
73
74 auto const item_type = pv->getMeshItemType();
75
76 auto const pv_name = pv->getPropertyName();
77
78 auto const pv_num_components = pv->getNumberOfGlobalComponents();
79
80 if (pv_name == "OGS_VERSION" || pv_name == "IntegrationPointMetaData")
81 {
83 merged_mesh, pv_name, item_type, pv_num_components);
84 new_pv->assign(*pv);
85
86 return true;
87 }
88
89 std::vector<MeshLib::PropertyVector<T>*> partition_property_vectors;
90 partition_property_vectors.reserve(partitioned_meshes.size());
91 for (auto const& mesh : partitioned_meshes)
92 {
93 partition_property_vectors.emplace_back(
94 mesh->getProperties().getPropertyVector<T>(pv_name, item_type,
95 pv_num_components));
96 }
97
98 auto createNewCellOrNodePropertyVector =
99 [&](std::vector<MeshEntityMapInfo> const& mesh_entity_map)
100 {
102 merged_mesh, pv_name, item_type, pv_num_components);
103 std::size_t counter = 0;
104 for (auto const& entity_info : mesh_entity_map)
105 {
106 auto const& partition_pv =
107 partition_property_vectors[entity_info.partition_id];
108 for (int i_com = 0; i_com < pv_num_components; i_com++)
109 {
110 (*new_pv)[counter * pv_num_components + i_com] =
111 (*partition_pv)[entity_info.original_id *
112 pv_num_components +
113 i_com];
114 }
115 counter++;
116 }
117 };
118
119 if (item_type == MeshLib::MeshItemType::Node)
120 {
121 createNewCellOrNodePropertyVector(merged_node_map);
122 return true;
123 }
124
125 if (item_type == MeshLib::MeshItemType::Cell)
126 {
127 createNewCellOrNodePropertyVector(merged_element_map);
128 return true;
129 }
130
132 {
133 std::vector<std::vector<std::size_t>> partition_element_offsets;
134 partition_element_offsets.reserve(partitioned_meshes.size());
135 for (auto const& mesh : partitioned_meshes)
136 {
137 partition_element_offsets.emplace_back(
139 mesh->getElements(), *pv, properties));
140 }
141
143 merged_mesh, pv_name, item_type, pv_num_components);
144
145 // Count the integration points
146 auto const ip_meta_data =
148 MeshLib::getIntegrationPointMetaData(properties), pv_name);
149
150 auto number_of_integration_points = [&](auto const* element)
151 {
153 ip_meta_data, *element);
154 };
155
156 std::size_t const counter = ranges::accumulate(
157 merged_mesh.getElements() |
158 ranges::views::transform(number_of_integration_points),
159 std::size_t{0});
160 new_pv->resize(counter * pv_num_components);
161
162 auto const global_ip_offsets =
164 merged_mesh.getElements(), *pv, properties);
165
166 std::size_t element_counter = 0;
167 for (auto const& element_info : merged_element_map)
168 {
169 MeshLib::PropertyVector<T> const& partition_pv =
170 *(partition_property_vectors[element_info.partition_id]);
171
172 auto const& offsets =
173 partition_element_offsets[element_info.partition_id];
174
175 int const begin_pos = offsets[element_info.original_id];
176 int const end_pos = offsets[element_info.original_id + 1];
177
178 std::copy(partition_pv.begin() + begin_pos,
179 partition_pv.begin() + end_pos,
180 new_pv->begin() + global_ip_offsets[element_counter]);
181
182 element_counter++;
183 }
184 }
185
186 return true;
187}
188
189std::vector<std::string> readVtuFileNames(std::string const& pvtu_file_name)
190{
191 std::ifstream ins(pvtu_file_name);
192
193 if (!ins)
194 {
195 OGS_FATAL("Could not open pvtu file {:s}.", pvtu_file_name);
196 }
197
198 using boost::property_tree::ptree;
199 ptree pt;
200 read_xml(ins, pt);
201
202 auto root = pt.get_child("VTKFile");
203
204 std::vector<std::string> vtu_file_names;
205
206 std::string file_path = BaseLib::extractPath(pvtu_file_name);
207
208 for (ptree::value_type const& v : root.get_child("PUnstructuredGrid"))
209 {
210 if (v.first == "Piece")
211 {
212 vtu_file_names.push_back(BaseLib::joinPaths(
213 file_path,
214 // only gets the vtu file name:
215 std::filesystem::path(v.second.get("<xmlattr>.Source", ""))
216 .filename()
217 .string()));
218 }
219 }
220
221 if (vtu_file_names.empty())
222 {
223 OGS_FATAL("PVTU file {:s} does not contain any vtu piece",
224 pvtu_file_name);
225 }
226
227 return vtu_file_names;
228}
229
230// all nodes (also 'ghost' nodes) of all meshes sorted by partition
231std::tuple<std::vector<MeshLib::Node*>, std::vector<std::size_t>>
232getMergedNodesVector(std::vector<std::unique_ptr<MeshLib::Mesh>> const& meshes)
233{
234 std::vector<std::size_t> number_of_nodes_per_partition;
235 ranges::transform(meshes, std::back_inserter(number_of_nodes_per_partition),
236 [](auto const& mesh)
237 { return mesh->getNumberOfNodes(); });
238 std::vector<std::size_t> const offsets =
239 BaseLib::sizesToOffsets(number_of_nodes_per_partition);
240
241 std::vector<MeshLib::Node*> all_nodes;
242 all_nodes.reserve(offsets.back());
243 for (auto const& mesh : meshes)
244 {
245 ranges::copy(mesh->getNodes(), std::back_inserter(all_nodes));
246 }
247 return {all_nodes, offsets};
248}
249
250std::tuple<std::vector<MeshLib::Element*>, std::vector<MeshEntityMapInfo>>
251getRegularElements(std::vector<std::unique_ptr<MeshLib::Mesh>> const& meshes)
252{
253 std::vector<MeshLib::Element*> regular_elements;
254
255 std::size_t partition_counter = 0;
256 std::vector<MeshEntityMapInfo> merged_element_map;
257 for (auto const& mesh : meshes)
258 {
259 MeshLib::Properties const& properties = mesh->getProperties();
260
261 auto const* const ghost_id_vector =
262 properties.getPropertyVector<unsigned char>("vtkGhostType");
263 assert(ghost_id_vector);
264
265 auto const& mesh_elements = mesh->getElements();
266
267 auto const last_element_id_of_previous_partition =
268 regular_elements.size();
269
270 auto is_regular_element = [&](MeshLib::Element const* element)
271 { return (*ghost_id_vector)[element->getID()] == 0; };
272
273 auto regular_mesh_elements =
274 mesh_elements | ranges::views::filter(is_regular_element);
275 regular_elements.insert(regular_elements.end(),
276 regular_mesh_elements.begin(),
277 regular_mesh_elements.end());
278
279 for (auto element_id = last_element_id_of_previous_partition;
280 element_id < regular_elements.size();
281 element_id++)
282 {
283 merged_element_map.push_back(
284 {partition_counter, regular_elements[element_id]->getID()});
285 }
286
287 partition_counter++;
288 }
289
290 return {regular_elements, merged_element_map};
291}
292
294 GeoLib::OctTree<MeshLib::Node, 16>& oct_tree, Eigen::Vector3d const& extent,
295 MeshLib::Node const& node, std::size_t const element_id)
296{
297 std::vector<MeshLib::Node*> query_nodes;
298 auto const eps =
299 std::numeric_limits<double>::epsilon() * extent.squaredNorm();
300 Eigen::Vector3d const min = node.asEigenVector3d().array() - eps;
301 auto constexpr dir = std::numeric_limits<double>::max();
302 Eigen::Vector3d const max = {std::nextafter(node[0] + eps, dir),
303 std::nextafter(node[1] + eps, dir),
304 std::nextafter(node[2] + eps, dir)};
305 oct_tree.getPointsInRange(min, max, query_nodes);
306
307 if (query_nodes.empty())
308 {
309 OGS_FATAL(
310 "query_nodes for node [{}], ({}, {}, {}) of element "
311 "[{}] are empty, eps is {}",
312 node.getID(), node[0], node[1], node[2], element_id, eps);
313 }
314 auto const it =
315 std::find_if(query_nodes.begin(), query_nodes.end(),
316 [&node, eps](auto const* p)
317 {
318 return (p->asEigenVector3d() - node.asEigenVector3d())
319 .squaredNorm() < eps;
320 });
321 if (it == query_nodes.end())
322 {
323 OGS_FATAL(
324 "did not find node: [{}] ({}, {}, {}) of element [{}] in "
325 "query_nodes",
326 node.getID(), node[0], node[1], node[2], element_id);
327 }
328 return *it;
329}
330
332 std::vector<MeshLib::Element*> const& regular_elements,
334 Eigen::Vector3d const& extent)
335{
336 for (auto& e : regular_elements)
337 {
338 for (unsigned i = 0; i < e->getNumberOfNodes(); i++)
339 {
340 auto* const node = e->getNode(i);
341 MeshLib::Node* node_ptr = nullptr;
342 if (!oct_tree.addPoint(node, node_ptr))
343 {
344 auto const node_ptr = getExistingNodeFromOctTree(
345 oct_tree, extent, *node, e->getID());
346 e->setNode(i, node_ptr);
347 }
348 }
349 }
350}
351
352std::pair<std::vector<MeshLib::Node*>, std::vector<MeshEntityMapInfo>>
353makeNodesUnique(std::vector<MeshLib::Node*> const& all_merged_nodes_tmp,
354 std::vector<std::size_t> const& partition_offsets,
356{
357 std::vector<MeshLib::Node*> unique_merged_nodes;
358 unique_merged_nodes.reserve(all_merged_nodes_tmp.size());
359
360 std::vector<MeshEntityMapInfo> merged_node_map;
361 merged_node_map.reserve(all_merged_nodes_tmp.size());
362
363 for (std::size_t i = 0; i < partition_offsets.size() - 1; ++i)
364 {
365 for (std::size_t pos = partition_offsets[i];
366 pos < partition_offsets[i + 1];
367 ++pos)
368 {
369 auto* node = all_merged_nodes_tmp[pos];
370 MeshLib::Node* node_ptr = nullptr;
371 if (oct_tree.addPoint(node, node_ptr))
372 {
373 unique_merged_nodes.push_back(node);
374 merged_node_map.push_back({i, pos - partition_offsets[i]});
375 }
376 }
377 }
378 return {unique_merged_nodes, merged_node_map};
379}
380
381int main(int argc, char* argv[])
382{
383 TCLAP::CmdLine cmd(
384 "This tool merges VTU files of PVTU into one single VTU file. Apart "
385 "from the mesh data, all property data are merged as well"
386 "\n\nOpenGeoSys-6 software, version " +
388 ".\n"
389 "Copyright (c) 2012-2025, OpenGeoSys Community "
390 "(http://www.opengeosys.org)",
392
393 TCLAP::ValueArg<std::string> output_arg(
394 "o", "output", "Output (.vtu). The output mesh file (format = *.vtu)",
395 true, "", "OUTPUT_FILE");
396 cmd.add(output_arg);
397
398 TCLAP::ValueArg<std::string> input_arg(
399 "i", "input", "Input (.pvtu). The partitioned input mesh file", true,
400 "", "INPUT_FILE");
401 cmd.add(input_arg);
402 auto log_level_arg = BaseLib::makeLogLevelArg();
403 cmd.add(log_level_arg);
404 cmd.parse(argc, argv);
405
406 BaseLib::MPI::Setup mpi_setup(argc, argv);
407 BaseLib::initOGSLogger(log_level_arg.getValue());
408
409 if (BaseLib::getFileExtension(input_arg.getValue()) != ".pvtu")
410 {
411 OGS_FATAL("The extension of input file name {:s} is not \"pvtu\"",
412 input_arg.getValue());
413 }
414 if (BaseLib::getFileExtension(output_arg.getValue()) != ".vtu")
415 {
416 OGS_FATAL("The extension of output file name {:s} is not \"vtu\"",
417 output_arg.getValue());
418 }
419
420 auto const vtu_file_names = readVtuFileNames(input_arg.getValue());
421
422 std::vector<std::unique_ptr<MeshLib::Mesh>> meshes;
423 meshes.reserve(vtu_file_names.size());
424
425 BaseLib::RunTime io_timer;
426 io_timer.start();
427 for (auto const& file_name : vtu_file_names)
428 {
429 auto mesh = std::unique_ptr<MeshLib::Mesh>(
431
432 MeshLib::Properties const& properties = mesh->getProperties();
433
434 if (!properties.existsPropertyVector<unsigned char>("vtkGhostType"))
435 {
436 OGS_FATAL(
437 "Property vector vtkGhostType does not exist in mesh {:s}.",
438 file_name);
439 }
440
441 meshes.emplace_back(std::move(mesh));
442 }
443 INFO("Reading meshes took {} s", io_timer.elapsed());
444
445 BaseLib::RunTime merged_element_timer;
446 merged_element_timer.start();
447 // If structured binding is used for the returned tuple, Mac compiler gives
448 // an error in reference to local binding in calling applyToPropertyVectors.
449 auto [regular_elements, merged_element_map] = getRegularElements(meshes);
450 INFO(
451 "Collection of {} regular elements and computing element map took {} s",
452 regular_elements.size(), merged_element_timer.elapsed());
453
454 // alternative implementation of getNodesOfRegularElements
455 BaseLib::RunTime collect_nodes_timer;
456 collect_nodes_timer.start();
457 auto [all_merged_nodes_tmp, partition_offsets] =
458 getMergedNodesVector(meshes);
459 INFO("Collection of {} nodes and computing offsets took {} s",
460 all_merged_nodes_tmp.size(), collect_nodes_timer.elapsed());
461
462 BaseLib::RunTime merged_nodes_timer;
463 merged_nodes_timer.start();
464 GeoLib::AABB aabb(all_merged_nodes_tmp.begin(), all_merged_nodes_tmp.end());
465 auto oct_tree = std::unique_ptr<GeoLib::OctTree<MeshLib::Node, 16>>(
467 aabb.getMinPoint(), aabb.getMaxPoint(), 1e-16));
468
469 auto [unique_merged_nodes, merged_node_map] =
470 makeNodesUnique(all_merged_nodes_tmp, partition_offsets, *oct_tree);
471 INFO("Make nodes unique ({} unique nodes) / computing map took {} s",
472 unique_merged_nodes.size(), merged_nodes_timer.elapsed());
473
474 BaseLib::RunTime reset_nodes_in_elements_timer;
475 reset_nodes_in_elements_timer.start();
476 auto const extent = aabb.getMaxPoint() - aabb.getMinPoint();
477 resetNodesInRegularElements(regular_elements, *oct_tree, extent);
478 INFO("Reset nodes in regular elements took {} s",
479 reset_nodes_in_elements_timer.elapsed());
480
481 BaseLib::RunTime mesh_creation_timer;
482 mesh_creation_timer.start();
483 // The Node pointers of 'merged_nodes' and Element pointers of
484 // 'regular_elements' are shared with 'meshes', the partitioned meshes.
485 MeshLib::Mesh merged_mesh =
486 MeshLib::Mesh("pvtu_merged_mesh", unique_merged_nodes, regular_elements,
487 false /* compute_element_neighbors */);
488 INFO("creation of merged mesh took {} s", mesh_creation_timer.elapsed());
489
490 auto const& properties = meshes[0]->getProperties();
491
492 BaseLib::RunTime property_timer;
493 property_timer.start();
495 properties,
496 [&, &merged_node_map = merged_node_map,
497 &merged_element_map = merged_element_map](auto type,
498 auto const& property)
499 {
501 merged_mesh, meshes,
502 dynamic_cast<MeshLib::PropertyVector<decltype(type)> const*>(
503 property),
504 properties, merged_node_map, merged_element_map);
505 });
506 INFO("merge properties into merged mesh took {} s",
507 property_timer.elapsed());
508
509 MeshLib::IO::VtuInterface writer(&merged_mesh);
510
511 BaseLib::RunTime writing_timer;
512 writing_timer.start();
513 auto const result = writer.writeToFile(output_arg.getValue());
514 if (!result)
515 {
516 ERR("Could not write mesh to '{:s}'.", output_arg.getValue());
517 return EXIT_FAILURE;
518 }
519 INFO("writing mesh took {} s", writing_timer.elapsed());
520
521 // Since the Node pointers of 'merged_nodes' and Element pointers of
522 // 'regular_elements' are held by 'meshes', the partitioned meshes, the
523 // memory by these pointers are released by 'meshes' automatically.
524 // Therefore, only node vector and element vector of merged_mesh should be
525 // cleaned.
526 merged_mesh.shallowClean();
527
528 return EXIT_SUCCESS;
529}
Definition of the AABB class.
Definition of the Element class.
#define OGS_FATAL(...)
Definition Error.h:26
Filename manipulation routines.
Git information.
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:36
void ERR(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:48
Definition of the class Properties that implements a container of properties.
Definition of the Mesh class.
Definition of the Node class.
Implementation of the OctTree class.
int main(int argc, char *argv[])
Definition PVTU2VTU.cpp:381
std::pair< std::vector< MeshLib::Node * >, std::vector< MeshEntityMapInfo > > makeNodesUnique(std::vector< MeshLib::Node * > const &all_merged_nodes_tmp, std::vector< std::size_t > const &partition_offsets, GeoLib::OctTree< MeshLib::Node, 16 > &oct_tree)
Definition PVTU2VTU.cpp:353
MeshLib::Node * getExistingNodeFromOctTree(GeoLib::OctTree< MeshLib::Node, 16 > &oct_tree, Eigen::Vector3d const &extent, MeshLib::Node const &node, std::size_t const element_id)
Definition PVTU2VTU.cpp:293
void resetNodesInRegularElements(std::vector< MeshLib::Element * > const &regular_elements, GeoLib::OctTree< MeshLib::Node, 16 > &oct_tree, Eigen::Vector3d const &extent)
Definition PVTU2VTU.cpp:331
std::tuple< std::vector< MeshLib::Element * >, std::vector< MeshEntityMapInfo > > getRegularElements(std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes)
Definition PVTU2VTU.cpp:251
std::vector< std::string > readVtuFileNames(std::string const &pvtu_file_name)
Definition PVTU2VTU.cpp:189
bool createPropertyVector(MeshLib::Mesh &merged_mesh, std::vector< std::unique_ptr< MeshLib::Mesh > > const &partitioned_meshes, MeshLib::PropertyVector< T > const *const pv, MeshLib::Properties const &properties, std::vector< MeshEntityMapInfo > const &merged_node_map, std::vector< MeshEntityMapInfo > const &merged_element_map)
Definition PVTU2VTU.cpp:55
std::tuple< std::vector< MeshLib::Node * >, std::vector< std::size_t > > getMergedNodesVector(std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes)
Definition PVTU2VTU.cpp:232
Definition of the Point3d class.
void applyToPropertyVectors(Properties const &properties, Function f)
Definition of the RunTime class.
Implementation of the VtuInterface class.
Count the running time.
Definition RunTime.h:29
double elapsed() const
Get the elapsed time in seconds.
Definition RunTime.h:42
void start()
Start the timer.
Definition RunTime.h:32
Class AABB is an axis aligned bounding box around a given set of geometric points of (template) type ...
Definition AABB.h:56
Eigen::Vector3d const & getMaxPoint() const
Definition AABB.h:187
Eigen::Vector3d const & getMinPoint() const
Definition AABB.h:180
bool addPoint(POINT *pnt, POINT *&ret_pnt)
void getPointsInRange(T const &min, T const &max, std::vector< POINT * > &pnts) const
static OctTree< POINT, MAX_POINTS > * createOctTree(Eigen::Vector3d ll, Eigen::Vector3d ur, double eps=std::numeric_limits< double >::epsilon())
std::size_t getID() const
Eigen::Vector3d const & asEigenVector3d() const
Definition Point3d.h:64
Reads and writes VtkXMLUnstructuredGrid-files (vtu) to and from OGS data structures....
static MeshLib::Mesh * readVTUFile(std::string const &file_name, bool const compute_element_neighbors=false)
bool writeToFile(std::filesystem::path const &file_path)
std::vector< Element * > const & getElements() const
Get the element-vector for the mesh.
Definition Mesh.h:111
void shallowClean()
Definition Mesh.cpp:134
Property manager on mesh items. Class Properties manages scalar, vector or matrix properties....
Definition Properties.h:33
bool existsPropertyVector(std::string_view name) const
Definition Properties.h:93
PropertyVector< T > const * getPropertyVector(std::string_view name) const
MeshItemType getMeshItemType() const
int getNumberOfGlobalComponents() const
std::string const & getPropertyName() const
constexpr PROP_VAL_TYPE * begin()
TCLAP::ValueArg< std::string > makeLogLevelArg()
void initOGSLogger(std::string const &log_level)
Definition Logging.cpp:64
std::string getFileExtension(const std::string &path)
std::string extractPath(std::string const &pathname)
std::string joinPaths(std::string const &pathA, std::string const &pathB)
std::vector< ranges::range_value_t< R > > sizesToOffsets(R const &sizes)
Definition Algorithm.h:283
GITINFOLIB_EXPORT const std::string ogs_version
PropertyVector< T > * getOrCreateMeshProperty(Mesh &mesh, std::string const &property_name, MeshItemType const item_type, int const number_of_components)
std::optional< IntegrationPointMetaData > getIntegrationPointMetaData(MeshLib::Properties const &properties)
IntegrationPointMetaDataSingleField getIntegrationPointMetaDataSingleField(std::optional< IntegrationPointMetaData > const &ip_meta_data, std::string const &field_name)
std::vector< std::size_t > getIntegrationPointDataOffsetsOfMeshElements(std::vector< MeshLib::Element * > const &mesh_elements, MeshLib::PropertyVectorBase const &pv, MeshLib::Properties const &properties)
int getNumberOfElementIntegrationPoints(MeshLib::IntegrationPointMetaDataSingleField const &ip_meta_data, MeshLib::Element const &e)
std::size_t partition_id
Definition PVTU2VTU.cpp:50
std::size_t original_id
Definition PVTU2VTU.cpp:51