`pymor.operators.constructions`¶

Module containing some constructions to obtain new operators from old ones.

Module Contents¶

class pymor.operators.constructions.AdjointOperator(operator, source_product=None, range_product=None, name=None, with_apply_inverse=True, solver_options=None)[source]¶

Bases: pymor.operators.interface.Operator

Represents the adjoint of a given linear Operator.

For a linear Operator op the adjoint op^* of op is given by:

(op^*(v), u)_s = (v, op(u))_r,

where ( , )_s and ( , )_r denote the inner products on the source and range space of op. If two products are given by P_s and P_r, then:

op^*(v) = P_s^(-1) o op.H o P_r,

Thus, if ( , )_s and ( , )_r are the Euclidean inner products, op^*v is simply given by application of the :attr:adjoint <pymor.operators.interface.Operator.H>` Operator.

Parameters:

operator – The Operator of which the adjoint is formed.
source_product – If not None, inner product Operator for the source VectorSpace w.r.t. which to take the adjoint.
range_product – If not None, inner product Operator for the range VectorSpace w.r.t. which to take the adjoint.
name – If not None, name of the operator.
with_apply_inverse – If True, provide own apply_inverse and apply_inverse_adjoint implementations by calling these methods on the given operator. (Is set to False in the default implementation of and apply_inverse_adjoint.)
solver_options – When with_apply_inverse is False, the solver_options to use for the apply_inverse default implementation.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.

linear = True[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

class pymor.operators.constructions.AffineOperator(operator, name=None)[source]¶

Bases: ProxyOperator

Decompose an affine Operator into affine_shift and linear_part.

Methods

jacobian

Return the operator's Jacobian as a new Operator.

jacobian(U, mu=None)[source]¶

Return the operator’s Jacobian as a new Operator.

Parameters:

U – Length 1 VectorArray containing the vector for which to compute the Jacobian.
mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

class pymor.operators.constructions.ComponentProjectionOperator(components, source, name=None)[source]¶

Bases: pymor.operators.interface.Operator

Operator representing the projection of a VectorArray onto some of its components.

Parameters:

components – List or 1D NumPy array of the indices of the vector dofs that are to be extracted by the operator.
source – Source VectorSpace of the operator.
name – Name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`restricted`	Restrict the operator range to a given set of degrees of freedom.

linear = True[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

restricted(dofs)[source]¶

Restrict the operator range to a given set of degrees of freedom.

This method returns a restricted version restricted_op of the operator along with an array source_dofs such that for any VectorArray U in self.source the following is true:

self.apply(U, mu).dofs(dofs)
    == restricted_op.apply(restricted_op.source.from_numpy(U.dofs(source_dofs))
                           mu).to_numpy()

Such an operator is mainly useful for empirical interpolation where the evaluation of the original operator only needs to be known for few selected degrees of freedom. If the operator has a small stencil, only few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters:

dofs – One-dimensional NumPy array of degrees of freedom in the operator range to which to restrict.

Returns:

restricted_op – The restricted operator as defined above. The operator will have NumpyVectorSpace (len(source_dofs)) as source and NumpyVectorSpace (len(dofs)) as range.
source_dofs – One-dimensional NumPy array of source degrees of freedom as defined above.

class pymor.operators.constructions.ConcatenationOperator(operators, solver_options=None, name=None)[source]¶

Bases: pymor.operators.interface.Operator

Operator representing the concatenation of two Operators.

Parameters:

operators – Tuple of Operators to concatenate. operators[-1] is the first applied operator, operators[0] is the last applied operator.
solver_options – The solver_options for the operator.
name – Name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`d_mu`	Return the operator's derivative with respect to a given parameter.
`jacobian`	Return the operator's Jacobian as a new `Operator`.
`restricted`	Restrict the operator range to a given set of degrees of freedom.

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

d_mu(parameter, index=0)[source]¶

Return the operator’s derivative with respect to a given parameter.

Parameters:

parameter – The parameter w.r.t. which to return the derivative.
index – Index of the parameter’s component w.r.t which to return the derivative.

Returns:

New |Operator| representing the partial derivative.

jacobian(U, mu=None)[source]¶

Return the operator’s Jacobian as a new Operator.

Parameters:

U – Length 1 VectorArray containing the vector for which to compute the Jacobian.
mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

restricted(dofs)[source]¶

Restrict the operator range to a given set of degrees of freedom.

This method returns a restricted version restricted_op of the operator along with an array source_dofs such that for any VectorArray U in self.source the following is true:

self.apply(U, mu).dofs(dofs)
    == restricted_op.apply(restricted_op.source.from_numpy(U.dofs(source_dofs))
                           mu).to_numpy()

Such an operator is mainly useful for empirical interpolation where the evaluation of the original operator only needs to be known for few selected degrees of freedom. If the operator has a small stencil, only few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters:

dofs – One-dimensional NumPy array of degrees of freedom in the operator range to which to restrict.

Returns:

restricted_op – The restricted operator as defined above. The operator will have NumpyVectorSpace (len(source_dofs)) as source and NumpyVectorSpace (len(dofs)) as range.
source_dofs – One-dimensional NumPy array of source degrees of freedom as defined above.

class pymor.operators.constructions.ConstantOperator(value, source, name=None)[source]¶

Bases: pymor.operators.interface.Operator

A constant Operator always returning the same vector.

Parameters:

value – A VectorArray of length 1 containing the vector which is returned by the operator.
source – Source VectorSpace of the operator.
name – Name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_inverse`	Apply the inverse operator.
`jacobian`	Return the operator's Jacobian as a new `Operator`.
`restricted`	Restrict the operator range to a given set of degrees of freedom.

linear = False[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

jacobian(U, mu=None)[source]¶

Return the operator’s Jacobian as a new Operator.

Parameters:

U – Length 1 VectorArray containing the vector for which to compute the Jacobian.
mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

restricted(dofs)[source]¶

Restrict the operator range to a given set of degrees of freedom.

This method returns a restricted version restricted_op of the operator along with an array source_dofs such that for any VectorArray U in self.source the following is true:

self.apply(U, mu).dofs(dofs)
    == restricted_op.apply(restricted_op.source.from_numpy(U.dofs(source_dofs))
                           mu).to_numpy()

Such an operator is mainly useful for empirical interpolation where the evaluation of the original operator only needs to be known for few selected degrees of freedom. If the operator has a small stencil, only few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters:

dofs – One-dimensional NumPy array of degrees of freedom in the operator range to which to restrict.

Returns:

restricted_op – The restricted operator as defined above. The operator will have NumpyVectorSpace (len(source_dofs)) as source and NumpyVectorSpace (len(dofs)) as range.
source_dofs – One-dimensional NumPy array of source degrees of freedom as defined above.

class pymor.operators.constructions.FixedParameterOperator(operator, mu=None, name=None)[source]¶

Bases: ProxyOperator

Makes an Operator Parameter-independent by setting fixed parameter values.

Parameters:

operator – The Operator to wrap.
mu – The fixed parameter values that will be fed to the apply method (and related methods) of operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.
`jacobian`	Return the operator's Jacobian as a new `Operator`.

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

jacobian(U, mu=None)[source]¶

Return the operator’s Jacobian as a new Operator.

Parameters:

U – Length 1 VectorArray containing the vector for which to compute the Jacobian.
mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

class pymor.operators.constructions.IdentityOperator(space, name=None)[source]¶

Bases: pymor.operators.interface.Operator

The identity Operator.

In other words:

op.apply(U) == U

Parameters:

space – The VectorSpace the operator acts on.
name – Name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.
`assemble`	Assemble the operator for given `parameter values`.
`restricted`	Restrict the operator range to a given set of degrees of freedom.

linear = True[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

assemble(mu=None)[source]¶

Assemble the operator for given parameter values.

The result of the method strongly depends on the given operator. For instance, a matrix-based operator will assemble its matrix, a LincombOperator will try to form the linear combination of its operators, whereas an arbitrary operator might simply return a FixedParameterOperator. The only assured property of the assembled operator is that it no longer depends on a Parameter.

Parameters:: mu – The parameter values for which to assemble the operator.
Returns:: Parameter-independent, assembled |Operator|.

restricted(dofs)[source]¶

Restrict the operator range to a given set of degrees of freedom.

This method returns a restricted version restricted_op of the operator along with an array source_dofs such that for any VectorArray U in self.source the following is true:

self.apply(U, mu).dofs(dofs)
    == restricted_op.apply(restricted_op.source.from_numpy(U.dofs(source_dofs))
                           mu).to_numpy()

Such an operator is mainly useful for empirical interpolation where the evaluation of the original operator only needs to be known for few selected degrees of freedom. If the operator has a small stencil, only few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters:

dofs – One-dimensional NumPy array of degrees of freedom in the operator range to which to restrict.

Returns:

restricted_op – The restricted operator as defined above. The operator will have NumpyVectorSpace (len(source_dofs)) as source and NumpyVectorSpace (len(dofs)) as range.
source_dofs – One-dimensional NumPy array of source degrees of freedom as defined above.

class pymor.operators.constructions.InducedNorm(product, raise_negative, tol, name)[source]¶

Bases: pymor.parameters.base.ParametricObject

Instantiated by induced_norm. Do not use directly.

class pymor.operators.constructions.InverseAdjointOperator(operator, name=None)[source]¶

Bases: pymor.operators.interface.Operator

Represents the inverse adjoint of a given Operator.

Parameters:

operator – The Operator of which the inverse adjoint is formed.
name – If not None, name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.

linear = True[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

class pymor.operators.constructions.InverseOperator(operator, name=None)[source]¶

Bases: pymor.operators.interface.Operator

Represents the inverse of a given Operator.

Parameters:

operator – The Operator of which the inverse is formed.
name – If not None, name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

class pymor.operators.constructions.LincombOperator(operators, coefficients, solver_options=None, name=None)[source]¶

Bases: pymor.operators.interface.Operator

Linear combination of arbitrary Operators.

This Operator represents a (possibly Parameter dependent) linear combination of a given list of Operators.

Parameters:

operators – List of Operators whose linear combination is formed.
coefficients – A list of linear coefficients. A linear coefficient can either be a fixed number or a ParameterFunctional.
solver_options – The solver_options for the operator.
name – Name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply2`	Treat the operator as a 2-form and apply it to V and U.
`apply_adjoint`	Apply the adjoint operator.
`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.
`as_range_array`	Return a `VectorArray` representation of the operator in its range space.
`as_source_array`	Return a `VectorArray` representation of the operator in its source space.
`assemble`	Assemble the operator for given `parameter values`.
`d_mu`	Return the operator's derivative with respect to a given parameter.
`evaluate_coefficients`	Compute the linear coefficients for given `parameter values`.
`jacobian`	Return the operator's Jacobian as a new `Operator`.
`pairwise_apply2`	Treat the operator as a 2-form and apply it to V and U in pairs.

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply2(V, U, mu=None)[source]¶

Treat the operator as a 2-form and apply it to V and U.

This method is usually implemented as V.inner(self.apply(U)). In particular, if the operator is a linear operator given by multiplication with a matrix M, then apply2 is given as:

op.apply2(V, U) = V^T*M*U.

In the case of complex numbers, note that apply2 is anti-linear in the first variable by definition of inner.

Parameters:

V – VectorArray of the left arguments V.
U – VectorArray of the right arguments U.
mu – The parameter values for which to evaluate the operator.

Returns:

A NumPy array with shape (len(V), len(U)) containing the 2-form
evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

as_range_array(mu=None)[source]¶

Return a VectorArray representation of the operator in its range space.

In the case of a linear operator with NumpyVectorSpace as source, this method returns for given parameter values mu a VectorArray V in the operator’s range, such that

V.lincomb(U.to_numpy()) == self.apply(U, mu)

for all VectorArrays U.

Parameters:: mu – The parameter values for which to return the VectorArray representation.
Returns:: V – The VectorArray defined above.

as_source_array(mu=None)[source]¶

Return a VectorArray representation of the operator in its source space.

In the case of a linear operator with NumpyVectorSpace as range, this method returns for given parameter values mu a VectorArray V in the operator’s source, such that

self.range.make_array(V.inner(U)) == self.apply(U, mu)

for all VectorArrays U.

Parameters:: mu – The parameter values for which to return the VectorArray representation.
Returns:: V – The VectorArray defined above.

assemble(mu=None)[source]¶

Assemble the operator for given parameter values.

The result of the method strongly depends on the given operator. For instance, a matrix-based operator will assemble its matrix, a LincombOperator will try to form the linear combination of its operators, whereas an arbitrary operator might simply return a FixedParameterOperator. The only assured property of the assembled operator is that it no longer depends on a Parameter.

Parameters:: mu – The parameter values for which to assemble the operator.
Returns:: Parameter-independent, assembled |Operator|.

d_mu(parameter, index=0)[source]¶

Return the operator’s derivative with respect to a given parameter.

Parameters:

parameter – The parameter w.r.t. which to return the derivative.
index – Index of the parameter’s component w.r.t which to return the derivative.

Returns:

New |Operator| representing the partial derivative.

evaluate_coefficients(mu)[source]¶

Compute the linear coefficients for given parameter values.

Parameters:: mu – Parameter values for which to compute the linear coefficients.
Returns:: List of linear coefficients.

jacobian(U, mu=None)[source]¶

Return the operator’s Jacobian as a new Operator.

Parameters:

U – Length 1 VectorArray containing the vector for which to compute the Jacobian.
mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

pairwise_apply2(V, U, mu=None)[source]¶

Treat the operator as a 2-form and apply it to V and U in pairs.

This method is usually implemented as V.pairwise_inner(self.apply(U)). In particular, if the operator is a linear operator given by multiplication with a matrix M, then apply2 is given as:

op.apply2(V, U)[i] = V[i]^T*M*U[i].

In the case of complex numbers, note that pairwise_apply2 is anti-linear in the first variable by definition of pairwise_inner.

Parameters:

V – VectorArray of the left arguments V.
U – VectorArray of the right arguments U.
mu – The parameter values for which to evaluate the operator.

Returns:

A NumPy array with shape (len(V),) == (len(U),) containing
the 2-form evaluations.

class pymor.operators.constructions.LinearInputOperator(B)[source]¶

Bases: pymor.operators.interface.Operator

Operator representing the product B(mu)*input(t).

Parameters:: B – The input Operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`as_range_array`	Return a `VectorArray` representation of the operator in its range space.

linear = True[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

as_range_array(mu=None)[source]¶

Return a VectorArray representation of the operator in its range space.

In the case of a linear operator with NumpyVectorSpace as source, this method returns for given parameter values mu a VectorArray V in the operator’s range, such that

V.lincomb(U.to_numpy()) == self.apply(U, mu)

for all VectorArrays U.

Parameters:: mu – The parameter values for which to return the VectorArray representation.
Returns:: V – The VectorArray defined above.

class pymor.operators.constructions.LinearOperator(operator, name=None)[source]¶

Bases: ProxyOperator

Mark the wrapped Operator to be linear.

class pymor.operators.constructions.LowRankOperator(left, core, right, inverted=False, solver_options=None, name=None)[source]¶

Bases: pymor.operators.interface.Operator

Non-parametric low-rank operator.

Represents an operator of the form \(L C R^H\) or \(L C^{-1} R^H\) where \(L\) and \(R\) are VectorArrays of column vectors and \(C\) a 2D NumPy array.

Parameters:

left – VectorArray representing \(L\).
core – NumPy array representing \(C\).
right – VectorArray representing \(R\).
inverted – Whether \(C\) is inverted.
solver_options – The solver_options for the operator.
name – Name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.

linear = True[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

class pymor.operators.constructions.LowRankUpdatedOperator(operator, lr_operator, coeff, lr_coeff, solver_options=None, name=None)[source]¶

Bases: LincombOperator

Operator plus LowRankOperator.

Represents a linear combination of an Operator and LowRankOperator. Uses the Sherman-Morrison-Woodbury formula in apply_inverse and apply_inverse_adjoint:

\[\begin{split}\left(\alpha A + \beta L C R^H \right)^{-1} & = \alpha^{-1} A^{-1} - \alpha^{-1} \beta A^{-1} L C \left(\alpha C + \beta C R^H A^{-1} L C \right)^{-1} C R^H A^{-1}, \\ \left(\alpha A + \beta L C^{-1} R^H \right)^{-1} & = \alpha^{-1} A^{-1} - \alpha^{-1} \beta A^{-1} L \left(\alpha C + \beta R^H A^{-1} L \right)^{-1} R^H A^{-1}.\end{split}\]

Parameters:

operator – Operator.
lr_operator – LowRankOperator.
coeff – A linear coefficient for operator. Can either be a fixed number or a ParameterFunctional.
lr_coeff – A linear coefficient for lr_operator. Can either be a fixed number or a ParameterFunctional.
solver_options – The solver_options for the operator.
name – Name of the operator.

Methods

`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

class pymor.operators.constructions.NumpyConversionOperator(space, direction='to_numpy')[source]¶

Bases: pymor.operators.interface.Operator

Converts VectorArrays to NumpyVectorArrays.

Note that the input VectorArrays need to support to_numpy. For the adjoint, from_numpy needs to be implemented.

Parameters:

space – The VectorSpace of the VectorArrays that are converted to NumpyVectorArrays.
direction – Either 'to_numpy' or 'from_numpy'. In case of 'to_numpy' apply takes a VectorArray from space and returns a NumpyVectorArray. In case of 'from_numpy', apply takes a NumpyVectorArray and returns a VectorArray from space.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.

linear = True[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

class pymor.operators.constructions.ProjectedOperator(operator, range_basis, source_basis, product=None, solver_options=None, name=None)[source]¶

Bases: pymor.operators.interface.Operator

Generic Operator representing the projection of an Operator to a subspace.

This operator is implemented as the concatenation of the linear combination with source_basis, application of the original operator and projection onto range_basis. As such, this operator can be used to obtain a reduced basis projection of any given Operator. However, no offline/online decomposition is performed, so this operator is mainly useful for testing before implementing offline/online decomposition for a specific application.

This operator is instantiated in pymor.algorithms.projection.project as a default implementation for parametric or nonlinear operators.

Parameters:

operator – The Operator to project.
range_basis – See pymor.algorithms.projection.project.
source_basis – See pymor.algorithms.projection.project.
product – See pymor.algorithms.projection.project.
solver_options – The solver_options for the projected operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`assemble`	Assemble the operator for given `parameter values`.
`jacobian`	Return the operator's Jacobian as a new `Operator`.

linear = False[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

assemble(mu=None)[source]¶

Assemble the operator for given parameter values.

The result of the method strongly depends on the given operator. For instance, a matrix-based operator will assemble its matrix, a LincombOperator will try to form the linear combination of its operators, whereas an arbitrary operator might simply return a FixedParameterOperator. The only assured property of the assembled operator is that it no longer depends on a Parameter.

Parameters:: mu – The parameter values for which to assemble the operator.
Returns:: Parameter-independent, assembled |Operator|.

jacobian(U, mu=None)[source]¶

Return the operator’s Jacobian as a new Operator.

Parameters:

U – Length 1 VectorArray containing the vector for which to compute the Jacobian.
mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

class pymor.operators.constructions.ProxyOperator(operator, name=None)[source]¶

Bases: pymor.operators.interface.Operator

Forwards all interface calls to given Operator.

Mainly useful as base class for other Operator implementations.

Parameters:

operator – The Operator to wrap.
name – Name of the wrapping operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.
`jacobian`	Return the operator's Jacobian as a new `Operator`.
`restricted`	Restrict the operator range to a given set of degrees of freedom.

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

jacobian(U, mu=None)[source]¶

Return the operator’s Jacobian as a new Operator.

Parameters:

U – Length 1 VectorArray containing the vector for which to compute the Jacobian.
mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

restricted(dofs)[source]¶

Restrict the operator range to a given set of degrees of freedom.

This method returns a restricted version restricted_op of the operator along with an array source_dofs such that for any VectorArray U in self.source the following is true:

self.apply(U, mu).dofs(dofs)
    == restricted_op.apply(restricted_op.source.from_numpy(U.dofs(source_dofs))
                           mu).to_numpy()

Such an operator is mainly useful for empirical interpolation where the evaluation of the original operator only needs to be known for few selected degrees of freedom. If the operator has a small stencil, only few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters:

dofs – One-dimensional NumPy array of degrees of freedom in the operator range to which to restrict.

Returns:

restricted_op – The restricted operator as defined above. The operator will have NumpyVectorSpace (len(source_dofs)) as source and NumpyVectorSpace (len(dofs)) as range.
source_dofs – One-dimensional NumPy array of source degrees of freedom as defined above.

class pymor.operators.constructions.QuadraticFunctional(operator, name=None)[source]¶

Bases: pymor.operators.interface.Operator

An Operator representing a quadratic functional.

Given an operator A acting on R^d, this class represents the functional:

op: R^d ----> R^1
     u  |---> (A(u), u).

Parameters:: operator – The Operator defining the quadratic functional.

Methods

`apply`	Apply the operator to a `VectorArray`.
`d_mu`	Return the operator's derivative with respect to a given parameter.
`jacobian`	Return the operator's Jacobian as a new `Operator`.

linear = False[source]¶

range[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

d_mu(parameter, index=1)[source]¶

Return the operator’s derivative with respect to a given parameter.

Parameters:

parameter – The parameter w.r.t. which to return the derivative.
index – Index of the parameter’s component w.r.t which to return the derivative.

Returns:

New |Operator| representing the partial derivative.

jacobian(U, mu=None)[source]¶

Return the operator’s Jacobian as a new Operator.

Parameters:

U – Length 1 VectorArray containing the vector for which to compute the Jacobian.
mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

class pymor.operators.constructions.QuadraticProductFunctional(left, right, product=None, name=None)[source]¶

Bases: QuadraticFunctional

An Operator representing a quadratic functional by multiplying two linear functionals.

Given linear operators A, B: R^d —-> R^n, this class represents the functional:

op: R^d ----> R^1
     u  |---> (A(u), B(u)).

Parameters:

left – The Operator that defines the left operator of the quadratic functional.
right – The Operator that defines the right operator of the quadratic functional.
product – The Operator that defines the inner product.

linear = False[source]¶

range[source]¶

class pymor.operators.constructions.SelectionOperator(operators, parameter_functional, boundaries, name=None)[source]¶

Bases: pymor.operators.interface.Operator

An Operator selected from a list of Operators.

operators[i] is used if parameter_functional(mu) is less or equal than boundaries[i] and greater than boundaries[i-1]:

-infty ------- boundaries[i] ---------- boundaries[i+1] ------- infty
                    |                        |
--- operators[i] ---|---- operators[i+1] ----|---- operators[i+2]
                    |                        |

Parameters:

operators – List of Operators from which one Operator is selected based on the given parameter values.
parameter_functional – The ParameterFunctional used for the selection of one Operator.
boundaries – The interval boundaries as defined above.
name – Name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`as_range_array`	Return a `VectorArray` representation of the operator in its range space.
`as_source_array`	Return a `VectorArray` representation of the operator in its source space.
`assemble`	Assemble the operator for given `parameter values`.

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

as_range_array(mu=None)[source]¶

Return a VectorArray representation of the operator in its range space.

In the case of a linear operator with NumpyVectorSpace as source, this method returns for given parameter values mu a VectorArray V in the operator’s range, such that

V.lincomb(U.to_numpy()) == self.apply(U, mu)

for all VectorArrays U.

Parameters:: mu – The parameter values for which to return the VectorArray representation.
Returns:: V – The VectorArray defined above.

as_source_array(mu=None)[source]¶

Return a VectorArray representation of the operator in its source space.

In the case of a linear operator with NumpyVectorSpace as range, this method returns for given parameter values mu a VectorArray V in the operator’s source, such that

self.range.make_array(V.inner(U)) == self.apply(U, mu)

for all VectorArrays U.

Parameters:: mu – The parameter values for which to return the VectorArray representation.
Returns:: V – The VectorArray defined above.

assemble(mu=None)[source]¶

Assemble the operator for given parameter values.

The result of the method strongly depends on the given operator. For instance, a matrix-based operator will assemble its matrix, a LincombOperator will try to form the linear combination of its operators, whereas an arbitrary operator might simply return a FixedParameterOperator. The only assured property of the assembled operator is that it no longer depends on a Parameter.

Parameters:: mu – The parameter values for which to assemble the operator.
Returns:: Parameter-independent, assembled |Operator|.

class pymor.operators.constructions.VectorArrayOperator(array, adjoint=False, name=None)[source]¶

Bases: pymor.operators.interface.Operator

Wraps a VectorArray as an Operator.

If adjoint is False, the operator maps from NumpyVectorSpace(len(array)) to array.space by forming linear combinations of the vectors in the array with given coefficient arrays.

If adjoint == True, the operator maps from array.space to NumpyVectorSpace(len(array)) by forming the inner products of the argument with the vectors in the given array.

Parameters:

array – The VectorArray which is to be treated as an operator.
adjoint – See description above.
name – The name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.
`as_range_array`	Return a `VectorArray` representation of the operator in its range space.
`as_source_array`	Return a `VectorArray` representation of the operator in its source space.
`restricted`	Restrict the operator range to a given set of degrees of freedom.

linear = True[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

as_range_array(mu=None)[source]¶

Return a VectorArray representation of the operator in its range space.

In the case of a linear operator with NumpyVectorSpace as source, this method returns for given parameter values mu a VectorArray V in the operator’s range, such that

V.lincomb(U.to_numpy()) == self.apply(U, mu)

for all VectorArrays U.

Parameters:: mu – The parameter values for which to return the VectorArray representation.
Returns:: V – The VectorArray defined above.

as_source_array(mu=None)[source]¶

Return a VectorArray representation of the operator in its source space.

In the case of a linear operator with NumpyVectorSpace as range, this method returns for given parameter values mu a VectorArray V in the operator’s source, such that

self.range.make_array(V.inner(U)) == self.apply(U, mu)

for all VectorArrays U.

Parameters:: mu – The parameter values for which to return the VectorArray representation.
Returns:: V – The VectorArray defined above.

restricted(dofs)[source]¶

Restrict the operator range to a given set of degrees of freedom.

This method returns a restricted version restricted_op of the operator along with an array source_dofs such that for any VectorArray U in self.source the following is true:

self.apply(U, mu).dofs(dofs)
    == restricted_op.apply(restricted_op.source.from_numpy(U.dofs(source_dofs))
                           mu).to_numpy()

Such an operator is mainly useful for empirical interpolation where the evaluation of the original operator only needs to be known for few selected degrees of freedom. If the operator has a small stencil, only few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters:

dofs – One-dimensional NumPy array of degrees of freedom in the operator range to which to restrict.

Returns:

restricted_op – The restricted operator as defined above. The operator will have NumpyVectorSpace (len(source_dofs)) as source and NumpyVectorSpace (len(dofs)) as range.
source_dofs – One-dimensional NumPy array of source degrees of freedom as defined above.

class pymor.operators.constructions.VectorFunctional(vector, product=None, name=None)[source]¶

Bases: VectorArrayOperator

Wrap a vector as a linear Functional.

Given a vector v of dimension d, this class represents the functional

f: R^d ----> R^1
    u  |---> (u, v)

where ( , ) denotes the inner product given by product.

In particular, if product is None

VectorFunctional(vector).as_source_array() == vector.

If product is not none, we obtain

VectorFunctional(vector).as_source_array() == product.apply(vector).

Parameters:

vector – VectorArray of length 1 containing the vector v.
product – Operator representing the scalar product to use.
name – Name of the operator.

linear = True[source]¶

range[source]¶

class pymor.operators.constructions.VectorOperator(vector, name=None)[source]¶

Bases: VectorArrayOperator

Wrap a vector as a vector-like Operator.

Given a vector v of dimension d, this class represents the operator

op: R^1 ----> R^d
     x  |---> x⋅v

In particular:

VectorOperator(vector).as_range_array() == vector

Parameters:

vector – VectorArray of length 1 containing the vector v.
name – Name of the operator.

linear = True[source]¶

source[source]¶

class pymor.operators.constructions.ZeroOperator(range, source, name=None)[source]¶

Bases: pymor.operators.interface.Operator

The Operator which maps every vector to zero.

Parameters:

range – Range VectorSpace of the operator.
source – Source VectorSpace of the operator.
name – Name of the operator.

Methods

`apply`	Apply the operator to a `VectorArray`.
`apply_adjoint`	Apply the adjoint operator.
`apply_inverse`	Apply the inverse operator.
`apply_inverse_adjoint`	Apply the inverse adjoint operator.
`restricted`	Restrict the operator range to a given set of degrees of freedom.

linear = True[source]¶

apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]¶

Apply the adjoint operator.

For any given linear Operator op, parameter values mu and VectorArrays U, V in the source resp. range we have:

op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))

Thus, when op is represented by a matrix M, apply_adjoint is given by left-multiplication of (the complex conjugate of) M with V.

Parameters:

V – VectorArray of vectors to which the adjoint operator is applied.
mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse operator.

Parameters:

V – VectorArray of vectors to which the inverse operator is applied.
mu – The parameter values for which to evaluate the inverse operator.
initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
u = argmin ||op(u) - v||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

apply_inverse_adjoint(U, mu=None, initial_guess=None, least_squares=False)[source]¶

Apply the inverse adjoint operator.

Parameters:

U – VectorArray of vectors to which the inverse adjoint operator is applied.
mu – The parameter values for which to evaluate the inverse adjoint operator.
initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.
least_squares –
If True, solve the least squares problem:
```
v = argmin ||op^*(v) - u||_2.
```
Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

restricted(dofs)[source]¶

Restrict the operator range to a given set of degrees of freedom.

This method returns a restricted version restricted_op of the operator along with an array source_dofs such that for any VectorArray U in self.source the following is true:

self.apply(U, mu).dofs(dofs)
    == restricted_op.apply(restricted_op.source.from_numpy(U.dofs(source_dofs))
                           mu).to_numpy()

Such an operator is mainly useful for empirical interpolation where the evaluation of the original operator only needs to be known for few selected degrees of freedom. If the operator has a small stencil, only few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters:

dofs – One-dimensional NumPy array of degrees of freedom in the operator range to which to restrict.

Returns:

restricted_op – The restricted operator as defined above. The operator will have NumpyVectorSpace (len(source_dofs)) as source and NumpyVectorSpace (len(dofs)) as range.
source_dofs – One-dimensional NumPy array of source degrees of freedom as defined above.

pymor.operators.constructions.induced_norm(product, raise_negative=True, tol=1e-10, name=None)[source]¶

Obtain induced norm of an inner product.

The norm of the vectors in a VectorArray U is calculated by calling

product.pairwise_apply2(U, U, mu=mu).

In addition, negative norm squares of absolute value smaller than tol are clipped to 0. If raise_negative is True, a ValueError exception is raised if there are negative norm squares of absolute value larger than tol.

Parameters:

product – The inner product Operator for which the norm is to be calculated.
raise_negative – If True, raise an exception if calculated norm is negative.
tol – See above.
name – Optional, if None product’s name is used.

Returns:

norm – A function norm(U, mu=None) taking a VectorArray U as input together with the parameter values mu which are passed to the product.

pymor.operators.constructions.vector_array_to_selection_operator(array, time_instances=None, initial_time=None, end_time=None, name=None)[source]¶

Create a SelectionOperator from a VectorArray.

A SelectionOperator is created that selects an element from the VectorArray array depending on the time component of the parameter that is passed to the Operator. If time_instances is provided, these values are used for selection according to the behavior of the SelectionOperator. If initial_time and end_time are used, the time interval is split equidistantly where the number of subintervals is determined by the length of array. In time, the operator is therefore piecewise constant and the discontinuity points are at t_i - eps, i.e.:

-infty ------- initial_time --------- t_1 ----------- t_2 --------------- ... --------------- t_{n-1} ----------- end_time ----------- infty
                                   |               |               |                       |                   |
---------------- array[0] ---------|--- array[1] --|--- array[2] --|----------...----------|---- array[n-2] ---|-------- array[n-1] --------
                                   |               |               |                       |                   |

where n = len(array), t_i = initial_time + i * (end_time - initial_time) / n, eps = (end_time - initial_time) * machine_eps * n * 10.

Parameters:

array – VectorArray that is used to build VectorArrayOperators that can be selected using the created SelectionOperator.
time_instances – List of time instances used for selecting the element of the VectorArray array within the SelectionOperator. If None, initial_time and end_time need to be provided.
initial_time – If time_instances is not provided, the initial_time is used to determine the start of the time interval that is equidistantly divided into subintervals on which the SelectionOperator is piecewise constant.
end_time – Similar to initial_time but determines the end time of the time interval.
name – Name of the operator.

Returns:

operator – SelectionOperator where the selection of the element in the VectorArray is performed according to the time parameter.

pymor.operators.constructions¶

Module Contents¶

`pymor.operators.constructions`¶