FileIO::GMSH::GMSHInterface Class Reference

Detailed Description

Reads and writes GMSH-files to and from OGS data structures.

Definition at line 39 of file GMSHInterface.h.

#include <GMSHInterface.h>

Inheritance diagram for FileIO::GMSH::GMSHInterface:

Collaboration diagram for FileIO::GMSH::GMSHInterface:

Public Member Functions
	GMSHInterface (GeoLib::GEOObjects &geo_objs, bool include_stations_as_constraints, GMSH::MeshDensityAlgorithm mesh_density_algorithm, double pnt_density, double station_density, std::size_t max_pnts_per_leaf, std::vector< std::string > const &selected_geometries, bool rotate, bool keep_preprocessed_geometry)
	GMSHInterface (GMSHInterface const &)=delete
	GMSHInterface (GMSHInterface &&)=delete
GMSHInterface &	operator= (GMSHInterface const &)=delete
GMSHInterface &	operator= (GMSHInterface &&)=delete
	~GMSHInterface () override
void	writePhysicalGroups (bool flag)
Public Member Functions inherited from BaseLib::IO::Writer
	Writer ()
virtual	~Writer ()=default
std::string	writeToString ()
	Writes the object to a string.

Protected Member Functions
bool	write () override
	Writes the object to the internal stream. This method must be implemented by a subclass. The implementation should return true on success, else false.

Private Member Functions
int	writeGMSHInputFile (std::ostream &out)

Private Attributes
std::size_t	_n_lines = 0
std::size_t	_n_plane_sfc = 0
GeoLib::GEOObjects &	_geo_objs
std::vector< std::string > const &	_selected_geometries
std::string	_gmsh_geo_name
std::list< GMSH::GMSHPolygonTree * >	_polygon_tree_list
std::vector< GMSH::GMSHPoint * >	_gmsh_pnts
std::unique_ptr< GMSH::GMSHMeshDensityStrategy >	_mesh_density_strategy
Eigen::Matrix3d	_inverse_rot_mat = Eigen::Matrix3d::Zero()
bool const	_rotate = false
bool	_keep_preprocessed_geometry = true
bool	_write_physical_groups = false

Additional Inherited Members
Protected Attributes inherited from BaseLib::IO::Writer
std::ostringstream	out
	The stream to write to.

Constructor & Destructor Documentation

GMSHInterface() [1/3]

FileIO::GMSH::GMSHInterface::GMSHInterface	(	GeoLib::GEOObjects &	geo_objs,
		bool	include_stations_as_constraints,
		GMSH::MeshDensityAlgorithm	mesh_density_algorithm,
		double	pnt_density,
		double	station_density,
		std::size_t	max_pnts_per_leaf,
		std::vector< std::string > const &	selected_geometries,
		bool	rotate,
		bool	keep_preprocessed_geometry )

Parameters

geo_objs	reference to instance of class GEOObject that maintains the geometries. The instance is used for preparation geometries for writing them to the gmsh file format.
include_stations_as_constraints	switch to enable writing stations as constraints
mesh_density_algorithm	one of the mesh density algorithms (@see enum MeshDensityAlgorithm)
pnt_density	parameter of the mesh density algorithm
station_density	parameter of the mesh density algorithm
max_pnts_per_leaf	parameter of the mesh density algorithm
selected_geometries	vector of names of geometries, that should be employed for mesh generation.
rotate	if the value of the parameter is true then the input points will be rotated on the \(x\)- \(y\)-plane, else the input points will be (orthogonal) projected to the \(x\)- \(y\)-plane.
keep_preprocessed_geometry	keep the pre-processed geometry, useful for debugging the mesh creation

Definition at line 43 of file GMSHInterface.cpp.

    : _geo_objs(geo_objs),
      _selected_geometries(selected_geometries),
      _rotate(rotate),
      _keep_preprocessed_geometry(keep_preprocessed_geometry)
{
    switch (mesh_density_algorithm)
    {
        case GMSH::MeshDensityAlgorithm::FixedMeshDensity:
            _mesh_density_strategy =
                std::make_unique<GMSH::GMSHFixedMeshDensity>(pnt_density);
            break;
        case GMSH::MeshDensityAlgorithm::AdaptiveMeshDensity:
            _mesh_density_strategy =
                std::make_unique<GMSH::GMSHAdaptiveMeshDensity>(
                    pnt_density, station_density, max_pnts_per_leaf);
            break;
    }
}

References _geo_objs, _keep_preprocessed_geometry, _mesh_density_strategy, _rotate, _selected_geometries, FileIO::GMSH::AdaptiveMeshDensity, and FileIO::GMSH::FixedMeshDensity.

Referenced by GMSHInterface(), GMSHInterface(), operator=(), and operator=().

GMSHInterface() [2/3]

FileIO::GMSH::GMSHInterface::GMSHInterface ( GMSHInterface const & )

delete

References GMSHInterface().

GMSHInterface() [3/3]

FileIO::GMSH::GMSHInterface::GMSHInterface ( GMSHInterface && )

delete

References GMSHInterface().

~GMSHInterface()

FileIO::GMSH::GMSHInterface::~GMSHInterface ( )

override

Definition at line 69 of file GMSHInterface.cpp.

{
    BaseLib::cleanupVectorElements(_gmsh_pnts);
    for (auto const* polygon_tree : _polygon_tree_list)
    {
        delete polygon_tree;
    }
}

References _gmsh_pnts, _polygon_tree_list, and BaseLib::cleanupVectorElements().

Member Function Documentation

operator=() [1/2]

GMSHInterface & FileIO::GMSH::GMSHInterface::operator= ( GMSHInterface && )

delete

References GMSHInterface().

operator=() [2/2]

GMSHInterface & FileIO::GMSH::GMSHInterface::operator= ( GMSHInterface const & )

delete

References GMSHInterface().

write()

bool FileIO::GMSH::GMSHInterface::write ( )

overrideprotectedvirtual

Writes the object to the internal stream. This method must be implemented by a subclass. The implementation should return true on success, else false.

Implements BaseLib::IO::Writer.

Definition at line 78 of file GMSHInterface.cpp.

{
    out << "// GMSH input file created by OpenGeoSys "
        << GitInfoLib::GitInfo::ogs_version;
    out << "\n\n";
 
    return writeGMSHInputFile(out) <= 0;
}

References GitInfoLib::GitInfo::ogs_version, BaseLib::IO::Writer::out, and writeGMSHInputFile().

writeGMSHInputFile()

int FileIO::GMSH::GMSHInterface::writeGMSHInputFile ( std::ostream & out )

private

1. get and merge data from _geo_objs
2. compute topological hierarchy

   Parameters

   out

   Todo

   activate error codes and hand them on to the Writer class, i.e. 0 = okay, 1 = geo_objects is empty, 2 = error while merging, 3 = error writing file

Definition at line 87 of file GMSHInterface.cpp.

{
    DBUG("GMSHInterface::writeGMSHInputFile(): get data from GEOObjects.");
 
    if (_selected_geometries.empty())
    {
        return 1;
    }
 
    // *** get and merge data from _geo_objs
    if (_selected_geometries.size() > 1)
    {
        _gmsh_geo_name = "GMSHGeometry";
        if (_geo_objs.mergeGeometries(_selected_geometries, _gmsh_geo_name))
        {
            return 2;
        }
    }
    else
    {
        _gmsh_geo_name = _selected_geometries[0];
        _keep_preprocessed_geometry = true;
    }
 
    auto* merged_pnts(const_cast<std::vector<GeoLib::Point*>*>(
        _geo_objs.getPointVec(_gmsh_geo_name)));
    if (!merged_pnts)
    {
        ERR("GMSHInterface::writeGMSHInputFile(): Did not found any points.");
        return 2;
    }
 
    if (_rotate)
    {
        // Rotate points to the x-y-plane.
        _inverse_rot_mat = GeoLib::rotatePointsToXY(*merged_pnts);
        // Compute inverse rotation matrix to reverse the rotation later on.
        _inverse_rot_mat.transposeInPlace();
    }
    else
    {
        // project data on the x-y-plane
        _inverse_rot_mat = Eigen::Matrix3d::Identity();
        for (auto pnt : *merged_pnts)
        {
            (*pnt)[2] = 0.0;
        }
    }
 
    std::vector<GeoLib::Polyline*> const* merged_plys(
        _geo_objs.getPolylineVec(_gmsh_geo_name));
    DBUG("GMSHInterface::writeGMSHInputFile(): Obtained data.");
 
    if (!merged_plys)
    {
        ERR("GMSHInterface::writeGMSHInputFile(): Did not find any polylines.");
        return 2;
    }
 
    // *** compute and insert all intersection points between polylines
    GeoLib::PointVec& pnt_vec(*const_cast<GeoLib::PointVec*>(
        _geo_objs.getPointVecObj(_gmsh_geo_name)));
    GeoLib::computeAndInsertAllIntersectionPoints(
        pnt_vec, *(const_cast<std::vector<GeoLib::Polyline*>*>(merged_plys)));
 
    std::vector<GeoLib::Polyline*> polygons;
    // for each closed polyline add a PolygonWithSegmentMarker object into
    // polygons
    for (auto polyline : *merged_plys)
    {
        if (!polyline->isClosed())
        {
            continue;
        }
        polygons.push_back(new GeoLib::PolygonWithSegmentMarker(*polyline));
    }
    if (polygons.empty())
    {
        OGS_FATAL("GMSHInterface::writeGMSHInputFile(): no polygons found.");
    }
    // let the polygon memory management be done by GEOObjects
    _geo_objs.appendPolylineVec(polygons, _gmsh_geo_name);
    // create for each polygon a PolygonTree
    std::transform(
        polygons.begin(), polygons.end(),
        std::back_inserter(_polygon_tree_list),
        [this](auto const& polygon)
        {
            return new GMSH::GMSHPolygonTree(
                dynamic_cast<GeoLib::PolygonWithSegmentMarker*>(polygon),
                nullptr, _geo_objs, _gmsh_geo_name, *_mesh_density_strategy);
        });
    DBUG(
        "GMSHInterface::writeGMSHInputFile(): Computed topological hierarchy - "
        "detected {:d} polygons.",
        _polygon_tree_list.size());
    // compute topological hierarchy of polygons
    GeoLib::createPolygonTrees<GMSH::GMSHPolygonTree>(_polygon_tree_list);
    DBUG(
        "GMSHInterface::writeGMSHInputFile(): Computed topological hierarchy - "
        "calculated {:d} polygon trees.",
        _polygon_tree_list.size());
 
    // *** Mark in each polygon tree the segments shared by two polygons.
    for (auto* polygon_tree : _polygon_tree_list)
    {
        polygon_tree->markSharedSegments();
    }
 
    // *** insert stations and polylines (except polygons) in the appropriate
    // object of
    //     class GMSHPolygonTree
    // *** insert stations
    std::vector<GeoLib::Point*> gmsh_stations{};
    for (auto const& geometry_name : _selected_geometries)
    {
        auto const* stations(_geo_objs.getStationVec(geometry_name));
        if (stations)
        {
            for (auto* station : *stations)
            {
                bool found(false);
                for (auto it(_polygon_tree_list.begin());
                     it != _polygon_tree_list.end() && !found;
                     ++it)
                {
                    gmsh_stations.emplace_back(new GeoLib::Station(
                        *static_cast<GeoLib::Station*>(station)));
                    if ((*it)->insertStation(gmsh_stations.back()))
                    {
                        found = true;
                    }
                }
            }
        }
    }
    std::string gmsh_stations_name(_gmsh_geo_name + "-Stations");
    if (!gmsh_stations.empty())
    {
        _geo_objs.addStationVec(std::move(gmsh_stations), gmsh_stations_name);
    }
 
    // *** insert polylines
    for (auto polyline : *merged_plys)
    {
        if (!polyline->isClosed())
        {
            for (auto* polygon_tree : _polygon_tree_list)
            {
                auto polyline_with_segment_marker =
                    new GeoLib::PolylineWithSegmentMarker(*polyline);
                polygon_tree->insertPolyline(polyline_with_segment_marker);
            }
        }
    }
 
    // *** init mesh density strategies
    for (auto& polygon_tree : _polygon_tree_list)
    {
        polygon_tree->initMeshDensityStrategy();
    }
 
    // *** create GMSH data structures
    const std::size_t n_merged_pnts(merged_pnts->size());
    _gmsh_pnts.resize(n_merged_pnts);
    for (std::size_t k(0); k < n_merged_pnts; k++)
    {
        _gmsh_pnts[k] = nullptr;
    }
    for (auto& polygon_tree : _polygon_tree_list)
    {
        polygon_tree->createGMSHPoints(_gmsh_pnts);
    }
 
    std::stringstream error_messages;
    error_messages.precision(std::numeric_limits<double>::max_digits10);
    for (std::size_t k = 0; k < _gmsh_pnts.size(); ++k)
    {
        if (_gmsh_pnts[k] == nullptr)
        {
            error_messages
                << "The point at (" << *(*merged_pnts)[k]
                << ") is not part of a polyline, and won't be used in the "
                   "meshing as a constraint. If you want to include it in the "
                   "mesh please create a observation/measurement station for "
                   "the point and include it additional in the meshing "
                   "process.\n";
        }
    }
    auto const error_message = error_messages.str();
    if (!error_message.empty())
    {
        OGS_FATAL("{}", error_message);
    }
 
    // *** finally write data :-)
    GeoLib::rotatePoints(_inverse_rot_mat, _gmsh_pnts);
    out << _gmsh_pnts;
 
    std::size_t pnt_id_offset(_gmsh_pnts.size());
    for (auto* polygon_tree : _polygon_tree_list)
    {
        polygon_tree->writeLineLoop(_n_lines, _n_plane_sfc, out,
                                    _write_physical_groups);
        polygon_tree->writeSubPolygonsAsLineConstraints(_n_lines,
                                                        _n_plane_sfc - 1, out);
        polygon_tree->writeLineConstraints(_n_lines, _n_plane_sfc - 1, out);
        polygon_tree->writeStations(pnt_id_offset, _n_plane_sfc - 1, out);
        polygon_tree->writeAdditionalPointData(pnt_id_offset, _n_plane_sfc - 1,
                                               out);
    }
 
    if (!_keep_preprocessed_geometry)
    {
        _geo_objs.removeSurfaceVec(_gmsh_geo_name);
        _geo_objs.removePolylineVec(_gmsh_geo_name);
        _geo_objs.removePointVec(_gmsh_geo_name);
        _geo_objs.removeStationVec(gmsh_stations_name);
    }
 
    return 0;
}

References _geo_objs, _gmsh_geo_name, _gmsh_pnts, _inverse_rot_mat, _keep_preprocessed_geometry, _n_lines, _n_plane_sfc, _polygon_tree_list, _rotate, _selected_geometries, _write_physical_groups, GeoLib::computeAndInsertAllIntersectionPoints(), GeoLib::createPolygonTrees(), DBUG(), ERR(), OGS_FATAL, BaseLib::IO::Writer::out, GeoLib::rotatePoints(), and GeoLib::rotatePointsToXY().

Referenced by write().

writePhysicalGroups()

void FileIO::GMSH::GMSHInterface::writePhysicalGroups ( bool flag )

inline

Definition at line 77 of file GMSHInterface.h.

{ _write_physical_groups = flag; }

References _write_physical_groups.

Referenced by generateMesh().

Member Data Documentation

_geo_objs

GeoLib::GEOObjects& FileIO::GMSH::GMSHInterface::_geo_objs

private

Definition at line 96 of file GMSHInterface.h.

Referenced by GMSHInterface(), and writeGMSHInputFile().

_gmsh_geo_name

std::string FileIO::GMSH::GMSHInterface::_gmsh_geo_name

private

Definition at line 98 of file GMSHInterface.h.

Referenced by writeGMSHInputFile().

_gmsh_pnts

std::vector<GMSH::GMSHPoint*> FileIO::GMSH::GMSHInterface::_gmsh_pnts

private

Definition at line 101 of file GMSHInterface.h.

Referenced by ~GMSHInterface(), and writeGMSHInputFile().

_inverse_rot_mat

Eigen::Matrix3d FileIO::GMSH::GMSHInterface::_inverse_rot_mat = Eigen::Matrix3d::Zero()

private

Holds the inverse rotation matrix. The matrix is used to revert the rotation done in writeGMSHInputFile().

Definition at line 106 of file GMSHInterface.h.

Referenced by writeGMSHInputFile().

_keep_preprocessed_geometry

bool FileIO::GMSH::GMSHInterface::_keep_preprocessed_geometry = true

private

Definition at line 110 of file GMSHInterface.h.

Referenced by GMSHInterface(), and writeGMSHInputFile().

_mesh_density_strategy

std::unique_ptr<GMSH::GMSHMeshDensityStrategy> FileIO::GMSH::GMSHInterface::_mesh_density_strategy

private

Definition at line 103 of file GMSHInterface.h.

Referenced by GMSHInterface().

_n_lines

std::size_t FileIO::GMSH::GMSHInterface::_n_lines = 0

private

Definition at line 93 of file GMSHInterface.h.

Referenced by writeGMSHInputFile().

_n_plane_sfc

std::size_t FileIO::GMSH::GMSHInterface::_n_plane_sfc = 0

private

Definition at line 94 of file GMSHInterface.h.

Referenced by writeGMSHInputFile().

_polygon_tree_list

std::list<GMSH::GMSHPolygonTree*> FileIO::GMSH::GMSHInterface::_polygon_tree_list

private

Definition at line 99 of file GMSHInterface.h.

Referenced by ~GMSHInterface(), and writeGMSHInputFile().

_rotate

bool const FileIO::GMSH::GMSHInterface::_rotate = false

private

Signals if the input points should be rotated or projected to the \(x\)- \(y\)-plane

Definition at line 109 of file GMSHInterface.h.

Referenced by GMSHInterface(), and writeGMSHInputFile().

_selected_geometries

std::vector<std::string> const& FileIO::GMSH::GMSHInterface::_selected_geometries

private

Definition at line 97 of file GMSHInterface.h.

Referenced by GMSHInterface(), and writeGMSHInputFile().

_write_physical_groups

bool FileIO::GMSH::GMSHInterface::_write_physical_groups = false

private

Definition at line 111 of file GMSHInterface.h.

Referenced by writeGMSHInputFile(), and writePhysicalGroups().

---

The documentation for this class was generated from the following files:

• GMSHInterface.h
• GMSHInterface.cpp