MeshLib::NodeSearch Class Reference

Detailed Description

Node search class.

Definition at line 24 of file NodeSearch.h.

#include <NodeSearch.h>

Collaboration diagram for MeshLib::NodeSearch:

Public Member Functions
	NodeSearch (const MeshLib::Mesh &mesh)
const std::vector< std::size_t > &	getSearchedNodeIDs () const
	return marked node IDs
std::size_t	searchNodesConnectedToOnlyGivenElements (const std::vector< std::size_t > &elements)
std::size_t	searchUnused ()
	Marks all unused nodes.
std::size_t	searchBoundaryNodes ()
	Marks all boundary nodes.

Private Member Functions
void	updateUnion (const std::vector< std::size_t > &vec)
	Updates the vector of marked items with values from vec.

Private Attributes
const MeshLib::Mesh &	_mesh
	The mesh from which elements should be removed.
std::vector< std::size_t >	_marked_nodes
	The vector of element indices that should be removed.

Constructor & Destructor Documentation

NodeSearch()

MeshLib::NodeSearch::NodeSearch ( const MeshLib::Mesh & mesh )

explicit

Definition at line 22 of file NodeSearch.cpp.

: _mesh(mesh) {}

Member Function Documentation

getSearchedNodeIDs()

const std::vector< std::size_t > & MeshLib::NodeSearch::getSearchedNodeIDs ( ) const

inline

return marked node IDs

Definition at line 30 of file NodeSearch.h.

{return _marked_nodes; }

References _marked_nodes.

Referenced by ProcessLib::LIE::anonymous_namespace{MeshUtils.cpp}::IsCrackTip::IsCrackTip(), MeshToolsLib::MeshValidation::allNodesUsed(), LayeredMeshGenerator::getMesh(), MeshAnalysisDialog::on_startButton_pressed(), and MeshToolsLib::removeElements().

searchBoundaryNodes()

std::size_t MeshLib::NodeSearch::searchBoundaryNodes

(

)

Marks all boundary nodes.

Definition at line 76 of file NodeSearch.cpp.

{
    std::vector<std::size_t> vec_boundary_nodes;
    if (_mesh.getDimension() == 1)
    {
        for (MeshLib::Node const* n : _mesh.getNodes())
        {
            if (_mesh.getElementsConnectedToNode(*n).size() == 1)
            {
                vec_boundary_nodes.push_back(n->getID());
            }
        }
    }
    else if (_mesh.getDimension() == 2)
    {
        for (MeshLib::Element const* elem : _mesh.getElements())
        {
            if (elem->getDimension() < _mesh.getDimension())
            {
                continue;
            }
            if (!elem->isBoundaryElement())
            {
                continue;
            }
 
            std::size_t const n_edges(elem->getNumberOfEdges());
            for (std::size_t i = 0; i < n_edges; ++i)
            {
                if (elem->getNeighbor(i) != nullptr)
                {
                    continue;
                }
                std::unique_ptr<MeshLib::Element const> edge(elem->getEdge(i));
                for (unsigned j = 0; j < edge->getNumberOfNodes(); j++)
                {
                    vec_boundary_nodes.push_back(edge->getNode(j)->getID());
                }
            }
        }
    }
    else
    {
        for (MeshLib::Element const* elem : _mesh.getElements())
        {
            if (elem->getDimension() < _mesh.getDimension())
            {
                continue;
            }
            if (!elem->isBoundaryElement())
            {
                continue;
            }
 
            std::size_t const n_faces(elem->getNumberOfFaces());
            for (std::size_t i = 0; i < n_faces; ++i)
            {
                if (elem->getNeighbor(i) != nullptr)
                {
                    continue;
                }
                std::unique_ptr<MeshLib::Element const> face(elem->getFace(i));
                for (unsigned j = 0; j < face->getNumberOfNodes(); j++)
                {
                    vec_boundary_nodes.push_back(face->getNode(j)->getID());
                }
            }
        }
    }
    std::sort(vec_boundary_nodes.begin(), vec_boundary_nodes.end());
    vec_boundary_nodes.erase(
        std::unique(vec_boundary_nodes.begin(), vec_boundary_nodes.end()),
        vec_boundary_nodes.end());
 
    this->updateUnion(vec_boundary_nodes);
    return vec_boundary_nodes.size();
}

References _mesh, MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getElementsConnectedToNode(), MeshLib::Mesh::getNodes(), and updateUnion().

Referenced by ProcessLib::LIE::anonymous_namespace{MeshUtils.cpp}::IsCrackTip::IsCrackTip().

searchNodesConnectedToOnlyGivenElements()

std::size_t MeshLib::NodeSearch::searchNodesConnectedToOnlyGivenElements

(

const std::vector< std::size_t > &

elements

)

Marks all nodes connected to any of the given elements ids.

Returns

number of connected nodes.

Definition at line 24 of file NodeSearch.cpp.

{
    // Find out by how many elements a node would be removed.
    //
    // Note: If there are only few elements to be removed, using a different
    // algorithm might be more memory efficient.
    std::vector<std::size_t> node_marked_counts(_mesh.getNumberOfNodes(), 0);
 
    for (std::size_t eid : elements)
    {
        auto* e = _mesh.getElement(eid);
        for (unsigned i = 0; i < e->getNumberOfNodes(); i++)
        {
            node_marked_counts[getNodeIndex(*e, i)]++;
        }
    }
 
    // Push back nodes which counts are equal to number of connected elements to
    // that node.
    std::vector<std::size_t> connected_nodes;
    for (std::size_t i = 0; i < node_marked_counts.size(); i++)
    {
        if (node_marked_counts[i] ==
            _mesh.getElementsConnectedToNode(*_mesh.getNode(i)).size())
        {
            connected_nodes.push_back(i);
        }
    }
 
    this->updateUnion(connected_nodes);
    return connected_nodes.size();
}

References _mesh, MeshLib::Mesh::getElement(), MeshLib::Mesh::getElementsConnectedToNode(), MeshLib::Mesh::getNode(), MeshLib::getNodeIndex(), MeshLib::Mesh::getNumberOfNodes(), and updateUnion().

Referenced by MeshToolsLib::removeElements().

searchUnused()

std::size_t MeshLib::NodeSearch::searchUnused

(

)

Marks all unused nodes.

Definition at line 58 of file NodeSearch.cpp.

{
    const std::size_t nNodes(_mesh.getNumberOfNodes());
    const std::vector<MeshLib::Node*>& nodes(_mesh.getNodes());
    std::vector<std::size_t> del_node_idx;
 
    for (unsigned i = 0; i < nNodes; ++i)
    {
        if (_mesh.getElementsConnectedToNode(*nodes[i]).empty())
        {
            del_node_idx.push_back(i);
        }
    }
 
    this->updateUnion(del_node_idx);
    return del_node_idx.size();
}

References _mesh, MeshLib::Mesh::getElementsConnectedToNode(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfNodes(), and updateUnion().

Referenced by MeshToolsLib::MeshValidation::allNodesUsed(), LayeredMeshGenerator::getMesh(), and MeshAnalysisDialog::on_startButton_pressed().

updateUnion()

void MeshLib::NodeSearch::updateUnion ( const std::vector< std::size_t > & vec )

private

Updates the vector of marked items with values from vec.

Definition at line 154 of file NodeSearch.cpp.

{
    std::vector<std::size_t> vec_temp(vec.size() + _marked_nodes.size());
    auto it = std::set_union(vec.begin(), vec.end(), _marked_nodes.begin(),
                             _marked_nodes.end(), vec_temp.begin());
    vec_temp.resize(it - vec_temp.begin());
    _marked_nodes.assign(vec_temp.begin(), vec_temp.end());
}

References _marked_nodes.

Referenced by searchBoundaryNodes(), searchNodesConnectedToOnlyGivenElements(), and searchUnused().

Member Data Documentation

_marked_nodes

std::vector<std::size_t> MeshLib::NodeSearch::_marked_nodes

private

The vector of element indices that should be removed.

Definition at line 50 of file NodeSearch.h.

Referenced by getSearchedNodeIDs(), and updateUnion().

_mesh

const MeshLib::Mesh& MeshLib::NodeSearch::_mesh

private

The mesh from which elements should be removed.

Definition at line 48 of file NodeSearch.h.

Referenced by searchBoundaryNodes(), searchNodesConnectedToOnlyGivenElements(), and searchUnused().

---

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

• MeshLib/MeshSearch/NodeSearch.h
• MeshLib/MeshSearch/NodeSearch.cpp