MeshToolsLib::MeshValidation Struct Reference

Detailed Description

A collection of methods for testing mesh quality and correctness.

Definition at line 24 of file MeshValidation.h.

#include <MeshValidation.h>

Static Public Member Functions
static bool	allNodesUsed (MeshLib::Mesh const &mesh)
static bool	existCollapsibleNodes (MeshLib::Mesh &mesh, double const eps)
static void	evaluateElementGeometry (MeshLib::Mesh const &mesh)
static std::vector< ElementErrorCode >	testElementGeometry (const MeshLib::Mesh &mesh, double min_volume=std::numeric_limits< double >::epsilon())
static std::array< std::string, static_cast< std::size_t >(ElementErrorFlag::MaxValue)>	ElementErrorCodeOutput (const std::vector< ElementErrorCode > &error_codes)
static unsigned	detectHoles (MeshLib::Mesh const &mesh)

Member Function Documentation

allNodesUsed()

bool MeshToolsLib::MeshValidation::allNodesUsed ( MeshLib::Mesh const & mesh )

static

Tests if all nodes of the mesh are used in an element.

Parameters

mesh	The mesh that is tested

Returns

true, if all nodes are used, else false

Definition at line 53 of file MeshValidation.cpp.

{
    INFO("Looking for unused nodes...");
    MeshLib::NodeSearch ns(mesh);
    ns.searchUnused();
    if (!ns.getSearchedNodeIDs().empty())
    {
        INFO("{:d} unused mesh nodes found.", ns.getSearchedNodeIDs().size());
        return false;
    }
    return true;
}

References MeshLib::NodeSearch::getSearchedNodeIDs(), INFO(), and MeshLib::NodeSearch::searchUnused().

Referenced by MeshToolsLib::MeshInformation::writeMeshValidationResults().

detectHoles()

unsigned MeshToolsLib::MeshValidation::detectHoles ( MeshLib::Mesh const & mesh )

static

Tests if holes are located within the mesh. In this context, a hole is a boundary of an element with no neighbor that cannot be reached from the actual boundary of the mesh. Examples include a missing triangle in a 2D mesh or a missing Tetrahedron in a 3D mesh. The method does not work for 1d-meshes. Note, that this method does not work when complex 3D structures are build from 2D mesh elements, e.g. using the LayeredVolume-class, where more than two 2D elements may share an edge.

Parameters

mesh	The mesh that is tested

Returns

The number of holes that have been found.

Definition at line 197 of file MeshValidation.cpp.

{
    if (mesh.getDimension() == 1)
    {
        return 0;
    }
 
    auto boundary_mesh =
        MeshToolsLib::BoundaryExtraction::getBoundaryElementsAsMesh(
            mesh,
            MeshLib::getBulkIDString(MeshLib::MeshItemType::Node),
            MeshLib::getBulkIDString(MeshLib::MeshItemType::Cell),
            MeshLib::getBulkIDString(MeshLib::MeshItemType::Face));
    std::vector<MeshLib::Element*> const& elements(
        boundary_mesh->getElements());
 
    std::vector<unsigned> sfc_idx(elements.size(),
                                  std::numeric_limits<unsigned>::max());
    unsigned current_surface_id(0);
    auto it = sfc_idx.cbegin();
 
    while (it != sfc_idx.cend())
    {
        std::size_t const idx =
            static_cast<std::size_t>(std::distance(sfc_idx.cbegin(), it));
        trackSurface(elements[idx], sfc_idx, current_surface_id++);
        it = std::find(sfc_idx.cbegin(),
                       sfc_idx.cend(),
                       std::numeric_limits<unsigned>::max());
    }
 
    // Subtract "1" from the number of surfaces found to get the number of
    // holes.
    return (--current_surface_id);
}

References MeshLib::Cell, MeshLib::Face, MeshToolsLib::BoundaryExtraction::getBoundaryElementsAsMesh(), MeshLib::getBulkIDString(), MeshLib::Mesh::getDimension(), MeshLib::Node, and MeshToolsLib::trackSurface().

Referenced by MeshAnalysisDialog::on_startButton_pressed(), and MeshToolsLib::MeshInformation::writeMeshValidationResults().

ElementErrorCodeOutput()

std::array< std::string, static_cast< std::size_t >(ElementErrorFlag::MaxValue)> MeshToolsLib::MeshValidation::ElementErrorCodeOutput ( const std::vector< ElementErrorCode > & error_codes )

static

Detailed output which ElementID is associated with which error(s)

Returns

String containing the report

Definition at line 159 of file MeshValidation.cpp.

{
    const auto nErrorFlags(
        static_cast<std::size_t>(ElementErrorFlag::MaxValue));
    const ElementErrorFlag flags[nErrorFlags] = {
        ElementErrorFlag::ZeroVolume, ElementErrorFlag::NonCoplanar,
        ElementErrorFlag::NonConvex, ElementErrorFlag::NodeOrder};
    const std::size_t nElements(error_codes.size());
    std::array<std::string,
               static_cast<std::size_t>(ElementErrorFlag::MaxValue)>
        output;
 
    for (std::size_t i = 0; i < nErrorFlags; ++i)
    {
        unsigned count(0);
        std::string elementIdStr;
 
        for (std::size_t j = 0; j < nElements; ++j)
        {
            if (error_codes[j][flags[i]])
            {
                elementIdStr += (std::to_string(j) + ", ");
                count++;
            }
        }
        const std::string nErrorsStr = (count) ? std::to_string(count) : "No";
        output[i] = (nErrorsStr + " elements found with " +
                     ElementErrorCode::toString(flags[i]) + ".\n");
 
        if (count)
        {
            output[i] += ("ElementIDs: " + elementIdStr + "\n");
        }
    }
    return output;
}

References MaxValue, NodeOrder, NonConvex, NonCoplanar, ElementErrorCode::toString(), and ZeroVolume.

Referenced by MeshAnalysisDialog::elementsMsgOutput(), and evaluateElementGeometry().

evaluateElementGeometry()

void MeshToolsLib::MeshValidation::evaluateElementGeometry ( MeshLib::Mesh const & mesh )

static

Prints evaluation data computed by testElementGeometry.

Parameters

mesh	The mesh that is tested

Definition at line 75 of file MeshValidation.cpp.

{
    const std::vector<ElementErrorCode> codes(
        MeshToolsLib::MeshValidation::testElementGeometry(mesh));
    std::array<std::string,
               static_cast<std::size_t>(ElementErrorFlag::MaxValue)>
        output_str(MeshToolsLib::MeshValidation::ElementErrorCodeOutput(codes));
    for (auto& i : output_str)
    {
        INFO("{:s}", i);
    }
}

References ElementErrorCodeOutput(), INFO(), MaxValue, and testElementGeometry().

Referenced by MeshToolsLib::MeshInformation::writeMeshValidationResults().

existCollapsibleNodes()

bool MeshToolsLib::MeshValidation::existCollapsibleNodes ( MeshLib::Mesh & mesh, double const eps )

static

Tests if nodes of the mesh can be collapsed.

Parameters

mesh	The mesh that is tested
eps	Distance threshold, if distance of two nodes is less than the eps then they are considered as collapsible.

Returns

true, if nodes can be collapsed, else false

Definition at line 66 of file MeshValidation.cpp.

{
    MeshRevision const rev(mesh);
    INFO("Found {:d} potentially collapsible nodes.",
         rev.getNumberOfCollapsibleNodes(eps));
    return (rev.getNumberOfCollapsibleNodes() > 0);
}

References MeshToolsLib::MeshRevision::getNumberOfCollapsibleNodes(), and INFO().

Referenced by MeshToolsLib::MeshInformation::writeMeshValidationResults().

testElementGeometry()

std::vector< ElementErrorCode > MeshToolsLib::MeshValidation::testElementGeometry ( const MeshLib::Mesh & mesh, double min_volume = std::numeric_limits<double>::epsilon() )

static

Tests if elements are geometrically correct.

Parameters

mesh	The mesh that is tested
min_volume	The minimum required volume for a mesh element, so it is NOT considered faulty

Returns

Vector of error codes for each mesh element

Definition at line 88 of file MeshValidation.cpp.

{
    INFO("Testing mesh element geometry:");
    const auto nErrorCodes(
        static_cast<std::size_t>(ElementErrorFlag::MaxValue));
    unsigned error_count[nErrorCodes];
    std::fill_n(error_count, 4, 0);
    const std::size_t nElements(mesh.getNumberOfElements());
    const std::vector<MeshLib::Element*>& elements(mesh.getElements());
    std::vector<ElementErrorCode> error_code_vector;
    error_code_vector.reserve(nElements);
 
    for (std::size_t i = 0; i < nElements; ++i)
    {
        const ElementErrorCode e = elements[i]->validate();
        error_code_vector.push_back(e);
        if (e.none())
        {
            continue;
        }
 
        // increment error statistics
        const std::bitset<static_cast<std::size_t>(ElementErrorFlag::MaxValue)>
            flags(static_cast<std::bitset<static_cast<std::size_t>(
                      ElementErrorFlag::MaxValue)>>(e));
        for (unsigned j = 0; j < nErrorCodes; ++j)
        {
            error_count[j] += flags[j];
        }
    }
 
    // if a larger volume threshold is given, evaluate elements again to add
    // them even if they are formally okay
    if (min_volume > std::numeric_limits<double>::epsilon())
    {
        for (std::size_t i = 0; i < nElements; ++i)
        {
            if (elements[i]->getContent() < min_volume)
            {
                error_code_vector[i].set(ElementErrorFlag::ZeroVolume);
            }
        }
    }
 
    // output
    const auto error_sum(static_cast<unsigned>(
        std::accumulate(error_count, error_count + nErrorCodes, 0.0)));
    if (error_sum != 0)
    {
        ElementErrorFlag const flags[nErrorCodes] = {
            ElementErrorFlag::ZeroVolume, ElementErrorFlag::NonCoplanar,
            ElementErrorFlag::NonConvex, ElementErrorFlag::NodeOrder};
        for (std::size_t i = 0; i < nErrorCodes; ++i)
        {
            if (error_count[i])
            {
                INFO("{:d} elements found with {:s}.",
                     error_count[i],
                     ElementErrorCode::toString(flags[i]));
            }
        }
    }
    else
    {
        INFO("No errors found.");
    }
    return error_code_vector;
}

References MeshLib::Mesh::getElements(), MeshLib::Mesh::getNumberOfElements(), INFO(), MaxValue, NodeOrder, NonConvex, NonCoplanar, ElementErrorCode::toString(), and ZeroVolume.

Referenced by evaluateElementGeometry(), and MeshAnalysisDialog::on_startButton_pressed().

---

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

• MeshValidation.h
• MeshValidation.cpp