OGS
ReorderMesh.cpp File Reference

Detailed Description

Definition in file ReorderMesh.cpp.

#include <tclap/CmdLine.h>
#include <memory>
#include <string>
#include "BaseLib/MPI.h"
#include "InfoLib/GitInfo.h"
#include "MeshLib/Elements/Element.h"
#include "MeshLib/IO/readMeshFromFile.h"
#include "MeshLib/IO/writeMeshToFile.h"
#include "MeshLib/Mesh.h"
#include "MeshLib/Node.h"
Include dependency graph for ReorderMesh.cpp:

Go to the source code of this file.

Functions

std::vector< std::size_t > generateBulkIDsReverseMapping (std::span< std::size_t const > bulk_ids)
 
template<typename T >
bool reorderProperty (MeshLib::PropertyVector< T > const &original_pv, std::span< std::size_t const > bulk_ids, MeshLib::PropertyVector< T > &reordered_pv)
 
template<typename T >
bool reorderProperty (MeshLib::Properties const &original_properties, std::span< std::size_t const > bulk_ids, std::string const &property_name, MeshLib::Properties &reordered_properties)
 
void reorderProperties (MeshLib::Properties const &original_properties, std::span< std::size_t const > bulk_ids, std::vector< std::string > const &property_names, MeshLib::Properties &reordered_properties)
 
int main (int argc, char *argv[])
 

Function Documentation

◆ generateBulkIDsReverseMapping()

std::vector< std::size_t > generateBulkIDsReverseMapping ( std::span< std::size_t const > bulk_ids)

Definition at line 23 of file ReorderMesh.cpp.

25{
26 std::vector<std::size_t> parallel_to_sequential_node_ids(bulk_ids.size());
27
28 std::size_t pos = 0;
29 for (auto const id : bulk_ids)
30 {
31 parallel_to_sequential_node_ids[id] = pos;
32 pos++;
33 }
34 return parallel_to_sequential_node_ids;
35}

Referenced by main().

◆ main()

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

Definition at line 120 of file ReorderMesh.cpp.

121{
122 TCLAP::CmdLine cmd(
123 "Reorder mesh nodes and cells.\n\n"
124 "OpenGeoSys-6 software, version " +
126 ".\n"
127 "Copyright (c) 2012-2025, OpenGeoSys Community "
128 "(http://www.opengeosys.org)",
130 TCLAP::ValueArg<std::string> mesh_in_arg(
131 "i", "input", "name of the input mesh file", true, "", "string");
132 cmd.add(mesh_in_arg);
133 TCLAP::ValueArg<std::string> mesh_out_arg(
134 "o", "output", "name of the output mesh file", true, "", "string");
135 cmd.add(mesh_out_arg);
136
137 cmd.parse(argc, argv);
138
139 BaseLib::MPI::Setup mpi_setup(argc, argv);
140
141 const std::string filename(mesh_in_arg.getValue());
142
143 // read the mesh file
144 auto const mesh =
145 std::unique_ptr<MeshLib::Mesh>(MeshLib::IO::readMeshFromFile(filename));
146 if (!mesh)
147 {
148 return EXIT_FAILURE;
149 }
150
151 auto const* bulk_node_ids = MeshLib::bulkNodeIDs(*mesh);
152 if (!bulk_node_ids)
153 {
154 OGS_FATAL("Property / data array '{}' has not been found in the mesh.",
156 }
157
158 auto const& nodes = mesh->getNodes();
159 auto const node_ids_reverse_mapping(
160 generateBulkIDsReverseMapping(*bulk_node_ids));
161
162 std::vector<MeshLib::Node*> reordered_nodes(nodes.size());
163 std::size_t pos = 0;
164 for (auto const id : node_ids_reverse_mapping)
165 {
166 auto const& n = *(nodes[id]);
167 reordered_nodes[pos] = new MeshLib::Node(n[0], n[1], n[2], pos);
168 pos++;
169 }
170
171 auto const bulk_element_ids_string =
173 if (!mesh->getProperties().existsPropertyVector<std::size_t>(
174 bulk_element_ids_string))
175 {
176 OGS_FATAL("Property / data array '{}' has not been found in the mesh.",
177 bulk_element_ids_string);
178 }
179 auto const& bulk_element_ids =
180 *mesh->getProperties().getPropertyVector<std::size_t>(
181 bulk_element_ids_string);
182
183 std::vector<std::size_t> element_ids_reverse_mapping(
184 generateBulkIDsReverseMapping(bulk_element_ids));
185
186 auto const& elements = mesh->getElements();
187 std::vector<MeshLib::Element*> reordered_elements(elements.size());
188 pos = 0;
189 for (auto const id : element_ids_reverse_mapping)
190 {
191 auto const& e = *elements[id];
192 auto* reordered_element =
193 e.clone(); // use clone to have the same element type
194 // reset the nodes to the reordered nodes
195 auto const number_of_nodes = reordered_element->getNumberOfNodes();
196 for (std::size_t node_number = 0; node_number < number_of_nodes;
197 node_number++)
198 {
199 reordered_element->setNode(
200 node_number,
201 reordered_nodes[(
202 *bulk_node_ids)[e.getNode(node_number)->getID()]]);
203 }
204 reordered_elements[pos] = reordered_element;
205 pos++;
206 }
207 auto const& original_properties = mesh->getProperties();
208 // reordering of PropertyVector with following MeshItemTypes isn't supported
209 std::vector<MeshLib::MeshItemType> const exclude_property_vectors{
212 // Create reordered mesh - only the PropertyVectors for which the reordering
213 // is implemented are copied
214 MeshLib::Mesh reordered_mesh{
215 "reordered_mesh", reordered_nodes, reordered_elements,
216 false /* compute_element_neighbors */,
217 original_properties.excludeCopyProperties(exclude_property_vectors)};
218 auto& properties = reordered_mesh.getProperties();
219
220 // node based properties
221 auto const node_property_names =
222 mesh->getProperties().getPropertyVectorNames(
224 reorderProperties(original_properties, std::span{*bulk_node_ids},
225 node_property_names, properties);
226
227 // element based properties
228 auto const element_property_names =
229 mesh->getProperties().getPropertyVectorNames(
231 reorderProperties(original_properties, bulk_element_ids,
232 element_property_names, properties);
233 MeshLib::IO::writeMeshToFile(reordered_mesh, mesh_out_arg.getValue());
234
235 auto const number_of_properties =
236 mesh->getProperties().getPropertyVectorNames().size();
237 if (node_property_names.size() + element_property_names.size() <
238 number_of_properties)
239 {
240 WARN(
241 "Properties that are not assigened to nodes or elements are not "
242 "transferred to the reordered mesh.");
243 }
244
245 return EXIT_SUCCESS;
246}
#define OGS_FATAL(...)
Definition Error.h:26
void WARN(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:40
void reorderProperties(MeshLib::Properties const &original_properties, std::span< std::size_t const > bulk_ids, std::vector< std::string > const &property_names, MeshLib::Properties &reordered_properties)
std::vector< std::size_t > generateBulkIDsReverseMapping(std::span< std::size_t const > bulk_ids)
Properties & getProperties()
Definition Mesh.h:136
std::vector< std::string > getPropertyVectorNames() const
GITINFOLIB_EXPORT const std::string ogs_version
MeshLib::Mesh * readMeshFromFile(const std::string &file_name, bool const compute_element_neighbors)
int writeMeshToFile(const MeshLib::Mesh &mesh, std::filesystem::path const &file_path, std::set< std::string > variable_output_names)
constexpr std::string_view getBulkIDString(MeshItemType mesh_item_type)
Definition Properties.h:185
PropertyVector< std::size_t > const * bulkNodeIDs(Mesh const &mesh)
Definition Mesh.cpp:292

References MeshLib::bulkNodeIDs(), MeshLib::Cell, MeshLib::Edge, MeshLib::Face, generateBulkIDsReverseMapping(), MeshLib::getBulkIDString(), MeshLib::IntegrationPoint, MeshLib::Node, OGS_FATAL, GitInfoLib::GitInfo::ogs_version, MeshLib::IO::readMeshFromFile(), reorderProperties(), WARN(), and MeshLib::IO::writeMeshToFile().

◆ reorderProperties()

void reorderProperties ( MeshLib::Properties const & original_properties,
std::span< std::size_t const > bulk_ids,
std::vector< std::string > const & property_names,
MeshLib::Properties & reordered_properties )

Definition at line 85 of file ReorderMesh.cpp.

90{
91 for (auto const& property_name : property_names)
92 {
93 bool const success =
94 reorderProperty<double>(original_properties, bulk_ids,
95 property_name, reordered_properties) ||
96 reorderProperty<float>(original_properties, bulk_ids, property_name,
97 reordered_properties) ||
98 reorderProperty<int>(original_properties, bulk_ids, property_name,
99 reordered_properties) ||
100 reorderProperty<long>(original_properties, bulk_ids, property_name,
101 reordered_properties) ||
102 reorderProperty<unsigned>(original_properties, bulk_ids,
103 property_name, reordered_properties) ||
104 reorderProperty<unsigned long>(original_properties, bulk_ids,
105 property_name,
106 reordered_properties) ||
107 reorderProperty<std::size_t>(original_properties, bulk_ids,
108 property_name, reordered_properties) ||
109 reorderProperty<char>(original_properties, bulk_ids, property_name,
110 reordered_properties) ||
111 reorderProperty<unsigned char>(original_properties, bulk_ids,
112 property_name, reordered_properties);
113 if (!success)
114 {
115 OGS_FATAL("Could not reorder PropertyVector '{}'.", property_name);
116 }
117 }
118}
bool reorderProperty(MeshLib::PropertyVector< T > const &original_pv, std::span< std::size_t const > bulk_ids, MeshLib::PropertyVector< T > &reordered_pv)

References OGS_FATAL, and reorderProperty().

Referenced by main().

◆ reorderProperty() [1/2]

template<typename T >
bool reorderProperty ( MeshLib::Properties const & original_properties,
std::span< std::size_t const > bulk_ids,
std::string const & property_name,
MeshLib::Properties & reordered_properties )

Definition at line 68 of file ReorderMesh.cpp.

73{
74 if (!reordered_properties.existsPropertyVector<T>(property_name))
75 {
76 return false;
77 }
78 auto const& original_property =
79 *original_properties.getPropertyVector<T>(property_name);
80 auto& reordered_property =
81 *reordered_properties.getPropertyVector<T>(property_name);
82 return reorderProperty(original_property, bulk_ids, reordered_property);
83}
bool existsPropertyVector(std::string_view name) const
PropertyVector< T > const * getPropertyVector(std::string_view name) const

References MeshLib::Properties::existsPropertyVector(), MeshLib::Properties::getPropertyVector(), and reorderProperty().

◆ reorderProperty() [2/2]

template<typename T >
bool reorderProperty ( MeshLib::PropertyVector< T > const & original_pv,
std::span< std::size_t const > bulk_ids,
MeshLib::PropertyVector< T > & reordered_pv )

Definition at line 38 of file ReorderMesh.cpp.

42{
43 if (original_pv.getNumberOfGlobalComponents() !=
44 reordered_pv.getNumberOfGlobalComponents())
45 {
47 "Could not reorder property {} since the number of components "
48 "isn't equal ({} != {}).",
49 original_pv.getPropertyName(),
50 original_pv.getNumberOfGlobalComponents(),
51 reordered_pv.getNumberOfGlobalComponents());
52 }
53
54 auto const number_of_components = original_pv.getNumberOfGlobalComponents();
55 std::size_t pos = 0;
56 for (auto const& id : bulk_ids)
57 {
58 for (int c = 0; c < number_of_components; c++)
59 {
60 reordered_pv.getComponent(id, c) = original_pv.getComponent(pos, c);
61 }
62 pos++;
63 }
64 return true;
65}
int getNumberOfGlobalComponents() const
std::string const & getPropertyName() const
PROP_VAL_TYPE & getComponent(std::size_t tuple_index, int component)
Returns the value for the given component stored in the given tuple.

References MeshLib::PropertyVector< PROP_VAL_TYPE >::getComponent(), MeshLib::PropertyVectorBase::getNumberOfGlobalComponents(), MeshLib::PropertyVectorBase::getPropertyName(), and OGS_FATAL.

Referenced by reorderProperties(), and reorderProperty().