TimeDependentHeterogeneousParameter.cpp

Go to the documentation of this file.

// SPDX-FileCopyrightText: Copyright (c) OpenGeoSys Community (opengeosys.org)
// SPDX-License-Identifier: BSD-3-Clause
 
#include "TimeDependentHeterogeneousParameter.h"
 
#include "BaseLib/ConfigTree.h"
#include "BaseLib/Error.h"
#include "Utils.h"
 
namespace ParameterLib
{
TimeDependentHeterogeneousParameter::TimeDependentHeterogeneousParameter(
    std::string name,
    std::vector<PairTimeParameterName>
        time_parameter_name_mapping)
    : Parameter<double>(std::move(name), nullptr),
      _time_parameter_name_mapping(std::move(time_parameter_name_mapping))
{
}
 
int TimeDependentHeterogeneousParameter::getNumberOfGlobalComponents() const
{
    return _time_parameter_mapping[0].second->getNumberOfGlobalComponents();
}
 
bool TimeDependentHeterogeneousParameter::isTimeDependent() const
{
    return true;
}
 
std::vector<double> TimeDependentHeterogeneousParameter::operator()(
    double const t, SpatialPosition const& pos) const
{
    // No local coordinate transformation here, which might happen twice
    // otherwise.
    assert(!this->_coordinate_system ||
           "Coordinate system not expected to be set for curve scaled "
           "parameters.");
    if (t < _time_parameter_mapping[0].first)
    {
        return _time_parameter_mapping[0].second->operator()(t, pos);
    }
    if (_time_parameter_mapping.back().first <= t)
    {
        return _time_parameter_mapping.back().second->operator()(t, pos);
    }
    std::size_t k(1);
    for (; k < _time_parameter_mapping.size(); ++k)
    {
        if (_time_parameter_mapping[k - 1].first <= t &&
            t < _time_parameter_mapping[k].first)
        {
            break;
        }
    }
    if (k == _time_parameter_mapping.size())
    {
        OGS_FATAL(
            "Could not find parameter for time {}. There are {:d} "
            "time-parameter pairs.",
            t, _time_parameter_mapping.size());
    }
    auto const t0 = _time_parameter_mapping[k - 1].first;
    auto const t1 = _time_parameter_mapping[k].first;
    auto const alpha = (t - t0) / (t1 - t0);
 
    auto r0 = _time_parameter_mapping[k - 1].second->operator()(t, pos);
    std::transform(r0.begin(), r0.end(), r0.begin(),
                   [alpha](auto const& v) { return (1 - alpha) * v; });
    auto r1 = _time_parameter_mapping[k].second->operator()(t, pos);
    std::transform(r1.begin(), r1.end(), r1.begin(),
                   [alpha](auto const& v) { return alpha * v; });
    std::transform(r0.begin(), r0.end(), r1.begin(), r0.begin(),
                   [](auto const& v0, auto const& v1) { return v0 + v1; });
    return r0;
}
 
void TimeDependentHeterogeneousParameter::initialize(
    std::vector<std::unique_ptr<ParameterBase>> const& parameters)
{
    DBUG("TimeDependentHeterogeneousParameter init {:d} time series entries.",
         _time_parameter_name_mapping.size());
    for (auto const& time_parameter_map : _time_parameter_name_mapping)
    {
        auto parameter =
            &findParameter<double>(time_parameter_map.second, parameters, 0);
        _time_parameter_mapping.emplace_back(time_parameter_map.first,
                                             parameter);
    }
 
    // check that all parameters have the same number of components
    auto const n =
        _time_parameter_mapping[0].second->getNumberOfGlobalComponents();
    if (!std::all_of(_time_parameter_mapping.begin(),
                     _time_parameter_mapping.end(),
                     [n](auto const p)
                     { return n == p.second->getNumberOfGlobalComponents(); }))
    {
        OGS_FATAL(
            "All referenced parameters in time dependent heterogeneous "
            "parameter '{:s}' have to have the same number of components.",
            name);
    }
}
 
std::unique_ptr<ParameterBase> createTimeDependentHeterogeneousParameter(
    std::string const& name, BaseLib::ConfigTree const& config)
{
    auto const type = config.getConfigParameter<std::string>("type");
    if (type != "TimeDependentHeterogeneous" &&
        type != "TimeDependentHeterogeneousParameter")
    {
        OGS_FATAL(
            "Expected the parameter type 'TimeDependentHeterogeneous' (or its "
            "deprecated spelling 'TimeDependentHeterogeneousParameter'), but "
            "got '{:s}'.",
            type);
    }
    auto const time_series_config =
        config.getConfigSubtree("time_series");
 
    std::vector<TimeDependentHeterogeneousParameter::PairTimeParameterName>
        time_series;
    for (auto const p : time_series_config.getConfigSubtreeList("pair"))
    {
        auto time = p.getConfigParameter<double>("time");
        auto parameter_name =
            p.getConfigParameter<std::string>("parameter_name");
        time_series.emplace_back(time, parameter_name);
    }
 
    if (time_series.empty())
    {
        OGS_FATAL(
            "Time dependent heterogeneous parameter '{:s}' doesn't contain "
            "necessary time series data.",
            name);
    }
 
    if (!std::is_sorted(
            time_series.begin(), time_series.end(),
            [](TimeDependentHeterogeneousParameter::PairTimeParameterName const
                   & p0,
               TimeDependentHeterogeneousParameter::PairTimeParameterName const
                   & p1) { return p0.first < p1.first; }))
    {
        OGS_FATAL(
            "The points in time in the time series '{:s}' aren't in ascending "
            "order.",
            name);
    }
 
    return std::make_unique<TimeDependentHeterogeneousParameter>(
        name, std::move(time_series));
}
 
}  // namespace ParameterLib