/**
* \file
* \author Karsten Rink
* \date 2011-03-17
* \brief Implementation of the ElementSizeMetric class.
*
* \copyright
* Copyright (c) 2012-2023, OpenGeoSys Community (http://www.opengeosys.org)
* Distributed under a Modified BSD License.
* See accompanying file LICENSE.txt or
* http://www.opengeosys.org/project/license
*
*/
#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