MaterialPropertyLib::Function::Implementation< D > Class Template Reference

Detailed Description

template<int D>
class MaterialPropertyLib::Function::Implementation< D >

Definition at line 50 of file Function.h.

Collaboration diagram for MaterialPropertyLib::Function::Implementation< D >:

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

Public Member Functions
	Implementation (std::vector< std::string > const &variables, std::vector< std::string > const &value_string_expressions, std::vector< std::pair< std::string, std::vector< std::string > > > const &dvalue_string_expressions)

Public Attributes
std::vector< Expression >	value_expressions
std::vector< std::pair< Variable, std::vector< Expression > > >	dvalue_expressions
VariableArray	variable_array
bool	spatial_position_is_required = false

Private Member Functions
exprtk::symbol_table< double >	createSymbolTable (std::vector< std::string > const &variables)

Member Typedef Documentation

Expression

template<int D>

using MaterialPropertyLib::Function::Implementation< D >::Expression = exprtk::expression<double>

Definition at line 53 of file Function.cpp.

Constructor & Destructor Documentation

Implementation()

template<int D>

MaterialPropertyLib::Function::Implementation< D >::Implementation	(	std::vector< std::string > const &	variables,
		std::vector< std::string > const &	value_string_expressions,
		std::vector< std::pair< std::string, std::vector< std::string > > > const &	dvalue_string_expressions )

Definition at line 151 of file Function.cpp.

{
    auto symbol_table = createSymbolTable(variables);
 
    // value expressions.
    value_expressions =
        compileExpressions(symbol_table, value_string_expressions);
 
    // dValue expressions.
    for (auto const& [variable_name, string_expressions] :
         dvalue_string_expressions)
    {
        dvalue_expressions.emplace_back(
            convertStringToVariable(variable_name),
            compileExpressions(symbol_table, string_expressions));
    }
}

References MaterialPropertyLib::compileExpressions(), and MaterialPropertyLib::convertStringToVariable().

Member Function Documentation

createSymbolTable()

template<int D>

exprtk::symbol_table< double > MaterialPropertyLib::Function::Implementation< D >::createSymbolTable ( std::vector< std::string > const & variables )

private

Create symbol table for given variables and populates the variable_array as needed.

Definition at line 86 of file Function.cpp.

{
    exprtk::symbol_table<double> symbol_table;
    symbol_table.add_constants();
 
    symbol_table.create_variable("t");
 
    for (auto const& v : variables)
    {
        if (v == "t")
        {
            symbol_table.create_variable("t");
        }
        else if (v == "x")
        {
            symbol_table.create_variable("x");
            spatial_position_is_required = true;
        }
        else if (v == "y")
        {
            symbol_table.create_variable("y");
            spatial_position_is_required = true;
        }
        else if (v == "z")
        {
            symbol_table.create_variable("z");
            spatial_position_is_required = true;
        }
        else
        {
            auto add_scalar = [&v, &symbol_table](double& value)
            { symbol_table.add_variable(v, value); };
 
            auto add_vector =
                [&v, &symbol_table](double* ptr, std::size_t const size)
            { symbol_table.add_vector(v, ptr, size); };
 
            auto add_any_variable = BaseLib::Overloaded{
                [&add_scalar](VariableArray::Scalar* address)
                { add_scalar(*address); },
                [&add_vector](VariableArray::KelvinVector* address)
                {
                    auto constexpr size =
                        MathLib::KelvinVector::kelvin_vector_dimensions(D);
                    auto& result = address->template emplace<
                        Eigen::Matrix<double, size, 1>>();
                    add_vector(result.data(), size);
                },
                [&add_vector](VariableArray::DeformationGradient* address)
                {
                    auto constexpr size = MathLib::VectorizedTensor::size(D);
                    auto& result = address->template emplace<
                        Eigen::Matrix<double, size, 1>>();
                    add_vector(result.data(), size);
                }};
 
            Variable const variable = convertStringToVariable(v);
            variable_array.visitVariable(add_any_variable, variable);
        }
    }
    return symbol_table;
}

References MaterialPropertyLib::convertStringToVariable(), MathLib::KelvinVector::kelvin_vector_dimensions(), and MathLib::VectorizedTensor::size().

Member Data Documentation

dvalue_expressions

template<int D>

std::vector<std::pair<Variable, std::vector<Expression> > > MaterialPropertyLib::Function::Implementation< D >::dvalue_expressions

Derivative expressions with respect to the variable. Multiple expressions are representing vector-valued functions.

Definition at line 76 of file Function.cpp.

spatial_position_is_required

template<int D>

bool MaterialPropertyLib::Function::Implementation< D >::spatial_position_is_required = false

Definition at line 82 of file Function.cpp.

value_expressions

template<int D>

std::vector<Expression> MaterialPropertyLib::Function::Implementation< D >::value_expressions

Value expressions. Multiple expressions are representing vector-valued functions.

Definition at line 71 of file Function.cpp.

variable_array

template<int D>

VariableArray MaterialPropertyLib::Function::Implementation< D >::variable_array

mutable

Stores values for evaluation of vectorial quantities. Needed for constant pointers for exprtk.

Definition at line 80 of file Function.cpp.

---

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

• MaterialLib/MPL/Properties/Function.cpp
• MaterialLib/MPL/Properties/Function.h