Detailed Description

Definition at line 22 of file TimeDependentHeterogeneousParameter.h.

#include <TimeDependentHeterogeneousParameter.h>

Inheritance diagram for ParameterLib::TimeDependentHeterogeneousParameter:

Collaboration diagram for ParameterLib::TimeDependentHeterogeneousParameter:

Public Types
using	PairTimeParameterName = std::pair<double, std::string>

using	PairTimeParameter = std::pair<double, Parameter<double> const* const>

Public Member Functions
	TimeDependentHeterogeneousParameter (std::string name, std::vector< PairTimeParameterName > time_parameter_name_mapping)

int	getNumberOfGlobalComponents () const override

bool	isTimeDependent () const override

std::vector< double >	operator() (double const t, SpatialPosition const &pos) const override
	Returns the parameter value at the given time and position.

void	initialize (std::vector< std::unique_ptr< ParameterBase > > const &parameters) override

Public Member Functions inherited from ParameterLib::Parameter< double >
	~Parameter () override=default

virtual Eigen::Matrix< double, Eigen::Dynamic, Eigen::Dynamic >	getNodalValuesOnElement (MeshLib::Element const &element, double const t) const
	Returns a matrix of values for all nodes of the given element.

	ParameterBase (std::string name_, MeshLib::Mesh const *mesh=nullptr)

Public Member Functions inherited from ParameterLib::ParameterBase
	ParameterBase (std::string name_, MeshLib::Mesh const *mesh=nullptr)

virtual	~ParameterBase ()=default

void	setCoordinateSystem (CoordinateSystem const &coordinate_system)

MeshLib::Mesh const *	mesh () const

Private Attributes
std::vector< PairTimeParameterName >	_time_parameter_name_mapping

std::vector< PairTimeParameter >	_time_parameter_mapping

Additional Inherited Members
Public Attributes inherited from ParameterLib::ParameterBase
std::string const	name

Protected Member Functions inherited from ParameterLib::ParameterBase
std::vector< double >	rotateWithCoordinateSystem (std::vector< double > const &values, SpatialPosition const &pos) const

Protected Attributes inherited from ParameterLib::ParameterBase
std::optional< CoordinateSystem >	_coordinate_system

MeshLib::Mesh const *	_mesh

Member Typedef Documentation

◆ PairTimeParameter

using ParameterLib::TimeDependentHeterogeneousParameter::PairTimeParameter = std::pair<double, Parameter<double> const* const>

Definition at line 26 of file TimeDependentHeterogeneousParameter.h.

◆ PairTimeParameterName

using ParameterLib::TimeDependentHeterogeneousParameter::PairTimeParameterName = std::pair<double, std::string>

Definition at line 25 of file TimeDependentHeterogeneousParameter.h.

Constructor & Destructor Documentation

◆ TimeDependentHeterogeneousParameter()

ParameterLib::TimeDependentHeterogeneousParameter::TimeDependentHeterogeneousParameter	(	std::string	name,
		std::vector< PairTimeParameterName >	time_parameter_name_mapping )

Definition at line 19 of file TimeDependentHeterogeneousParameter.cpp.

    : Parameter<double>(std::move(name), nullptr),
      _time_parameter_name_mapping(std::move(time_parameter_name_mapping))
{
}

Member Function Documentation

◆ getNumberOfGlobalComponents()

int ParameterLib::TimeDependentHeterogeneousParameter::getNumberOfGlobalComponents ( ) const

overridevirtual

Returns the number of components this Parameter has at every position and point in time.

Implements ParameterLib::Parameter< double >.

Definition at line 28 of file TimeDependentHeterogeneousParameter.cpp.

{
    return _time_parameter_mapping[0].second->getNumberOfGlobalComponents();
}

References _time_parameter_mapping, and ParameterLib::Parameter< T >::getNumberOfGlobalComponents().

◆ initialize()

void ParameterLib::TimeDependentHeterogeneousParameter::initialize ( std::vector< std::unique_ptr< ParameterBase > > const & parameters )

overridevirtual

The TimeDependentHeterogeneousParameter depends in each time step on a parameter. Since, at construction time of the TimeDependentHeterogeneousParameter other parameter needs not to be constructed and hence can't be used to setup the object this is done later on in the initialize method.

Reimplemented from ParameterLib::ParameterBase.

Definition at line 85 of file TimeDependentHeterogeneousParameter.cpp.

{
    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);
    }
}

References _time_parameter_mapping, _time_parameter_name_mapping, DBUG(), ParameterLib::findParameter(), ParameterLib::ParameterBase::name, and OGS_FATAL.

◆ isTimeDependent()

bool ParameterLib::TimeDependentHeterogeneousParameter::isTimeDependent ( ) const

overridevirtual

Implements ParameterLib::ParameterBase.

Definition at line 33 of file TimeDependentHeterogeneousParameter.cpp.

{
    return true;
}

◆ operator()()

std::vector< double > ParameterLib::TimeDependentHeterogeneousParameter::operator()	(	double const	t,
		SpatialPosition const &	pos ) const

overridevirtual

Returns the parameter value at the given time and position.

Implements ParameterLib::Parameter< double >.

Definition at line 38 of file TimeDependentHeterogeneousParameter.cpp.

{
    // 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;
}