Detailed Description

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

Definition at line 63 of file Function.cpp.

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

Public Member Functions
	Implementation (int num_threads, 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, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)

Public Attributes
std::vector< std::vector< Expression > >	value_expressions
std::vector< std::vector< std::pair< Variable, std::vector< Expression > > > >	dvalue_expressions
std::vector< VariableArray >	variable_arrays
std::map< std::string, CurveWrapper >	_curve_wrappers
bool	spatial_position_is_required = false

Private Member Functions
exprtk::symbol_table< double >	createSymbolTable (std::vector< std::string > const &variables, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves, VariableArray &variable_array)
std::vector< exprtk::symbol_table< double > >	createSymbolTables (int num_threads, std::vector< std::string > const &variables, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
	Create symbol tables for all threads.

Member Typedef Documentation

◆ Expression

template<int D>

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

Definition at line 66 of file Function.cpp.

Constructor & Destructor Documentation

◆ Implementation()

template<int D>

MaterialPropertyLib::Function::Implementation< D >::Implementation	(	int	num_threads,
		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,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

Definition at line 219 of file Function.cpp.

{
    variable_arrays.resize(num_threads);
    value_expressions.resize(num_threads);
    dvalue_expressions.resize(num_threads);
 
    auto symbol_tables = createSymbolTables(num_threads, variables, curves);
 
    // value expressions per thread.
    for (int thread_id = 0; thread_id < num_threads; ++thread_id)
    {
        value_expressions[thread_id] = compileExpressions(
            symbol_tables[thread_id], value_string_expressions);
    }
 
    // dValue expressions per thread.
    for (int thread_id = 0; thread_id < num_threads; ++thread_id)
    {
        for (auto const& [variable_name, string_expressions] :
             dvalue_string_expressions)
        {
            dvalue_expressions[thread_id].emplace_back(
                convertStringToVariable(variable_name),
                compileExpressions(symbol_tables[thread_id],
                                   string_expressions));
        }
    }
}

References MaterialPropertyLib::compileExpressions(), MaterialPropertyLib::convertStringToVariable(), createSymbolTables(), dvalue_expressions, value_expressions, and variable_arrays.

Member Function Documentation

◆ createSymbolTable()

template<int D>

exprtk::symbol_table< double > MaterialPropertyLib::Function::Implementation< D >::createSymbolTable	(	std::vector< std::string > const &	variables,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves,
		VariableArray &	variable_array )

private

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

Definition at line 117 of file Function.cpp.

{
    exprtk::symbol_table<double> symbol_table;
    symbol_table.add_constants();
 
    std::unordered_set<std::string> curve_names;
    for (auto const& curve : curves)
    {
        curve_names.insert(curve.first);
    }
 
    std::unordered_set<std::string> used_curves;
 
    symbol_table.create_variable("t");
 
    for (auto const& v : variables)
    {
        if (v == "t")
        {
            continue;
        }
        else if (v == "x" || v == "y" || v == "z")
        {
            symbol_table.create_variable("x");
            symbol_table.create_variable("y");
            symbol_table.create_variable("z");
            spatial_position_is_required = true;
        }
        else if (curve_names.contains(v))
        {
            used_curves.insert(v);
        }
        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);
        }
    }
 
    for (const auto& name : used_curves)
    {
        const auto& curve_ptr = curves.at(name);
        _curve_wrappers.emplace(name, CurveWrapper(*curve_ptr));
    }
    for (auto& [name, wrapper] : _curve_wrappers)
    {
        symbol_table.add_function(name, wrapper);
    }
    return symbol_table;
}

References _curve_wrappers, MaterialPropertyLib::convertStringToVariable(), MathLib::KelvinVector::kelvin_vector_dimensions(), MaterialPropertyLib::name, MathLib::VectorizedTensor::size(), spatial_position_is_required, MaterialPropertyLib::Function::value(), and MaterialPropertyLib::VariableArray::visitVariable().

Referenced by createSymbolTables().

◆ createSymbolTables()

template<int D>

std::vector< exprtk::symbol_table< double > > MaterialPropertyLib::Function::Implementation< D >::createSymbolTables	(	int	num_threads,
		std::vector< std::string > const &	variables,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

private

Create symbol tables for all threads.

Definition at line 200 of file Function.cpp.

{
    std::vector<exprtk::symbol_table<double>> symbol_tables(num_threads);
 
    for (int thread_id = 0; thread_id < num_threads; ++thread_id)
    {
        symbol_tables[thread_id] =
            createSymbolTable(variables, curves, variable_arrays[thread_id]);
    }
 
    return symbol_tables;
}