ElementQualityInterface.h

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#pragma once
 
#include <memory>
#include <vector>
 
#include "BaseLib/Histogram.h"
#include "MeshLib/Mesh.h"
#include "MeshToolsLib/MeshQuality/AngleSkewMetric.h"
#include "MeshToolsLib/MeshQuality/EdgeRatioMetric.h"
#include "MeshToolsLib/MeshQuality/ElementQualityMetric.h"
#include "MeshToolsLib/MeshQuality/ElementSizeMetric.h"
#include "MeshToolsLib/MeshQuality/RadiusEdgeRatioMetric.h"
#include "MeshToolsLib/MeshQuality/SizeDifferenceMetric.h"
 
namespace MeshToolsLib
{

class ElementQualityInterface
{
public:
    ElementQualityInterface(MeshLib::Mesh const& mesh,
                            MeshLib::MeshQualityType t)
        : _type(t), _mesh(mesh), _quality_tester(nullptr)
    {
        calculateElementQuality(_mesh, _type);
    }

    std::vector<double> const getQualityVector() const
    {
        if (_quality_tester)
        {
            return _quality_tester->getElementQuality();
        }
 
        std::vector<double> empty_quality_vec(0);
        return empty_quality_vec;
    }

    BaseLib::Histogram<double> getHistogram(std::size_t n_bins = 0) const
    {
        if (_quality_tester)
        {
            return _quality_tester->getHistogram(
                static_cast<std::size_t>(n_bins));
        }
 
        return BaseLib::Histogram<double>{{}};
    }

    int writeHistogram(std::string const& file_name,
                       std::size_t n_bins = 0) const
    {
        if (_quality_tester == nullptr)
        {
            return 1;
        }
 
        BaseLib::Histogram<double> const histogram(
            _quality_tester->getHistogram(n_bins));
        histogram.write(file_name, _mesh.getName(),
                        MeshQualityType2String(_type));
        return 0;
    }
 
private:
    void calculateElementQuality(MeshLib::Mesh const& mesh,
                                 MeshLib::MeshQualityType t)
    {
        if (t == MeshLib::MeshQualityType::EDGERATIO)
        {
            _quality_tester =
                std::make_unique<MeshToolsLib::EdgeRatioMetric>(mesh);
        }
        else if (t == MeshLib::MeshQualityType::ELEMENTSIZE)
        {
            _quality_tester =
                std::make_unique<MeshToolsLib::ElementSizeMetric>(mesh);
        }
        else if (t == MeshLib::MeshQualityType::SIZEDIFFERENCE)
        {
            _quality_tester =
                std::make_unique<MeshToolsLib::SizeDifferenceMetric>(mesh);
        }
        else if (t == MeshLib::MeshQualityType::EQUIANGLESKEW)
        {
            _quality_tester =
                std::make_unique<MeshToolsLib::AngleSkewMetric>(mesh);
        }
        else if (t == MeshLib::MeshQualityType::RADIUSEDGERATIO)
        {
            _quality_tester =
                std::make_unique<MeshToolsLib::RadiusEdgeRatioMetric>(mesh);
        }
        else
        {
            ERR("ElementQualityInterface::calculateElementQuality(): Unknown "
                "MeshQualityType.");
            return;
        }
        _quality_tester->calculateQuality();
    }
 
    MeshLib::MeshQualityType const _type;
    MeshLib::Mesh const& _mesh;
    std::unique_ptr<MeshToolsLib::ElementQualityMetric> _quality_tester;
};
 
}  // namespace MeshToolsLib