Detailed Description

Class for searching mesh node ids along polylines or points. This ids can be used to set boundary conditions, source terms, initial conditions or for outputting simulation results.

Definition at line 52 of file MeshNodeSearcher.h.

#include <MeshNodeSearcher.h>

Collaboration diagram for MeshGeoToolsLib::MeshNodeSearcher:

[legend]

Public Member Functions
	MeshNodeSearcher (MeshLib::Mesh const &mesh, std::unique_ptr< MeshGeoToolsLib::SearchLength > &&search_length_algorithm, SearchAllNodes search_all_nodes)

virtual	~MeshNodeSearcher ()

std::vector< std::size_t >	getMeshNodeIDs (GeoLib::GeoObject const &geoObj) const

std::vector< std::size_t >	getMeshNodeIDs (std::vector< MathLib::Point3dWithID * > const &points) const

Static Public Member Functions
static OGS_NO_DANGLING MeshNodeSearcher const &	getMeshNodeSearcher (MeshLib::Mesh const &mesh, std::unique_ptr< MeshGeoToolsLib::SearchLength > &&search_length_algorithm)

Private Attributes
MeshLib::Mesh const &	_mesh

GeoLib::Grid< MeshLib::Node >	_mesh_grid

std::unique_ptr< MeshGeoToolsLib::SearchLength >	_search_length_algorithm

SearchAllNodes	_search_all_nodes

std::vector< MeshNodesOnPoint * >	_mesh_nodes_on_points

std::vector< MeshNodesAlongPolyline * >	_mesh_nodes_along_polylines

std::vector< MeshNodesAlongSurface * >	_mesh_nodes_along_surfaces

Static Private Attributes
static std::vector< std::unique_ptr< MeshNodeSearcher > >	_mesh_node_searchers
	Mesh node searcher for the meshes indexed by the meshs' ids.

Constructor & Destructor Documentation

◆ MeshNodeSearcher()

MeshGeoToolsLib::MeshNodeSearcher::MeshNodeSearcher	(	MeshLib::Mesh const &	mesh,
		std::unique_ptr< MeshGeoToolsLib::SearchLength > &&	search_length_algorithm,
		SearchAllNodes	search_all_nodes )

Constructor for objects of class MeshNodeSearcher. It calculates internally used search length from the given MeshLib::Mesh.

Parameters

mesh	Run search algorithm on this mesh. It is assumed that the mesh does not change its geometry.
search_length_algorithm	Algorithm to determine the search length.
search_all_nodes	switch between searching all mesh nodes and searching the base nodes.

Definition at line 34 of file MeshNodeSearcher.cpp.

    : _mesh(mesh),
      _mesh_grid(_mesh.getNodes().cbegin(), _mesh.getNodes().cend()),
      _search_length_algorithm(std::move(search_length_algorithm)),
      _search_all_nodes(search_all_nodes)
{
    DBUG("The search length for mesh '{:s}' is {:e}.", _mesh.getName(),
         _search_length_algorithm->getSearchLength());
}

References _mesh, _search_length_algorithm, DBUG(), and MeshLib::Mesh::getName().

◆ ~MeshNodeSearcher()

MeshGeoToolsLib::MeshNodeSearcher::~MeshNodeSearcher ( )

virtual

Definition at line 47 of file MeshNodeSearcher.cpp.

{
    for (auto pointer : _mesh_nodes_on_points)
    {
        delete pointer;
    }
    for (auto pointer : _mesh_nodes_along_polylines)
    {
        delete pointer;
    }
    for (auto pointer : _mesh_nodes_along_surfaces)
    {
        delete pointer;
    }
}

References _mesh_nodes_along_polylines, _mesh_nodes_along_surfaces, and _mesh_nodes_on_points.

Member Function Documentation

◆ getMeshNodeIDs() [1/2]

std::vector< std::size_t > MeshGeoToolsLib::MeshNodeSearcher::getMeshNodeIDs ( GeoLib::GeoObject const & geoObj ) const

Searches for the nearest mesh nodes on the given geometric object (point, polyline, surface).

Parameters

geoObj a GeoLib::GeoObject where the nearest mesh node is searched for

Returns: a vector of mesh node ids

Definition at line 92 of file MeshNodeSearcher.cpp.

{
    std::vector<std::size_t> vec_nodes;
    switch (geoObj.getGeoType())
    {
        case GeoLib::GEOTYPE::POINT:
        {
            std::function<GeoLib::Point(MeshNodesOnPoint const&)>
                get_cached_item_function = &MeshNodesOnPoint::getPoint;
            return MeshGeoToolsLib::getMeshNodeIDs(
                _mesh_nodes_on_points, get_cached_item_function,
                *static_cast<const GeoLib::Point*>(&geoObj), _mesh, _mesh_grid,
                _search_length_algorithm->getSearchLength(), _search_all_nodes);
        }
        case GeoLib::GEOTYPE::POLYLINE:
        {
            std::function<GeoLib::Polyline(MeshNodesAlongPolyline const&)>
                get_cached_item_function = &MeshNodesAlongPolyline::getPolyline;
            return MeshGeoToolsLib::getMeshNodeIDs(
                _mesh_nodes_along_polylines, get_cached_item_function,
                *static_cast<const GeoLib::Polyline*>(&geoObj), _mesh,
                _mesh_grid, _search_length_algorithm->getSearchLength(),
                _search_all_nodes);
        }
        case GeoLib::GEOTYPE::SURFACE:
        {
            std::function<GeoLib::Surface(MeshNodesAlongSurface const&)>
                get_cached_item_function = &MeshNodesAlongSurface::getSurface;
            return MeshGeoToolsLib::getMeshNodeIDs(
                _mesh_nodes_along_surfaces, get_cached_item_function,
                *static_cast<const GeoLib::Surface*>(&geoObj), _mesh,
                _mesh_grid, _search_length_algorithm->getSearchLength(),
                _search_all_nodes);
        }
        default:
            break;
    }
    return vec_nodes;
}

References _mesh, _mesh_grid, _mesh_nodes_along_polylines, _mesh_nodes_along_surfaces, _mesh_nodes_on_points, _search_all_nodes, _search_length_algorithm, GeoLib::GeoObject::getGeoType(), MeshGeoToolsLib::getMeshNodeIDs(), MeshGeoToolsLib::MeshNodesOnPoint::getPoint(), MeshGeoToolsLib::MeshNodesAlongPolyline::getPolyline(), MeshGeoToolsLib::MeshNodesAlongSurface::getSurface(), GeoLib::POINT, GeoLib::POLYLINE, and GeoLib::SURFACE.

Referenced by MeshGeoToolsLib::BoundaryElementsAlongPolyline::BoundaryElementsAlongPolyline(), MeshGeoToolsLib::BoundaryElementsAtPoint::BoundaryElementsAtPoint(), MeshGeoToolsLib::BoundaryElementsOnSurface::BoundaryElementsOnSurface(), anonymous_namespace{IdentifySubdomainMesh.cpp}::identifySubdomainMeshNodes(), and main().

◆ getMeshNodeIDs() [2/2]

std::vector< std::size_t > MeshGeoToolsLib::MeshNodeSearcher::getMeshNodeIDs ( std::vector< MathLib::Point3dWithID * > const & points ) const

Finds unique mesh nodes of each of the input points.

Returns: a vector of mesh node ids.

Definition at line 133 of file MeshNodeSearcher.cpp.

{
    double const epsilon_radius = _search_length_algorithm->getSearchLength();
 
    std::vector<std::size_t> node_ids;
    node_ids.reserve(points.size());
 
    for (auto const* const p_ptr : points)
    {
        auto const& p = *p_ptr;
        std::vector<std::size_t> const ids =
            _mesh_grid.getPointsInEpsilonEnvironment(p, epsilon_radius);
        if (ids.empty())
        {
            OGS_FATAL(
                "No nodes could be found in the mesh for point {:d} : ({:g}, "
                "{:g}, {:g}) in {:g} epsilon radius in the mesh '{:s}'",
                p.getID(), p[0], p[1], p[2], epsilon_radius, _mesh.getName());
        }
        if (ids.size() != 1)
        {
            std::stringstream ss;
            auto const& bulk_nodes = _mesh.getNodes();
            for (auto const id : ids)
            {
                ss << "- bulk node: " << (*bulk_nodes[id])[0] << ", "
                   << (*bulk_nodes[id])[1] << ", " << (*bulk_nodes[id])[2]
                   << ", distance: "
                   << std::sqrt(MathLib::sqrDist(*bulk_nodes[id], p)) << "\n";
            }
            OGS_FATAL(
                "Found {:d} nodes in the mesh for point {:d} : ({:g}, {:g}, "
                "{:g}) in {:g} epsilon radius in the mesh '{:s}'. Expected to "
                "find exactly one node.\n{:s}",
                ids.size(), p.getID(), p[0], p[1], p[2], epsilon_radius,
                _mesh.getName(), ss.str());
        }
        node_ids.push_back(ids.front());
    }
    return node_ids;
}

References _mesh, _mesh_grid, _search_length_algorithm, MeshLib::Mesh::getName(), MeshLib::Mesh::getNodes(), GeoLib::Grid< POINT >::getPointsInEpsilonEnvironment(), OGS_FATAL, and MathLib::sqrDist().

◆ getMeshNodeSearcher()

MeshNodeSearcher const & MeshGeoToolsLib::MeshNodeSearcher::getMeshNodeSearcher	(	MeshLib::Mesh const &	mesh,
		std::unique_ptr< MeshGeoToolsLib::SearchLength > &&	search_length_algorithm )

static

Returns a (possibly new) mesh node searcher for the mesh. A new one will be created, if it does not already exists.

Definition at line 176 of file MeshNodeSearcher.cpp.

{
    std::size_t const mesh_id = mesh.getID();
    if (_mesh_node_searchers.size() < mesh_id + 1)
    {
        _mesh_node_searchers.resize(mesh_id + 1);
    }
 
    if (_mesh_node_searchers[mesh_id])
    {
        auto const& m = *_mesh_node_searchers[mesh_id];
        // return searcher if search length algorithm and the returned search
        // length are the same, else recreate the searcher
        if (typeid(m._search_length_algorithm) ==
                typeid(search_length_algorithm) &&
            m._search_length_algorithm->getSearchLength() ==
                search_length_algorithm->getSearchLength())
        {
            return m;
        }
    }
 
    _mesh_node_searchers[mesh_id] =
        std::make_unique<MeshGeoToolsLib::MeshNodeSearcher>(
            mesh, std::move(search_length_algorithm), SearchAllNodes::Yes);
 
    return *_mesh_node_searchers[mesh_id];
}