OGS
PVTU2VTU.cpp File Reference

Detailed Description

Created on September 22, 2022, 12:29 PM

Definition in file PVTU2VTU.cpp.

#include <tclap/CmdLine.h>
#include <algorithm>
#include <boost/property_tree/ptree.hpp>
#include <boost/property_tree/xml_parser.hpp>
#include <filesystem>
#include <fstream>
#include <memory>
#include <numeric>
#include <range/v3/algorithm/copy.hpp>
#include <range/v3/algorithm/transform.hpp>
#include <range/v3/numeric/accumulate.hpp>
#include <range/v3/range/conversion.hpp>
#include <range/v3/view/filter.hpp>
#include <string>
#include <unordered_set>
#include <vector>
#include "BaseLib/FileTools.h"
#include "BaseLib/Logging.h"
#include "BaseLib/MPI.h"
#include "BaseLib/RunTime.h"
#include "BaseLib/TCLAPArguments.h"
#include "GeoLib/AABB.h"
#include "GeoLib/OctTree.h"
#include "InfoLib/GitInfo.h"
#include "MathLib/Point3d.h"
#include "MeshLib/Elements/Element.h"
#include "MeshLib/IO/VtkIO/VtuInterface.h"
#include "MeshLib/Mesh.h"
#include "MeshLib/Node.h"
#include "MeshLib/Properties.h"
#include "MeshLib/Utils/IntegrationPointWriter.h"
#include "MeshLib/Utils/getOrCreateMeshProperty.h"
#include "MeshToolsLib/IntegrationPointDataTools.h"
Include dependency graph for PVTU2VTU.cpp:

Go to the source code of this file.

Classes

struct  MeshEntityMapInfo
 

Functions

template<typename T >
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)
 
std::vector< std::string > readVtuFileNames (std::string const &pvtu_file_name)
 
std::tuple< std::vector< MeshLib::Node * >, std::vector< std::size_t > > getMergedNodesVector (std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes)
 
std::tuple< std::vector< MeshLib::Element * >, std::vector< MeshEntityMapInfo > > getRegularElements (std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes)
 
MeshLib::NodegetExistingNodeFromOctTree (GeoLib::OctTree< MeshLib::Node, 16 > &oct_tree, Eigen::Vector3d const &extent, MeshLib::Node const &node, std::size_t const element_id)
 
void resetNodesInRegularElements (std::vector< MeshLib::Element * > const &regular_elements, GeoLib::OctTree< MeshLib::Node, 16 > &oct_tree, Eigen::Vector3d const &extent)
 
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)
 
int main (int argc, char *argv[])
 

Function Documentation

◆ createPropertyVector()

template<typename T >
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 at line 55 of file PVTU2VTU.cpp.

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}
std::vector< Element * > const & getElements() const
Get the element-vector for the mesh.
Definition Mesh.h:111
MeshItemType getMeshItemType() const
int getNumberOfGlobalComponents() const
std::string const & getPropertyName() const
constexpr PROP_VAL_TYPE * begin()
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)

References MeshLib::PropertyVector< T >::begin(), MeshLib::Cell, MeshLib::Mesh::getElements(), MeshToolsLib::getIntegrationPointDataOffsetsOfMeshElements(), MeshLib::getIntegrationPointMetaData(), MeshLib::getIntegrationPointMetaDataSingleField(), MeshLib::PropertyVectorBase::getMeshItemType(), MeshToolsLib::getNumberOfElementIntegrationPoints(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::getOrCreateMeshProperty(), MeshLib::PropertyVectorBase::getPropertyName(), MeshLib::IntegrationPoint, and MeshLib::Node.

Referenced by main().

◆ getExistingNodeFromOctTree()

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 at line 293 of file PVTU2VTU.cpp.

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}
#define OGS_FATAL(...)
Definition Error.h:26
void getPointsInRange(T const &min, T const &max, std::vector< POINT * > &pnts) const

References MathLib::Point3d::asEigenVector3d(), MathLib::Point3dWithID::getID(), GeoLib::OctTree< POINT, MAX_POINTS >::getPointsInRange(), and OGS_FATAL.

Referenced by resetNodesInRegularElements().

◆ getMergedNodesVector()

std::tuple< std::vector< MeshLib::Node * >, std::vector< std::size_t > > getMergedNodesVector ( std::vector< std::unique_ptr< MeshLib::Mesh > > const & meshes)

Definition at line 232 of file PVTU2VTU.cpp.

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}
std::vector< ranges::range_value_t< R > > sizesToOffsets(R const &sizes)
Definition Algorithm.h:283

References BaseLib::sizesToOffsets().

Referenced by main().

◆ getRegularElements()

std::tuple< std::vector< MeshLib::Element * >, std::vector< MeshEntityMapInfo > > getRegularElements ( std::vector< std::unique_ptr< MeshLib::Mesh > > const & meshes)

Definition at line 251 of file PVTU2VTU.cpp.

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}
Property manager on mesh items. Class Properties manages scalar, vector or matrix properties....
Definition Properties.h:33
PropertyVector< T > const * getPropertyVector(std::string_view name) const

References MeshLib::Properties::getPropertyVector().

Referenced by main().

◆ main()

int main ( int argc,
char * argv[] )

Definition at line 381 of file PVTU2VTU.cpp.

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}
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
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
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
void applyToPropertyVectors(Properties const &properties, Function f)
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
static OctTree< POINT, MAX_POINTS > * createOctTree(Eigen::Vector3d ll, Eigen::Vector3d ur, double eps=std::numeric_limits< double >::epsilon())
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)
void shallowClean()
Definition Mesh.cpp:134
bool existsPropertyVector(std::string_view name) const
TCLAP::ValueArg< std::string > makeLogLevelArg()
void initOGSLogger(std::string const &log_level)
Definition Logging.cpp:64
std::string getFileExtension(const std::string &path)
GITINFOLIB_EXPORT const std::string ogs_version

References applyToPropertyVectors(), GeoLib::OctTree< POINT, MAX_POINTS >::createOctTree(), createPropertyVector(), BaseLib::RunTime::elapsed(), ERR(), MeshLib::Properties::existsPropertyVector(), BaseLib::getFileExtension(), GeoLib::AABB::getMaxPoint(), getMergedNodesVector(), GeoLib::AABB::getMinPoint(), getRegularElements(), INFO(), BaseLib::initOGSLogger(), BaseLib::makeLogLevelArg(), makeNodesUnique(), OGS_FATAL, GitInfoLib::GitInfo::ogs_version, MeshLib::IO::VtuInterface::readVTUFile(), readVtuFileNames(), resetNodesInRegularElements(), MeshLib::Mesh::shallowClean(), BaseLib::RunTime::start(), and MeshLib::IO::VtuInterface::writeToFile().

◆ makeNodesUnique()

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 at line 353 of file PVTU2VTU.cpp.

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}
bool addPoint(POINT *pnt, POINT *&ret_pnt)

References GeoLib::OctTree< POINT, MAX_POINTS >::addPoint().

Referenced by main().

◆ readVtuFileNames()

std::vector< std::string > readVtuFileNames ( std::string const & pvtu_file_name)

Definition at line 189 of file PVTU2VTU.cpp.

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}
std::string extractPath(std::string const &pathname)
std::string joinPaths(std::string const &pathA, std::string const &pathB)

References BaseLib::extractPath(), BaseLib::joinPaths(), and OGS_FATAL.

Referenced by main().

◆ resetNodesInRegularElements()

void resetNodesInRegularElements ( std::vector< MeshLib::Element * > const & regular_elements,
GeoLib::OctTree< MeshLib::Node, 16 > & oct_tree,
Eigen::Vector3d const & extent )

Definition at line 331 of file PVTU2VTU.cpp.

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}
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

References GeoLib::OctTree< POINT, MAX_POINTS >::addPoint(), and getExistingNodeFromOctTree().

Referenced by main().