MaterialPropertyLib::PerThreadData Struct Reference

Detailed Description

Symbol table storage and compiled expressions for one OpenMP thread. Each thread receives its own instance so that concurrent evaluations do not race on the exprtk symbol table or the VariableArray scratch space. The symbol table has to point to some fixed addresses. Therefore, it cannot directly use a user-provided VariableArray during evaluation. Instead, a user-provided VariableArray will be copied to this object before expression evaluation.

Definition at line 160 of file Function.cpp.

Collaboration diagram for MaterialPropertyLib::PerThreadData:

Public Member Functions
template<int D>
	PerThreadData (std::integral_constant< int, D >, std::vector< std::string > const &expression_symbol_names, bool spatial_position_is_required, std::vector< std::string > const &used_curve_names, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves, std::vector< Variable > const &variables_enum, std::vector< Variable > *non_scalar_out, std::vector< std::string > const &value_string_expressions, std::vector< std::pair< std::string, std::vector< std::string > > > const &dvalue_string_expressions, std::vector< D2ValueConfig > const &d2value_string_expressions)
	PerThreadData (PerThreadData &&)
PerThreadData &	operator= (PerThreadData &&other) noexcept=delete
	PerThreadData (PerThreadData const &)=delete
PerThreadData &	operator= (PerThreadData const &)=delete
void	updateNonScalarVariables (std::vector< Variable > const &non_scalar_variables, VariableArray const &new_variable_array)
PropertyDataType	evaluate (std::vector< Variable > const &non_scalar_variables, VariableArray const &new_variable_array, ParameterLib::SpatialPosition const &pos, double t, std::vector< exprtk::expression< double > > const &expressions)
void	buildCopyOps (std::vector< Variable > const &variables_enum, std::vector< Variable > *non_scalar_out)
void	compileExpressions (std::vector< std::string > const &value_string_expressions, std::vector< std::pair< std::string, std::vector< std::string > > > const &dvalue_string_expressions, std::vector< D2ValueConfig > const &d2value_string_expressions)

Public Attributes
std::map< std::string, ParameterLib::CurveWrapper >	curve_wrappers
	Curve wrappers owned by this thread; must outlive the symbol table.
VariableArray	variable_array
exprtk::symbol_table< double >	symbol_table
std::vector< exprtk::expression< double > >	value_expressions
std::vector< std::pair< Variable, std::vector< exprtk::expression< double > > > >	dvalue_expressions
std::vector< D2ValueExpression >	d2value_expressions
ParameterLib::SymbolTableCache	symbol_table_cache
	Cached pointers to symbol table variables (t, x, y, z).
std::vector< ScalarCopyOp >	scalar_copy_ops
	Scalar copy operations into this thread's symbol table.

Constructor & Destructor Documentation

PerThreadData() [1/3]

template<int D>

MaterialPropertyLib::PerThreadData::PerThreadData ( std::integral_constant< int, D > , std::vector< std::string > const & expression_symbol_names, bool spatial_position_is_required, std::vector< std::string > const & used_curve_names, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const & curves, std::vector< Variable > const & variables_enum, std::vector< Variable > * non_scalar_out, std::vector< std::string > const & value_string_expressions, std::vector< std::pair< std::string, std::vector< std::string > > > const & dvalue_string_expressions, std::vector< D2ValueConfig > const & d2value_string_expressions )

inline

Definition at line 163 of file Function.cpp.

        : symbol_table(createSymbolTable<D>(
              expression_symbol_names, spatial_position_is_required,
              used_curve_names, curves, variable_array, curve_wrappers)),
          symbol_table_cache(symbol_table, spatial_position_is_required)
    {
        buildCopyOps(variables_enum, non_scalar_out);
        compileExpressions(value_string_expressions, dvalue_string_expressions,
                           d2value_string_expressions);
    }

References buildCopyOps(), compileExpressions(), MaterialPropertyLib::createSymbolTable(), curve_wrappers, symbol_table, symbol_table_cache, and variable_array.

Referenced by PerThreadData(), PerThreadData(), operator=(), and operator=().

PerThreadData() [2/3]

MaterialPropertyLib::PerThreadData::PerThreadData ( PerThreadData && )

inline

Definition at line 187 of file Function.cpp.

    {
        OGS_FATAL(
            "MPL's Function property: The internal PerThreadData is not "
            "move-constructible.");
    }

References PerThreadData(), and OGS_FATAL.

PerThreadData() [3/3]

MaterialPropertyLib::PerThreadData::PerThreadData ( PerThreadData const & )

delete

References PerThreadData().

Member Function Documentation

buildCopyOps()

void MaterialPropertyLib::PerThreadData::buildCopyOps ( std::vector< Variable > const & variables_enum, std::vector< Variable > * non_scalar_out )

inline

Build scalar_copy_ops for this thread.

Parameters

variables_enum	All variables to visit.
non_scalar_out	If non-null, non-scalar variables are appended here (pass only for thread 0).

Definition at line 281 of file Function.cpp.

    {
        for (auto const variable : variables_enum)
        {
            auto const add_non_scalar = [&]()
            {
                if (non_scalar_out)
                {
                    non_scalar_out->push_back(variable);
                }
            };
 
            variable_array.visitVariable(
                BaseLib::Overloaded{[&](VariableArray::Scalar* dst)
                                    {
                                        scalar_copy_ops.emplace_back(
                                            variable_array, dst, variable);
                                    },
                                    [&](VariableArray::KelvinVector*)
                                    { add_non_scalar(); },
                                    [&](VariableArray::DeformationGradient*)
                                    { add_non_scalar(); }},
                variable);
        }
    }

References scalar_copy_ops, and variable_array.

Referenced by PerThreadData().

compileExpressions()

void MaterialPropertyLib::PerThreadData::compileExpressions ( std::vector< std::string > const & value_string_expressions, std::vector< std::pair< std::string, std::vector< std::string > > > const & dvalue_string_expressions, std::vector< D2ValueConfig > const & d2value_string_expressions )

inline

Compile value, dValue, and d2Value expressions for this thread.

Parameters

value_string_expressions	Raw value expression strings.
dvalue_string_expressions	Variable name paired with its derivative expression strings.
d2value_string_expressions	Two variable names and second- derivative expression strings.

Definition at line 314 of file Function.cpp.

    {
        value_expressions = ParameterLib::compileExpressions(
            symbol_table, value_string_expressions);
 
        for (auto const& [variable_name, string_expressions] :
             dvalue_string_expressions)
        {
            if (string_expressions.size() != value_string_expressions.size())
            {
                OGS_FATAL(
                    "The number of dValue expressions ({:d}) for variable "
                    "'{:s}' does not match the number of value expressions "
                    "({:d}).",
                    string_expressions.size(), variable_name,
                    value_string_expressions.size());
            }
            dvalue_expressions.emplace_back(
                convertStringToVariable(variable_name),
                ParameterLib::compileExpressions(symbol_table,
                                                 string_expressions));
        }
 
        // Component-count consistency is validated once in the Function
        // constructor; here only the per-thread compilation remains.
        for (auto const& [variable_name1, variable_name2, string_expressions] :
             d2value_string_expressions)
        {
            d2value_expressions.emplace_back(
                convertStringToVariable(variable_name1),
                convertStringToVariable(variable_name2),
                ParameterLib::compileExpressions(symbol_table,
                                                 string_expressions));
        }
    }

References ParameterLib::compileExpressions(), MaterialPropertyLib::convertStringToVariable(), d2value_expressions, dvalue_expressions, OGS_FATAL, symbol_table, and value_expressions.

Referenced by PerThreadData().

evaluate()

PropertyDataType MaterialPropertyLib::PerThreadData::evaluate	(	std::vector< Variable > const &	non_scalar_variables,
		VariableArray const &	new_variable_array,
		ParameterLib::SpatialPosition const &	pos,
		double	t,
		std::vector< exprtk::expression< double > > const &	expressions )

Evaluate expressions against the given variable array and position, returning the result as a PropertyDataType.

Parameters

non_scalar_variables	Non-scalar variables from Implementation (shared read-only).
new_variable_array	Input variable array for this evaluation.
pos	Spatial position (coordinates required when spatial variables x, y, z are used).
t	Current time.
expressions	Compiled exprtk expressions to evaluate.

Definition at line 519 of file Function.cpp.

{
    // Fast path: direct offset arithmetic.
    for (auto const& op : scalar_copy_ops)
    {
        op.apply(new_variable_array);
    }
    // Fallback for KelvinVector / DeformationGradient variables.
    updateNonScalarVariables(non_scalar_variables, new_variable_array);
 
    // Set symbol table variables using cached pointers.
    symbol_table_cache.setTimeAndPosition(t, pos);
 
    // Dispatch on expression count: template specialisations fix N at compile
    // time, enabling stack allocation in evaluateToArray and branch-free
    // conversion in fromArray.
    auto const n = expressions.size();
    switch (n)
    {
        case 1:
            return fromArray(evaluateToArray<1>(expressions));
        case 2:
            return fromArray(evaluateToArray<2>(expressions));
        case 3:
            return fromArray(evaluateToArray<3>(expressions));
        case 4:
            return fromArray(evaluateToArray<4>(expressions));
        case 6:
            return fromArray(evaluateToArray<6>(expressions));
        case 9:
            return fromArray(evaluateToArray<9>(expressions));
        default:
            OGS_FATAL(
                "Cannot convert a vector of size {} to a PropertyDataType", n);
    }
}

References MaterialPropertyLib::evaluateToArray(), MaterialPropertyLib::fromArray(), OGS_FATAL, scalar_copy_ops, symbol_table_cache, and updateNonScalarVariables().

operator=() [1/2]

PerThreadData & MaterialPropertyLib::PerThreadData::operator= ( PerThreadData && other )

deletenoexcept

References PerThreadData().

operator=() [2/2]

PerThreadData & MaterialPropertyLib::PerThreadData::operator= ( PerThreadData const & )

delete

References PerThreadData().

updateNonScalarVariables()

void MaterialPropertyLib::PerThreadData::updateNonScalarVariables	(	std::vector< Variable > const &	non_scalar_variables,
		VariableArray const &	new_variable_array )

Update non-scalar (KelvinVector / DeformationGradient) variables in this thread's variable_array from new_variable_array.

Definition at line 417 of file Function.cpp.

{
    for (auto const& variable : non_scalar_variables)
    {
        auto assign_kelvin_vector = [&variable, &new_variable_array](
                                        VariableArray::KelvinVector* address)
        {
            auto assign_value = [&destination = *address,
                                 &variable]<typename S>(S const& source)
            {
                if constexpr (std::is_same_v<S, std::monostate>)
                {
                    OGS_FATAL(
                        "Function property: Kelvin vector variable '{:s}' is "
                        "not initialized.",
                        variable_enum_to_string[static_cast<int>(variable)]);
                }
                else
                {
                    if (std::holds_alternative<S>(destination))
                    {
                        std::get<S>(destination) = MathLib::KelvinVector::
                            kelvinVectorToSymmetricTensor(source);
                    }
                    else
                    {
                        OGS_FATAL(
                            "Function property: Mismatch of Kelvin vector "
                            "sizes for variable {:s}.",
                            variable_enum_to_string[static_cast<int>(
                                variable)]);
                    }
                }
            };
            std::visit(assign_value,
                       *std::get<VariableArray::KelvinVector const*>(
                           new_variable_array.address_of(variable)));
        };
        auto assign_deformation_gradient =
            [&variable,
             &new_variable_array](VariableArray::DeformationGradient* address)
        {
            auto assign_value = [&destination = *address,
                                 &variable]<typename S>(S const& source)
            {
                if constexpr (std::is_same_v<S, std::monostate>)
                {
                    OGS_FATAL(
                        "Function property: Vectorized tensor variable '{:s}' "
                        "is not initialized.",
                        variable_enum_to_string[static_cast<int>(variable)]);
                }
                else
                {
                    if (std::holds_alternative<S>(destination))
                    {
                        std::get<S>(destination) = source;
                    }
                    else
                    {
                        OGS_FATAL(
                            "Function property: Mismatch of vectorized tensor "
                            "sizes for variable {:s}.",
                            variable_enum_to_string[static_cast<int>(
                                variable)]);
                    }
                }
            };
            std::visit(assign_value,
                       *std::get<VariableArray::DeformationGradient const*>(
                           new_variable_array.address_of(variable)));
        };
 
        variable_array.visitVariable(
            BaseLib::Overloaded{
                [](VariableArray::Scalar*)
                {
                    OGS_FATAL(
                        "Function property: updateNonScalarVariables called "
                        "with a scalar variable.");
                },
                assign_kelvin_vector, assign_deformation_gradient},
            variable);
    }
}

References MaterialPropertyLib::VariableArray::address_of(), MathLib::KelvinVector::kelvinVectorToSymmetricTensor(), OGS_FATAL, variable_array, and MaterialPropertyLib::variable_enum_to_string.

Referenced by evaluate().

Member Data Documentation

curve_wrappers

std::map<std::string, ParameterLib::CurveWrapper> MaterialPropertyLib::PerThreadData::curve_wrappers

Curve wrappers owned by this thread; must outlive the symbol table.

Definition at line 198 of file Function.cpp.

Referenced by PerThreadData().

d2value_expressions

std::vector<D2ValueExpression> MaterialPropertyLib::PerThreadData::d2value_expressions

Second-derivative expressions w.r.t. an unordered pair of variables. Each entry stores the VariablePair - where (v1, v2) and (v2, v1) are treated as identical - together with multi-component expressions corresponding one-to-one with the value expressions. Specified in the project file as:

<d2value>
  <variable_name>temperature</variable_name>
  <variable_name>phase_pressure</variable_name>
  <expression>d2f1/dT dp</expression>
  <expression>d2f2/dT dp</expression>
</d2value>

Definition at line 248 of file Function.cpp.

Referenced by compileExpressions().

dvalue_expressions

std::vector<std::pair<Variable, std::vector<exprtk::expression<double> > > > MaterialPropertyLib::PerThreadData::dvalue_expressions

Derivative expressions w.r.t. a differentiation variable. Outer vector is an unordered set of (Variable, expressions) pairs. Each pair's second element holds multi-component expressions, corresponding one-to-one with the input XML entries, e.g.:

<dvalue>
  <variable>T</variable>
  <expression>df1/dT</expression>
  <expression>df2/dT</expression>
</dvalue>

Definition at line 233 of file Function.cpp.

Referenced by compileExpressions().

scalar_copy_ops

std::vector<ScalarCopyOp> MaterialPropertyLib::PerThreadData::scalar_copy_ops

Scalar copy operations into this thread's symbol table.

Definition at line 254 of file Function.cpp.

Referenced by buildCopyOps(), and evaluate().

symbol_table

exprtk::symbol_table<double> MaterialPropertyLib::PerThreadData::symbol_table

Symbol table holding variable storage. Must be destroyed after expressions (exprtk requirement) and after curve_wrappers and variable_array.

Definition at line 208 of file Function.cpp.

Referenced by PerThreadData(), and compileExpressions().

symbol_table_cache

ParameterLib::SymbolTableCache MaterialPropertyLib::PerThreadData::symbol_table_cache

Cached pointers to symbol table variables (t, x, y, z).

Definition at line 251 of file Function.cpp.

Referenced by PerThreadData(), and evaluate().

value_expressions

std::vector<exprtk::expression<double> > MaterialPropertyLib::PerThreadData::value_expressions

Value expressions evaluating the property value. Multi-component expressions corresponding one-to-one with the input XML entries, e.g.:

<value>
  <expression>f1</expression>
  <expression>f2</expression>
</value>

Definition at line 219 of file Function.cpp.

Referenced by compileExpressions().

variable_array

VariableArray MaterialPropertyLib::PerThreadData::variable_array

Storage for vectorial variables (KelvinVector / DeformationGradient). Must be declared before symbol_table so it is initialized first (symbol_table stores pointers into variable_array).

Definition at line 203 of file Function.cpp.

Referenced by PerThreadData(), buildCopyOps(), and updateNonScalarVariables().

---

The documentation for this struct was generated from the following file:

• Function.cpp