Detailed Description

Shared implementation for mathematical function evaluation using exprtk. Provides per-thread storage for thread-safe evaluation under OpenMP.

Definition at line 20 of file FunctionEvaluation.h.

#include <FunctionEvaluation.h>

Classes
struct	PerThreadData

Public Types
using	Expression = exprtk::expression<double>
using	SymbolTable = exprtk::symbol_table<double>

Public Member Functions
	FunctionEvaluation (int num_threads, std::vector< std::string > const &variables, std::vector< std::string > const &expression_strings, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::vector< double >	evaluate (SpatialPosition const &pos, double t) const
void	evaluate (SpatialPosition const &pos, double t, std::span< double > result) const
int	getNumberOfComponents () const
	Number of components (number of compiled value expressions).
bool	isTimeDependent () const

Private Attributes
std::vector< PerThreadData >	per_thread_data_
	Per-thread evaluation context; indexed by omp_get_thread_num().

Member Typedef Documentation

◆ Expression

using ParameterLib::FunctionEvaluation::Expression = exprtk::expression<double>

Definition at line 23 of file FunctionEvaluation.h.

◆ SymbolTable

using ParameterLib::FunctionEvaluation::SymbolTable = exprtk::symbol_table<double>

Definition at line 24 of file FunctionEvaluation.h.

Constructor & Destructor Documentation

◆ FunctionEvaluation()

ParameterLib::FunctionEvaluation::FunctionEvaluation	(	int	num_threads,
		std::vector< std::string > const &	variables,
		std::vector< std::string > const &	expression_strings,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

Parameters

num_threads	Number of threads for per-thread storage.
variables	Variable names to register in the symbol table. Spatial variables (x, y, z) are created only when they appear here.
expression_strings	Expression strings to compile.
curves	Named piecewise-linear curves available to expressions.

Definition at line 18 of file FunctionEvaluation.cpp.

{
    auto const expression_symbol_names = collectVariables(expression_strings);
    auto const spatial_position_is_required =
        hasSpatialVariables(expression_symbol_names);
    auto const used_curve_names =
        collectUsedCurveNames(expression_symbol_names, curves);
 
    per_thread_data_.reserve(num_threads);
    for (int thread_id = 0; thread_id < num_threads; ++thread_id)
    {
        per_thread_data_.emplace_back(variables, spatial_position_is_required,
                                      used_curve_names, curves,
                                      expression_strings);
    }
}

References ParameterLib::collectUsedCurveNames(), ParameterLib::collectVariables(), ParameterLib::hasSpatialVariables(), and per_thread_data_.

Member Function Documentation

◆ evaluate() [1/2]

std::vector< double > ParameterLib::FunctionEvaluation::evaluate	(	SpatialPosition const &	pos,
		double	t ) const

Evaluate all value expressions at the given spatial position and time.

Although marked const, this method writes to per-thread symbol-table slots through cached pointers. Each OpenMP thread writes exclusively to its own slot, so concurrent calls from different threads do not race. The mathematical function itself is immutable after construction.

Definition at line 120 of file FunctionEvaluation.cpp.

{
    std::vector<double> result(
        per_thread_data_.front().value_expressions.size());
    evaluate(pos, t, result);
    return result;
}

References evaluate(), and per_thread_data_.

Referenced by evaluate().

◆ evaluate() [2/2]

void ParameterLib::FunctionEvaluation::evaluate	(	SpatialPosition const &	pos,
		double	t,
		std::span< double >	result ) const

Evaluate all value expressions into a caller-provided output buffer.

No heap allocation is performed. Thread-safety is identical to the vector-returning overload.

Parameters

pos	Spatial position for evaluation.
t	Time for evaluation.
result	Must have size equal to getNumberOfComponents().

Definition at line 89 of file FunctionEvaluation.cpp.

{
#ifdef _OPENMP
    int const thread_id = omp_get_thread_num();
#else
    int const thread_id = 0;
#endif
 
    if (thread_id >= static_cast<int>(per_thread_data_.size()))
    {
        OGS_FATAL("Thread id {:d} exceeds allocated threads {:d}.", thread_id,
                  per_thread_data_.size());
    }
 
    auto const& thread_data = per_thread_data_[thread_id];
    auto const& expressions = thread_data.value_expressions;
    assert(result.size() == expressions.size());
 
    auto const& cache = thread_data.symbol_table_cache;
 
    // Update time and spatial position.
    cache.setTimeAndPosition(t, pos);
 
    // Evaluate expressions.
    for (unsigned i = 0; i < expressions.size(); ++i)
    {
        result[i] = expressions[i].value();
    }
}

References OGS_FATAL, and per_thread_data_.

◆ getNumberOfComponents()

int ParameterLib::FunctionEvaluation::getNumberOfComponents ( ) const

Number of components (number of compiled value expressions).

Definition at line 129 of file FunctionEvaluation.cpp.

{
    return static_cast<int>(per_thread_data_.front().value_expressions.size());
}

References per_thread_data_.

◆ isTimeDependent()

bool ParameterLib::FunctionEvaluation::isTimeDependent ( ) const

inline

Definition at line 62 of file FunctionEvaluation.h.

62{ return true; }

Member Data Documentation

◆ per_thread_data_

std::vector<PerThreadData> ParameterLib::FunctionEvaluation::per_thread_data_

private

Per-thread evaluation context; indexed by omp_get_thread_num().

Definition at line 97 of file FunctionEvaluation.h.

Referenced by FunctionEvaluation(), evaluate(), evaluate(), and getNumberOfComponents().

The documentation for this class was generated from the following files: