MeshToolsLib::MeshSurfaceExtraction Class Reference

Detailed Description

A set of tools concerned with extracting nodes and elements from a mesh surface.

Definition at line 38 of file MeshSurfaceExtraction.h.

#include <MeshSurfaceExtraction.h>

Static Public Member Functions
static std::vector< double >	getSurfaceAreaForNodes (const MeshLib::Mesh &mesh)
	Returns a vector of the areas assigned to each node on a surface mesh.
static std::vector< MeshLib::Node * >	getSurfaceNodes (const MeshLib::Mesh &mesh, Eigen::Vector3d const &dir, double angle)
	Returns the surface nodes of a 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 Private Member Functions
static void	get2DSurfaceElements (const std::vector< MeshLib::Element * > &all_elements, std::vector< MeshLib::Element * > &sfc_elements, std::vector< std::size_t > &element_to_bulk_element_id_map, std::vector< std::size_t > &element_to_bulk_face_id_map, Eigen::Vector3d const &dir, double angle, unsigned mesh_dimension)
	Functionality needed for getSurfaceNodes() and getMeshSurface()

Member Function Documentation

get2DSurfaceElements()

void MeshToolsLib::MeshSurfaceExtraction::get2DSurfaceElements ( const std::vector< MeshLib::Element * > & all_elements, std::vector< MeshLib::Element * > & sfc_elements, std::vector< std::size_t > & element_to_bulk_element_id_map, std::vector< std::size_t > & element_to_bulk_face_id_map, Eigen::Vector3d const & dir, double angle, unsigned mesh_dimension )

staticprivate

Functionality needed for getSurfaceNodes() and getMeshSurface()

Definition at line 300 of file MeshSurfaceExtraction.cpp.

{
    if (mesh_dimension < 2 || mesh_dimension > 3)
    {
        ERR("Cannot handle meshes of dimension {}", mesh_dimension);
    }
 
    bool const complete_surface = (dir.dot(dir) == 0);
 
    double const cos_theta(std::cos(angle * std::numbers::pi / 180.0));
    Eigen::Vector3d const norm_dir(dir.normalized());
 
    for (auto const* elem : all_elements)
    {
        const unsigned element_dimension(elem->getDimension());
        if (element_dimension < mesh_dimension)
        {
            continue;
        }
 
        if (element_dimension == 2)
        {
            if (!complete_surface)
            {
                if (MeshLib::FaceRule::getSurfaceNormal(*elem).normalized().dot(
                        norm_dir) > cos_theta)
                {
                    continue;
                }
            }
            sfc_elements.push_back(elem->clone());
            element_to_bulk_element_id_map.push_back(elem->getID());
            element_to_bulk_face_id_map.push_back(0);
        }
        else
        {
            if (!elem->isBoundaryElement())
            {
                continue;
            }
            const unsigned nFaces(elem->getNumberOfFaces());
            for (unsigned j = 0; j < nFaces; ++j)
            {
                if (elem->getNeighbor(j) != nullptr)
                {
                    continue;
                }
 
                auto const face =
                    std::unique_ptr<MeshLib::Element const>{elem->getFace(j)};
                if (!complete_surface)
                {
                    if (MeshLib::FaceRule::getSurfaceNormal(*face)
                            .normalized()
                            .dot(norm_dir) < cos_theta)
                    {
                        continue;
                    }
                }
                switch (face->getCellType())
                {
                    case MeshLib::CellType::TRI3:
                        sfc_elements.push_back(new MeshLib::Tri(
                            *static_cast<const MeshLib::Tri*>(face.get())));
                        break;
                    case MeshLib::CellType::TRI6:
                        sfc_elements.push_back(new MeshLib::Tri6(
                            *static_cast<const MeshLib::Tri6*>(face.get())));
                        break;
                    case MeshLib::CellType::QUAD4:
                        sfc_elements.push_back(new MeshLib::Quad(
                            *static_cast<const MeshLib::Quad*>(face.get())));
                        break;
                    case MeshLib::CellType::QUAD8:
                        sfc_elements.push_back(new MeshLib::Quad8(
                            *static_cast<const MeshLib::Quad8*>(face.get())));
                        break;
                    case MeshLib::CellType::QUAD9:
                        sfc_elements.push_back(new MeshLib::Quad9(
                            *static_cast<const MeshLib::Quad9*>(face.get())));
                        break;
                    default:
                        DBUG("unknown cell type");
                }
                element_to_bulk_element_id_map.push_back(elem->getID());
                element_to_bulk_face_id_map.push_back(j);
            }
        }
    }
}

References DBUG(), ERR(), MeshLib::FaceRule::getSurfaceNormal(), MeshLib::QUAD4, MeshLib::QUAD8, MeshLib::QUAD9, MeshLib::TRI3, and MeshLib::TRI6.

Referenced by getMeshSurface(), and getSurfaceNodes().

getMeshSurface()

MeshLib::Mesh * MeshToolsLib::MeshSurfaceExtraction::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

Returns the 2d-element mesh representing the surface of the given mesh.

Parameters

subsfc_mesh	The original mesh
dir	The direction in which face normals have to point to be considered surface elements
angle	The angle of the allowed deviation from the given direction (0 <= angle <= 90 degrees)
subsfc_node_id_prop_name	The name of the PropertyVector in the surface mesh the subsurface mesh node ids are stored to. If the string is empty, there won't be such a PropertyVector.
subsfc_element_id_prop_name	The name of the PropertyVector in the surface mesh that stores the subsurface element ids. If the string is empty, there won't be such a PropertyVector.
face_id_prop_name	The name of the PropertyVector in the surface mesh that stores the face number of the subsurface element that belongs to the boundary. If the string is empty, there won't be such a PropertyVector.

Returns

A 2D mesh representing the surface in direction dir

Definition at line 244 of file MeshSurfaceExtraction.cpp.

{
    // allow slightly greater angles than 90 degrees for numerical errors
    if (angle < 0 || angle > 91)
    {
        ERR("Supported angle between 0 and 90 degrees only.");
        return nullptr;
    }
 
    INFO("Extracting mesh surface...");
    std::vector<MeshLib::Element*> sfc_elements;
    std::vector<std::size_t> element_ids_map;
    std::vector<std::size_t> face_ids_map;
    get2DSurfaceElements(subsfc_mesh.getElements(), sfc_elements,
                         element_ids_map, face_ids_map, dir, angle,
                         subsfc_mesh.getDimension());
 
    if (sfc_elements.empty())
    {
        return nullptr;
    }
 
    auto [sfc_nodes, node_id_map] = createNodesAndIDMapFromElements(
        sfc_elements, subsfc_mesh.getNumberOfNodes());
 
    // create new elements vector with newly created nodes (and delete
    // temp-elements)
    auto new_elements =
        MeshLib::copyElementVector(sfc_elements, sfc_nodes, &node_id_map);
    std::for_each(sfc_elements.begin(), sfc_elements.end(),
                  [](MeshLib::Element* e) { delete e; });
 
    auto sfc_node_ids = sfc_nodes | MeshLib::views::ids;
    std::vector<std::size_t> const id_map(sfc_node_ids.begin(),
                                          sfc_node_ids.end());
 
    MeshLib::Mesh* result(
        new MeshLib::Mesh(subsfc_mesh.getName() + "-Surface", sfc_nodes,
                          new_elements, true /* compute_element_neighbors */));
 
    addBulkIDPropertiesToMesh(*result, subsfc_node_id_prop_name, id_map,
                              subsfc_element_id_prop_name, element_ids_map,
                              face_id_prop_name, face_ids_map);
 
    if (!createSfcMeshProperties(*result, subsfc_mesh.getProperties(), id_map,
                                 element_ids_map))
    {
        ERR("Transferring subsurface properties failed.");
    }
    return result;
}

References MeshToolsLib::addBulkIDPropertiesToMesh(), MeshLib::copyElementVector(), MeshToolsLib::createNodesAndIDMapFromElements(), MeshToolsLib::createSfcMeshProperties(), ERR(), get2DSurfaceElements(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getName(), MeshLib::Mesh::getNumberOfNodes(), MeshLib::Mesh::getProperties(), MeshLib::views::ids, and INFO().

Referenced by MeshToolsLib::addLayerToMesh(), MeshGeoToolsLib::GeoMapper::advancedMapOnMesh(), DirectConditionGenerator::directWithSurfaceIntegration(), MeshView::extractSurfaceMesh(), main(), and MeshGeoToolsLib::GeoMapper::mapOnMesh().

getSurfaceAreaForNodes()

std::vector< double > MeshToolsLib::MeshSurfaceExtraction::getSurfaceAreaForNodes ( const MeshLib::Mesh & mesh )

static

Returns a vector of the areas assigned to each node on a surface mesh.

Definition at line 202 of file MeshSurfaceExtraction.cpp.

{
    std::vector<double> node_area_vec;
    if (mesh.getDimension() != 2)
    {
        ERR("Error in MeshSurfaceExtraction::getSurfaceAreaForNodes() - Given "
            "mesh is no surface mesh (dimension != 2).");
        return node_area_vec;
    }
 
    double total_area(0);
 
    // for each node, a vector containing all the element idget every element
    const std::vector<MeshLib::Node*>& nodes = mesh.getNodes();
    const std::size_t nNodes(mesh.getNumberOfNodes());
    for (std::size_t n = 0; n < nNodes; ++n)
    {
        double node_area(0);
 
        auto const conn_elems = mesh.getElementsConnectedToNode(*nodes[n]);
        const std::size_t nConnElems(conn_elems.size());
 
        for (std::size_t i = 0; i < nConnElems; ++i)
        {
            const MeshLib::Element* elem(conn_elems[i]);
            const unsigned nElemParts =
                (elem->getGeomType() == MeshLib::MeshElemType::TRIANGLE) ? 3
                                                                         : 4;
            const double area = conn_elems[i]->getContent() / nElemParts;
            node_area += area;
            total_area += area;
        }
 
        node_area_vec.push_back(node_area);
    }
 
    INFO("Total surface Area: {:f}", total_area);
 
    return node_area_vec;
}

References ERR(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElementsConnectedToNode(), MeshLib::Element::getGeomType(), MeshLib::Mesh::getNodes(), MeshLib::Mesh::getNumberOfNodes(), INFO(), and MeshLib::TRIANGLE.

Referenced by DirectConditionGenerator::directWithSurfaceIntegration(), and main().

getSurfaceNodes()

std::vector< MeshLib::Node * > MeshToolsLib::MeshSurfaceExtraction::getSurfaceNodes ( const MeshLib::Mesh & mesh, Eigen::Vector3d const & dir, double angle )

static

Returns the surface nodes of a mesh.

Definition at line 396 of file MeshSurfaceExtraction.cpp.

{
    INFO("Extracting surface nodes...");
    std::vector<MeshLib::Element*> sfc_elements;
    std::vector<std::size_t> element_to_bulk_element_id_map;
    std::vector<std::size_t> element_to_bulk_face_id_map;
 
    get2DSurfaceElements(
        mesh.getElements(), sfc_elements, element_to_bulk_element_id_map,
        element_to_bulk_face_id_map, dir, angle, mesh.getDimension());
 
    std::vector<MeshLib::Node*> surface_nodes;
    std::tie(surface_nodes, std::ignore) =
        createNodesAndIDMapFromElements(sfc_elements, mesh.getNumberOfNodes());
 
    for (auto e : sfc_elements)
    {
        delete e;
    }
 
    return surface_nodes;
}

References MeshToolsLib::createNodesAndIDMapFromElements(), get2DSurfaceElements(), MeshLib::Mesh::getDimension(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getNumberOfNodes(), and INFO().

Referenced by DirectConditionGenerator::directToSurfaceNodes(), and main().

---

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

• MeshToolsLib/MeshSurfaceExtraction.h
• MeshToolsLib/MeshSurfaceExtraction.cpp