ParameterLib Namespace Reference

Detailed Description

The TimeDependentHeterogeneousParameter class implements a parameter that varies in time and space, i.e., it is a function \( (t, x) \mapsto f(t, x) \in T^n \).

Classes
struct	Parameter
struct	ConstantParameter
	Single, constant value parameter. More...
struct	CoordinateSystem
struct	CurveScaledParameter
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	ParameterBase
struct	RandomFieldMeshElementParameter
	A parameter represented by a mesh property vector. More...
class	SpatialPosition
class	TimeDependentHeterogeneousParameter

Functions
std::unique_ptr< ParameterBase >	createConstantParameter (std::string const &name, BaseLib::ConfigTree const &config)
std::unique_ptr< ParameterBase >	createCurveScaledParameter (std::string const &name, BaseLib::ConfigTree const &config, std::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &curves)
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::map< std::string, std::unique_ptr< MathLib::PiecewiseLinearInterpolation >> const &curves)
std::optional< std::string >	isDefinedOnSameMesh (ParameterBase const &parameter, MeshLib::Mesh const &mesh)
std::unique_ptr< ParameterBase >	createRandomFieldMeshElementParameter (std::string const &name, BaseLib::ConfigTree const &config, MeshLib::Mesh &mesh)
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 >
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 >
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 = 1.e-15
static const char *const	error_info

Function Documentation

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 19 of file ConstantParameter.cpp.

{
    config.checkConfigParameter("type", "Constant");
 
    // Optional case for single-component variables where the value can be used.
    // If the 'value' tag is found, use it and return. Otherwise continue with
    // then required tag 'values'.
    {
        auto const value =
            config.getConfigParameterOptional<std::vector<double>>("value");
 
        if (value)
        {
            if (value->size() != 1)
            {
                OGS_FATAL(
                    "Expected to read exactly one value, but {:d} were given.",
                    value->size());
            }
            DBUG("Using value {:g} for constant parameter.", (*value)[0]);
            return std::make_unique<ConstantParameter<double>>(name,
                                                               (*value)[0]);
        }
    }
 
    // Value tag not available; continue with required values tag.
    std::vector<double> const values =
        config.getConfigParameter<std::vector<double>>("values");
 
    if (values.empty())
    {
        OGS_FATAL("No value available for constant parameter.");
    }
 
    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, values);
}

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

Referenced by createParameter().

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 17 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(), MaterialPropertyLib::name, 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 17 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(), BaseLib::ConfigTree::getConfigSubtreeList(), and MaterialPropertyLib::name.

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 19 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(), MaterialPropertyLib::name, 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 18 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(), MaterialPropertyLib::name, 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 18 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(), MaterialPropertyLib::name, 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::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.

Input File Parameter:

prj__parameters__parameter__name

Input File Parameter:

prj__parameters__parameter__type

Input File Parameter:

prj__parameters__parameter__mesh

Definition at line 26 of file 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 = *BaseLib::findElementOrError(
        begin(meshes), end(meshes),
        [&mesh_name](auto const& m) { return m->getName() == mesh_name; },
        "Expected to find a mesh named " + 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 = *BaseLib::findElementOrError(
            begin(meshes), end(meshes),
            [&mesh_name](auto const& m) { return m->getName() == mesh_name; },
            "Expected to find a mesh named " + mesh_name + ".");
        INFO("RandomFieldMeshElement: {:s}", name);
        return createRandomFieldMeshElementParameter(name, config, mesh_var);
    }
    if (type == "TimeDependentHeterogeneousParameter")
    {
        INFO("TimeDependentHeterogeneousParameter: {: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(), createTimeDependentHeterogeneousParameter(), BaseLib::findElementOrError(), BaseLib::ConfigTree::getConfigParameter(), INFO(), MaterialPropertyLib::name, OGS_FATAL, and BaseLib::ConfigTree::peekConfigParameter().

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__RandomFieldMeshElementParameter__field_name

Input File Parameter:

prj__parameters__parameter__RandomFieldMeshElementParameter__range

Input File Parameter:

prj__parameters__parameter__RandomFieldMeshElementParameter__seed

Definition at line 21 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(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(), MaterialPropertyLib::name, and OGS_FATAL.

Referenced by createParameter().

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__TimeDependentHeterogeneousParameter__time_series

Input File Parameter:

prj__parameters__parameter__TimeDependentHeterogeneousParameter__time_series__pair

Input File Parameter:

prj__parameters__parameter__TimeDependentHeterogeneousParameter__time_series__pair__time

Input File Parameter:

prj__parameters__parameter__TimeDependentHeterogeneousParameter__time_series__pair__parameter_name

Definition at line 106 of file TimeDependentHeterogeneousParameter.cpp.

{
    config.checkConfigParameter("type", "TimeDependentHeterogeneousParameter");
    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::checkConfigParameter(), BaseLib::ConfigTree::getConfigSubtree(), MaterialPropertyLib::name, 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 163 of file 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 BaseLib::ConfigTree::getConfigParameterOptional(), and MaterialPropertyLib::name.

Referenced by ProcessLib::SmallDeformation::createSmallDeformationProcess().

findParameter() [1/2]

template<typename ParameterDataType >

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 134 of file 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 BaseLib::ConfigTree::getConfigParameter(), and MaterialPropertyLib::name.

findParameter() [2/2]

template<typename ParameterDataType >

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 102 of file 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 OGS_FATAL.

Referenced by ProcessLib::LIE::HydroMechanics::createHydroMechanicsProcess(), MaterialLib::PorousMedium::createPermeabilityModel(), and ProcessLib::ThermoMechanicalPhaseField::createThermoMechanicalPhaseFieldProcess().

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 15 of file 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 42 of file 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.

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 98 of file 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().

Variable Documentation

error_info

const char* const ParameterLib::error_info

static

Initial value:

=
    "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"

Definition at line 20 of file CoordinateSystem.cpp.

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

tolerance

double const ParameterLib::tolerance = 1.e-15

static

Definition at line 19 of file CoordinateSystem.cpp.

Referenced by MaterialPropertyLib::RelPermNonWettingPhaseVanGenuchtenMualem::computeSaturationForMinimumRelativePermeability(), ChemistryLib::PhreeqcIOData::createKnobs(), MeshView::extractSurfaceMesh(), and ParameterLib::CoordinateSystem::transformation_3d().