pymor.parameters.base

This module contains the implementation of pyMOR’s parameter handling facilities.

Use the ParametricObject base class to define immutable (mathematical) objects that depend on some Parameters. Each Parameter in pyMOR has a name and a fixed dimension (number of scalar components of the parameter vector). In particular, scalar parameters are treated as parameter vectors of dimension 1. Mappings of Parameters to parameter values are stored in pyMOR using dedicated Mu objects. To sample parameter values within a given range, ParameterSpace objects can be used.

Module Contents

Classes

Parameters	Immutable dict mapping parameter names to parameter dimensions.
Mu	Immutable mapping of Parameter names to parameter values.
ParametricObject	Base class for immutable mathematical entities depending on some Parameters.
ParameterSpace	A set of Parameters with allowed ranges for their values.

class pymor.parameters.base.Parameters(*args, **kwargs)

Bases: pymor.tools.frozendict.SortedFrozenDict

Immutable dict mapping parameter names to parameter dimensions.

Each key of a Parameters dict is a string specifying the name of a parameter. The corresponding value is a non-negative int specifying the dimension (number of scalar components) of the parameter.

__slots__ = []

_post_init(self)

classmethod of(cls, *args)

Computes the total set of Parameters a collection of objects depends on.

If two objects depend on a parameter with the same name, both parameters must have the same dimension.

Parameters

args

Each positional argument must either be None, a ParametricObject or lists, tuples, dicts or NumPy arrays of such objects. The latter will be traversed recursively.

property dim(self)

The sum of the dimensions of all parameters.

parse(self, mu)

Takes a user input mu and interprets it as set of parameter values according to the given Parameters.

Depending on the Parameters, mu can be given as a dict, list, tuple, NumPy array or scalar. In the latter cases, multiple parameters will be concatenated by alphabetical ordering. E.g.:

Parameters(b=2, a=1).parse([1,2,3])

will assign to parameter a the value [1] and to parameter b the values [2, 3]. Further, each parameter value can be given as a vector-valued Function with dim_domain == 1 to specify time-dependent values. A str is converted to an appropriate ExpressionFunction. Note that ExpressionFunctions are functions of the variable x, so you have to write x instead of t for the time parameter in the string expression.

Parameters

mu

The user input which shall be interpreted as parameter values.

Returns

The resulting object of parameter values.

Raises

ValueError

Is raised if mu cannot be interpreted as parameter values for the given Parameters.

space(self, *ranges)

Create a ParameterSpace with given ranges.

This is a shorthand for

ParameterSpace(self, *range)

See ParameterSpace for allowed range arguments.

assert_compatible(self, mu)

Assert that parameter values are compatible with the given Parameters.

Each of the parameter must be contained in mu and the dimensions have to match, i.e.

mu[parameter].size == self[parameter]

Otherwise, an AssertionError will be raised.

is_compatible(self, mu)

Check if parameter values are compatible with the given Parameters.

Each of the parameter must be contained in mu and the dimensions have to match, i.e.

mu[parameter].size == self[parameter]

why_incompatible(self, mu)

__or__(self, other)

__sub__(self, other)

__le__(self, params)

Return self<=value.

__str__(self)

Return str(self).

__repr__(self)

Return repr(self).

__hash__(self)

Return hash(self).

class pymor.parameters.base.Mu(*args, **kwargs)

Bases: pymor.tools.frozendict.FrozenDict

Immutable mapping of Parameter names to parameter values.

Parameters

Anything that dict accepts for the construction of a dictionary. Values are automatically converted to one-dimensional NumPy arrays, except for Functions which are interpreted as time-dependent parameter values. Unless the Python interpreter runs with the -O flag, the arrays are made immutable.

parameters

The Parameters to which the mapping assigns values.

__slots__ = _raw_values

is_time_dependent(self, param)

Check whether the values for a given parameter depend on time.

This is the case when the value for self[param] was given by a Function instead of a constant array.

get_time_dependent_value(self, param)

Return time-dependent Function for given parameter.

Parameters

param

The parameter for which to return the time-dependent values.

Returns

If param depends on time, this corresponding Function (and not its evaluation at the current time) is returned. If param is not given by a Function, a ConstantFunction is returned.

with_(self, **kwargs)

allclose(self, mu)

Compare two dicts of parameter values using float_cmp_all.

Parameters

mu

The parameter values with which to compare.

Returns

True if both parameter value dicts contain values for the same Parameters and all components of the parameter values are almost equal, else False.

to_numpy(self)

All parameter values as a NumPy array, ordered alphabetically.

copy(self)

D.copy() -> a shallow copy of D

__eq__(self, mu)

Return self==value.

__str__(self)

Return str(self).

__repr__(self)

Return repr(self).

class pymor.parameters.base.ParametricObject

Bases: pymor.core.base.ImmutableObject

Base class for immutable mathematical entities depending on some Parameters.

Each ParametricObject lists the Parameters it depends on in the parameters attribute. Usually, these Parameters are automatically derived as the union of all Parameters of the object’s __init__ arguments.

Additional Parameters introduced by the object itself can be specified by setting the parameters_own attribute in __init__. In case the object fixes some Parameters it’s child objects depend on to concrete values, those Parameters can be removed from the parameters attribute by setting parameters_internal.

Alternatively, parameters can be initialized manually in __init__.

parameters

The Parameters the object depends on.

parameters_own

The Parameters the object depends on which are not inherited from a child object the object depends on. Each item of parameters_own is also an item of parameters.

parameters_inherited

The Parameters the object depends on because some child object depends on them. Each item of parameters_own is also an item of parameters.

parameters_internal

The Parameters some of the object’s child objects may depend on, but which are fixed to a concrete value by this object. All items of parameters_internal are removed from parameters and parameters_inherited. When initializing parameters_own and parameters_internal, it has to be ensured that both dicts are disjoint.

parametric

True if the object really depends on a parameter, i.e. parameters is not empty.

_parameters

_parameters_own

_parameters_internal

__check_parameter_consistency(self)

class pymor.parameters.base.ParameterSpace(parameters, *ranges)

Bases: ParametricObject

A set of Parameters with allowed ranges for their values.

ParameterSpaces are mostly used to create sample set of parameter values for given Parameters within a specified range.

Parameters

parameters

The Parameters which are part of the space.

ranges

Allowed ranges for the parameter values. Either:

• two numbers specifying the lower and upper bound for all parameter value components,

• a list/tuple of two numbers specifying these bounds,

• or a dict of those tuples, specifying upper and lower bounds individually for each parameter of the space.

sample_uniformly(self, counts)

Uniformly sample parameter values from the space.

Parameters

counts

Number of samples to take per parameter and component of the parameter. Either a dict of counts per Parameter or a single count that is taken for all Parameters

Returns

List of parameter value dicts.

sample_randomly(self, count=None, random_state=None, seed=None)

Randomly sample parameter values from the space.

Parameters

count

If None, a single dict mu of parameter values is returned. Otherwise, the number of random samples to generate and return as a list of parameter values dicts.

random_state

RandomState to use for sampling. If None, a new random state is generated using seed as random seed, or the default random state is used.

seed

If not None, a new random state with this seed is used.

Returns

The sampled parameter values.

contains(self, mu)