pymor.operators package¶
Submodules¶
basic module¶

class
pymor.operators.basic.
LinearComplexifiedListVectorArrayOperatorBase
[source]¶ Bases:
pymor.operators.basic.ListVectorArrayOperatorBase
Methods

class
pymor.operators.basic.
ListVectorArrayOperatorBase
[source]¶ Bases:
pymor.operators.basic.OperatorBase
Methods
Attributes
OperatorInterface
H
,linear
,range
,solver_options
,source
ImmutableInterface
sid
,sid_ignore
BasicInterface
logger
,logging_disabled
,name
,uid
Parametric
parameter_space
,parameter_type
,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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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.basic.
OperatorBase
[source]¶ Bases:
pymor.operators.interfaces.OperatorInterface
Base class for
Operators
providing some default implementations.When implementing a new operator, it is usually advisable to derive from this class.
Methods
Attributes
OperatorInterface
H
,linear
,range
,solver_options
,source
ImmutableInterface
sid
,sid_ignore
BasicInterface
logger
,logging_disabled
,name
,uid
Parametric
parameter_space
,parameter_type
,parametric

__radd__
(other)¶ Sum of two operators.

apply2
(V, U, mu=None)[source]¶ Treat the operator as a 2form by computing
V.dot(self.apply(U))
.If the operator is a linear operator given by multiplication with a matrix M, then
apply2
is given as:op.apply2(V, U) = V^T*M*U.
In the case of complex numbers, note that
apply2
is antilinear in the first variable by definition ofdot
.Parameters
 V
VectorArray
of the left arguments V. U
VectorArray
of the right right arguments U. mu
 The
Parameter
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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 everyParameter
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
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 everyParameter
mu
aVectorArray
V
in the operator’ssource
, such thatself.range.make_array(V.dot(U).T) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
 The
Parameter
for which to return theVectorArray
representation.
Returns
 V
 The
VectorArray
defined above.

assemble
(mu=None)[source]¶ Assemble the operator for a given parameter.
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
for which to assemble the operator.
Returns
Parameterindependent, assembled
Operator
.

d_mu
(component, index=())[source]¶ Return the operator’s derivative with respect to an index of a parameter component.
Parameters
 component
 Parameter component
 index
 index in the parameter component
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
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 by computing
V.dot(self.apply(U))
.Same as
OperatorInterface.apply2
, except that vectors fromV
andU
are applied in pairs.Parameters
 V
VectorArray
of the left arguments V. U
VectorArray
of the right right arguments U. mu
 The
Parameter
for which to evaluate the operator.
Returns
A
NumPy array
with shape(len(V),) == (len(U),)
containing the 2form evaluations.


class
pymor.operators.basic.
ProjectedOperator
(operator, range_basis, source_basis, product=None, solver_options=None)[source]¶ Bases:
pymor.operators.basic.OperatorBase
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
 See
pymor.algorithms.projection.project
.  source_basis
 See
pymor.algorithms.projection.project
.  product
 See
pymor.algorithms.projection.project
.  solver_options
 The
solver_options
for the projected operator.
Methods
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

assemble
(mu=None)[source]¶ Assemble the operator for a given parameter.
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
for which to assemble the operator.
Returns
Parameterindependent, assembled
Operator
.
block module¶

class
pymor.operators.block.
BlockColumnOperator
(blocks)[source]¶ Bases:
pymor.operators.block.BlockOperatorBase
A column vector of arbitrary
Operators
.Methods
Attributes
BlockColumnOperator
adjoint_type
,blocked_range
,blocked_source
BlockOperatorBase
H
OperatorInterface
linear
,range
,solver_options
,source
ImmutableInterface
sid
,sid_ignore
BasicInterface
logger
,logging_disabled
,name
,uid
Parametric
parameter_space
,parameter_type
,parametric

adjoint_type
¶ alias of
BlockRowOperator


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
Attributes
BlockOperator
adjoint_type
,blocked_range
,blocked_source
BlockOperatorBase
H
OperatorInterface
linear
,range
,solver_options
,source
ImmutableInterface
sid
,sid_ignore
BasicInterface
logger
,logging_disabled
,name
,uid
Parametric
parameter_space
,parameter_type
,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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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 a given parameter.
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
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
Attributes
BlockColumnOperator
adjoint_type
,blocked_range
,blocked_source
BlockOperatorBase
H
OperatorInterface
linear
,range
,solver_options
,source
ImmutableInterface
sid
,sid_ignore
BasicInterface
logger
,logging_disabled
,name
,uid
Parametric
parameter_space
,parameter_type
,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
Attributes
BlockOperator
adjoint_type
,blocked_range
,blocked_source
BlockOperatorBase
H
OperatorInterface
linear
,range
,solver_options
,source
ImmutableInterface
sid
,sid_ignore
BasicInterface
logger
,logging_disabled
,name
,uid
Parametric
parameter_space
,parameter_type
,parametric

adjoint_type
¶ alias of
BlockOperator

class
pymor.operators.block.
BlockOperatorBase
(blocks)[source]¶ Bases:
pymor.operators.basic.OperatorBase
Methods
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
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 everyParameter
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
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 everyParameter
mu
aVectorArray
V
in the operator’ssource
, such thatself.range.make_array(V.dot(U).T) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
 The
Parameter
for which to return theVectorArray
representation.
Returns
 V
 The
VectorArray
defined above.

assemble
(mu=None)[source]¶ Assemble the operator for a given parameter.
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
for which to assemble the operator.
Returns
Parameterindependent, assembled
Operator
.


class
pymor.operators.block.
BlockProjectionOperator
(block_space, component)[source]¶ Bases:
pymor.operators.block.BlockRowOperator
Methods
Attributes
BlockRowOperator
adjoint_type
,blocked_range
,blocked_source
BlockOperatorBase
H
OperatorInterface
linear
,range
,solver_options
,source
ImmutableInterface
sid
,sid_ignore
BasicInterface
logger
,logging_disabled
,name
,uid
Parametric
parameter_space
,parameter_type
,parametric

class
pymor.operators.block.
BlockRowOperator
(blocks)[source]¶ Bases:
pymor.operators.block.BlockOperatorBase
A row vector of arbitrary
Operators
.Methods
Attributes
BlockRowOperator
adjoint_type
,blocked_range
,blocked_source
BlockOperatorBase
H
OperatorInterface
linear
,range
,solver_options
,source
ImmutableInterface
sid
,sid_ignore
BasicInterface
logger
,logging_disabled
,name
,uid
Parametric
parameter_space
,parameter_type
,parametric

adjoint_type
¶ alias of
BlockColumnOperator


class
pymor.operators.block.
SecondOrderModelOperator
(E, K)[source]¶ Bases:
pymor.operators.block.BlockOperator
BlockOperator appearing in SecondOrderModel.to_lti().
This represents a block operator
which satisfies
Methods
Attributes
BlockOperator
adjoint_type
,blocked_range
,blocked_source
BlockOperatorBase
H
OperatorInterface
linear
,range
,solver_options
,source
ImmutableInterface
sid
,sid_ignore
BasicInterface
logger
,logging_disabled
,name
,uid
Parametric
parameter_space
,parameter_type
,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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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 a given parameter.
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
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
which satisfies
Methods
Attributes
BlockOperator
adjoint_type
,blocked_range
,blocked_source
BlockOperatorBase
H
OperatorInterface
linear
,range
,solver_options
,source
ImmutableInterface
sid
,sid_ignore
BasicInterface
logger
,logging_disabled
,name
,uid
Parametric
parameter_space
,parameter_type
,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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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 a given parameter.
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
for which to assemble the operator.
Returns
Parameterindependent, assembled
Operator
.

cg module¶
This module provides some operators for continuous finite element discretizations.

class
pymor.operators.cg.
AdvectionOperatorP1
(grid, boundary_info, advection_function=None, advection_constant=None, dirichlet_clear_columns=False, dirichlet_clear_diag=False, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Linear advection
Operator
for linear finite elements.The operator is of the form
(Lu)(x) = c ∇ ⋅ [ v(x) u(x) ]
The function
v
is vectorvalued.Parameters
 grid
 The
Grid
for which to assemble the operator.  boundary_info
BoundaryInfo
for the treatment of Dirichlet boundary conditions. advection_function
 The
Function
v(x)
withshape_range = (grid.dim, )
. IfNone
, constant one is assumed.  advection_constant
 The constant
c
. IfNone
,c
is set to one.  dirichlet_clear_columns
 If
True
, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero to obtain a symmetric system matrix. Otherwise, only the rows will be set to zero.  dirichlet_clear_diag
 If
True
, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise they are set to one.  solver_options
 The
solver_options
for the operator.  name
 Name of the operator.
Methods

class
pymor.operators.cg.
AdvectionOperatorQ1
(grid, boundary_info, advection_function=None, advection_constant=None, dirichlet_clear_columns=False, dirichlet_clear_diag=False, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Linear advection
Operator
for bilinear finite elements.The operator is of the form
(Lu)(x) = c ∇ ⋅ [ v(x) u(x) ]
The function
v
has to be vectorvalued.Parameters
 grid
 The
Grid
for which to assemble the operator.  boundary_info
BoundaryInfo
for the treatment of Dirichlet boundary conditions. advection_function
 The
Function
v(x)
withshape_range = (grid.dim, )
. IfNone
, constant one is assumed.  advection_constant
 The constant
c
. IfNone
,c
is set to one.  dirichlet_clear_columns
 If
True
, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero to obtain a symmetric system matrix. Otherwise, only the rows will be set to zero.  dirichlet_clear_diag
 If
True
, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise they are set to one.  solver_options
 The
solver_options
for the operator.  name
 Name of the operator.
Methods

class
pymor.operators.cg.
BoundaryDirichletFunctional
(grid, dirichlet_data, boundary_info, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Linear finite element functional for enforcing Dirichlet boundary values.
Parameters
 grid
Grid
for which to assemble the functional. dirichlet_data
Function
providing the Dirichlet boundary values. boundary_info
BoundaryInfo
determining the Dirichlet boundaries. name
 The name of the functional.
Methods

class
pymor.operators.cg.
BoundaryL2ProductFunctional
(grid, function, boundary_type=None, dirichlet_clear_dofs=False, boundary_info=None, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Linear finite element functional representing the inner product with an L2
Function
on the boundary.Parameters
 grid
Grid
for which to assemble the functional. function
 The
Function
with which to take the inner product.  boundary_type
 The type of domain boundary (e.g. ‘neumann’) on which to assemble the functional.
If
None
the functional is assembled over the whole boundary.  dirichlet_clear_dofs
 If
True
, set dirichlet boundary DOFs to zero.  boundary_info
 If
boundary_type
is specified ordirichlet_clear_dofs
isTrue
, theBoundaryInfo
determining which boundary entity belongs to which physical boundary.  name
 The name of the functional.
Methods

class
pymor.operators.cg.
DiffusionOperatorP1
(grid, boundary_info, diffusion_function=None, diffusion_constant=None, dirichlet_clear_columns=False, dirichlet_clear_diag=False, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Diffusion
Operator
for linear finite elements.The operator is of the form
(Lu)(x) = c ∇ ⋅ [ d(x) ∇ u(x) ]
The function
d
can be scalar or matrixvalued.Parameters
 grid
 The
Grid
for which to assemble the operator.  boundary_info
BoundaryInfo
for the treatment of Dirichlet boundary conditions. diffusion_function
 The
Function
d(x)
withshape_range == ()
orshape_range = (grid.dim, grid.dim)
. IfNone
, constant one is assumed.  diffusion_constant
 The constant
c
. IfNone
,c
is set to one.  dirichlet_clear_columns
 If
True
, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero to obtain a symmetric system matrix. Otherwise, only the rows will be set to zero.  dirichlet_clear_diag
 If
True
, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise they are set to one.  solver_options
 The
solver_options
for the operator.  name
 Name of the operator.
Methods

class
pymor.operators.cg.
DiffusionOperatorQ1
(grid, boundary_info, diffusion_function=None, diffusion_constant=None, dirichlet_clear_columns=False, dirichlet_clear_diag=False, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Diffusion
Operator
for bilinear finite elements.The operator is of the form
(Lu)(x) = c ∇ ⋅ [ d(x) ∇ u(x) ]
The function
d
can be scalar or matrixvalued.Parameters
 grid
 The
Grid
for which to assemble the operator.  boundary_info
BoundaryInfo
for the treatment of Dirichlet boundary conditions. diffusion_function
 The
Function
d(x)
withshape_range == ()
orshape_range = (grid.dim, grid.dim)
. IfNone
, constant one is assumed.  diffusion_constant
 The constant
c
. IfNone
,c
is set to one.  dirichlet_clear_columns
 If
True
, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero to obtain a symmetric system matrix. Otherwise, only the rows will be set to zero.  dirichlet_clear_diag
 If
True
, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise they are set to one.  solver_options
 The
solver_options
for the operator.  name
 Name of the operator.
Methods

class
pymor.operators.cg.
InterpolationOperator
(grid, function)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Vectorlike Lagrange interpolation
Operator
for continuous finite element spaces.Methods

class
pymor.operators.cg.
L2ProductFunctionalP1
(grid, function, dirichlet_clear_dofs=False, boundary_info=None, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Linear finite element functional representing the inner product with an L2
Function
.Parameters
 grid
Grid
for which to assemble the functional. function
 The
Function
with which to take the inner product.  dirichlet_clear_dofs
 If
True
, set dirichlet boundary DOFs to zero.  boundary_info
BoundaryInfo
determining the Dirichlet boundaries in casedirichlet_clear_dofs
is set toTrue
. name
 The name of the functional.
Methods

class
pymor.operators.cg.
L2ProductFunctionalQ1
(grid, function, dirichlet_clear_dofs=False, boundary_info=None, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Bilinear finite element functional representing the inner product with an L2
Function
.Parameters
 grid
Grid
for which to assemble the functional. function
 The
Function
with which to take the inner product.  dirichlet_clear_dofs
 If
True
, set dirichlet boundary DOFs to zero.  boundary_info
BoundaryInfo
determining the Dirichlet boundaries in casedirichlet_clear_dofs
is set toTrue
. name
 The name of the functional.
Methods

class
pymor.operators.cg.
L2ProductP1
(grid, boundary_info, dirichlet_clear_rows=True, dirichlet_clear_columns=False, dirichlet_clear_diag=False, coefficient_function=None, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Operator
representing the L2product between linear finite element functions.Parameters
 grid
 The
Grid
for which to assemble the product.  boundary_info
BoundaryInfo
for the treatment of Dirichlet boundary conditions. dirichlet_clear_rows
 If
True
, set the rows of the system matrix corresponding to Dirichlet boundary DOFs to zero.  dirichlet_clear_columns
 If
True
, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero.  dirichlet_clear_diag
 If
True
, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise, if eitherdirichlet_clear_rows
ordirichlet_clear_columns
isTrue
, the diagonal entries are set to one.  coefficient_function
 Coefficient
Function
for product withshape_range == ()
. IfNone
, constant one is assumed.  solver_options
 The
solver_options
for the operator.  name
 The name of the product.
Methods

class
pymor.operators.cg.
L2ProductQ1
(grid, boundary_info, dirichlet_clear_rows=True, dirichlet_clear_columns=False, dirichlet_clear_diag=False, coefficient_function=None, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Operator
representing the L2product between bilinear finite element functions.Parameters
 grid
 The
Grid
for which to assemble the product.  boundary_info
BoundaryInfo
for the treatment of Dirichlet boundary conditions. dirichlet_clear_rows
 If
True
, set the rows of the system matrix corresponding to Dirichlet boundary DOFs to zero.  dirichlet_clear_columns
 If
True
, set columns of the system matrix corresponding to Dirichlet boundary DOFs to zero.  dirichlet_clear_diag
 If
True
, also set diagonal entries corresponding to Dirichlet boundary DOFs to zero. Otherwise, if eitherdirichlet_clear_rows
ordirichlet_clear_columns
isTrue
, the diagonal entries are set to one.  coefficient_function
 Coefficient
Function
for product withshape_range == ()
. IfNone
, constant one is assumed.  solver_options
 The
solver_options
for the operator.  name
 The name of the product.
Methods

class
pymor.operators.cg.
RobinBoundaryOperator
(grid, boundary_info, robin_data=None, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.numpy.NumpyMatrixBasedOperator
Robin boundary
Operator
for linear finite elements.The operator represents the contribution of Robin boundary conditions to the stiffness matrix, where the boundary condition is supposed to be given in the form
[ d(x) ∇u(x) ] ⋅ n(x) = c(x) (u(x)  g(x))
d
andn
are the diffusion function (seeDiffusionOperatorP1
) and the unit outer normal inx
, whilec
is the (scalar) Robin parameter function andg
is the (also scalar) Robin boundary value function.Parameters
 grid
 The
Grid
over which to assemble the operator.  boundary_info
BoundaryInfo
for the treatment of Dirichlet boundary conditions. robin_data
 Tuple providing two
Functions
that represent the Robin parameter and boundary value function. IfNone
, the resulting operator is zero.  solver_options
 The
solver_options
for the operator.  name
 Name of the operator.
Methods
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.basic.OperatorBase
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.OperatorInterface.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
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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

class
pymor.operators.constructions.
ComponentProjection
(components, source, name=None)[source]¶ Bases:
pymor.operators.basic.OperatorBase
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
Attributes

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
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.
Concatenation
(operators, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.basic.OperatorBase
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
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
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
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.basic.OperatorBase
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
Attributes

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
for which to evaluate the operator.
Returns
VectorArray
of the operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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
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 a fixedParameter
.Parameters
Methods
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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.
IdentityOperator
(space, name=None)[source]¶ Bases:
pymor.operators.basic.OperatorBase
The identity
Operator
.In other words:
op.apply(U) == U
Parameters
 space
 The
VectorSpace
the operator acts on.  name
 Name of the operator.
Methods
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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 a given parameter.
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
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.core.interfaces.ImmutableInterface
,pymor.parameters.base.Parametric
Instantiated by
induced_norm
. Do not use directly.Methods

class
pymor.operators.constructions.
InverseAdjointOperator
(operator, name=None)[source]¶ Bases:
pymor.operators.basic.OperatorBase
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
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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.basic.OperatorBase
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
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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.basic.OperatorBase
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
Attributes

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
for which to evaluate the operator.
Returns
VectorArray
of the operator evaluations.

apply2
(V, U, mu=None)[source]¶ Treat the operator as a 2form by computing
V.dot(self.apply(U))
.If the operator is a linear operator given by multiplication with a matrix M, then
apply2
is given as:op.apply2(V, U) = V^T*M*U.
In the case of complex numbers, note that
apply2
is antilinear in the first variable by definition ofdot
.Parameters
 V
VectorArray
of the left arguments V. U
VectorArray
of the right right arguments U. mu
 The
Parameter
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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 everyParameter
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
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 everyParameter
mu
aVectorArray
V
in the operator’ssource
, such thatself.range.make_array(V.dot(U).T) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
 The
Parameter
for which to return theVectorArray
representation.
Returns
 V
 The
VectorArray
defined above.

assemble
(mu=None)[source]¶ Assemble the operator for a given parameter.
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
for which to assemble the operator.
Returns
Parameterindependent, assembled
Operator
.

d_mu
(component, index=())[source]¶ Return the operator’s derivative with respect to an index of a parameter component.
Parameters
 component
 Parameter component
 index
 index in the parameter component
Returns
New
Operator
representing the partial derivative.

evaluate_coefficients
(mu)[source]¶ Compute the linear coefficients for a given
Parameter
.Parameters
 mu
Parameter
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
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 by computing
V.dot(self.apply(U))
.Same as
OperatorInterface.apply2
, except that vectors fromV
andU
are applied in pairs.Parameters
 V
VectorArray
of the left arguments V. U
VectorArray
of the right right arguments U. mu
 The
Parameter
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.Methods

class
pymor.operators.constructions.
LowRankOperator
(left, core, right, inverted=False, solver_options=None, name=None)[source]¶ Bases:
pymor.operators.basic.OperatorBase
Nonparametric lowrank operator.
Represents an operator of the form or where and are
VectorArrays
of column vectors and a 2DNumPy array
.Parameters
 left
VectorArray
representing . core
NumPy array
representing . right
VectorArray
representing . inverted
 Whether is inverted.
 solver_options
 The
solver_options
for the operator.  name
 Name of the operator.
Methods
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
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
:Parameters
 operator
Operator
. lr_operator
LowRankOperator
. 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
Attributes

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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.
ProxyOperator
(operator, name=None)[source]¶ Bases:
pymor.operators.basic.OperatorBase
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
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse
(V, mu=None, least_squares=False)[source]¶ Apply the inverse operator.
Parameters
 V
VectorArray
of vectors to which the inverse operator is applied. mu
 The
Parameter
for which to evaluate the inverse operator.  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, 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
for which to evaluate the inverse adjoint operator.  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
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.basic.OperatorBase
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
.  parameter_functional
 The
ParameterFunctional
used for the selection of oneOperator
.  boundaries
 The interval boundaries as defined above.
 name
 Name of the operator.
Methods
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
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 everyParameter
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
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 everyParameter
mu
aVectorArray
V
in the operator’ssource
, such thatself.range.make_array(V.dot(U).T) == self.apply(U, mu)
for all
VectorArrays
U
.Parameters
 mu
 The
Parameter
for which to return theVectorArray
representation.
Returns
 V
 The
VectorArray
defined above.

assemble
(mu=None)[source]¶ Assemble the operator for a given parameter.
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
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.basic.OperatorBase
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
Attributes

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
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
mu
andVectorArrays
U
,V
in thesource
resp.range
we have:op.apply_adjoint(V, mu).dot(U) == V.dot(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
for which to apply the adjoint operator.
Returns
VectorArray
of the adjoint operator evaluations.

apply_inverse_adjoint
(U, mu=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
for which to evaluate the inverse adjoint operator.  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 everyParameter
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
for which to return theVectorArray
representation.