ElementSizeMetric.cpp

Go to the documentation of this file.

 
#include "ElementSizeMetric.h"
 
#include <limits>
 
namespace MeshLib
{
void ElementSizeMetric::calculateQuality()
{
    std::size_t error_count(0);
    if (_mesh.getDimension() == 1)
    {
        error_count = calc1dQuality();
    }
    else if (_mesh.getDimension() == 2)
    {
        error_count = calc2dQuality();
    }
    else if (_mesh.getDimension() == 3)
    {
        error_count = calc3dQuality();
    }
 
    INFO(
        "ElementSizeMetric::calculateQuality() minimum: {:f}, max_volume: {:f}",
        _min,
        _max);
    if (error_count > 0)
    {
        WARN("Warning: {:d} elements with zero volume found.", error_count);
    }
}
 
std::size_t ElementSizeMetric::calc1dQuality()
{
    const std::vector<MeshLib::Element*>& elements(_mesh.getElements());
    const std::size_t nElems(elements.size());
    std::size_t error_count(0);
 
    for (std::size_t k(0); k < nElems; k++)
    {
        double area(std::numeric_limits<double>::max());
        _element_quality_metric[k] = elements[k]->getContent();
        if (_element_quality_metric[k] <
            std::sqrt(std::abs(std::numeric_limits<double>::epsilon())))
        {
            error_count++;
        }
 
        // update _min and _max values
        if (_min > area)
        {
            _min = area;
        }
        if (_max < area)
        {
            _max = area;
        }
    }
    return error_count;
}
 
std::size_t ElementSizeMetric::calc2dQuality()
{
    const std::vector<MeshLib::Element*>& elements(_mesh.getElements());
    const std::size_t nElems(elements.size());
    std::size_t error_count(0);
 
    for (std::size_t k(0); k < nElems; k++)
    {
        Element const& elem(*elements[k]);
 
        if (elem.getDimension() == 1)
        {
            _element_quality_metric[k] = 0.0;
            continue;
        }
        double const area = elem.getContent();
        if (area < std::sqrt(std::abs(std::numeric_limits<double>::epsilon())))
        {
            error_count++;
        }
 
        // update _min and _max values
        if (_min > area)
        {
            _min = area;
        }
        if (_max < area)
        {
            _max = area;
        }
        _element_quality_metric[k] = area;
    }
    return error_count;
}
 
std::size_t ElementSizeMetric::calc3dQuality()
{
    const std::vector<MeshLib::Element*>& elements(_mesh.getElements());
    const std::size_t nElems(elements.size());
    std::size_t error_count(0);
 
    for (std::size_t k(0); k < nElems; k++)
    {
        Element const& elem(*elements[k]);
        if (elem.getDimension() < 3)
        {
            _element_quality_metric[k] = 0.0;
            continue;
        }
 
        double const volume(elem.getContent());
        if (volume < sqrt(std::abs(std::numeric_limits<double>::epsilon())))
        {
            error_count++;
        }
 
        if (_min > volume)
        {
            _min = volume;
        }
        if (_max < volume)
        {
            _max = volume;
        }
        _element_quality_metric[k] = volume;
    }
    return error_count;
}
 
}  // end namespace MeshLib