Detailed Description

template<typename T>
struct ParameterLib::FunctionParameter< T >

A parameter class evaluating functions defined by user-provided mathematical expressions.

Currently, x, y, z, and t are supported as variables of the functions.

Definition at line 22 of file FunctionParameter.h.

#include <FunctionParameter.h>

Inheritance diagram for ParameterLib::FunctionParameter< T >:

[legend]

Collaboration diagram for ParameterLib::FunctionParameter< T >:

[legend]

Classes
class	CurveWrapper

Public Types
using	symbol_table_t = exprtk::symbol_table<T>
using	expression_t = exprtk::expression<T>
using	parser_t = exprtk::parser<T>

Public Member Functions
	FunctionParameter (std::string const &name, std::vector< std::string > const &vec_expression_str, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
bool	isTimeDependent () const override
int	getNumberOfGlobalComponents () const override
std::vector< T >	operator() (double const t, SpatialPosition const &pos) const override
	Returns the parameter value at the given time and position.
Public Member Functions inherited from ParameterLib::Parameter< T >
	~Parameter () override=default
virtual Eigen::Matrix< T, 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)
virtual void	initialize (std::vector< std::unique_ptr< ParameterBase > > const &)
MeshLib::Mesh const *	mesh () const

Private Attributes
symbol_table_t	_symbol_table
std::vector< expression_t >	_vec_expression
std::vector< std::pair< std::string, CurveWrapper > >	_curves
std::mutex	_mutex

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

◆ expression_t

template<typename T>

using ParameterLib::FunctionParameter< T >::expression_t = exprtk::expression<T>

Definition at line 43 of file FunctionParameter.h.

◆ parser_t

template<typename T>

using ParameterLib::FunctionParameter< T >::parser_t = exprtk::parser<T>

Definition at line 44 of file FunctionParameter.h.

◆ symbol_table_t

template<typename T>

using ParameterLib::FunctionParameter< T >::symbol_table_t = exprtk::symbol_table<T>

Definition at line 42 of file FunctionParameter.h.

Constructor & Destructor Documentation

◆ FunctionParameter()

template<typename T>

ParameterLib::FunctionParameter< T >::FunctionParameter	(	std::string const &	name,
		std::vector< std::string > const &	vec_expression_str,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

inline

Constructing from a vector of expressions

Parameters

name	the parameter's name
vec_expression_str	a vector of mathematical expressions
curves	named list of curves used by expressions. The vector size specifies the number of components of the parameter.

Definition at line 54 of file FunctionParameter.h.

        : Parameter<T>(name, nullptr)
    {
        // Convert curves to function objects callable by the exprtk.
        _curves.reserve(curves.size());
        std::transform(
            begin(curves), end(curves), std::back_inserter(_curves),
            [](auto const& curve) -> std::pair<std::string, CurveWrapper> {
                return {curve.first, CurveWrapper(*curve.second)};
            });
 
        // Create symbol table for variables and functions.
        _symbol_table.add_constants();
        _symbol_table.create_variable("x");
        _symbol_table.create_variable("y");
        _symbol_table.create_variable("z");
        _symbol_table.create_variable("t");
        for (auto& curve : _curves)
        {
            _symbol_table.add_function(curve.first, curve.second);
        }
 
        // Compile expressions.
        _vec_expression.resize(vec_expression_str.size());
        for (unsigned i = 0; i < vec_expression_str.size(); i++)
        {
            _vec_expression[i].register_symbol_table(_symbol_table);
            parser_t parser;
            if (!parser.compile(vec_expression_str[i], _vec_expression[i]))
            {
                OGS_FATAL("Error: {:s}\tExpression: {:s}\n",
                          parser.error(),
                          vec_expression_str[i]);
            }
        }
    }

References _curves, _symbol_table, _vec_expression, ParameterLib::ParameterBase::name, and OGS_FATAL.

Member Function Documentation

◆ getNumberOfGlobalComponents()

template<typename T>

int ParameterLib::FunctionParameter< T >::getNumberOfGlobalComponents ( ) const

inlineoverridevirtual

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

Implements ParameterLib::Parameter< T >.

Definition at line 98 of file FunctionParameter.h.

    {
        return _vec_expression.size();
    }

References _vec_expression.

Referenced by operator()().

◆ isTimeDependent()

template<typename T>

bool ParameterLib::FunctionParameter< T >::isTimeDependent ( ) const

inlineoverridevirtual

Implements ParameterLib::ParameterBase.

Definition at line 96 of file FunctionParameter.h.

96{ return true; }

◆ operator()()

template<typename T>

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

inlineoverridevirtual

Returns the parameter value at the given time and position.

Implements ParameterLib::Parameter< T >.

Definition at line 103 of file FunctionParameter.h.

    {
        std::vector<T> cache(getNumberOfGlobalComponents());
        auto& x = _symbol_table.get_variable("x")->ref();
        auto& y = _symbol_table.get_variable("y")->ref();
        auto& z = _symbol_table.get_variable("z")->ref();
        auto& time = _symbol_table.get_variable("t")->ref();
        if (!pos.getCoordinates())
        {
            OGS_FATAL(
                "FunctionParameter: The spatial position has to be set by "
                "coordinates.");
        }
        auto const coords = pos.getCoordinates().value();
 
        {
            std::lock_guard lock_guard(_mutex);
            x = coords[0];
            y = coords[1];
            z = coords[2];
            time = t;
 
            {
                for (unsigned i = 0; i < _vec_expression.size(); i++)
                {
                    cache[i] = _vec_expression[i].value();
                }
            }
        }
 
        if (!this->_coordinate_system)
        {
            return cache;
        }
 
        return this->rotateWithCoordinateSystem(cache, pos);
    }