pymor.operators package¶
Submodules¶
block module¶

class
pymor.operators.block.
BlockColumnOperator
(blocks)[source]¶ Bases:
pymor.operators.block.BlockOperatorBase
A column vector of arbitrary
Operators
.Methods
apply
,apply_adjoint
,as_range_array
,as_source_array
,assemble
,d_mu
apply2
,apply_inverse
,apply_inverse_adjoint
,as_vector
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
adjoint_type
,blocked_range
,blocked_source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

adjoint_type
¶


class
pymor.operators.block.
BlockDiagonalOperator
(blocks)[source]¶ Bases:
pymor.operators.block.BlockOperator
Block diagonal
Operator
of arbitraryOperators
.This is a specialization of
BlockOperator
for the block diagonal case.Methods
apply
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,assemble
apply2
,as_vector
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
adjoint_type
,blocked_range
,blocked_source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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 matrixbased operator will assemble its matrix, a
LincombOperator
will try to form the linear combination of its operators, whereas an arbitrary operator might simply return aFixedParameterOperator
. The only assured property of the assembled operator is that it no longer depends on aParameter
.Parameters
 mu
The
parameter values
for which to assemble the operator.
Returns
Parameterindependent, assembled
Operator
.


class
pymor.operators.block.
BlockEmbeddingOperator
(block_space, component)[source]¶ Bases:
pymor.operators.block.BlockColumnOperator
Methods
apply
,apply_adjoint
,as_range_array
,as_source_array
,assemble
,d_mu
apply2
,apply_inverse
,apply_inverse_adjoint
,as_vector
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
adjoint_type
,blocked_range
,blocked_source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

class
pymor.operators.block.
BlockOperator
(blocks)[source]¶ Bases:
pymor.operators.block.BlockOperatorBase
A matrix of arbitrary
Operators
.This operator can be
applied
to a compatibleBlockVectorArrays
.Parameters
 blocks
Twodimensional arraylike where each entry is an
Operator
orNone
.
Methods
apply
,apply_adjoint
,as_range_array
,as_source_array
,assemble
,d_mu
apply2
,apply_inverse
,apply_inverse_adjoint
,as_vector
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
adjoint_type
,blocked_range
,blocked_source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

adjoint_type
¶ alias of
pymor.operators.block.BlockOperator

class
pymor.operators.block.
BlockOperatorBase
(blocks)[source]¶ Bases:
pymor.operators.interface.Operator
Methods
apply
,apply_adjoint
,as_range_array
,as_source_array
,assemble
,d_mu
apply2
,apply_inverse
,apply_inverse_adjoint
,as_vector
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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
assource
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’srange
, such thatV.lincomb(U.to_numpy()) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
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
asrange
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’ssource
, such thatself.range.make_array(V.inner(U).T) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
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 matrixbased operator will assemble its matrix, a
LincombOperator
will try to form the linear combination of its operators, whereas an arbitrary operator might simply return aFixedParameterOperator
. The only assured property of the assembled operator is that it no longer depends on aParameter
.Parameters
 mu
The
parameter values
for which to assemble the operator.
Returns
Parameterindependent, 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.


class
pymor.operators.block.
BlockProjectionOperator
(block_space, component)[source]¶ Bases:
pymor.operators.block.BlockRowOperator
Methods
apply
,apply_adjoint
,as_range_array
,as_source_array
,assemble
,d_mu
apply2
,apply_inverse
,apply_inverse_adjoint
,as_vector
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
adjoint_type
,blocked_range
,blocked_source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

class
pymor.operators.block.
BlockRowOperator
(blocks)[source]¶ Bases:
pymor.operators.block.BlockOperatorBase
A row vector of arbitrary
Operators
.Methods
apply
,apply_adjoint
,as_range_array
,as_source_array
,assemble
,d_mu
apply2
,apply_inverse
,apply_inverse_adjoint
,as_vector
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
adjoint_type
,blocked_range
,blocked_source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

adjoint_type
¶


class
pymor.operators.block.
SecondOrderModelOperator
(E, K)[source]¶ Bases:
pymor.operators.block.BlockOperator
BlockOperator appearing in SecondOrderModel.to_lti().
This represents a block operator
\[\begin{split}\mathcal{A} = \begin{bmatrix} 0 & I \\ K & E \end{bmatrix},\end{split}\]which satisfies
\[\begin{split}\mathcal{A}^H &= \begin{bmatrix} 0 & K^H \\ I & E^H \end{bmatrix}, \\ \mathcal{A}^{1} &= \begin{bmatrix} K^{1} E & K^{1} \\ I & 0 \end{bmatrix}, \\ \mathcal{A}^{H} &= \begin{bmatrix} E^H K^{H} & I \\ K^{H} & 0 \end{bmatrix}.\end{split}\]Methods
apply
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,assemble
apply2
,as_vector
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
adjoint_type
,blocked_range
,blocked_source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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 matrixbased operator will assemble its matrix, a
LincombOperator
will try to form the linear combination of its operators, whereas an arbitrary operator might simply return aFixedParameterOperator
. The only assured property of the assembled operator is that it no longer depends on aParameter
.Parameters
 mu
The
parameter values
for which to assemble the operator.
Returns
Parameterindependent, assembled
Operator
.


class
pymor.operators.block.
ShiftedSecondOrderModelOperator
(M, E, K, a, b)[source]¶ Bases:
pymor.operators.block.BlockOperator
BlockOperator appearing in secondorder systems.
This represents a block operator
\[\begin{split}a \mathcal{E} + b \mathcal{A} = \begin{bmatrix} a I & b I \\ b K & a M  b E \end{bmatrix},\end{split}\]which satisfies
\[\begin{split}(a \mathcal{E} + b \mathcal{A})^H &= \begin{bmatrix} \overline{a} I & \overline{b} K^H \\ \overline{b} I & \overline{a} M^H  \overline{b} E^H \end{bmatrix}, \\ (a \mathcal{E} + b \mathcal{A})^{1} &= \begin{bmatrix} (a^2 M  a b E + b^2 K)^{1} (a M  b E) & b (a^2 M  a b E + b^2 K)^{1} \\ b (a^2 M  a b E + b^2 K)^{1} K & a (a^2 M  a b E + b^2 K)^{1} \end{bmatrix}, \\ (a \mathcal{E} + b \mathcal{A})^{H} &= \begin{bmatrix} (a M  b E)^H (a^2 M  a b E + b^2 K)^{H} & \overline{b} K^H (a^2 M  a b E + b^2 K)^{H} \\ \overline{b} (a^2 M  a b E + b^2 K)^{H} & \overline{a} (a^2 M  a b E + b^2 K)^{H} \end{bmatrix}.\end{split}\]Methods
apply
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,assemble
apply2
,as_vector
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
adjoint_type
,blocked_range
,blocked_source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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 matrixbased operator will assemble its matrix, a
LincombOperator
will try to form the linear combination of its operators, whereas an arbitrary operator might simply return aFixedParameterOperator
. The only assured property of the assembled operator is that it no longer depends on aParameter
.Parameters
 mu
The
parameter values
for which to assemble the operator.
Returns
Parameterindependent, assembled
Operator
.

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

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 adjointop^*
ofop
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 ofop
. If two products are given byP_s
andP_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 productOperator
for the sourceVectorSpace
w.r.t. which to take the adjoint. range_product
If not
None
, inner productOperator
for the rangeVectorSpace
w.r.t. which to take the adjoint. name
If not
None
, name of the operator. with_apply_inverse
If
True
, provide ownapply_inverse
andapply_inverse_adjoint
implementations by calling these methods on the givenoperator
. (Is set toFalse
in the default implementation of andapply_inverse_adjoint
.) solver_options
When
with_apply_inverse
isFalse
, thesolver_options
to use for theapply_inverse
default implementation.
Methods
apply2
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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:
pymor.operators.constructions.ProxyOperator
Decompose an affine
Operator
into affine_shift and linear_part.Methods
apply
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,restricted
apply2
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,pairwise_apply2
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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 aVectorArray
onto some of its components.Parameters
 components
List or 1D
NumPy array
of the indices of the vectorcomponents
that are to be extracted by the operator. source
Source
VectorSpace
of the operator. name
Name of the operator.
Methods
apply2
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,jacobian
,pairwise_apply2
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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 arraysource_dofs
such that for anyVectorArray
U
inself.source
the following is true:self.apply(U, mu).dofs(dofs) == restricted_op.apply(NumpyVectorArray(U.dofs(source_dofs)), mu))
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 fewsource_dofs
will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.Parameters
 dofs
Onedimensional
NumPy array
of degrees of freedom in the operatorrange
to which to restrict.
Returns
 restricted_op
The restricted operator as defined above. The operator will have
NumpyVectorSpace
(len(source_dofs))
assource
andNumpyVectorSpace
(len(dofs))
asrange
. source_dofs
Onedimensional
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 twoOperators
.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
apply2
,apply_inverse
,apply_inverse_adjoint
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,pairwise_apply2
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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.

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 arraysource_dofs
such that for anyVectorArray
U
inself.source
the following is true:self.apply(U, mu).dofs(dofs) == restricted_op.apply(NumpyVectorArray(U.dofs(source_dofs)), mu))
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 fewsource_dofs
will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.Parameters
 dofs
Onedimensional
NumPy array
of degrees of freedom in the operatorrange
to which to restrict.
Returns
 restricted_op
The restricted operator as defined above. The operator will have
NumpyVectorSpace
(len(source_dofs))
assource
andNumpyVectorSpace
(len(dofs))
asrange
. source_dofs
Onedimensional
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
apply2
,apply_adjoint
,apply_inverse_adjoint
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,pairwise_apply2
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 arraysource_dofs
such that for anyVectorArray
U
inself.source
the following is true:self.apply(U, mu).dofs(dofs) == restricted_op.apply(NumpyVectorArray(U.dofs(source_dofs)), mu))
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 fewsource_dofs
will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.Parameters
 dofs
Onedimensional
NumPy array
of degrees of freedom in the operatorrange
to which to restrict.
Returns
 restricted_op
The restricted operator as defined above. The operator will have
NumpyVectorSpace
(len(source_dofs))
assource
andNumpyVectorSpace
(len(dofs))
asrange
. source_dofs
Onedimensional
NumPy array
of source degrees of freedom as defined above.

class
pymor.operators.constructions.
FixedParameterOperator
(operator, mu=None, name=None)[source]¶ Bases:
pymor.operators.constructions.ProxyOperator
Makes an
Operator
Parameter
independent by setting fixedparameter values
.Parameters
 operator
The
Operator
to wrap. mu
The fixed
parameter values
that will be fed to theapply
method (and related methods) ofoperator
.
Methods
apply
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,jacobian
apply2
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,pairwise_apply2
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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_adjoint
,apply_inverse
,apply_inverse_adjoint
,assemble
,restricted
apply2
,as_range_array
,as_source_array
,as_vector
,d_mu
,jacobian
,pairwise_apply2
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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 matrixbased operator will assemble its matrix, a
LincombOperator
will try to form the linear combination of its operators, whereas an arbitrary operator might simply return aFixedParameterOperator
. The only assured property of the assembled operator is that it no longer depends on aParameter
.Parameters
 mu
The
parameter values
for which to assemble the operator.
Returns
Parameterindependent, 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 arraysource_dofs
such that for anyVectorArray
U
inself.source
the following is true:self.apply(U, mu).dofs(dofs) == restricted_op.apply(NumpyVectorArray(U.dofs(source_dofs)), mu))
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 fewsource_dofs
will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.Parameters
 dofs
Onedimensional
NumPy array
of degrees of freedom in the operatorrange
to which to restrict.
Returns
 restricted_op
The restricted operator as defined above. The operator will have
NumpyVectorSpace
(len(source_dofs))
assource
andNumpyVectorSpace
(len(dofs))
asrange
. source_dofs
Onedimensional
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.Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
apply2
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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
apply2
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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 (possiblyParameter
dependent) linear combination of a given list ofOperators
.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
,apply2
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,as_range_array
,as_source_array
,assemble
,d_mu
,evaluate_coefficients
,jacobian
,pairwise_apply2
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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 2form 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, thenapply2
is given as:op.apply2(V, U) = V^T*M*U.
In the case of complex numbers, note that
apply2
is antilinear in the first variable by definition ofinner
.Parameters
 V
VectorArray
of the left arguments V. U
VectorArray
of the right 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 2form evaluations.

apply_adjoint
(V, mu=None)[source]¶ Apply the adjoint operator.
For any given linear
Operator
op
,parameter values
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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
assource
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’srange
, such thatV.lincomb(U.to_numpy()) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
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
asrange
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’ssource
, such thatself.range.make_array(V.inner(U).T) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
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 matrixbased operator will assemble its matrix, a
LincombOperator
will try to form the linear combination of its operators, whereas an arbitrary operator might simply return aFixedParameterOperator
. The only assured property of the assembled operator is that it no longer depends on aParameter
.Parameters
 mu
The
parameter values
for which to assemble the operator.
Returns
Parameterindependent, 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 2form 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, thenapply2
is given as:op.apply2(V, U)[i] = V[i]^T*M*U[i].
In the case of complex numbers, note that
pairwirse_apply2
is antilinear in the first variable by definition ofpairwise_inner
.Parameters
 V
VectorArray
of the left arguments V. U
VectorArray
of the right 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 2form evaluations.

class
pymor.operators.constructions.
LinearOperator
(operator, name=None)[source]¶ Bases:
pymor.operators.constructions.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
Nonparametric lowrank 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 2DNumPy 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
apply2
,apply_inverse
,apply_inverse_adjoint
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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:
pymor.operators.constructions.LincombOperator
Operator
plusLowRankOperator
.Represents a linear combination of an
Operator
andLowRankOperator
. Uses the ShermanMorrisonWoodbury formula inapply_inverse
andapply_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
 lr_operator
 coeff
A linear coefficient for
operator
. Can either be a fixed number or aParameterFunctional
. lr_coeff
A linear coefficient for
lr_operator
. Can either be a fixed number or aParameterFunctional
. solver_options
The
solver_options
for the operator. name
Name of the operator.
Methods
apply
,apply2
,apply_adjoint
,as_range_array
,as_source_array
,assemble
,d_mu
,evaluate_coefficients
,jacobian
,pairwise_apply2
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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)[source]¶ Bases:
pymor.operators.interface.Operator
Generic
Operator
representing the projection of anOperator
to a subspace.This operator is implemented as the concatenation of the linear combination with
source_basis
, application of the originaloperator
and projection ontorange_basis
. As such, this operator can be used to obtain a reduced basis projection of any givenOperator
. 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
 source_basis
 product
 solver_options
The
solver_options
for the projected operator.
Methods
apply2
,apply_inverse
,apply_inverse_adjoint
,as_range_array
,as_source_array
,as_vector
,d_mu
,pairwise_apply2
,restricted
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 matrixbased operator will assemble its matrix, a
LincombOperator
will try to form the linear combination of its operators, whereas an arbitrary operator might simply return aFixedParameterOperator
. The only assured property of the assembled operator is that it no longer depends on aParameter
.Parameters
 mu
The
parameter values
for which to assemble the operator.
Returns
Parameterindependent, 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_adjoint
,apply_inverse
,apply_inverse_adjoint
,jacobian
,restricted
apply2
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,pairwise_apply2
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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 arraysource_dofs
such that for anyVectorArray
U
inself.source
the following is true:self.apply(U, mu).dofs(dofs) == restricted_op.apply(NumpyVectorArray(U.dofs(source_dofs)), mu))
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 fewsource_dofs
will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.Parameters
 dofs
Onedimensional
NumPy array
of degrees of freedom in the operatorrange
to which to restrict.
Returns
 restricted_op
The restricted operator as defined above. The operator will have
NumpyVectorSpace
(len(source_dofs))
assource
andNumpyVectorSpace
(len(dofs))
asrange
. source_dofs
Onedimensional
NumPy array
of source degrees of freedom as defined above.

class
pymor.operators.constructions.
SelectionOperator
(operators, parameter_functional, boundaries, name=None)[source]¶ Bases:
pymor.operators.interface.Operator
An
Operator
selected from a list ofOperators
.operators[i]
is used ifparameter_functional(mu)
is less or equal thanboundaries[i]
and greater thanboundaries[i1]
:infty  boundaries[i]  boundaries[i+1]  infty    operators[i]  operators[i+1]  operators[i+2]  
Parameters
 operators
List of
Operators
from which oneOperator
is selected based on the givenparameter values
. parameter_functional
The
ParameterFunctional
used for the selection of oneOperator
. boundaries
The interval boundaries as defined above.
 name
Name of the operator.
Methods
apply
,apply_adjoint
,as_range_array
,as_source_array
,assemble
apply2
,apply_inverse
,apply_inverse_adjoint
,as_vector
,d_mu
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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
assource
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’srange
, such thatV.lincomb(U.to_numpy()) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
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
asrange
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’ssource
, such thatself.range.make_array(V.inner(U).T) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
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 matrixbased operator will assemble its matrix, a
LincombOperator
will try to form the linear combination of its operators, whereas an arbitrary operator might simply return aFixedParameterOperator
. The only assured property of the assembled operator is that it no longer depends on aParameter
.Parameters
 mu
The
parameter values
for which to assemble the operator.
Returns
Parameterindependent, assembled
Operator
.

class
pymor.operators.constructions.
VectorArrayOperator
(array, adjoint=False, space_id=None, name=None)[source]¶ Bases:
pymor.operators.interface.Operator
Wraps a
VectorArray
as anOperator
.If
adjoint
isFalse
, the operator maps fromNumpyVectorSpace(len(array))
toarray.space
by forming linear combinations of the vectors in the array with given coefficient arrays.If
adjoint == True
, the operator maps fromarray.space
toNumpyVectorSpace(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.
 space_id
Id of the
source
(range
)VectorSpace
in caseadjoint
isFalse
(True
). name
The name of the operator.
Methods
apply
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,as_range_array
,as_source_array
,restricted
apply2
,as_vector
,assemble
,d_mu
,jacobian
,pairwise_apply2
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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
assource
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’srange
, such thatV.lincomb(U.to_numpy()) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
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
asrange
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’ssource
, such thatself.range.make_array(V.inner(U).T) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
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 arraysource_dofs
such that for anyVectorArray
U
inself.source
the following is true:self.apply(U, mu).dofs(dofs) == restricted_op.apply(NumpyVectorArray(U.dofs(source_dofs)), mu))
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 fewsource_dofs
will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.Parameters
 dofs
Onedimensional
NumPy array
of degrees of freedom in the operatorrange
to which to restrict.
Returns
 restricted_op
The restricted operator as defined above. The operator will have
NumpyVectorSpace
(len(source_dofs))
assource
andNumpyVectorSpace
(len(dofs))
asrange
. source_dofs
Onedimensional
NumPy array
of source degrees of freedom as defined above.

class
pymor.operators.constructions.
VectorFunctional
(vector, product=None, name=None)[source]¶ Bases:
pymor.operators.constructions.VectorArrayOperator
Wrap a vector as a linear
Functional
.Given a vector
v
of dimensiond
, this class represents the functionalf: R^d > R^1 u > (u, v)
where
( , )
denotes the inner product given byproduct
.In particular, if
product
isNone
VectorFunctional(vector).as_source_array() == vector.
If
product
is not none, we obtainVectorFunctional(vector).as_source_array() == product.apply(vector).
Parameters
 vector
VectorArray
of length 1 containing the vectorv
. product
Operator
representing the scalar product to use. name
Name of the operator.

class
pymor.operators.constructions.
VectorOperator
(vector, name=None)[source]¶ Bases:
pymor.operators.constructions.VectorArrayOperator
Wrap a vector as a vectorlike
Operator
.Given a vector
v
of dimensiond
, this class represents the operatorop: R^1 > R^d x > x⋅v
In particular:
VectorOperator(vector).as_range_array() == vector
Parameters
 vector
VectorArray
of length 1 containing the vectorv
. name
Name of the operator.

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_adjoint
,apply_inverse
,apply_inverse_adjoint
,restricted
apply2
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,jacobian
,pairwise_apply2
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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 arraysource_dofs
such that for anyVectorArray
U
inself.source
the following is true:self.apply(U, mu).dofs(dofs) == restricted_op.apply(NumpyVectorArray(U.dofs(source_dofs)), mu))
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 fewsource_dofs
will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.Parameters
 dofs
Onedimensional
NumPy array
of degrees of freedom in the operatorrange
to which to restrict.
Returns
 restricted_op
The restricted operator as defined above. The operator will have
NumpyVectorSpace
(len(source_dofs))
assource
andNumpyVectorSpace
(len(dofs))
asrange
. source_dofs
Onedimensional
NumPy array
of source degrees of freedom as defined above.

pymor.operators.constructions.
induced_norm
(product, raise_negative=True, tol=1e10, name=None)[source]¶ Obtain induced norm of an inner product.
The norm of the vectors in a
VectorArray
U is calculated by callingproduct.pairwise_apply2(U, U, mu=mu).
In addition, negative norm squares of absolute value smaller than
tol
are clipped to0
. Ifraise_negative
isTrue
, aValueError
exception is raised if there are negative norm squares of absolute value larger thantol
.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 aVectorArray
U
as input together with theparameter values
mu
which are passed to the product.
Defaults
raise_negative, tol (see
pymor.core.defaults
)
ei module¶

class
pymor.operators.ei.
EmpiricalInterpolatedOperator
(operator, interpolation_dofs, collateral_basis, triangular, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.interface.Operator
Interpolate an
Operator
using Empirical Operator Interpolation.Let
L
be anOperator
,0 <= c_1, ..., c_M < L.range.dim
indices of interpolation DOFs and letb_1, ..., b_M in R^(L.range.dim)
be collateral basis vectors. If moreoverψ_j(U)
denotes the jth component ofU
, the empirical interpolationL_EI
ofL
w.r.t. the given data is given by M  L_EI(U, μ) = ∑ b_i⋅λ_i such that  i=1   ψ_(c_i)(L_EI(U, μ)) = ψ_(c_i)(L(U, μ)) for i=0,...,M
Since the original operator only has to be evaluated at the given interpolation DOFs,
EmpiricalInterpolatedOperator
callsrestricted
to obtain a restricted version of the operator which is used to quickly obtain the required evaluations. If therestricted
method, is not implemented, the full operator will be evaluated (which will lead to the same result, but without any speedup).The interpolation DOFs and the collateral basis can be generated using the algorithms provided in the
pymor.algorithms.ei
module.Parameters
 operator
The
Operator
to interpolate. interpolation_dofs
List or 1D
NumPy array
of the interpolation DOFsc_1, ..., c_M
. collateral_basis
VectorArray
containing the collateral basisb_1, ..., b_M
. triangular
If
True
, assume that ψ_(c_i)(b_j) = 0 for i < j, which means that the interpolation matrix is triangular. solver_options
The
solver_options
for the operator. name
Name of the operator.
Methods
apply2
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,pairwise_apply2
,restricted
,__matmul__
Attributes
operator
H
,linear
,range
,solver_options
,source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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.

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.ei.
ProjectedEmpiciralInterpolatedOperator
(restricted_operator, interpolation_matrix, source_basis_dofs, projected_collateral_basis, triangular, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.interface.Operator
A projected
EmpiricalInterpolatedOperator
.Methods
apply2
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,pairwise_apply2
,restricted
,__matmul__
Attributes
H
,linear
,range
,solver_options
,source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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.

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.

interface module¶

class
pymor.operators.interface.
Operator
[source]¶ Bases:
pymor.parameters.base.ParametricObject
Interface for
Parameter
dependent discrete operators.An operator in pyMOR is simply a mapping which for any given
parameter values
maps vectors from itssource
VectorSpace
to vectors in itsrange
VectorSpace
.Note that there is no special distinction between functionals and operators in pyMOR. A functional is simply an operator with
NumpyVectorSpace
(1)
as itsrange
VectorSpace
.Methods
apply
,apply2
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
H
,linear
,range
,solver_options
,source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

solver_options
¶ If not
None
, a dict which can contain the following keys: ‘inverse’
solver options used for
apply_inverse
 ‘inverse_adjoint’
solver options used for
apply_inverse_adjoint
 ‘jacobian’
solver options for the operators returned by
jacobian
(has no effect for linear operators)
If
solver_options
isNone
or a dict entry is missing orNone
, default options are used. The interpretation of the given solver options is up to the operator at hand. In general, values insolver_options
should either be strings (indicating a solver type) or dicts of options, usually with an entry'type'
which specifies the solver type to use and further items which configure this solver.

linear
¶ True
if the operator is linear.

source
¶ The source
VectorSpace
.

range
¶ The range
VectorSpace
.

H
¶ The adjoint operator, i.e.
self.H.apply(V, mu) == self.apply_adjoint(V, mu)
for all V, mu.

_assemble_lincomb
(operators, coefficients, identity_shift=0.0, solver_options=None, name=None)[source]¶ Try to assemble a linear combination of the given operators.
Returns a new
Operator
which represents the sumc_1*O_1 + ... + c_N*O_N + s*I
where
O_i
areOperators
,c_i
,s
scalar coefficients andI
the identity.This method is called in the
assemble
method ofLincombOperator
on the first of its operators. If an assembly of the given linear combination is possible, e.g. the linear combination of the system matrices of the operators can be formed, then the assembled operator is returned. Otherwise, the method returnsNone
to indicate that assembly is not possible.Parameters
 operators
List of
Operators
O_i
whose linear combination is formed. coefficients
List of the corresponding linear coefficients
c_i
. identity_shift
The coefficient
s
. solver_options
solver_options
for the assembled operator. name
Name of the assembled operator.
Returns
The assembled
Operator
if assembly is possible, otherwiseNone
.

abstract
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 2form 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, thenapply2
is given as:op.apply2(V, U) = V^T*M*U.
In the case of complex numbers, note that
apply2
is antilinear in the first variable by definition ofinner
.Parameters
 V
VectorArray
of the left arguments V. U
VectorArray
of the right 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 2form evaluations.

apply_adjoint
(V, mu=None)[source]¶ Apply the adjoint operator.
For any given linear
Operator
op
,parameter values
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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
assource
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’srange
, such thatV.lincomb(U.to_numpy()) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
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
asrange
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’ssource
, such thatself.range.make_array(V.inner(U).T) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
representation.
Returns
 V
The
VectorArray
defined above.

as_vector
(mu=None)[source]¶ Return a vector representation of a linear functional or vector operator.
Depending on the operator’s
source
andrange
, this method is equivalent to callingas_range_array
oras_source_array
respectively. The resultingVectorArray
is required to have length 1.Parameters
 mu
The
parameter values
for which to return the vector representation.
Returns
 V
VectorArray
of length 1 containing the vector representation.

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 matrixbased operator will assemble its matrix, a
LincombOperator
will try to form the linear combination of its operators, whereas an arbitrary operator might simply return aFixedParameterOperator
. The only assured property of the assembled operator is that it no longer depends on aParameter
.Parameters
 mu
The
parameter values
for which to assemble the operator.
Returns
Parameterindependent, 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.

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 2form 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, thenapply2
is given as:op.apply2(V, U)[i] = V[i]^T*M*U[i].
In the case of complex numbers, note that
pairwirse_apply2
is antilinear in the first variable by definition ofpairwise_inner
.Parameters
 V
VectorArray
of the left arguments V. U
VectorArray
of the right 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 2form 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 arraysource_dofs
such that for anyVectorArray
U
inself.source
the following is true:self.apply(U, mu).dofs(dofs) == restricted_op.apply(NumpyVectorArray(U.dofs(source_dofs)), mu))
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 fewsource_dofs
will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.Parameters
 dofs
Onedimensional
NumPy array
of degrees of freedom in the operatorrange
to which to restrict.
Returns
 restricted_op
The restricted operator as defined above. The operator will have
NumpyVectorSpace
(len(source_dofs))
assource
andNumpyVectorSpace
(len(dofs))
asrange
. source_dofs
Onedimensional
NumPy array
of source degrees of freedom as defined above.

list module¶

class
pymor.operators.list.
LinearComplexifiedListVectorArrayOperatorBase
[source]¶ Bases:
pymor.operators.list.ListVectorArrayOperatorBase
Methods
apply2
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,jacobian
,pairwise_apply2
,restricted
,__matmul__

class
pymor.operators.list.
ListVectorArrayOperatorBase
[source]¶ Bases:
pymor.operators.interface.Operator
Methods
apply2
,as_range_array
,as_source_array
,as_vector
,assemble
,d_mu
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
H
,linear
,range
,solver_options
,source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

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
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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.list.
NumpyListVectorArrayMatrixOperator
(matrix, source_id=None, range_id=None, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.list.ListVectorArrayOperatorBase
,pymor.operators.numpy.NumpyMatrixOperator
Variant of
NumpyMatrixOperator
usingListVectorArray
instead ofNumpyVectorArray
.This class is mainly intended for performance tests of
ListVectorArray
. In generalNumpyMatrixOperator
should be used instead of this class.Parameters
 matrix
The
NumPy array
which is to be wrapped. source_id
The id of the operator’s
source
VectorSpace
. range_id
The id of the operator’s
range
VectorSpace
. solver_options
The
solver_options
for the operator. name
Name of the operator.
Methods
as_range_array
,as_source_array
,assemble
,from_file
apply2
,as_vector
,d_mu
,jacobian
,pairwise_apply2
,restricted
,__matmul__
Attributes
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

_assemble_lincomb
(operators, coefficients, identity_shift=0.0, solver_options=None, name=None)[source]¶ Try to assemble a linear combination of the given operators.
Returns a new
Operator
which represents the sumc_1*O_1 + ... + c_N*O_N + s*I
where
O_i
areOperators
,c_i
,s
scalar coefficients andI
the identity.This method is called in the
assemble
method ofLincombOperator
on the first of its operators. If an assembly of the given linear combination is possible, e.g. the linear combination of the system matrices of the operators can be formed, then the assembled operator is returned. Otherwise, the method returnsNone
to indicate that assembly is not possible.Parameters
 operators
List of
Operators
O_i
whose linear combination is formed. coefficients
List of the corresponding linear coefficients
c_i
. identity_shift
The coefficient
s
. solver_options
solver_options
for the assembled operator. name
Name of the assembled operator.
Returns
The assembled
Operator
if assembly is possible, otherwiseNone
.

apply_adjoint
(V, mu=None)[source]¶ Apply the adjoint operator.
For any given linear
Operator
op
,parameter values
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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_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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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.
mpi module¶

class
pymor.operators.mpi.
MPIOperator
(obj_id, mpi_range, mpi_source, with_apply2=False, pickle_local_spaces=True, space_type=<class 'pymor.vectorarrays.mpi.MPIVectorSpace'>)[source]¶ Bases:
pymor.operators.interface.Operator
MPI distributed
Operator
.Given a singlerank implementation of an
Operator
, this wrapper class uses the event loop frompymor.tools.mpi
to allow an MPI distributed usage of theOperator
.Instances of
MPIOperator
can be used on rank 0 like any other (nondistributed)Operator
.Note, however, that the underlying
Operator
implementation needs to be MPI aware. For instance, the operator’sapply
method has to perform the necessary MPI communication to obtain all DOFs hosted on other MPI ranks which are required for the local operator evaluation.Instead of instantiating
MPIOperator
directly, it is usually preferable to usempi_wrap_operator
instead.Parameters
 obj_id
 mpi_range
Set to
True
if the range of theOperator
is MPI distributed. mpi_source
Set to
True
if the source of theOperator
is MPI distributed. with_apply2
Set to
True
if the operator implementation has its own MPI aware implementation ofapply2
andpairwise_apply2
. Otherwise, the default implementations usingapply
andinner
will be used. pickle_local_spaces
If
pickle_local_spaces
isFalse
, a unique identifier is computed for each local source/rangeVectorSpace
, which is then transferred to rank 0 instead of the trueVectorSpace
. This allows the useage ofMPIVectorArray
even when the localVectorSpaces
are not picklable. space_type
This class will be used to wrap the local
VectorArrays
returned by the local operators into an MPI distributedVectorArray
managed from rank 0. By default,MPIVectorSpace
will be used, other options areMPIVectorSpaceAutoComm
andMPIVectorSpaceNoComm
.
Methods
apply
,apply2
,apply_adjoint
,apply_inverse
,apply_inverse_adjoint
,as_range_array
,as_source_array
,assemble
,jacobian
,pairwise_apply2
,restricted
Attributes
H
,linear
,range
,solver_options
,source
parameters
,parameters_inherited
,parameters_internal
,parameters_own
,parametric

_assemble_lincomb
(operators, coefficients, identity_shift=0.0, solver_options=None, name=None)[source]¶ Try to assemble a linear combination of the given operators.
Returns a new
Operator
which represents the sumc_1*O_1 + ... + c_N*O_N + s*I
where
O_i
areOperators
,c_i
,s
scalar coefficients andI
the identity.This method is called in the
assemble
method ofLincombOperator
on the first of its operators. If an assembly of the given linear combination is possible, e.g. the linear combination of the system matrices of the operators can be formed, then the assembled operator is returned. Otherwise, the method returnsNone
to indicate that assembly is not possible.Parameters
 operators
List of
Operators
O_i
whose linear combination is formed. coefficients
List of the corresponding linear coefficients
c_i
. identity_shift
The coefficient
s
. solver_options
solver_options
for the assembled operator. name
Name of the assembled operator.
Returns
The assembled
Operator
if assembly is possible, otherwiseNone
.

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 2form 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, thenapply2
is given as:op.apply2(V, U) = V^T*M*U.
In the case of complex numbers, note that
apply2
is antilinear in the first variable by definition ofinner
.Parameters
 V
VectorArray
of the left arguments V. U
VectorArray
of the right 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 2form evaluations.

apply_adjoint
(V, mu=None)[source]¶ Apply the adjoint operator.
For any given linear
Operator
op
,parameter values
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.inner(op.apply(U, mu))
Thus, when
op
is represented by a matrixM
,apply_adjoint
is given by leftmultplication of (the complex conjugate of)M
withV
.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 asV
containing initial guesses for the solution. Some implementations ofapply_inverse
may ignore this parameter. IfNone
a solverdependent 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 asU
containing initial guesses for the solution. Some implementations ofapply_inverse_adjoint
may ignore this parameter. IfNone
a solverdependent 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
assource
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’srange
, such thatV.lincomb(U.to_numpy()) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
The
parameter values
for which to return theVectorArray
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
asrange
, this method returns for givenparameter values
mu
aVectorArray
V
in the operator’s