OGS
computeSurfaceNodeIDsInPolygonalRegion.cpp File Reference

Detailed Description

Computes mesh node ids of mesh nodes within a polygonal region, that resides on the surface.

Definition in file computeSurfaceNodeIDsInPolygonalRegion.cpp.

#include <tclap/CmdLine.h>
#include <mpi.h>
#include <algorithm>
#include <fstream>
#include <memory>
#include <string>
#include <vector>
#include "Applications/FileIO/readGeometryFromFile.h"
#include "BaseLib/Error.h"
#include "BaseLib/FileTools.h"
#include "GeoLib/GEOObjects.h"
#include "GeoLib/Polygon.h"
#include "InfoLib/GitInfo.h"
#include "MeshLib/IO/readMeshFromFile.h"
#include "MeshLib/Mesh.h"
#include "MeshLib/Node.h"
#include "MeshToolsLib/MeshSurfaceExtraction.h"
Include dependency graph for computeSurfaceNodeIDsInPolygonalRegion.cpp:

Go to the source code of this file.

Functions

void writeToFile (std::string const &id_area_fname, std::string const &csv_fname, std::vector< std::pair< std::size_t, double > > const &ids_and_areas, std::vector< MeshLib::Node * > const &mesh_nodes)
 
int main (int argc, char *argv[])
 

Function Documentation

◆ main()

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

Definition at line 73 of file computeSurfaceNodeIDsInPolygonalRegion.cpp.

74{
75 TCLAP::CmdLine cmd(
76 "Computes ids of mesh nodes that are in polygonal regions and resides "
77 "on the top surface. The polygonal regions have to be given in a gml- "
78 "or gli-file. The found mesh nodes and the associated area are written "
79 "as txt and csv data. The documentation is available at "
80 "https://docs.opengeosys.org/docs/tools/model-preparation/"
81 "computesurfacenodeidsinpolygonalregion.\n\n"
82 "OpenGeoSys-6 software, version " +
84 ".\n"
85 "Copyright (c) 2012-2024, OpenGeoSys Community "
86 "(http://www.opengeosys.org)",
88 TCLAP::ValueArg<std::string> mesh_in(
89 "m", "mesh-input-file",
90 "the name of the file containing the input mesh", true, "",
91 "file name of input mesh");
92 cmd.add(mesh_in);
93 TCLAP::ValueArg<std::string> geo_in(
94 "g", "geo-file", "the name of the gml file containing the polygons",
95 true, "", "file name of input geometry");
96 cmd.add(geo_in);
97
98 TCLAP::ValueArg<std::string> gmsh_path_arg("", "gmsh-path",
99 "the path to the gmsh binary",
100 false, "", "path as string");
101 cmd.add(gmsh_path_arg);
102 cmd.parse(argc, argv);
103
104#ifdef USE_PETSC
105 MPI_Init(&argc, &argv);
106#endif
107
108 std::unique_ptr<MeshLib::Mesh const> mesh(
109 MeshLib::IO::readMeshFromFile(mesh_in.getValue()));
110 INFO("Mesh read: {:d} nodes, {:d} elements.", mesh->getNumberOfNodes(),
111 mesh->getNumberOfElements());
112
113 GeoLib::GEOObjects geo_objs;
114 FileIO::readGeometryFromFile(geo_in.getValue(), geo_objs,
115 gmsh_path_arg.getValue());
116 auto const geo_name = geo_objs.getGeometryNames()[0];
117 INFO("Geometry '{:s}' read: {:d} points, {:d} polylines.",
118 geo_name,
119 geo_objs.getPointVec(geo_name)->size(),
120 geo_objs.getPolylineVec(geo_name)->size());
121
122 Eigen::Vector3d const dir({0.0, 0.0, -1.0});
123 double angle(90);
124
125 auto computeElementTopSurfaceAreas =
126 [](MeshLib::Mesh const& mesh, Eigen::Vector3d const& d, double angle)
127 {
128 std::unique_ptr<MeshLib::Mesh> surface_mesh(
130 angle));
132 *surface_mesh);
133 };
134
135 std::vector<double> areas(computeElementTopSurfaceAreas(*mesh, dir, angle));
136 std::vector<MeshLib::Node*> all_sfc_nodes(
138 angle));
139
140 std::for_each(all_sfc_nodes.begin(), all_sfc_nodes.end(),
141 [](MeshLib::Node* p) { (*p)[2] = 0.0; });
142
143 std::vector<MeshLib::Node*> const& mesh_nodes(mesh->getNodes());
144 GeoLib::PolylineVec const* ply_vec(geo_objs.getPolylineVecObj(geo_name));
145 auto const& plys(ply_vec->getVector());
146
147 for (std::size_t j(0); j < plys.size(); j++)
148 {
149 if (!plys[j]->isClosed())
150 {
151 continue;
152 }
153 std::string polygon_name;
154 ply_vec->getNameOfElement(plys[j], polygon_name);
155 if (polygon_name.empty())
156 {
157 polygon_name = "Polygon-" + std::to_string(j);
158 }
159 // create Polygon from Polyline
160 GeoLib::Polygon const polygon{*plys[j]};
161 // ids of mesh nodes on surface that are within the given polygon
162 std::vector<std::pair<std::size_t, double>> ids_and_areas;
163 for (std::size_t k(0); k < all_sfc_nodes.size(); k++)
164 {
165 MeshLib::Node const& surface_node(*(all_sfc_nodes[k]));
166 if (polygon.isPntInPolygon(surface_node))
167 {
168 ids_and_areas.emplace_back(surface_node.getID(), areas[k]);
169 }
170 }
171 if (ids_and_areas.empty())
172 {
173 ERR("Polygonal part of surface '{:s}' doesn't contains nodes. No "
174 "output will be generated.",
175 polygon_name);
176 continue;
177 }
178
179 std::string const out_path(BaseLib::extractPath(geo_in.getValue()));
180 std::string id_and_area_fname(out_path + polygon_name);
181 std::string csv_fname(out_path + polygon_name);
182 id_and_area_fname += std::to_string(j) + ".txt";
183 csv_fname += std::to_string(j) + ".csv";
184 INFO(
185 "Polygonal part of surface '{}' contains {} nodes. Writing to "
186 "files '{}' and '{}'.",
187 polygon_name,
188 ids_and_areas.size(),
189 id_and_area_fname,
190 csv_fname);
191 writeToFile(id_and_area_fname, csv_fname, ids_and_areas, mesh_nodes);
192 }
193
194 std::for_each(all_sfc_nodes.begin(), all_sfc_nodes.end(),
195 std::default_delete<MeshLib::Node>());
196
197#ifdef USE_PETSC
198 MPI_Finalize();
199#endif
200 return EXIT_SUCCESS;
201}
void INFO(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:35
void ERR(fmt::format_string< Args... > fmt, Args &&... args)
Definition Logging.h:45
Container class for geometric objects.
Definition GEOObjects.h:57
std::vector< std::string > getGeometryNames() const
Returns the names of all geometry vectors.
const std::vector< Point * > * getPointVec(const std::string &name) const
const PolylineVec * getPolylineVecObj(const std::string &name) const
const std::vector< Polyline * > * getPolylineVec(const std::string &name) const
The class TemplateVec takes a unique name and manages a std::vector of pointers to data elements of t...
Definition TemplateVec.h:38
std::vector< Node * > const & getNodes() const
Get the nodes-vector for the mesh.
Definition Mesh.h:106
static std::vector< double > getSurfaceAreaForNodes(const MeshLib::Mesh &mesh)
Returns a vector of the areas assigned to each node on a surface mesh.
static MeshLib::Mesh * getMeshSurface(const MeshLib::Mesh &subsfc_mesh, Eigen::Vector3d const &dir, double angle, std::string_view subsfc_node_id_prop_name="", std::string_view subsfc_element_id_prop_name="", std::string_view face_id_prop_name="")
static std::vector< MeshLib::Node * > getSurfaceNodes(const MeshLib::Mesh &mesh, Eigen::Vector3d const &dir, double angle)
Returns the surface nodes of a mesh.
void writeToFile(std::string const &id_area_fname, std::string const &csv_fname, std::vector< std::pair< std::size_t, double > > const &ids_and_areas, std::vector< MeshLib::Node * > const &mesh_nodes)
std::string extractPath(std::string const &pathname)
void readGeometryFromFile(std::string const &fname, GeoLib::GEOObjects &geo_objs, std::string const &gmsh_path)
GITINFOLIB_EXPORT const std::string ogs_version
MeshLib::Mesh * readMeshFromFile(const std::string &file_name, bool const compute_element_neighbors)

References ERR(), BaseLib::extractPath(), GeoLib::GEOObjects::getGeometryNames(), MathLib::Point3dWithID::getID(), MeshToolsLib::MeshSurfaceExtraction::getMeshSurface(), GeoLib::TemplateVec< T >::getNameOfElement(), GeoLib::GEOObjects::getPointVec(), GeoLib::GEOObjects::getPolylineVec(), GeoLib::GEOObjects::getPolylineVecObj(), MeshToolsLib::MeshSurfaceExtraction::getSurfaceAreaForNodes(), MeshToolsLib::MeshSurfaceExtraction::getSurfaceNodes(), GeoLib::TemplateVec< T >::getVector(), INFO(), GitInfoLib::GitInfo::ogs_version, FileIO::readGeometryFromFile(), MeshLib::IO::readMeshFromFile(), and writeToFile().

◆ writeToFile()

void writeToFile ( std::string const & id_area_fname,
std::string const & csv_fname,
std::vector< std::pair< std::size_t, double > > const & ids_and_areas,
std::vector< MeshLib::Node * > const & mesh_nodes )

Definition at line 36 of file computeSurfaceNodeIDsInPolygonalRegion.cpp.

40{
41 std::ofstream ids_and_area_out(id_area_fname);
42 if (!ids_and_area_out)
43 {
44 OGS_FATAL("Unable to open the file '{:s}' - aborting.", id_area_fname);
45 }
46 std::ofstream csv_out(csv_fname);
47 if (!csv_out)
48 {
49 OGS_FATAL("Unable to open the file '{:s}' - aborting.", csv_fname);
50 }
51
52 ids_and_area_out << std::setprecision(20);
53 csv_out << std::setprecision(20);
54
55 ids_and_area_out << ids_and_areas[0].first << " "
56 << ids_and_areas[0].second;
57 csv_out << "ID x y z area node_id\n"; // CSV header
58 csv_out << 0 << " " << *mesh_nodes[ids_and_areas[0].first]
59 << ids_and_areas[0].second << " " << ids_and_areas[0].first;
60 for (std::size_t k(1); k < ids_and_areas.size(); k++)
61 {
62 ids_and_area_out << "\n"
63 << ids_and_areas[k].first << " "
64 << ids_and_areas[k].second;
65 csv_out << "\n"
66 << k << " " << *mesh_nodes[ids_and_areas[k].first]
67 << ids_and_areas[k].second << " " << ids_and_areas[k].first;
68 }
69 ids_and_area_out << "\n";
70 csv_out << "\n";
71}
#define OGS_FATAL(...)
Definition Error.h:26

References OGS_FATAL.

Referenced by GeoTabWidget::GeoTabWidget(), MeshTabWidget::MeshTabWidget(), StationTabWidget::StationTabWidget(), VtkVisPipelineView::exportSelectedPipelineItemAsVtk(), and main().