MeshToolsLib::MeshInformation Class Reference

Detailed Description

A set of tools for extracting information from a mesh.

Definition at line 23 of file MeshInformation.h.

#include <MeshInformation.h>

Static Public Member Functions
template<typename T>
static std::optional< std::pair< T, T > > const	getValueBounds (MeshLib::PropertyVector< T > const &property)
static GeoLib::AABB	getBoundingBox (const MeshLib::Mesh &mesh)
	Returns the bounding box of the mesh.
static std::map< MeshLib::MeshElemType, unsigned >	getNumberOfElementTypes (const MeshLib::Mesh &mesh)
static void	writeAllNumbersOfElementTypes (const MeshLib::Mesh &mesh)
	writes all numbers of element types
static void	writePropertyVectorInformation (const MeshLib::Mesh &mesh)
	writes out property vector information
static void	writeMeshValidationResults (MeshLib::Mesh &mesh)
static std::vector< int >	getMaterialIDs (const MeshLib::Mesh &mesh)
	writes out a list of all material IDs that occur in the mesh.

Member Function Documentation

getBoundingBox()

GeoLib::AABB MeshToolsLib::MeshInformation::getBoundingBox ( const MeshLib::Mesh & mesh )

static

Returns the bounding box of the mesh.

Definition at line 34 of file MeshInformation.cpp.

{
    const std::vector<MeshLib::Node*>& nodes(mesh.getNodes());
    return GeoLib::AABB(nodes.begin(), nodes.end());
}

References MeshLib::Mesh::getNodes().

Referenced by main(), outputAABB(), and ElementTreeModel::setMesh().

getMaterialIDs()

std::vector< int > MeshToolsLib::MeshInformation::getMaterialIDs ( const MeshLib::Mesh & mesh )

static

writes out a list of all material IDs that occur in the mesh.

Definition at line 157 of file MeshInformation.cpp.

{
    auto const* matids = MeshLib::materialIDs(mesh);
    if (!matids)
    {
        INFO("No MaterialIDs were found.");
        return {};
    }
 
    return *matids | ranges::views::unique | ranges::to<std::vector> |
           ranges::actions::sort | ranges::actions::unique |
           ranges::to<std::vector>;
}

References INFO(), and MeshLib::materialIDs().

Referenced by main().

getNumberOfElementTypes()

std::map< MeshLib::MeshElemType, unsigned > MeshToolsLib::MeshInformation::getNumberOfElementTypes ( const MeshLib::Mesh & mesh )

static

Returns an array with the number of elements of each type in the given mesh. On completion, n_element_types array contains the number of elements of each of the seven supported types. The index to element type conversion is this: 0: #lines 1: #triangles 2: #quads 3: #tetrahedra 4: #hexahedra 5: #pyramids 6: #prisms

Definition at line 41 of file MeshInformation.cpp.

{
    std::map<MeshLib::MeshElemType, unsigned> n_element_types;
    const std::vector<MeshLib::Element*>& elements(mesh.getElements());
    for (auto element : elements)
    {
        MeshLib::MeshElemType t = element->getGeomType();
        n_element_types[t]++;
    }
    return n_element_types;
}

References MeshLib::Mesh::getElements().

Referenced by LayeredMeshGenerator::createLayers(), ElementTreeModel::setMesh(), FileIO::TetGenInterface::write2dElements(), and writeAllNumbersOfElementTypes().

getValueBounds()

template<typename T>

std::optional< std::pair< T, T > > const MeshToolsLib::MeshInformation::getValueBounds ( MeshLib::PropertyVector< T > const & property )

inlinestatic

Returns the smallest and largest value of a scalar array with the given name.

Definition at line 29 of file MeshInformation.h.

    {
        if (property.empty())
        {
            INFO("Mesh property vector '{:s}' is empty.",
                 property.getPropertyName());
            return std::nullopt;
        }
 
        auto [min, max] = ranges::minmax(property);
        return {{min, max}};
    }

References MeshLib::PropertyVector< PROP_VAL_TYPE >::empty(), MeshLib::PropertyVectorBase::getPropertyName(), and INFO().

Referenced by ProcessLib::LIE::HydroMechanics::HydroMechanicsProcess< DisplacementDim >::HydroMechanicsProcess(), MeshToolsLib::convertMeshToGeo(), anonymous_namespace{MeshInformation.cpp}::printBounds(), and anonymous_namespace{ElementTreeModel.cpp}::propertyBounds().

writeAllNumbersOfElementTypes()

void MeshToolsLib::MeshInformation::writeAllNumbersOfElementTypes ( const MeshLib::Mesh & mesh )

static

writes all numbers of element types

Definition at line 53 of file MeshInformation.cpp.

{
    auto const& nr_ele_types =
        MeshToolsLib::MeshInformation::getNumberOfElementTypes(mesh);
 
    INFO("Number of elements in the mesh:");
    for (auto entry : nr_ele_types)
    {
        INFO("\t{:s}s: {:d}",
             MeshLib::MeshElemType2String(
                 static_cast<MeshLib::MeshElemType>(entry.first)),
             entry.second);
    }
}

References getNumberOfElementTypes(), INFO(), and MeshLib::MeshElemType2String().

Referenced by main().

writeMeshValidationResults()

void MeshToolsLib::MeshInformation::writeMeshValidationResults ( MeshLib::Mesh & mesh )

static

writes out mesh validation results Remark: MeshValidation can modify the original mesh

Definition at line 139 of file MeshInformation.cpp.

{
    INFO("Mesh Quality Control:");
    MeshToolsLib::MeshValidation::allNodesUsed(mesh);
    MeshToolsLib::MeshValidation::existCollapsibleNodes(mesh);
    MeshToolsLib::MeshValidation::evaluateElementGeometry(mesh);
 
    unsigned const n_holes(MeshToolsLib::MeshValidation::detectHoles(mesh));
    if (n_holes > 0)
    {
        INFO("{:d} hole(s) detected within the mesh", n_holes);
    }
    else
    {
        INFO("No holes found within the mesh.");
    }
}

References MeshToolsLib::MeshValidation::allNodesUsed(), MeshToolsLib::MeshValidation::detectHoles(), MeshToolsLib::MeshValidation::evaluateElementGeometry(), MeshToolsLib::MeshValidation::existCollapsibleNodes(), and INFO().

Referenced by main().

writePropertyVectorInformation()

void MeshToolsLib::MeshInformation::writePropertyVectorInformation ( const MeshLib::Mesh & mesh )

static

writes out property vector information

Definition at line 68 of file MeshInformation.cpp.

{
    auto const& properties = mesh.getProperties();
    INFO("There are {:d} properties in the mesh:", properties.size());
 
    for (auto [name, property] : properties)
    {
        if (auto const* p =
                dynamic_cast<MeshLib::PropertyVector<double>*>(property))
        {
            printBounds(*p);
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<float>*>(property))
        {
            printBounds(*p);
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<int>*>(property))
        {
            printBounds(*p);
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<unsigned>*>(property))
        {
            printBounds(*p);
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<long>*>(property))
        {
            printBounds(*p);
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<long long>*>(
                         property))
        {
            printBounds(*p);
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<unsigned long>*>(
                         property))
        {
            printBounds(*p);
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<unsigned long long>*>(
                         property))
        {
            printBounds(*p);
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<std::size_t>*>(
                         property))
        {
            printBounds(*p);
        }
        else if (auto const* p =
                     dynamic_cast<MeshLib::PropertyVector<char>*>(property))
        {
            printBounds(*p);
        }
        else
        {
            INFO(
                "\t{:s}: Could not get value bounds for property vector of "
                "type '{:s}'.",
                name, BaseLib::typeToString(*property));
        }
    }
}

References MeshLib::Mesh::getProperties(), INFO(), and BaseLib::typeToString().

Referenced by main().

---

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

• MeshInformation.h
• MeshInformation.cpp