ParameterLib Namespace Reference

Classes
struct	ConstantParameter
	Single, constant value parameter. More...
struct	CoordinateSystem
	A local coordinate system used for tensor transformations. More...
struct	CurveScaledParameter
struct	CurveWrapper
class	FunctionEvaluation
struct	FunctionParameter
struct	GroupBasedParameter
struct	MeshElementParameter
	A parameter represented by a mesh property vector. More...
struct	MeshNodeParameter
	A parameter represented by a mesh property vector. More...
struct	Parameter
struct	ParameterBase
struct	RandomFieldMeshElementParameter
	A parameter represented by a mesh property vector. More...
struct	RasterParameter
class	SpatialPosition
struct	SymbolTableCache
class	TimeDependentHeterogeneousParameter

Functions
std::unique_ptr< ParameterBase >	createConstantParameter (std::string const &name, BaseLib::ConfigTree const &config)
template<int Dim>
static void	checkTransformationIsSON (Eigen::Matrix< double, Dim, Dim, Eigen::ColMajor, Dim, Dim > const &t)
template<typename Derived>
static void	checkNormalization (Eigen::MatrixBase< Derived > const &vec, std::string_view const parmeter_name)
Eigen::Matrix< double, 2, 2 >	getTransformationFromSingleBase2D (Parameter< double > const &unit_direction, SpatialPosition const &pos)
Eigen::Matrix< double, 3, 3 >	getTransformationFromSingleBase3D (Parameter< double > const &unit_direction, SpatialPosition const &pos)
Parameter< double > const *	parseBase1OrBase2 (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters, int const expected_component_number, std::string_view const base_tag_name)
void	checkThirdBaseExistanceFor2D (BaseLib::ConfigTree const &config)
void	confirmThirdBaseExplicit (BaseLib::ConfigTree const &config)
std::optional< ParameterLib::CoordinateSystem >	createCoordinateSystemWithImplicitBase (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::optional< ParameterLib::CoordinateSystem >	createCoordinateSystem (std::optional< BaseLib::ConfigTree > const &config, std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &parameters)
std::unique_ptr< ParameterBase >	createCurveScaledParameter (std::string const &name, BaseLib::ConfigTree const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
bool	isBuiltinSymbol (std::string_view const name)
bool	hasSpatialVariables (std::vector< std::string > const &variables)
exprtk::symbol_table< double >	createBaseSymbolTable (bool spatial_position_is_required)
void	registerCurveWrappers (exprtk::symbol_table< double > &symbol_table, std::vector< std::string > const &curve_names, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves, std::map< std::string, CurveWrapper > &curve_wrappers)
template std::vector< exprtk::expression< double > >	compileExpressions< double > (exprtk::symbol_table< double > &, std::vector< std::string > const &)
std::vector< std::string >	collectVariables (std::vector< std::string > const &expression_strings)
std::vector< std::string >	collectUsedCurveNames (std::vector< std::string > const &expression_symbol_names, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
	Returns the subset of expression_symbol_names that are keys in curves.
template<typename T>
std::vector< exprtk::expression< T > >	compileExpressions (exprtk::symbol_table< T > &symbol_table, std::vector< std::string > const &string_expressions)
static FunctionEvaluation::SymbolTable	createSymbolTable (std::vector< std::string > const &variables, bool const spatial_position_is_required, std::vector< std::string > const &used_curve_names, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves, std::map< std::string, CurveWrapper > &curve_wrappers)
std::unique_ptr< ParameterBase >	createFunctionParameter (std::string const &name, BaseLib::ConfigTree const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::unique_ptr< ParameterBase >	createGroupBasedParameter (std::string const &name, BaseLib::ConfigTree const &config, MeshLib::Mesh const &mesh)
std::unique_ptr< ParameterBase >	createMeshElementParameter (std::string const &name, BaseLib::ConfigTree const &config, MeshLib::Mesh const &mesh)
std::unique_ptr< ParameterBase >	createMeshNodeParameter (std::string const &name, BaseLib::ConfigTree const &config, MeshLib::Mesh const &mesh)
std::unique_ptr< ParameterBase >	createParameter (BaseLib::ConfigTree const &config, std::vector< std::unique_ptr< MeshLib::Mesh > > const &meshes, std::vector< GeoLib::NamedRaster > const &named_rasters, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &curves)
std::optional< std::string >	isDefinedOnSameMesh (ParameterBase const &parameter, MeshLib::Mesh const &mesh)
Parameter< double > &	getNamedOrCreateInlineParameter (std::string const &parameter_or_value, std::vector< std::unique_ptr< ParameterBase > > &parameters, std::string const &property_name, std::string const &inline_suffix)
std::unique_ptr< ParameterBase >	createRandomFieldMeshElementParameter (std::string const &name, BaseLib::ConfigTree const &config, MeshLib::Mesh &mesh)
std::unique_ptr< ParameterBase >	createRasterParameter (std::string const &name, BaseLib::ConfigTree const &config, std::vector< GeoLib::NamedRaster > const &named_rasters)
std::ostream &	operator<< (std::ostream &os, SpatialPosition const &pos)
std::unique_ptr< ParameterBase >	createTimeDependentHeterogeneousParameter (std::string const &name, BaseLib::ConfigTree const &config)
ParameterBase *	findParameterByName (std::string const &parameter_name, std::vector< std::unique_ptr< ParameterBase > > const &parameters)
template<typename ParameterDataType>
Parameter< ParameterDataType > *	findParameterOptional (std::string const &parameter_name, std::vector< std::unique_ptr< ParameterBase > > const &parameters, int const num_components, MeshLib::Mesh const *const mesh=nullptr)
template<typename ParameterDataType>
OGS_NO_DANGLING Parameter< ParameterDataType > &	findParameter (std::string const &parameter_name, std::vector< std::unique_ptr< ParameterBase > > const &parameters, int const num_components, MeshLib::Mesh const *const mesh=nullptr)
template<typename ParameterDataType>
OGS_NO_DANGLING Parameter< ParameterDataType > &	findParameter (BaseLib::ConfigTree const &process_config, std::string const &tag, std::vector< std::unique_ptr< ParameterBase > > const &parameters, int const num_components, MeshLib::Mesh const *const mesh=nullptr)
template<typename ParameterDataType>
Parameter< ParameterDataType > *	findOptionalTagParameter (BaseLib::ConfigTree const &process_config, std::string const &tag, std::vector< std::unique_ptr< ParameterBase > > const &parameters, int const num_components, MeshLib::Mesh const *const mesh=nullptr)

Variables
static double const	tolerance = std::numeric_limits<double>::epsilon()

Function Documentation

checkNormalization()

template<typename Derived>

void ParameterLib::checkNormalization ( Eigen::MatrixBase< Derived > const & vec, std::string_view const parmeter_name )

static

Definition at line 48 of file ParameterLib/CoordinateSystem.cpp.

{
    if (std::abs(vec.squaredNorm() - 1.0) > tolerance)
    {
        OGS_FATAL(
            "The direction vector given by parameter {:s} for the "
            "local_coordinate_system is not normalized to unit length. Vector "
            "norm is {:g} and |v|^2-1 = {:g}.",
            parmeter_name, vec.norm(), vec.squaredNorm() - 1.0);
    }
}

References OGS_FATAL, and tolerance.

Referenced by ParameterLib::CoordinateSystem::transformation().

checkThirdBaseExistanceFor2D()

void ParameterLib::checkThirdBaseExistanceFor2D

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

prj__local_coordinate_system__basis_vector_2

Definition at line 54 of file CreateCoordinateSystem.cpp.

{
    auto const base2_config =
        config.getConfigSubtreeOptional("basis_vector_2");
    if (base2_config)
    {
        OGS_FATAL(
            "The tag \"basis_vector_2\" is not needed for a 2D local "
            "coordinate system.");
    }
}

References BaseLib::ConfigTree::getConfigSubtreeOptional(), and OGS_FATAL.

Referenced by createCoordinateSystem(), and createCoordinateSystemWithImplicitBase().

checkTransformationIsSON()

template<int Dim>

void ParameterLib::checkTransformationIsSON ( Eigen::Matrix< double, Dim, Dim, Eigen::ColMajor, Dim, Dim > const & t )

static

Definition at line 21 of file ParameterLib/CoordinateSystem.cpp.

{
    if (std::abs(t.determinant() - 1) > tolerance)
    {
        OGS_FATAL(
            "The determinant of the coordinate system transformation matrix is "
            "'{:g}', which is not sufficiently close to unity with the "
            "tolerance of '{:g}'. Please adjust the accuracy of the local "
            "system bases",
            t.determinant(), tolerance);
    }
    if (((t * t.transpose() - Eigen::Matrix<double, Dim, Dim>::Identity())
             .array() > 2 * tolerance)
            .any())
    {
        OGS_FATAL(
            "The transformation is not orthogonal because the difference "
            "A*A^T - I is:\n{}\nand at least one component deviates from zero "
            "by more then '{:g}'.",
            (t * t.transpose() - Eigen::Matrix<double, Dim, Dim>::Identity())
                .eval(),
            2 * tolerance);
    }
}

References OGS_FATAL, and tolerance.

Referenced by ParameterLib::CoordinateSystem::transformation(), and ParameterLib::CoordinateSystem::transformation_3d().

collectUsedCurveNames()

std::vector< std::string > ParameterLib::collectUsedCurveNames	(	std::vector< std::string > const &	expression_symbol_names,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

Returns the subset of expression_symbol_names that are keys in curves.

Definition at line 153 of file ExprtkUtils.cpp.

{
    std::vector<std::string> used;
    for (auto const& v : expression_symbol_names)
    {
        if (curves.contains(v))
        {
            used.push_back(v);
        }
    }
    return used;
}

Referenced by ParameterLib::FunctionEvaluation::FunctionEvaluation(), and MaterialPropertyLib::Function::Implementation< D >::Implementation().

collectVariables()

std::vector< std::string > ParameterLib::collectVariables

(

std::vector< std::string > const &

expression_strings

)

Collects and deduplicates all variable/function identifiers appearing in the given expression strings by calling exprtk::collect_variables on each.

Definition at line 126 of file ExprtkUtils.cpp.

{
    std::vector<std::string> expression_symbol_names;
    for (auto const& expr : expression_strings)
    {
        if (!exprtk::collect_variables(expr, expression_symbol_names))
        {
            OGS_FATAL("Collecting variables from expression '{}' didn't work.",
                      expr);
        }
    }
    BaseLib::makeVectorUnique(expression_symbol_names);
 
    // exprtk::collect_variables reports the named constants added by
    // add_constants() (pi, epsilon, inf) as variables. Drop them so that
    // downstream code does not try to (re)create them as variables and clash
    // with the constants. A base symbol table is used so the set of constants
    // is queried from exprtk itself rather than hard-coded.
    auto const constants = createBaseSymbolTable(false);
    std::erase_if(expression_symbol_names,
                  [&constants](std::string const& name)
                  { return constants.is_constant_node(name); });
 
    return expression_symbol_names;
}

References createBaseSymbolTable(), BaseLib::makeVectorUnique(), and OGS_FATAL.

Referenced by MaterialPropertyLib::Function::Function(), and ParameterLib::FunctionEvaluation::FunctionEvaluation().

compileExpressions()

template<typename T>

std::vector< exprtk::expression< T > > ParameterLib::compileExpressions	(	exprtk::symbol_table< T > &	symbol_table,
		std::vector< std::string > const &	string_expressions )

Compiles expression strings into exprtk expressions using the given symbol table. Assignment (:=, +=, ...) to user-defined local vars is allowed, but assignment to a symbol that is already registered in symbol_table (the built-in t/x/y/z, MPL variables, curves or constants) is rejected: such a write would corrupt the shared per-thread evaluation scratch. This is enforced by enabling exprtk's dependent-entity collector and checking, after each compile, whether any assignment target resolves to a registered symbol (local var assignments are not reported by the collector).

Definition at line 74 of file ExprtkUtils.h.

{
    using settings_t = typename exprtk::parser<T>::settings_store;
    exprtk::parser<T> parser(settings_t::default_compile_all_opts +
                             settings_t::e_collect_assings);
 
    std::vector<exprtk::expression<T>> expressions(string_expressions.size());
    for (unsigned i = 0; i < string_expressions.size(); ++i)
    {
        expressions[i].register_symbol_table(symbol_table);
        if (!parser.compile(string_expressions[i], expressions[i]))
        {
            OGS_FATAL("Error: {:s}\tExpression: {:s}\n", parser.error(),
                      string_expressions[i]);
        }
 
        std::vector<
            typename exprtk::parser<T>::dependent_entity_collector::symbol_t>
            assignments;
        parser.dec().assignment_symbols(assignments);
        if (!assignments.empty())
        {
            std::string names;
            for (auto const& [name, type] : assignments)
            {
                if (!names.empty())
                {
                    names += ", ";
                }
                names += name;
            }
            OGS_FATAL(
                "Expression '{:s}' assigns to the already-defined symbol(s) "
                "'{:s}'. Assignment to the built-in variables (t, x, y, z), to "
                "MPL variables, curves or constants is not allowed because it "
                "would corrupt the shared evaluation state. Assignment to "
                "user-defined local 'var's is permitted.",
                string_expressions[i], names);
        }
    }
    return expressions;
}

References OGS_FATAL.

Referenced by ParameterLib::FunctionEvaluation::PerThreadData::PerThreadData(), and MaterialPropertyLib::PerThreadData::compileExpressions().

compileExpressions< double >()

template std::vector< exprtk::expression< double > > ParameterLib::compileExpressions< double >	(	exprtk::symbol_table< double > &	,
		std::vector< std::string > const &	)

confirmThirdBaseExplicit()

void ParameterLib::confirmThirdBaseExplicit

(

BaseLib::ConfigTree const &

config

)

Input File Parameter

prj__local_coordinate_system__basis_vector_2__implicit

Definition at line 67 of file CreateCoordinateSystem.cpp.

{
    auto const implicit_base2 =
        config.getConfigAttribute<bool>("implicit", false);
    if (implicit_base2)
    {
        OGS_FATAL("basis_vector_2 must be explicit.");
    }
}

References BaseLib::ConfigTree::getConfigAttribute(), and OGS_FATAL.

Referenced by createCoordinateSystem(), and createCoordinateSystemWithImplicitBase().

createBaseSymbolTable()

exprtk::symbol_table< double > ParameterLib::createBaseSymbolTable

(

bool

spatial_position_is_required

)

Creates a symbol table with time variable ("t") and optionally spatial variables ("x", "y", "z"). Does not add any other variables or curves.

Definition at line 51 of file ExprtkUtils.cpp.

{
    exprtk::symbol_table<double> symbol_table;
    symbol_table.add_constants();
    symbol_table.create_variable("t");
    if (spatial_position_is_required)
    {
        symbol_table.create_variable("x");
        symbol_table.create_variable("y");
        symbol_table.create_variable("z");
    }
    return symbol_table;
}

Referenced by collectVariables(), MaterialPropertyLib::createSymbolTable(), and createSymbolTable().

createConstantParameter()

std::unique_ptr< ParameterBase > ParameterLib::createConstantParameter	(	std::string const &	name,
		BaseLib::ConfigTree const &	config )

Input File Parameter

prj__parameters__parameter__type

Input File Parameter

prj__parameters__parameter__Constant__value

Input File Parameter

prj__parameters__parameter__Constant__values

Definition at line 12 of file ConstantParameter.cpp.

{
    config.checkConfigParameter("type", "Constant");
 
    auto const value_data =
        config.getConfigParameterOptional<std::vector<double>>("value");
 
    auto const values_data =
        config.getConfigParameterOptional<std::vector<double>>("values");
 
    if ((value_data) && (values_data))
    {
        OGS_FATAL(
            "Both value and values tags were given.\n\
             Please give only one of them.");
    }
 
    std::vector<double> values;
 
    if (value_data)
    {
        values = *value_data;
    }
    else if (values_data)
    {
        values = *values_data;
    }
 
    if (values.empty())
    {
        OGS_FATAL("No value(s) was(were) provided.");
    }
 
    DBUG("Using following values for the constant parameter:");
    for (double const v : values)
    {
        (void)v;  // unused value if building w/o DBUG output.
        DBUG("\t{:g}", v);
    }
 
    return std::make_unique<ConstantParameter<double>>(name, std::move(values));
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameterOptional(), and OGS_FATAL.

Referenced by createParameter().

createCoordinateSystem()

std::optional< ParameterLib::CoordinateSystem > ParameterLib::createCoordinateSystem	(	std::optional< BaseLib::ConfigTree > const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

prj__local_coordinate_system__basis_vector_0

Input File Parameter

prj__local_coordinate_system__basis_vector_0__implicit

Input File Parameter

prj__local_coordinate_system__basis_vector_1

Input File Parameter

prj__local_coordinate_system__basis_vector_1__implicit

Input File Parameter

prj__local_coordinate_system__basis_vector_2

Definition at line 134 of file CreateCoordinateSystem.cpp.

{
    if (!config)
    {
        return {};
    }
 
    //
    // Fetch the first basis vector; its length defines the dimension.
    //
    auto const& config_base0 = config->getConfigSubtree("basis_vector_0");
    auto const implicit_base0 =
        config_base0.getConfigAttribute<bool>("implicit", false);
 
    // base0 and base1 can be implicit. If base0 is implicit, check whether
    // base1 is implicit.
    // If base1 is explicit, create a 2D system if its components is 2 or quit
    // if its components is not equal to 2.
    // Otherwise, read base2, create a 3D system if its components is 3 or quit
    // if its components is not equal to 3.
    if (implicit_base0)
    {
        return createCoordinateSystemWithImplicitBase(*config, parameters);
    }
 
    auto const base0_name = config_base0.getValue<std::string>();
    auto const& basis_vector_0 = ParameterLib::findParameter<double>(
        base0_name, parameters, 0 /* any dimension */);
    int const dimension = basis_vector_0.getNumberOfGlobalComponents();
    // check dimension
    if (dimension != 2 && dimension != 3)
    {
        OGS_FATAL(
            "Basis vector parameter '{:s}' must have two or three components, "
            "but it has {:d}.",
            base0_name, dimension);
    }
 
    // Fetch the second basis vector.
    auto const& config_base1 = config->getConfigSubtree("basis_vector_1");
    auto const implicit_base1 =
        config_base1.getConfigAttribute<bool>("implicit", false);
    if (implicit_base1)
    {
        OGS_FATAL(
            "Since basis_vector_0 is explicitly defined, basis_vector_1"
            " must be explicit as well.");
    }
    auto const base1_name = config_base1.getValue<std::string>();
    auto const& basis_vector_1 =
        ParameterLib::findParameter<double>(base1_name, parameters, dimension);
 
    if (dimension == 2)
    {
        checkThirdBaseExistanceFor2D(*config);
        return ParameterLib::CoordinateSystem{basis_vector_0, basis_vector_1};
    }
 
    // Parse the third basis vector, e2, for the three dimensional system.
    auto const& config_base2 = config->getConfigSubtree("basis_vector_2");
    confirmThirdBaseExplicit(config_base2);
 
    int const expected_component_number = 3;
    auto const basis_vector_2 = parseBase1OrBase2(
        config_base2, parameters, expected_component_number, "basis_vector_2");
 
    return ParameterLib::CoordinateSystem{basis_vector_0, basis_vector_1,
                                          *basis_vector_2};
}

References checkThirdBaseExistanceFor2D(), confirmThirdBaseExplicit(), createCoordinateSystemWithImplicitBase(), findParameter(), OGS_FATAL, and parseBase1OrBase2().

createCoordinateSystemWithImplicitBase()

std::optional< ParameterLib::CoordinateSystem > ParameterLib::createCoordinateSystemWithImplicitBase	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters )

Input File Parameter

prj__local_coordinate_system__basis_vector_1

Input File Parameter

prj__local_coordinate_system__basis_vector_1__implicit

Input File Parameter

prj__local_coordinate_system__basis_vector_2

Definition at line 79 of file CreateCoordinateSystem.cpp.

{
    auto const& config_base1 = config.getConfigSubtree("basis_vector_1");
 
    // Parse the second vectors.
    auto const implicit_base1 =
        config_base1.getConfigAttribute<bool>("implicit", false);
 
    if (!implicit_base1)
    {
        // For 2D problem.
        // Only the following case is accepted:
        // <basis_vector_0 implicit = false/>
        // <basis_vector_1> [two-component parameter] </basis_vector_1>.
        int const expected_component_number = 2;
        auto const basis_vector_1 =
            parseBase1OrBase2(config_base1, parameters,
                              expected_component_number, "basis_vector_1");
 
        checkThirdBaseExistanceFor2D(config);
 
        return ParameterLib::CoordinateSystem(*basis_vector_1);
    }
 
    // For 3D problem.
    // Only the following case is accepted:
    // <basis_vector_0 implicit = false/>
    // <basis_vector_1 implicit = false>.
    // <basis_vector_2> [three-component parameter] </basis_vector_2>.
 
    // Parse the third basis vector, e2, for the three dimensional system.
    auto const config_base2 =
        config.getConfigSubtreeOptional("basis_vector_2");
    if (!config_base2)
    {
        OGS_FATAL(
            "Both \"basis_vector_0\" and \"basis_vector_1\" are implicit but "
            "\"basis_vector_2\" does not exist. If 2D coordinate system is "
            "considered, please change \"basis_vector_1\" to explicit. If 3D "
            "coordinate system is considered, please add \"basis_vector_2\".");
    }
 
    confirmThirdBaseExplicit(*config_base2);
 
    int const expected_component_number = 3;
    auto const basis_vector_2 = parseBase1OrBase2(
        *config_base2, parameters, expected_component_number, "basis_vector_2");
    return ParameterLib::CoordinateSystem(*basis_vector_2);
}

References checkThirdBaseExistanceFor2D(), confirmThirdBaseExplicit(), BaseLib::ConfigTree::getConfigAttribute(), BaseLib::ConfigTree::getConfigSubtree(), BaseLib::ConfigTree::getConfigSubtreeOptional(), OGS_FATAL, and parseBase1OrBase2().

Referenced by createCoordinateSystem().

createCurveScaledParameter()

std::unique_ptr< ParameterBase > ParameterLib::createCurveScaledParameter	(	std::string const &	name,
		BaseLib::ConfigTree const &	config,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

Input File Parameter

prj__parameters__parameter__type

Input File Parameter

prj__parameters__parameter__CurveScaled__curve

Input File Parameter

prj__parameters__parameter__CurveScaled__parameter

Definition at line 10 of file CurveScaledParameter.cpp.

{
    config.checkConfigParameter("type", "CurveScaled");

    auto curve_name = config.getConfigParameter<std::string>("curve");
    DBUG("Using curve {:s}", curve_name);
 
    auto const curve_it = curves.find(curve_name);
    if (curve_it == curves.end())
    {
        OGS_FATAL("Curve `{:s}' does not exists.", curve_name);
    }
 
    auto referenced_parameter_name =
        config.getConfigParameter<std::string>("parameter");
    DBUG("Using parameter {:s}", referenced_parameter_name);
 
    // TODO other data types than only double
    return std::make_unique<CurveScaledParameter<double>>(
        name, *curve_it->second, referenced_parameter_name);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), and OGS_FATAL.

Referenced by createParameter().

createFunctionParameter()

std::unique_ptr< ParameterBase > ParameterLib::createFunctionParameter	(	std::string const &	name,
		BaseLib::ConfigTree const &	config,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

Input File Parameter

prj__parameters__parameter__type

Input File Parameter

prj__parameters__parameter__Function__expression

Definition at line 10 of file FunctionParameter.cpp.

{
    config.checkConfigParameter("type", "Function");
 
    std::vector<std::string> vec_expressions;

    for (auto const& p : config.getConfigSubtreeList("expression"))
    {
        std::string const expression_str = p.getValue<std::string>();
        vec_expressions.emplace_back(expression_str);
    }
 
    return std::make_unique<FunctionParameter<double>>(name, vec_expressions,
                                                       curves);
}

References BaseLib::ConfigTree::checkConfigParameter(), and BaseLib::ConfigTree::getConfigSubtreeList().

Referenced by createParameter().

createGroupBasedParameter()

std::unique_ptr< ParameterBase > ParameterLib::createGroupBasedParameter	(	std::string const &	name,
		BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	mesh )

Input File Parameter

prj__parameters__parameter__type

Input File Parameter

prj__parameters__parameter__Group__group_id_property

Input File Parameter

prj__parameters__parameter__Group__index_values

Input File Parameter

prj__parameters__parameter__Group__index_values__index

Input File Parameter

prj__parameters__parameter__Group__index_values__value

Input File Parameter

prj__parameters__parameter__Group__index_values__values

Definition at line 12 of file GroupBasedParameter.cpp.

{
    config.checkConfigParameter("type", "Group");
 
    // get a property vector of group IDs
    std::string const group_id_property_name =
        config.getConfigParameter<std::string>("group_id_property");
    DBUG("Using group_id_property {:s}", group_id_property_name);
 
    auto const& group_id_property =
        mesh.getProperties().getPropertyVector<int>(group_id_property_name);
 
    // parse mapping data
    using Values = std::vector<double>;
    std::map<int, Values> vec_index_values;
    for (auto p : config.getConfigSubtreeList("index_values"))
    {
        auto const index = p.getConfigParameter<int>("index");
        {
            auto const value = p.getConfigParameterOptional<double>("value");
 
            if (value)
            {
                Values values(1, *value);
                vec_index_values.emplace(index, values);
                continue;
            }
        }
 
        // Value tag not available; continue with required values tag.
        Values const values = p.getConfigParameter<Values>("values");
 
        if (values.empty())
        {
            OGS_FATAL("No value available for constant parameter.");
        }
 
        vec_index_values.emplace(index, values);
    }
 
    // check the input
    for (auto p : vec_index_values)
    {
#ifndef USE_PETSC  // In case of partitioned meshes not all of the material ids
                   // might be available in the particular partition, therefore
                   // the check is omitted.
        if (std::find(group_id_property->begin(), group_id_property->end(),
                      p.first) == group_id_property->end())
        {
            OGS_FATAL(
                "Specified property index {:d} does not exist in the property "
                "vector {:s}",
                p.first, group_id_property_name);
        }
#endif
 
        auto const n_values = vec_index_values.begin()->second.size();
        if (p.second.size() != n_values)
        {
            OGS_FATAL(
                "The length of some values ({:d}) is different from the first "
                "one ({:d}). The length should be same for all index_values.",
                p.second.size(), n_values);
        }
    }
 
    if (group_id_property->getMeshItemType() == MeshLib::MeshItemType::Node)
    {
        return std::make_unique<
            GroupBasedParameter<double, MeshLib::MeshItemType::Node>>(
            name, mesh, *group_id_property, vec_index_values);
    }
    if (group_id_property->getMeshItemType() == MeshLib::MeshItemType::Cell)
    {
        return std::make_unique<
            GroupBasedParameter<double, MeshLib::MeshItemType::Cell>>(
            name, mesh, *group_id_property, vec_index_values);
    }
 
    OGS_FATAL("Mesh item type of the specified property is not supported.");
}

References MeshLib::Cell, BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtreeList(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), MeshLib::Node, and OGS_FATAL.

Referenced by createParameter().

createMeshElementParameter()

std::unique_ptr< ParameterBase > ParameterLib::createMeshElementParameter	(	std::string const &	name,
		BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	mesh )

Input File Parameter

prj__parameters__parameter__type

Input File Parameter

prj__parameters__parameter__MeshElement__field_name

Definition at line 11 of file MeshElementParameter.cpp.

{
    config.checkConfigParameter("type", "MeshElement");
    auto const field_name =
        config.getConfigParameter<std::string>("field_name");
    DBUG("Using field_name {:s}", field_name);
 
    // TODO other data types than only double
    auto const& property =
        mesh.getProperties().getPropertyVector<double>(field_name);
 
    if (property->getMeshItemType() != MeshLib::MeshItemType::Cell)
    {
        OGS_FATAL("The mesh property `{:s}' is not an element property.",
                  field_name);
    }
 
    return std::make_unique<MeshElementParameter<double>>(name, mesh,
                                                          *property);
}

References MeshLib::Cell, BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), and OGS_FATAL.

Referenced by createParameter().

createMeshNodeParameter()

std::unique_ptr< ParameterBase > ParameterLib::createMeshNodeParameter	(	std::string const &	name,
		BaseLib::ConfigTree const &	config,
		MeshLib::Mesh const &	mesh )

Input File Parameter

prj__parameters__parameter__type

Input File Parameter

prj__parameters__parameter__MeshNode__field_name

Definition at line 11 of file MeshNodeParameter.cpp.

{
    config.checkConfigParameter("type", "MeshNode");
    auto const field_name =
        config.getConfigParameter<std::string>("field_name");
    DBUG("Using field_name {:s}", field_name);
 
    // TODO other data types than only double
    auto const& property =
        mesh.getProperties().getPropertyVector<double>(field_name);
 
    if (property->getMeshItemType() != MeshLib::MeshItemType::Node)
    {
        OGS_FATAL("The mesh property `{:s}' is not a nodal property.",
                  field_name);
    }
 
    return std::make_unique<MeshNodeParameter<double>>(name, mesh, *property);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), MeshLib::Node, and OGS_FATAL.

Referenced by createParameter().

createParameter()

std::unique_ptr< ParameterBase > ParameterLib::createParameter	(	BaseLib::ConfigTree const &	config,
		const std::vector< std::unique_ptr< MeshLib::Mesh > > &	meshes,
		std::vector< GeoLib::NamedRaster > const &	named_rasters,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves )

Constructs a new ParameterBase from the given configuration.

The meshes vector is used to set up parameters from mesh input data. The named_rasters vector is used to set up parameters from raster input data.

Input File Parameter

prj__parameters__parameter__name

Input File Parameter

prj__parameters__parameter__type

Input File Parameter

prj__parameters__parameter__mesh

Definition at line 21 of file ParameterLib/Parameter.cpp.

{
    auto const name = config.getConfigParameter<std::string>("name");
    auto const type = config.peekConfigParameter<std::string>("type");
 
    // Either the mesh name is given, or the first mesh's name will be
    // taken.
    auto const mesh_name =
        config.getConfigParameter<std::string>("mesh", meshes[0]->getName());
 
    auto const& mesh = MeshLib::findMeshByName(meshes, mesh_name);
 
    // Create parameter based on the provided type.
    if (type == "Constant")
    {
        INFO("ConstantParameter: {:s}", name);
        return createConstantParameter(name, config);
    }
    if (type == "CurveScaled")
    {
        INFO("CurveScaledParameter: {:s}", name);
        return createCurveScaledParameter(name, config, curves);
    }
    if (type == "Function")
    {
        INFO("FunctionParameter: {:s}", name);
        return createFunctionParameter(name, config, curves);
    }
    if (type == "Group")
    {
        INFO("GroupBasedParameter: {:s}", name);
        return createGroupBasedParameter(name, config, mesh);
    }
    if (type == "MeshElement")
    {
        INFO("MeshElementParameter: {:s}", name);
        return createMeshElementParameter(name, config, mesh);
    }
    if (type == "MeshNode")
    {
        INFO("MeshNodeParameter: {:s}", name);
        return createMeshNodeParameter(name, config, mesh);
    }
    if (type == "RandomFieldMeshElement")
    {
        auto& mesh_var = MeshLib::findMeshByName(meshes, mesh_name);
        INFO("RandomFieldMeshElement: {:s}", name);
        return createRandomFieldMeshElementParameter(name, config, mesh_var);
    }
    if (type == "Raster")
    {
        INFO("RasterParameter: {:s}", name);
        return createRasterParameter(name, config, named_rasters);
    }
    if (type == "TimeDependentHeterogeneous" ||
        type == "TimeDependentHeterogeneousParameter")
    {
        if (type == "TimeDependentHeterogeneousParameter")
        {
            WARN(
                "Parameter type 'TimeDependentHeterogeneousParameter' is "
                "deprecated. Use 'TimeDependentHeterogeneous' instead. "
                "The old type name will be removed in a future release.");
        }
        INFO("TimeDependentHeterogeneous: {:s}", name);
        return createTimeDependentHeterogeneousParameter(name, config);
    }
 
    OGS_FATAL("Cannot construct a parameter of given type '{:s}'.", type);
}

References createConstantParameter(), createCurveScaledParameter(), createFunctionParameter(), createGroupBasedParameter(), createMeshElementParameter(), createMeshNodeParameter(), createRandomFieldMeshElementParameter(), createRasterParameter(), createTimeDependentHeterogeneousParameter(), MeshLib::findMeshByName(), BaseLib::ConfigTree::getConfigParameter(), INFO(), OGS_FATAL, BaseLib::ConfigTree::peekConfigParameter(), and WARN().

Referenced by ProjectData::parseParameters().

createRandomFieldMeshElementParameter()

std::unique_ptr< ParameterBase > ParameterLib::createRandomFieldMeshElementParameter	(	std::string const &	name,
		BaseLib::ConfigTree const &	config,
		MeshLib::Mesh &	mesh )

Input File Parameter

prj__parameters__parameter__type

Input File Parameter

prj__parameters__parameter__RandomFieldMeshElement__field_name

Input File Parameter

prj__parameters__parameter__RandomFieldMeshElement__range

Input File Parameter

prj__parameters__parameter__RandomFieldMeshElement__seed

Definition at line 15 of file RandomFieldMeshElementParameter.cpp.

{
    config.checkConfigParameter("type", "RandomFieldMeshElement");
    auto const field_name =
        config.getConfigParameter<std::string>("field_name");
    auto const range =
        config.getConfigParameter<std::vector<double>>("range");
    if (range.size() != 2)
    {
        OGS_FATAL(
            "The range needs to have two components, but {:d} were given.",
            range.size());
    }
    auto const seed =
        config.getConfigParameter<int>("seed");
    DBUG("Generating field {:s} with range {:g} to {:g} and seed {:d}.",
         field_name, range[0], range[1], seed);
 
    std::vector<double> values(mesh.getElements().size());
 
    std::mt19937 generator(seed);
    std::uniform_real_distribution<> distr(range[0], range[1]);
    auto gen = [&distr, &generator]() { return distr(generator); };
    generate(begin(values), end(values), gen);
 
    MeshLib::addPropertyToMesh<double>(
        mesh, field_name, MeshLib::MeshItemType::Cell, 1, {values});
 
    auto const& property =
        mesh.getProperties().getPropertyVector<double>(field_name);
 
    if (property->getMeshItemType() != MeshLib::MeshItemType::Cell)
    {
        OGS_FATAL("The mesh property `{:s}' is not an element property.",
                  field_name);
    }
 
    return std::make_unique<RandomFieldMeshElementParameter<double>>(name, mesh,
                                                                     *property);
}

References MeshLib::addPropertyToMesh(), MeshLib::Cell, BaseLib::ConfigTree::checkConfigParameter(), DBUG(), BaseLib::ConfigTree::getConfigParameter(), MeshLib::Mesh::getElements(), MeshLib::Mesh::getProperties(), MeshLib::Properties::getPropertyVector(), and OGS_FATAL.

Referenced by createParameter().

createRasterParameter()

std::unique_ptr< ParameterBase > ParameterLib::createRasterParameter	(	std::string const &	name,
		BaseLib::ConfigTree const &	config,
		std::vector< GeoLib::NamedRaster > const &	named_rasters )

Input File Parameter

prj__parameters__parameter__type

Definition at line 12 of file RasterParameter.cpp.

{
    config.checkConfigParameter("type", "Raster");
 
    auto const& named_raster = BaseLib::getIfOrError(
        named_rasters,
        [&name](auto const& named_raster)
        { return name == named_raster.raster_name; },
        "Could not find raster '" + name);
 
    DBUG("Using the raster '{}' for the raster parameter.", name);
 
    return std::make_unique<RasterParameter>(name, named_raster);
}

References BaseLib::ConfigTree::checkConfigParameter(), DBUG(), and BaseLib::getIfOrError().

Referenced by createParameter().

createSymbolTable()

FunctionEvaluation::SymbolTable ParameterLib::createSymbolTable ( std::vector< std::string > const & variables, bool const spatial_position_is_required, std::vector< std::string > const & used_curve_names, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const & curves, std::map< std::string, CurveWrapper > & curve_wrappers )

static

Definition at line 41 of file FunctionEvaluation.cpp.

{
    auto symbol_table = createBaseSymbolTable(spatial_position_is_required);
 
    // Create additional (non-standard) variables.
    for (auto const& v : variables)
    {
        if (!isBuiltinSymbol(v))
        {
            symbol_table.create_variable(v);
        }
    }
 
    registerCurveWrappers(symbol_table, used_curve_names, curves,
                          curve_wrappers);
 
    return symbol_table;
}

References createBaseSymbolTable(), isBuiltinSymbol(), and registerCurveWrappers().

Referenced by ParameterLib::FunctionEvaluation::PerThreadData::PerThreadData().

createTimeDependentHeterogeneousParameter()

std::unique_ptr< ParameterBase > ParameterLib::createTimeDependentHeterogeneousParameter	(	std::string const &	name,
		BaseLib::ConfigTree const &	config )

Input File Parameter

prj__parameters__parameter__type

Input File Parameter

prj__parameters__parameter__TimeDependentHeterogeneous__time_series

Input File Parameter

prj__parameters__parameter__TimeDependentHeterogeneous__time_series__pair

Input File Parameter

prj__parameters__parameter__TimeDependentHeterogeneous__time_series__pair__time

Input File Parameter

prj__parameters__parameter__TimeDependentHeterogeneous__time_series__pair__parameter_name

Definition at line 106 of file TimeDependentHeterogeneousParameter.cpp.

{
    auto const type = config.getConfigParameter<std::string>("type");
    if (type != "TimeDependentHeterogeneous" &&
        type != "TimeDependentHeterogeneousParameter")
    {
        OGS_FATAL(
            "Expected the parameter type 'TimeDependentHeterogeneous' (or its "
            "deprecated spelling 'TimeDependentHeterogeneousParameter'), but "
            "got '{:s}'.",
            type);
    }
    auto const time_series_config =
        config.getConfigSubtree("time_series");
 
    std::vector<TimeDependentHeterogeneousParameter::PairTimeParameterName>
        time_series;
    for (auto const p : time_series_config.getConfigSubtreeList("pair"))
    {
        auto time = p.getConfigParameter<double>("time");
        auto parameter_name =
            p.getConfigParameter<std::string>("parameter_name");
        time_series.emplace_back(time, parameter_name);
    }
 
    if (time_series.empty())
    {
        OGS_FATAL(
            "Time dependent heterogeneous parameter '{:s}' doesn't contain "
            "necessary time series data.",
            name);
    }
 
    if (!std::is_sorted(
            time_series.begin(), time_series.end(),
            [](TimeDependentHeterogeneousParameter::PairTimeParameterName const
                   & p0,
               TimeDependentHeterogeneousParameter::PairTimeParameterName const
                   & p1) { return p0.first < p1.first; }))
    {
        OGS_FATAL(
            "The points in time in the time series '{:s}' aren't in ascending "
            "order.",
            name);
    }
 
    return std::make_unique<TimeDependentHeterogeneousParameter>(
        name, std::move(time_series));
}

References BaseLib::ConfigTree::getConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), and OGS_FATAL.

Referenced by createParameter().

findOptionalTagParameter()

template<typename ParameterDataType>

Parameter< ParameterDataType > * ParameterLib::findOptionalTagParameter	(	BaseLib::ConfigTree const &	process_config,
		std::string const &	tag,
		std::vector< std::unique_ptr< ParameterBase > > const &	parameters,
		int const	num_components,
		MeshLib::Mesh const *const	mesh = nullptr )

Find a parameter of specific type for a name given in the process configuration under the optional tag. If the tag is not present, a nullptr will be returned. The parameter must have the specified number of components. In the process config a parameter is referenced by a name. For example it will be looking for a parameter named "K" in the list of parameters when the tag is "hydraulic_conductivity":

<process>
    ...
    <hydraulic_conductivity>K</hydraulic_conductivity>
</process>

and return a pointer to that parameter. Additionally it checks for the type of the found parameter.

Input File Parameter

special OGS input file parameter

Definition at line 159 of file ParameterLib/Utils.h.

{
    // Find parameter name in process config.
    auto const name =
        process_config.getConfigParameterOptional<std::string>(tag);
 
    if (!name)
    {
        return nullptr;
    }
    return &findParameter<ParameterDataType>(*name, parameters, num_components,
                                             mesh);
}

References findParameter(), and BaseLib::ConfigTree::getConfigParameterOptional().

Referenced by ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::LargeDeformation::createLargeDeformationProcess(), ProcessLib::SmallDeformation::createSmallDeformationProcess(), and ProcessLib::ThermoMechanics::createThermoMechanicsProcess().

findParameter() [1/2]

template<typename ParameterDataType>

OGS_NO_DANGLING Parameter< ParameterDataType > & ParameterLib::findParameter	(	BaseLib::ConfigTree const &	process_config,
		std::string const &	tag,
		std::vector< std::unique_ptr< ParameterBase > > const &	parameters,
		int const	num_components,
		MeshLib::Mesh const *const	mesh = nullptr )

Find a parameter of specific type for a name given in the process configuration under the tag. The parameter must have the specified number of components. In the process config a parameter is referenced by a name. For example it will be looking for a parameter named "K" in the list of parameters when the tag is "hydraulic_conductivity":

<process>
    ...
    <hydraulic_conductivity>K</hydraulic_conductivity>
</process>

and return a reference to that parameter. Additionally it checks for the type of the found parameter.

Input File Parameter

special OGS input file parameter

Definition at line 128 of file ParameterLib/Utils.h.

{
    // Find parameter name in process config.
    auto const name = process_config.getConfigParameter<std::string>(tag);
 
    return findParameter<ParameterDataType>(name, parameters, num_components,
                                            mesh);
}

References findParameter(), BaseLib::ConfigTree::getConfigParameter(), and OGS_NO_DANGLING.

findParameter() [2/2]

template<typename ParameterDataType>

OGS_NO_DANGLING Parameter< ParameterDataType > & ParameterLib::findParameter	(	std::string const &	parameter_name,
		std::vector< std::unique_ptr< ParameterBase > > const &	parameters,
		int const	num_components,
		MeshLib::Mesh const *const	mesh = nullptr )

Find a parameter of specific type for a given name.

Template Parameters

ParameterDataType

the data type of the parameter

Parameters

parameter_name	name of the requested parameter
parameters	list of parameters in which it will be searched
num_components	the number of components of the parameters or zero if any number is acceptable
mesh	an optional mesh pointer used for test whether the parameter is defined on the given mesh. No test is performed if the pointer is a nullptr.

See also

The documentation of the other findParameter() function.

Definition at line 95 of file ParameterLib/Utils.h.

{
    auto* parameter = findParameterOptional<ParameterDataType>(
        parameter_name, parameters, num_components, mesh);
 
    if (!parameter)
    {
        OGS_FATAL(
            "Could not find parameter `{:s}' in the provided parameters list.",
            parameter_name);
    }
    return *parameter;
}

References findParameterOptional(), OGS_FATAL, and OGS_NO_DANGLING.

Referenced by ProcessLib::createAnchorTerm(), ProcessLib::ProcessVariable::createBoundaryConditionsForDeactivatedSubDomains(), MaterialLib::Fracture::CohesiveZoneModeI::createCohesiveZoneModeI(), ProcessLib::ComponentTransport::createComponentTransportProcess(), ProcessLib::createConstraintDirichletBoundaryCondition(), createCoordinateSystem(), MaterialLib::Fracture::createCoulomb(), MaterialLib::Solids::Creep::createCreepBGRa(), MaterialPropertyLib::createCubicLawPermeability(), MaterialLib::Solids::Ehlers::createDamageProperties(), ProcessLib::createDeactivatedSubdomain(), ProcessLib::createDirichletBoundaryCondition(), ProcessLib::createDirichletBoundaryConditionWithinTimeInterval(), MaterialPropertyLib::createDupuitPermeability(), MaterialLib::Solids::Ehlers::createEhlers(), MaterialPropertyLib::createEmbeddedFracturePermeability(), MaterialPropertyLib::createGasPressureDependentPermeability(), ProcessLib::createHCNonAdvectiveFreeComponentFlowBoundaryCondition(), ProcessLib::HMPhaseField::createHMPhaseFieldProcess(), ProcessLib::HT::createHTProcess(), ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess(), ProcessLib::createInitialStress(), MaterialPropertyLib::createKozenyCarmanModel(), MaterialLib::Fracture::createLinearElasticIsotropic(), MaterialLib::Solids::createLinearElasticIsotropic(), MaterialLib::Solids::createLinearElasticIsotropicSoftening(), MaterialLib::Solids::createLinearElasticOrthotropic(), MaterialLib::Solids::createLinearElasticTransverseIsotropic(), ProcessLib::LiquidFlow::createLiquidFlowProcess(), MaterialLib::Solids::Lubby2::createLubby2(), ProcessLib::createNeumannBoundaryCondition(), ProcessLib::createNodalSourceTerm(), ProcessLib::NormalTractionBoundaryCondition::createNormalTractionBoundaryCondition(), MaterialPropertyLib::createOrthotropicEmbeddedFracturePermeability(), MaterialPropertyLib::createParameterProperty(), MaterialPropertyLib::createPermeabilityMohrCoulombFailureIndexModel(), ProcessLib::PhaseField::createPhaseFieldProcess(), MaterialPropertyLib::createPorosityFromMassBalance(), ProcessLib::createPrimaryVariableConstraintDirichletBoundaryCondition(), ProcessLib::createReleaseNodalForce(), ProcessLib::WellboreSimulator::createReservoirProperties(), ProcessLib::createRobinBoundaryCondition(), ProcessLib::LIE::SmallDeformation::createSmallDeformationProcess(), ProcessLib::createSolutionDependentDirichletBoundaryCondition(), MaterialPropertyLib::createStrainDependentPermeability(), MaterialPropertyLib::createTemperatureDependentDiffusion(), ProcessLib::createTimeDecayDirichletBoundaryCondition(), MaterialPropertyLib::createTransportPorosityFromMassBalance(), ProcessLib::TwoPhaseFlowWithPP::createTwoPhaseFlowWithPPProcess(), ProcessLib::createVariableDependentNeumannBoundaryCondition(), MaterialPropertyLib::createVermaPruessModel(), ProcessLib::createVolumetricSourceTerm(), ProcessLib::WellboreSimulator::createWellboreGeometry(), ProcessLib::WellboreSimulator::createWellboreSimulatorProcess(), findOptionalTagParameter(), findParameter(), getNamedOrCreateInlineParameter(), ParameterLib::CurveScaledParameter< T >::initialize(), ParameterLib::TimeDependentHeterogeneousParameter::initialize(), parseBase1OrBase2(), parseOverwriteMeshData(), anonymous_namespace{CreateMFrontGeneric.cpp}::readMaterialProperties(), and anonymous_namespace{CreateMFrontGeneric.cpp}::readStateVariablesInitialValueProperties().

findParameterByName()

ParameterBase * ParameterLib::findParameterByName	(	std::string const &	parameter_name,
		std::vector< std::unique_ptr< ParameterBase > > const &	parameters )

Find an optional parameter of specific type for a given name.

Template Parameters

ParameterDataType

the data type of the parameter

Parameters

parameter_name	name of the requested parameter
parameters	list of parameters in which it will be searched

Definition at line 8 of file ParameterLib/Utils.cpp.

{
    // Find corresponding parameter by name.
    auto const it =
        std::find_if(parameters.cbegin(), parameters.cend(),
                     [&parameter_name](std::unique_ptr<ParameterBase> const& p)
                     { return p->name == parameter_name; });
 
    if (it == parameters.end())
    {
        return nullptr;
    }
 
    DBUG("Found parameter `{:s}'.", (*it)->name);
    return it->get();
}

References DBUG().

Referenced by findParameterOptional().

findParameterOptional()

template<typename ParameterDataType>

Parameter< ParameterDataType > * ParameterLib::findParameterOptional	(	std::string const &	parameter_name,
		std::vector< std::unique_ptr< ParameterBase > > const &	parameters,
		int const	num_components,
		MeshLib::Mesh const *const	mesh = nullptr )

Find an optional parameter of specific type for a given name.

Template Parameters

ParameterDataType

the data type of the parameter

Parameters

parameter_name	name of the requested parameter
parameters	list of parameters in which it will be searched
num_components	the number of components of the parameters or zero if any number is acceptable
mesh	an optional mesh pointer used for test whether the parameter is defined on the given mesh. No test is performed if the pointer is a nullptr.

See also

The documentation of the other findParameter() function.

Definition at line 36 of file ParameterLib/Utils.h.

{
    // Find corresponding parameter by name.
    ParameterBase* parameter_ptr =
        findParameterByName(parameter_name, parameters);
    if (parameter_ptr == nullptr)
    {
        return nullptr;
    }
 
    // Check the type correctness of the found parameter.
    auto* const parameter =
        dynamic_cast<Parameter<ParameterDataType>*>(parameter_ptr);
    if (!parameter)
    {
        OGS_FATAL("The read parameter `{:s}' is of incompatible type.",
                  parameter_name);
    }
 
    if (num_components != 0 &&
        parameter->getNumberOfGlobalComponents() != num_components)
    {
        OGS_FATAL(
            "The read parameter `{:s}' has the wrong number of components "
            "({:d} instead of {:d}).",
            parameter_name, parameter->getNumberOfGlobalComponents(),
            num_components);
    }
 
    // Test the parameter's mesh only if there is a "test"-mesh provided.
    if (mesh != nullptr)
    {
        if (auto const error = isDefinedOnSameMesh(*parameter, *mesh))
        {
            OGS_FATAL(
                "The found parameter is not suitable for the use on the "
                "required mesh.\n{:s}",
                error->c_str());
        }
    }
 
    return parameter;
}

References findParameterByName(), isDefinedOnSameMesh(), and OGS_FATAL.

Referenced by findParameter().

getNamedOrCreateInlineParameter()

OGS_NO_DANGLING Parameter< double > & ParameterLib::getNamedOrCreateInlineParameter	(	std::string const &	parameter_or_value,
		std::vector< std::unique_ptr< ParameterBase > > &	parameters,
		std::string const &	property_name,
		std::string const &	inline_suffix )

Returns a Parameter<double>& based on the value of the given config tag.

If the config entry <tag_name> is a double, creates a ConstantParameter with that value, adds it to parameters, and returns it.

If the entry is a string, interprets it as the name of an existing parameter and returns a reference to that parameter.

Parameters

parameter_or_value	The raw string to create parameter or value from.
parameters	The parameter storage vector (will be modified if an inline constant is created).
property_name	Name of the property (used for auto-generated parameter names in the inline case).
inline_suffix	Suffix for auto-generated parameter names.

Definition at line 126 of file ParameterLib/Parameter.cpp.

{
    // try to parse number(s) (if empty - no inline-values)
    std::size_t bad_idx = 0;
    if (auto values =
            BaseLib::tryParseVector<double>(parameter_or_value, &bad_idx);
        values)
    {
        if (values->empty())
        {
            OGS_FATAL(
                "Empty inline value list for property '{:s}'. "
                "Provide at least one numeric value (e.g., \"1.23 4.56\") or "
                "specify the name of an existing parameter. "
                "Raw input was: \"{:s}\".",
                property_name, parameter_or_value);
        }
 
        // collect all existing parameter names for checks against uniqueness
        std::vector<std::string> existing_names;
        existing_names.reserve(parameters.size());
        std::transform(parameters.begin(), parameters.end(),
                       std::back_inserter(existing_names),
                       [](auto const& p) { return p->name; });
 
        // assign inline values as constant parameter
        std::string pname = BaseLib::getUniqueName(
            existing_names, property_name + "_" + inline_suffix);
        using P = ConstantParameter<double>;
        parameters.push_back(std::make_unique<P>(pname, std::move(*values)));
        return static_cast<Parameter<double>&>(*parameters.back());
    }
 
    // No inline values -> 'parameter_or_value' is just a parameter name, now
    // find that parameter.
    return findParameter<double>(parameter_or_value, parameters, 0, nullptr);
}

References findParameter(), BaseLib::getUniqueName(), OGS_FATAL, and BaseLib::tryParseVector().

Referenced by ProcessLib::HeatTransportBHE::BHE::createBoreholeGeometry(), ProcessLib::HeatTransportBHE::BHE::createCoolingVariant(), ProcessLib::HeatTransportBHE::BHE::createFlowAndTemperatureControl(), ProcessLib::HeatTransportBHE::BHE::createPipe(), ProcessLib::HeatTransportBHE::BHE::createPowerWithCOPStruct(), and MaterialPropertyLib::createSaturationWeightedThermalConductivity().

getTransformationFromSingleBase2D()

Eigen::Matrix< double, 2, 2 > ParameterLib::getTransformationFromSingleBase2D	(	Parameter< double > const &	unit_direction,
		SpatialPosition const &	pos )

Definition at line 125 of file ParameterLib/CoordinateSystem.cpp.

{
    auto const& normal = unit_direction(0 /* time independent */, pos);
    checkNormalization(Eigen::Map<Eigen::Vector2d const>(normal.data()),
                       unit_direction.name);
 
    Eigen::Matrix<double, 2, 2> t;
    // base 0: ( normal[1], -normal[0])^T
    // base 1: ( normal[0], normal[1])^T
    t << normal[1], normal[0], -normal[0], normal[1];
 
    checkTransformationIsSON(t);
    return t;
}

getTransformationFromSingleBase3D()

Eigen::Matrix< double, 3, 3 > ParameterLib::getTransformationFromSingleBase3D	(	Parameter< double > const &	unit_direction,
		SpatialPosition const &	pos )

Definition at line 167 of file ParameterLib/CoordinateSystem.cpp.

{
    auto const& normal = unit_direction(0 /* time independent */, pos);
 
    Eigen::Matrix<double, 3, 3> t;
    auto e2 = t.col(2);
    e2 = Eigen::Map<Eigen::Vector3d const>(normal.data());
    checkNormalization(e2, unit_direction.name);
 
    // Find the id of the first non-zero component of e2:
    int id;
    e2.cwiseAbs().maxCoeff(&id);
 
    // Get other two component ids:
    const auto id_a = (id + 1) % 3;
    const auto id_b = (id + 2) % 3;
 
    // Compute basis vector e1 orthogonal to e2
    auto e1 = t.col(1);
    e1 = Eigen::Vector3d::Zero();
 
    if (std::abs(e2[id_a]) < tolerance)
    {
        e1[id_a] = 1.0;
    }
    else if (std::abs(e2[id_b]) < tolerance)
    {
        e1[id_b] = 1.0;
    }
    else
    {
        e1[id_a] = 1.0;
        e1[id_b] = -e2[id_a] / e2[id_b];
    }
 
    e1.normalize();
 
    // |e0| = |e1 x e2| = |e1||e2|sin(theta) with theta the angle between e1 and
    // e2. Since |e1| = |e2| = 1.0, and theta = pi/2, we have |e0|=1. Therefore
    // e0 is normalized by nature.
    t.col(0) = e1.cross(e2);
 
    checkTransformationIsSON(t);
 
    return t;
}

Referenced by ParameterLib::CoordinateSystem::transformationFromSingleBase_3d().

hasSpatialVariables()

bool ParameterLib::hasSpatialVariables

(

std::vector< std::string > const &

variables

)

Returns true if variables contains any of the spatial variable names "x", "y", or "z".

Definition at line 45 of file ExprtkUtils.cpp.

{
    return std::ranges::any_of(variables, [](std::string const& v)
                               { return v == "x" || v == "y" || v == "z"; });
}

Referenced by ParameterLib::FunctionEvaluation::FunctionEvaluation(), and MaterialPropertyLib::Function::Implementation< D >::Implementation().

isBuiltinSymbol()

bool ParameterLib::isBuiltinSymbol

(

std::string_view

name

)

Returns true if name is one of the built-in symbol names registered by createBaseSymbolTable ("t", "x", "y", "z").

Definition at line 40 of file ExprtkUtils.cpp.

{
    return name == "t" || name == "x" || name == "y" || name == "z";
}

Referenced by MaterialPropertyLib::Function::Function(), MaterialPropertyLib::createSymbolTable(), and createSymbolTable().

isDefinedOnSameMesh()

std::optional< std::string > ParameterLib::isDefinedOnSameMesh	(	ParameterBase const &	parameter,
		MeshLib::Mesh const &	mesh )

Checks whether the parameter can be used on the given mesh. The parameter's domain of definition can be arbitrary (like for constant parameters), or the parameter is defined on a mesh. In the latter case that mesh must be equal to the given mesh.

Returns

nothing if the parameter can be used on the given mesh, or an error string otherwise.

Definition at line 101 of file ParameterLib/Parameter.cpp.

{
    // Arbitrary domain of definition.
    if (parameter.mesh() == nullptr)
    {
        return {};
    }
 
    // Equal meshes.
    if (*parameter.mesh() == mesh)
    {
        return {};
    }
 
    return "The parameter's domain of definition mesh '" +
           parameter.mesh()->getName() + "' differs from the used mesh '" +
           mesh.getName() +
           "'. The same mesh (the same name) has to be referenced in the "
           "project file. Possible reasons are:\n - the parameter used for the "
           "initial condition is not defined on the bulk mesh,\n - the "
           "parameter's domain of definition mesh differs from the boundary "
           "condition or source term domain of definition mesh.";
}

References MeshLib::Mesh::getName(), and ParameterLib::ParameterBase::mesh().

Referenced by findParameterOptional().

operator<<()

std::ostream & ParameterLib::operator<<	(	std::ostream &	os,
		SpatialPosition const &	pos )

Prints the node id, element id and coordinates carried by pos, using "not set" for any of the three that is not specified.

Definition at line 12 of file SpatialPosition.cpp.

{
    auto const default_precision = os.precision();
    os << "{ node: ";
    if (auto const node_id = pos.getNodeID())
    {
        os << *node_id;
    }
    else
    {
        os << "not set";
    }
 
    os << ", element: ";
    if (auto const element_id = pos.getElementID())
    {
        os << *element_id;
    }
    else
    {
        os << "not set";
    }
 
    os << ", coordinates: ";
    if (auto const coordinates = pos.getCoordinates())
    {
        os << std::setprecision(std::numeric_limits<double>::digits10 + 1)
           << "(" << *coordinates << ")"
           << std::setprecision(default_precision);
    }
    else
    {
        os << "not set";
    }
    os << " }";
    return os;
}

References ParameterLib::SpatialPosition::getCoordinates(), ParameterLib::SpatialPosition::getElementID(), and ParameterLib::SpatialPosition::getNodeID().

parseBase1OrBase2()

Parameter< double > const * ParameterLib::parseBase1OrBase2	(	BaseLib::ConfigTree const &	config,
		std::vector< std::unique_ptr< ParameterLib::ParameterBase > > const &	parameters,
		int const	expected_component_number,
		std::string_view const	base_tag_name )

Definition at line 20 of file CreateCoordinateSystem.cpp.

{
    auto const base_parameter_name = config.getValue<std::string>();
    auto const& basis_vector = ParameterLib::findParameter<double>(
        base_parameter_name, parameters, 0 /* any dimension */);
 
    int const component_number = basis_vector.getNumberOfGlobalComponents();
    if (base_tag_name == "basis_vector_1" && component_number != 2)
    {
        OGS_FATAL(
            "The case of implicit \"basis_vector_0\" and "
            "explicit \"basis_vector_1\" is for a 2D coordinate system. The "
            "parameter for \"basis_vector_1\", {:s}, must have "
            "two components but it has {:d}. In addition, \"basis_vector_2\" "
            "should not exist in this case.",
            base_parameter_name, component_number);
    }
 
    if (component_number != expected_component_number)
    {
        OGS_FATAL(
            "The read parameter `{:s}' for tag {:s} has the wrong number of "
            "components ({:d} instead of {:d}).",
            base_parameter_name, base_tag_name, component_number,
            expected_component_number);
    }
 
    return &basis_vector;
}

References findParameter(), BaseLib::ConfigTree::getValue(), and OGS_FATAL.

Referenced by createCoordinateSystem(), and createCoordinateSystemWithImplicitBase().

registerCurveWrappers()

void ParameterLib::registerCurveWrappers	(	exprtk::symbol_table< double > &	symbol_table,
		std::vector< std::string > const &	curve_names,
		std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation > > const &	curves,
		std::map< std::string, CurveWrapper > &	curve_wrappers )

Registers CurveWrapper objects in the symbol table for the given curve names.

Parameters

symbol_table	The symbol table to register curves into.
curve_names	Names of curves to register.
curves	Map of all available curves.
curve_wrappers	Is filled with CurveWrapper objects and must outlive the returned symbol table.

Definition at line 66 of file ExprtkUtils.cpp.

{
    for (auto const& name : curve_names)
    {
        if (exprtk::details::is_reserved_symbol(name))
        {
            OGS_FATAL(
                "Curve name '{:s}' collides with an exprtk reserved symbol "
                "(built-in function or keyword). Such a curve cannot be "
                "registered: the built-in would silently be used instead. "
                "Please rename the curve.",
                name);
        }
        curve_wrappers.emplace(name, CurveWrapper(*curves.at(name)));
    }
    for (auto& [name, wrapper] : curve_wrappers)
    {
        if (!symbol_table.add_function(name, wrapper))
        {
            OGS_FATAL(
                "Failed to register curve '{:s}' as an exprtk function. The "
                "name is likely already in use (reserved symbol or duplicate).",
                name);
        }
    }
}

References OGS_FATAL.

Referenced by MaterialPropertyLib::createSymbolTable(), and createSymbolTable().

Variable Documentation

tolerance

double const ParameterLib::tolerance = std::numeric_limits<double>::epsilon()

static

Definition at line 18 of file ParameterLib/CoordinateSystem.cpp.

Referenced by checkNormalization(), checkTransformationIsSON(), and ParameterLib::CoordinateSystem::transformation().