GroupBasedParameter.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 <utility>
 
#include "BaseLib/Error.h"
#include "MeshLib/PropertyVector.h"
 
#include "Parameter.h"
 
namespace MeshLib
{
template <typename T>
class PropertyVector;
}  // namespace MeshLib
 
namespace ParameterLib
{
template <typename T, MeshLib::MeshItemType MeshItemType>
struct GroupBasedParameter final : public Parameter<T>
{
    GroupBasedParameter(std::string const& name_,
                        MeshLib::Mesh const& mesh,
                        MeshLib::PropertyVector<int> const& property,
                        std::map<int, std::vector<double>>
                            vec_values)
        : Parameter<T>(name_, &mesh),
          _property_index(property),
          _vec_values(std::move(vec_values))
    {
    }
 
    bool isTimeDependent() const override { return false; }
 
    int getNumberOfGlobalComponents() const override
    {
        return _vec_values.empty()
                   ? 0
                   : static_cast<int>(_vec_values.begin()->second.size());
    }
 
    std::vector<T> operator()(double const /*t*/,
                              SpatialPosition const& pos) const override
    {
        auto const item_id = getMeshItemID(pos, type<MeshItemType>());
        assert(item_id);
        int const index = _property_index[item_id.value()];
        auto const v = _vec_values.find(index);
        if (v == _vec_values.end())
        {
            OGS_FATAL("No data found for the group index {:d}", index);
        }
        auto const& values = v->second;
 
        if (!this->_coordinate_system)
        {
            return values;
        }
 
        return this->rotateWithCoordinateSystem(values, pos);
    }
 
private:
    template <MeshLib::MeshItemType ITEM_TYPE>
    struct type
    {
    };
 
    static std::optional<std::size_t> getMeshItemID(
        SpatialPosition const& pos,
        type<MeshLib::MeshItemType::Cell> /*unused*/)
    {
        return pos.getElementID();
    }
 
    static std::optional<std::size_t> getMeshItemID(
        SpatialPosition const& pos,
        type<MeshLib::MeshItemType::Node> /*unused*/)
    {
        return pos.getNodeID();
    }
 
    MeshLib::PropertyVector<int> const& _property_index;
    std::map<int, std::vector<T>> const _vec_values;
};
 
std::unique_ptr<ParameterBase> createGroupBasedParameter(
    std::string const& name,
    BaseLib::ConfigTree const& config,
    MeshLib::Mesh const& mesh);
 
}  // namespace ParameterLib