pymor.operators package

Submodules

basic module


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.

__add__(other)[source]

Sum of two operators.

__mul__(other)[source]

Product of operator by a scalar.

__radd__(other)

Sum of two operators.

__str__() <==> str(x)[source]
apply2(V, U, U_ind=None, V_ind=None, mu=None, product=None)[source]

Treat the operator as a 2-form by calculating (V, op(U)).

In general op.apply2(V, U) is equivalent to:

product.apply2(V, op.apply(U)).

In case no product has been specified, op.apply2(V, U) is equivialent to:

V.dot(op.apply(U)).

In the latter case, assuming that op is a linear operator given by multiplication with a matrix M, then:

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

Parameters

V
VectorArray of the left arguments V.
U
VectorArray of the right right arguments U.
V_ind
The indices of the vectors in V to which the operator shall be applied (see VectorArray documentation for further details).
U_ind
The indices of the vectors in U to which the operator shall be applied (see VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.
product
The inner product used in the expression (V, op(U)) given as an Operator. If None, the euclidean product is chosen.

Returns

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

apply_adjoint(U, ind=None, mu=None, source_product=None, range_product=None)[source]

Apply the adjoint operator.

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

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

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

op^*(v) = P_s^(-1) * M^T * P_r * v,

with M^T denoting the transposed of M. Thus, if ( , )_s and ( , )_r are the Euclidean inner products, op^*v is simply given by multiplication of the matrix of op with v from the left.

Parameters

U
VectorArray of vectors to which the adjoint operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to apply the adjoint operator.
source_product
The inner product Operator on the source space. If None, the Euclidean product is chosen.
range_product
The inner product Operator on the range space. If None, the Euclidean product is chosen.

Returns

VectorArray of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters

V
VectorArray of vectors to which the inverse operator is applied.
ind
The indices of the vectors in V to which the inverse operator shall be applied (see VectorArray documentation for further details).
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, ind=None, mu=None, source_product=None, range_product=None, least_squares=False)[source]

Apply the inverse adjoint operator.

Parameters

U
VectorArray of vectors to which the inverse adjoint operator is applied.
ind
The indices of the vectors in U to which the inverse adjoint operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the inverse adjoint operator.
source_product
See apply_adjoint.
range_product
See apply_adjoint.
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_vector(mu=None)[source]

Return a vector representation of a linear functional or vector operator.

This method may only be called on linear functionals, i.e. linear Operators with NumpyVectorSpace (1) as range, or on operators describing vectors, i.e. linear Operators with NumpyVectorSpace (1) as source.

In the case of a functional, the identity

self.as_vector(mu).dot(U) == self.apply(U, mu)

holds, whereas in the case of a vector-like operator we have

self.as_vector(mu) == self.apply(NumpyVectorArray(1), mu).

Parameters

mu
The Parameter for which to return the vector representation.

Returns

V
VectorArray of length 1 containing the vector representation. V belongs to self.source for functionals and to self.range for vector-like operators.
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 matrix-based operator will assemble its matrix, a LincombOperator will try to form the linear combination of its operators, whereas an arbitrary operator might simply return a FixedParameterOperator. The only assured property of the assembled operator is that it no longer depends on a Parameter.

Parameters

mu
The Parameter for which to assemble the operator.

Returns

Parameter-independent, assembled Operator.

jacobian(U, mu=None)[source]

Return the operator’s Jacobian as a new Operator.

Parameters

U
Length 1 VectorArray containing the vector for which to compute the Jacobian.
mu
The Parameter for which to compute the Jacobian.

Returns

Linear Operator representing the Jacobian.

pairwise_apply2(V, U, U_ind=None, V_ind=None, mu=None, product=None)[source]

Treat the operator as a 2-form by calculating (V, op(U)).

Same as OperatorInterface.apply2, except that vectors from V and U are applied in pairs.

Parameters

V
VectorArray of the left arguments V.
U
VectorArray of the right right arguments U.
V_ind
The indices of the vectors in V to which the operator shall be applied (see VectorArray documentation for further details).
U_ind
The indices of the vectors in U to which the operator shall be applied (see VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.
product
The inner product used in the expression (V, op(U)) given as an Operator. If None, the euclidean product is chosen.

Returns

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

projected(range_basis, source_basis, product=None, name=None)[source]

Project the operator to subspaces of the source and range space.

Given an inner product ( ⋅, ⋅), source vectors b_1, ..., b_N and range vectors c_1, ..., c_M, the projection op_proj of op is defined by

[ op_proj(e_j) ]_i = ( c_i, op(b_j) )

for all i,j, where e_j denotes the j-th canonical basis vector of R^N.

In particular, if the c_i are orthonormal w.r.t. the given product, then op_proj is the coordinate representation w.r.t. the b_i/c_i bases of the restriction of op to span(b_i) concatenated with the orthogonal projection onto span(c_i).

From another point of view, if op is viewed as a bilinear form (see apply2) and ( ⋅, ) is the Euclidean inner product, then op_proj represents the matrix of the bilinear form restricted span(b_i) / spanc(c_i) (w.r.t. the b_i/c_i bases).

How the projected operator is realized will depend on the implementation of the operator to project. While a projected NumpyMatrixOperator will again be a NumpyMatrixOperator, only a generic ProjectedOperator can be returned in general.

A default implementation is provided in OperatorBase.

Parameters

range_basis
The vectors c_1, ..., c_M as a VectorArray. If None, no projection in the range space is performed.
source_basis
The vectors b_1, ..., b_N as a VectorArray or None. If None, no restriction of the source space is performed.
product
An Operator representing the inner product. If None, the Euclidean inner product is chosen.
name
Name of the projected operator.

Returns

The projected Operator op_proj.


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

Bases: pymor.operators.basic.OperatorBase

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

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

This operator is instantiated in the default implementation of projected in OperatorBase for parametric or nonlinear operators.

Parameters

operator
The Operator to project.
source_basis
See projected.
range_basis
See projected.
product
See projected.
name
Name of the projected operator.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the 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 matrix-based operator will assemble its matrix, a LincombOperator will try to form the linear combination of its operators, whereas an arbitrary operator might simply return a FixedParameterOperator. The only assured property of the assembled operator is that it no longer depends on a Parameter.

Parameters

mu
The Parameter for which to assemble the operator.

Returns

Parameter-independent, assembled Operator.

jacobian(U, mu=None)[source]

Return the operator’s Jacobian as a new Operator.

Parameters

U
Length 1 VectorArray containing the vector for which to compute the Jacobian.
mu
The Parameter for which to compute the Jacobian.

Returns

Linear Operator representing the Jacobian.

projected_to_subbasis(dim_range=None, dim_source=None, name=None)[source]

See NumpyMatrixOperator.projected_to_subbasis.

block module


class pymor.operators.block.BlockDiagonalOperator(blocks)[source]

Bases: pymor.operators.block.BlockOperator

Block diagonal Operator of arbitrary Operators.

This is a specialization of BlockOperator for the block diagonal case.

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

Apply the inverse operator.

Parameters

V
VectorArray of vectors to which the inverse operator is applied.
ind
The indices of the vectors in V to which the inverse operator shall be applied (see VectorArray documentation for further details).
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, ind=None, mu=None, source_product=None, range_product=None, least_squares=False)[source]

Apply the inverse adjoint operator.

Parameters

U
VectorArray of vectors to which the inverse adjoint operator is applied.
ind
The indices of the vectors in U to which the inverse adjoint operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the inverse adjoint operator.
source_product
See apply_adjoint.
range_product
See apply_adjoint.
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.block.BlockOperator(blocks)[source]

Bases: pymor.operators.basic.OperatorBase

A sparse matrix of arbitrary Operators.

This operator can be applied to BlockVectorArrays of an appropriate subtype.

Parameters

blocks
Two-dimensional NumPy array where each entry is an Operator or None.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the operator evaluations.

apply_adjoint(U, ind=None, mu=None, source_product=None, range_product=None)[source]

Apply the adjoint operator.

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

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

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

op^*(v) = P_s^(-1) * M^T * P_r * v,

with M^T denoting the transposed of M. Thus, if ( , )_s and ( , )_r are the Euclidean inner products, op^*v is simply given by multiplication of the matrix of op with v from the left.

Parameters

U
VectorArray of vectors to which the adjoint operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to apply the adjoint operator.
source_product
The inner product Operator on the source space. If None, the Euclidean product is chosen.
range_product
The inner product Operator on the range space. If None, the Euclidean product is chosen.

Returns

VectorArray of the adjoint operator evaluations.

classmethod hstack(operators)[source]

Horizontal stacking of Operators.

Parameters

operators
A tuple, list, array, or iterable of Operators.
classmethod vstack(operators)[source]

Vertical stacking of Operators.

Parameters

operators
A tuple, list, array, or iterable of Operators.

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 vector-valued. The current implementation works in one and two dimensions, but can be trivially extended to arbitrary dimensions.

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) with shape_range = (grid.dim_outer, ). If None, constant one is assumed.
advection_constant
The constant c. If None, 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.
name
Name of the operator.

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 vector-valued. The current implementation works in two dimensions, but can be trivially extended to arbitrary dimensions.

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) with shape_range = (grid.dim_outer, ). If None, constant one is assumed.
advection_constant
The constant c. If None, 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.
name
Name of the operator.

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 matrix-valued. The current implementation works in one and two dimensions, but can be trivially extended to arbitrary dimensions.

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) with shape_range == () or shape_range = (grid.dim_outer, grid.dim_outer). If None, constant one is assumed.
diffusion_constant
The constant c. If None, 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.
name
Name of the operator.

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 matrix-valued. The current implementation works in two dimensions, but can be trivially extended to arbitrary dimensions.

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) with shape_range == () or shape_range = (grid.dim_outer, grid.dim_outer). If None, constant one is assumed.
diffusion_constant
The constant c. If None, 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.
name
Name of the operator.

class pymor.operators.cg.InterpolationOperator(grid, function)[source]

Bases: pymor.operators.numpy.NumpyMatrixBasedOperator

Vector-like Lagrange interpolation Operator for continuous finite element spaces.

Parameters

grid
The Grid on which to interpolate.
function
The Function to interpolate.

class pymor.operators.cg.L2ProductFunctionalP1(grid, function, boundary_info=None, dirichlet_data=None, neumann_data=None, robin_data=None, order=2, solver_options=None, name=None)[source]

Bases: pymor.operators.numpy.NumpyMatrixBasedOperator

Linear finite element Functional representing the inner product with an L2-Function.

Boundary treatment can be performed by providing boundary_info and dirichlet_data, in which case the DOFs corresponding to Dirichlet boundaries are set to the values provided by dirichlet_data. Neumann boundaries are handled by providing a neumann_data function, Robin boundaries by providing a robin_data tuple.

The current implementation works in one and two dimensions, but can be trivially extended to arbitrary dimensions.

Parameters

grid
Grid for which to assemble the functional.
function
The Function with which to take the inner product.
boundary_info
BoundaryInfo determining the Dirichlet and Neumann boundaries or None. If None, no boundary treatment is performed.
dirichlet_data
Function providing the Dirichlet boundary values. If None, constant-zero boundary is assumed.
neumann_data
Function providing the Neumann boundary values. If None, constant-zero is assumed.
robin_data
Tuple of two Functions providing the Robin parameter and boundary values, see RobinBoundaryOperator. If None, constant-zero for both functions is assumed.
order
Order of the Gauss quadrature to use for numerical integration.
name
The name of the functional.

class pymor.operators.cg.L2ProductFunctionalQ1(grid, function, boundary_info=None, dirichlet_data=None, neumann_data=None, robin_data=None, order=2, name=None)[source]

Bases: pymor.operators.numpy.NumpyMatrixBasedOperator

Bilinear finite element Functional representing the inner product with an L2-Function.

Boundary treatment can be performed by providing boundary_info and dirichlet_data, in which case the DOFs corresponding to Dirichlet boundaries are set to the values provided by dirichlet_data. Neumann boundaries are handled by providing a neumann_data function, Robin boundaries by providing a robin_data tuple.

The current implementation works in two dimensions, but can be trivially extended to arbitrary dimensions.

Parameters

grid
Grid for which to assemble the functional.
function
The Function with which to take the inner product.
boundary_info
BoundaryInfo determining the Dirichlet boundaries or None. If None, no boundary treatment is performed.
dirichlet_data
Function providing the Dirichlet boundary values. If None, constant-zero boundary is assumed.
neumann_data
Function providing the Neumann boundary values. If None, constant-zero is assumed.
robin_data
Tuple of two Functions providing the Robin parameter and boundary values, see RobinBoundaryOperator. If None, constant-zero for both functions is assumed.
order
Order of the Gauss quadrature to use for numerical integration.
name
The name of the functional.

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 L2-product between linear finite element functions.

The current implementation works in one and two dimensions, but can be trivially extended to arbitrary dimensions.

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 either dirichlet_clear_rows or dirichlet_clear_columns is True, the diagonal entries are set to one.
coefficient_function
Coefficient Function for product with shape_range == (). If None, constant one is assumed.
name
The name of the product.

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 L2-product between bilinear finite element functions.

The current implementation works in two dimensions, but can be trivially extended to arbitrary dimensions.

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 either dirichlet_clear_rows or dirichlet_clear_columns is True, the diagonal entries are set to one.
coefficient_function
Coefficient Function for product with shape_range == (). If None, constant one is assumed.
name
The name of the product.

class pymor.operators.cg.RobinBoundaryOperator(grid, boundary_info, robin_data=None, order=2, 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 and n are the diffusion function (see DiffusionOperatorP1) and the unit outer normal in x, while c is the (scalar) Robin parameter function and g 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. If None, the resulting operator is zero.
name
Name of the 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.basic.OperatorBase

Represents the adjoint of a given linear Operator.

See apply_adjoint.

Parameters

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

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the operator evaluations.

apply_adjoint(U, ind=None, mu=None, source_product=None, range_product=None)[source]

Apply the adjoint operator.

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

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

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

op^*(v) = P_s^(-1) * M^T * P_r * v,

with M^T denoting the transposed of M. Thus, if ( , )_s and ( , )_r are the Euclidean inner products, op^*v is simply given by multiplication of the matrix of op with v from the left.

Parameters

U
VectorArray of vectors to which the adjoint operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to apply the adjoint operator.
source_product
The inner product Operator on the source space. If None, the Euclidean product is chosen.
range_product
The inner product Operator on the range space. If None, the Euclidean product is chosen.

Returns

VectorArray of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters

V
VectorArray of vectors to which the inverse operator is applied.
ind
The indices of the vectors in V to which the inverse operator shall be applied (see VectorArray documentation for further details).
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, ind=None, mu=None, source_product=None, range_product=None, least_squares=False)[source]

Apply the inverse adjoint operator.

Parameters

U
VectorArray of vectors to which the inverse adjoint operator is applied.
ind
The indices of the vectors in U to which the inverse adjoint operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the inverse adjoint operator.
source_product
See apply_adjoint.
range_product
See apply_adjoint.
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.
projected(range_basis, source_basis, product=None, name=None)[source]

Project the operator to subspaces of the source and range space.

Given an inner product ( ⋅, ⋅), source vectors b_1, ..., b_N and range vectors c_1, ..., c_M, the projection op_proj of op is defined by

[ op_proj(e_j) ]_i = ( c_i, op(b_j) )

for all i,j, where e_j denotes the j-th canonical basis vector of R^N.

In particular, if the c_i are orthonormal w.r.t. the given product, then op_proj is the coordinate representation w.r.t. the b_i/c_i bases of the restriction of op to span(b_i) concatenated with the orthogonal projection onto span(c_i).

From another point of view, if op is viewed as a bilinear form (see apply2) and ( ⋅, ) is the Euclidean inner product, then op_proj represents the matrix of the bilinear form restricted span(b_i) / spanc(c_i) (w.r.t. the b_i/c_i bases).

How the projected operator is realized will depend on the implementation of the operator to project. While a projected NumpyMatrixOperator will again be a NumpyMatrixOperator, only a generic ProjectedOperator can be returned in general.

A default implementation is provided in OperatorBase.

Parameters

range_basis
The vectors c_1, ..., c_M as a VectorArray. If None, no projection in the range space is performed.
source_basis
The vectors b_1, ..., b_N as a VectorArray or None. If None, no restriction of the source space is performed.
product
An Operator representing the inner product. If None, the Euclidean inner product is chosen.
name
Name of the projected operator.

Returns

The projected Operator op_proj.


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

Bases: pymor.operators.basic.OperatorBase

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

Parameters

components
List or 1D NumPy array of the indices of the vector components that ar to be extracted by the operator.
source
Source VectorSpace of the operator.
name
Name of the operator.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
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 array source_dofs such that for any VectorArray U in self.source the following is true:

self.apply(U, mu).components(dofs)
    == restricted_op.apply(NumpyVectorArray(U.components(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 few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters

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

Returns

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

class pymor.operators.constructions.Concatenation(second, first, solver_options=None, name=None)[source]

Bases: pymor.operators.basic.OperatorBase

Operator representing the concatenation of two Operators.

Parameters

second
The Operator which is applied as second operator.
first
The Operator which is applied as first operator.
name
Name of the operator.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the operator evaluations.

apply_adjoint(U, ind=None, mu=None, source_product=None, range_product=None)[source]

Apply the adjoint operator.

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

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

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

op^*(v) = P_s^(-1) * M^T * P_r * v,

with M^T denoting the transposed of M. Thus, if ( , )_s and ( , )_r are the Euclidean inner products, op^*v is simply given by multiplication of the matrix of op with v from the left.

Parameters

U
VectorArray of vectors to which the adjoint operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to apply the adjoint operator.
source_product
The inner product Operator on the source space. If None, the Euclidean product is chosen.
range_product
The inner product Operator on the range space. If None, the Euclidean product is chosen.

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.

projected(range_basis, source_basis, product=None, name=None)[source]

Project the operator to subspaces of the source and range space.

Given an inner product ( ⋅, ⋅), source vectors b_1, ..., b_N and range vectors c_1, ..., c_M, the projection op_proj of op is defined by

[ op_proj(e_j) ]_i = ( c_i, op(b_j) )

for all i,j, where e_j denotes the j-th canonical basis vector of R^N.

In particular, if the c_i are orthonormal w.r.t. the given product, then op_proj is the coordinate representation w.r.t. the b_i/c_i bases of the restriction of op to span(b_i) concatenated with the orthogonal projection onto span(c_i).

From another point of view, if op is viewed as a bilinear form (see apply2) and ( ⋅, ) is the Euclidean inner product, then op_proj represents the matrix of the bilinear form restricted span(b_i) / spanc(c_i) (w.r.t. the b_i/c_i bases).

How the projected operator is realized will depend on the implementation of the operator to project. While a projected NumpyMatrixOperator will again be a NumpyMatrixOperator, only a generic ProjectedOperator can be returned in general.

A default implementation is provided in OperatorBase.

Parameters

range_basis
The vectors c_1, ..., c_M as a VectorArray. If None, no projection in the range space is performed.
source_basis
The vectors b_1, ..., b_N as a VectorArray or None. If None, no restriction of the source space is performed.
product
An Operator representing the inner product. If None, the Euclidean inner product is chosen.
name
Name of the projected operator.

Returns

The projected Operator op_proj.

restricted(dofs)[source]

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

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

self.apply(U, mu).components(dofs)
    == restricted_op.apply(NumpyVectorArray(U.components(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 few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters

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

Returns

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

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

Bases: pymor.operators.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.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter 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 for which to compute the Jacobian.

Returns

Linear Operator representing the Jacobian.

projected(range_basis, source_basis, product=None, name=None)[source]

Project the operator to subspaces of the source and range space.

Given an inner product ( ⋅, ⋅), source vectors b_1, ..., b_N and range vectors c_1, ..., c_M, the projection op_proj of op is defined by

[ op_proj(e_j) ]_i = ( c_i, op(b_j) )

for all i,j, where e_j denotes the j-th canonical basis vector of R^N.

In particular, if the c_i are orthonormal w.r.t. the given product, then op_proj is the coordinate representation w.r.t. the b_i/c_i bases of the restriction of op to span(b_i) concatenated with the orthogonal projection onto span(c_i).

From another point of view, if op is viewed as a bilinear form (see apply2) and ( ⋅, ) is the Euclidean inner product, then op_proj represents the matrix of the bilinear form restricted span(b_i) / spanc(c_i) (w.r.t. the b_i/c_i bases).

How the projected operator is realized will depend on the implementation of the operator to project. While a projected NumpyMatrixOperator will again be a NumpyMatrixOperator, only a generic ProjectedOperator can be returned in general.

A default implementation is provided in OperatorBase.

Parameters

range_basis
The vectors c_1, ..., c_M as a VectorArray. If None, no projection in the range space is performed.
source_basis
The vectors b_1, ..., b_N as a VectorArray or None. If None, no restriction of the source space is performed.
product
An Operator representing the inner product. If None, the Euclidean inner product is chosen.
name
Name of the projected operator.

Returns

The projected Operator op_proj.

restricted(dofs)[source]

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

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

self.apply(U, mu).components(dofs)
    == restricted_op.apply(NumpyVectorArray(U.components(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 few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters

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

Returns

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

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

Bases: pymor.operators.basic.OperatorBase

Makes an Operator Parameter-independent by setting a fixed Parameter.

Parameters

operator
The Operator to wrap.
mu
The fixed Parameter that will be fed to the apply method of operator.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the operator evaluations.

apply_adjoint(U, ind=None, mu=None, source_product=None, range_product=None)[source]

Apply the adjoint operator.

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

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

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

op^*(v) = P_s^(-1) * M^T * P_r * v,

with M^T denoting the transposed of M. Thus, if ( , )_s and ( , )_r are the Euclidean inner products, op^*v is simply given by multiplication of the matrix of op with v from the left.

Parameters

U
VectorArray of vectors to which the adjoint operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to apply the adjoint operator.
source_product
The inner product Operator on the source space. If None, the Euclidean product is chosen.
range_product
The inner product Operator on the range space. If None, the Euclidean product is chosen.

Returns

VectorArray of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters

V
VectorArray of vectors to which the inverse operator is applied.
ind
The indices of the vectors in V to which the inverse operator shall be applied (see VectorArray documentation for further details).
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, ind=None, mu=None, source_product=None, range_product=None, least_squares=False)[source]

Apply the inverse adjoint operator.

Parameters

U
VectorArray of vectors to which the inverse adjoint operator is applied.
ind
The indices of the vectors in U to which the inverse adjoint operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the inverse adjoint operator.
source_product
See apply_adjoint.
range_product
See apply_adjoint.
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 array source_dofs such that for any VectorArray U in self.source the following is true:

self.apply(U, mu).components(dofs)
    == restricted_op.apply(NumpyVectorArray(U.components(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 few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters

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

Returns

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

class pymor.operators.constructions.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.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the operator evaluations.

apply_adjoint(U, ind=None, mu=None, source_product=None, range_product=None)[source]

Apply the adjoint operator.

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

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

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

op^*(v) = P_s^(-1) * M^T * P_r * v,

with M^T denoting the transposed of M. Thus, if ( , )_s and ( , )_r are the Euclidean inner products, op^*v is simply given by multiplication of the matrix of op with v from the left.

Parameters

U
VectorArray of vectors to which the adjoint operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to apply the adjoint operator.
source_product
The inner product Operator on the source space. If None, the Euclidean product is chosen.
range_product
The inner product Operator on the range space. If None, the Euclidean product is chosen.

Returns

VectorArray of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters

V
VectorArray of vectors to which the inverse operator is applied.
ind
The indices of the vectors in V to which the inverse operator shall be applied (see VectorArray documentation for further details).
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, ind=None, mu=None, source_product=None, range_product=None, least_squares=False)[source]

Apply the inverse adjoint operator.

Parameters

U
VectorArray of vectors to which the inverse adjoint operator is applied.
ind
The indices of the vectors in U to which the inverse adjoint operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the inverse adjoint operator.
source_product
See apply_adjoint.
range_product
See apply_adjoint.
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 matrix-based operator will assemble its matrix, a LincombOperator will try to form the linear combination of its operators, whereas an arbitrary operator might simply return a FixedParameterOperator. The only assured property of the assembled operator is that it no longer depends on a Parameter.

Parameters

mu
The Parameter for which to assemble the operator.

Returns

Parameter-independent, assembled Operator.

assemble_lincomb(operators, coefficients, solver_options=None, name=None)[source]

Try to assemble a linear combination of the given operators.

This method is called in the assemble method of LincombOperator on the first of its operator. 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 returns None to indicate that assembly is not possible.

Parameters

operators
List of Operators whose linear combination is formed.
coefficients
List of the corresponding linear coefficients.
solver_options
solver_options for the assembled operator.
name
Name of the assembled operator.

Returns

The assembled Operator if assembly is possible, otherwise None.

restricted(dofs)[source]

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

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

self.apply(U, mu).components(dofs)
    == restricted_op.apply(NumpyVectorArray(U.components(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 few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters

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

Returns

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

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

Bases: pymor.core.interfaces.ImmutableInterface, pymor.parameters.base.Parametric

Instantiated by induced_norm. Do not use directly.

__call__(...) <==> x(...)[source]

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 (possibly Parameter dependent) linear combination of a given list of Operators.

Parameters

operators
List of Operators whose linear combination is formed.
coefficients
A list of linear coefficients. A linear coefficient can either be a fixed number or a ParameterFunctional.
name
Name of the operator.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the operator evaluations.

apply2(V, U, U_ind=None, V_ind=None, mu=None, product=None)[source]

Treat the operator as a 2-form by calculating (V, op(U)).

In general op.apply2(V, U) is equivalent to:

product.apply2(V, op.apply(U)).

In case no product has been specified, op.apply2(V, U) is equivialent to:

V.dot(op.apply(U)).

In the latter case, assuming that op is a linear operator given by multiplication with a matrix M, then:

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

Parameters

V
VectorArray of the left arguments V.
U
VectorArray of the right right arguments U.
V_ind
The indices of the vectors in V to which the operator shall be applied (see VectorArray documentation for further details).
U_ind
The indices of the vectors in U to which the operator shall be applied (see VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.
product
The inner product used in the expression (V, op(U)) given as an Operator. If None, the euclidean product is chosen.

Returns

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

apply_adjoint(U, ind=None, mu=None, source_product=None, range_product=None)[source]

Apply the adjoint operator.

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

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

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

op^*(v) = P_s^(-1) * M^T * P_r * v,

with M^T denoting the transposed of M. Thus, if ( , )_s and ( , )_r are the Euclidean inner products, op^*v is simply given by multiplication of the matrix of op with v from the left.

Parameters

U
VectorArray of vectors to which the adjoint operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to apply the adjoint operator.
source_product
The inner product Operator on the source space. If None, the Euclidean product is chosen.
range_product
The inner product Operator on the range space. If None, the Euclidean product is chosen.

Returns

VectorArray of the adjoint operator evaluations.

as_vector(mu=None)[source]

Return a vector representation of a linear functional or vector operator.

This method may only be called on linear functionals, i.e. linear Operators with NumpyVectorSpace (1) as range, or on operators describing vectors, i.e. linear Operators with NumpyVectorSpace (1) as source.

In the case of a functional, the identity

self.as_vector(mu).dot(U) == self.apply(U, mu)

holds, whereas in the case of a vector-like operator we have

self.as_vector(mu) == self.apply(NumpyVectorArray(1), mu).

Parameters

mu
The Parameter for which to return the vector representation.

Returns

V
VectorArray of length 1 containing the vector representation. V belongs to self.source for functionals and to self.range for vector-like operators.
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 matrix-based operator will assemble its matrix, a LincombOperator will try to form the linear combination of its operators, whereas an arbitrary operator might simply return a FixedParameterOperator. The only assured property of the assembled operator is that it no longer depends on a Parameter.

Parameters

mu
The Parameter for which to assemble the operator.

Returns

Parameter-independent, assembled Operator.

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, U_ind=None, V_ind=None, mu=None, product=None)[source]

Treat the operator as a 2-form by calculating (V, op(U)).

Same as OperatorInterface.apply2, except that vectors from V and U are applied in pairs.

Parameters

V
VectorArray of the left arguments V.
U
VectorArray of the right right arguments U.
V_ind
The indices of the vectors in V to which the operator shall be applied (see VectorArray documentation for further details).
U_ind
The indices of the vectors in U to which the operator shall be applied (see VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.
product
The inner product used in the expression (V, op(U)) given as an Operator. If None, the euclidean product is chosen.

Returns

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

projected(range_basis, source_basis, product=None, name=None)[source]

Project the operator to subspaces of the source and range space.

Given an inner product ( ⋅, ⋅), source vectors b_1, ..., b_N and range vectors c_1, ..., c_M, the projection op_proj of op is defined by

[ op_proj(e_j) ]_i = ( c_i, op(b_j) )

for all i,j, where e_j denotes the j-th canonical basis vector of R^N.

In particular, if the c_i are orthonormal w.r.t. the given product, then op_proj is the coordinate representation w.r.t. the b_i/c_i bases of the restriction of op to span(b_i) concatenated with the orthogonal projection onto span(c_i).

From another point of view, if op is viewed as a bilinear form (see apply2) and ( ⋅, ) is the Euclidean inner product, then op_proj represents the matrix of the bilinear form restricted span(b_i) / spanc(c_i) (w.r.t. the b_i/c_i bases).

How the projected operator is realized will depend on the implementation of the operator to project. While a projected NumpyMatrixOperator will again be a NumpyMatrixOperator, only a generic ProjectedOperator can be returned in general.

A default implementation is provided in OperatorBase.

Parameters

range_basis
The vectors c_1, ..., c_M as a VectorArray. If None, no projection in the range space is performed.
source_basis
The vectors b_1, ..., b_N as a VectorArray or None. If None, no restriction of the source space is performed.
product
An Operator representing the inner product. If None, the Euclidean inner product is chosen.
name
Name of the projected operator.

Returns

The projected Operator op_proj.

projected_to_subbasis(dim_range=None, dim_source=None, name=None)[source]

See pymor.operators.numpy.NumpyMatrixOperator.projected_to_subbasis.


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

Bases: pymor.operators.basic.OperatorBase

An Operator selected from a list of Operators.

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

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

Parameters

operators
List of Operators from which one Operator is selected based on the given Parameter.
parameter_functional
The ParameterFunctional used for the selection of one Operator.
boundaries
The interval boundaries as defined above.
name
Name of the operator.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the operator evaluations.

apply_adjoint(U, ind=None, mu=None, source_product=None, range_product=None)[source]

Apply the adjoint operator.

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

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

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

op^*(v) = P_s^(-1) * M^T * P_r * v,

with M^T denoting the transposed of M. Thus, if ( , )_s and ( , )_r are the Euclidean inner products, op^*v is simply given by multiplication of the matrix of op with v from the left.

Parameters

U
VectorArray of vectors to which the adjoint operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to apply the adjoint operator.
source_product
The inner product Operator on the source space. If None, the Euclidean product is chosen.
range_product
The inner product Operator on the range space. If None, the Euclidean product is chosen.

Returns

VectorArray of the adjoint operator evaluations.

as_vector(mu=None)[source]

Return a vector representation of a linear functional or vector operator.

This method may only be called on linear functionals, i.e. linear Operators with NumpyVectorSpace (1) as range, or on operators describing vectors, i.e. linear Operators with NumpyVectorSpace (1) as source.

In the case of a functional, the identity

self.as_vector(mu).dot(U) == self.apply(U, mu)

holds, whereas in the case of a vector-like operator we have

self.as_vector(mu) == self.apply(NumpyVectorArray(1), mu).

Parameters

mu
The Parameter for which to return the vector representation.

Returns

V
VectorArray of length 1 containing the vector representation. V belongs to self.source for functionals and to self.range for vector-like operators.
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 matrix-based operator will assemble its matrix, a LincombOperator will try to form the linear combination of its operators, whereas an arbitrary operator might simply return a FixedParameterOperator. The only assured property of the assembled operator is that it no longer depends on a Parameter.

Parameters

mu
The Parameter for which to assemble the operator.

Returns

Parameter-independent, assembled Operator.

projected(range_basis, source_basis, product=None, name=None)[source]

Project the operator to subspaces of the source and range space.

Given an inner product ( ⋅, ⋅), source vectors b_1, ..., b_N and range vectors c_1, ..., c_M, the projection op_proj of op is defined by

[ op_proj(e_j) ]_i = ( c_i, op(b_j) )

for all i,j, where e_j denotes the j-th canonical basis vector of R^N.

In particular, if the c_i are orthonormal w.r.t. the given product, then op_proj is the coordinate representation w.r.t. the b_i/c_i bases of the restriction of op to span(b_i) concatenated with the orthogonal projection onto span(c_i).

From another point of view, if op is viewed as a bilinear form (see apply2) and ( ⋅, ) is the Euclidean inner product, then op_proj represents the matrix of the bilinear form restricted span(b_i) / spanc(c_i) (w.r.t. the b_i/c_i bases).

How the projected operator is realized will depend on the implementation of the operator to project. While a projected NumpyMatrixOperator will again be a NumpyMatrixOperator, only a generic ProjectedOperator can be returned in general.

A default implementation is provided in OperatorBase.

Parameters

range_basis
The vectors c_1, ..., c_M as a VectorArray. If None, no projection in the range space is performed.
source_basis
The vectors b_1, ..., b_N as a VectorArray or None. If None, no restriction of the source space is performed.
product
An Operator representing the inner product. If None, the Euclidean inner product is chosen.
name
Name of the projected operator.

Returns

The projected Operator op_proj.


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

Bases: pymor.operators.basic.OperatorBase

Wraps a VectorArray as an Operator.

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

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

Parameters

array
The VectorArray which is to be treated as an operator.
transposed
See description above.
name
The name of the operator.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the operator evaluations.

apply_adjoint(U, ind=None, mu=None, source_product=None, range_product=None)[source]

Apply the adjoint operator.

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

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

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

op^*(v) = P_s^(-1) * M^T * P_r * v,

with M^T denoting the transposed of M. Thus, if ( , )_s and ( , )_r are the Euclidean inner products, op^*v is simply given by multiplication of the matrix of op with v from the left.

Parameters

U
VectorArray of vectors to which the adjoint operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to apply the adjoint operator.
source_product
The inner product Operator on the source space. If None, the Euclidean product is chosen.
range_product
The inner product Operator on the range space. If None, the Euclidean product is chosen.

Returns

VectorArray of the adjoint operator evaluations.

apply_inverse_adjoint(U, ind=None, mu=None, source_product=None, range_product=None, least_squares=False)[source]

Apply the inverse adjoint operator.

Parameters

U
VectorArray of vectors to which the inverse adjoint operator is applied.
ind
The indices of the vectors in U to which the inverse adjoint operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the inverse adjoint operator.
source_product
See apply_adjoint.
range_product
See apply_adjoint.
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_vector(mu=None)[source]

Return a vector representation of a linear functional or vector operator.

This method may only be called on linear functionals, i.e. linear Operators with NumpyVectorSpace (1) as range, or on operators describing vectors, i.e. linear Operators with NumpyVectorSpace (1) as source.

In the case of a functional, the identity

self.as_vector(mu).dot(U) == self.apply(U, mu)

holds, whereas in the case of a vector-like operator we have

self.as_vector(mu) == self.apply(NumpyVectorArray(1), mu).

Parameters

mu
The Parameter for which to return the vector representation.

Returns

V
VectorArray of length 1 containing the vector representation. V belongs to self.source for functionals and to self.range for vector-like operators.
assemble_lincomb(operators, coefficients, solver_options=None, name=None)[source]

Try to assemble a linear combination of the given operators.

This method is called in the assemble method of LincombOperator on the first of its operator. 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 returns None to indicate that assembly is not possible.

Parameters

operators
List of Operators whose linear combination is formed.
coefficients
List of the corresponding linear coefficients.
solver_options
solver_options for the assembled operator.
name
Name of the assembled operator.

Returns

The assembled Operator if assembly is possible, otherwise None.

restricted(dofs)[source]

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

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

self.apply(U, mu).components(dofs)
    == restricted_op.apply(NumpyVectorArray(U.components(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 few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters

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

Returns

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

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

Bases: pymor.operators.constructions.VectorArrayOperator

Wrap a vector as a linear Functional.

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

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

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

In particular, if product is None

VectorFunctional(vector).as_vector() == vector.

If product is not none, we obtain

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

Parameters

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

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

Bases: pymor.operators.constructions.VectorArrayOperator

Wrap a vector as a vector-like Operator.

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

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

In particular:

VectorOperator(vector).as_vector() == vector

Parameters

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

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

Bases: pymor.operators.basic.OperatorBase

The Operator which maps every vector to zero.

Parameters

source
Source VectorSpace of the operator.
range
Range VectorSpace of the operator.
name
Name of the operator.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the operator evaluations.

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

Apply the inverse operator.

Parameters

V
VectorArray of vectors to which the inverse operator is applied.
ind
The indices of the vectors in V to which the inverse operator shall be applied (see VectorArray documentation for further details).
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, ind=None, mu=None, source_product=None, range_product=None, least_squares=False)[source]

Apply the inverse adjoint operator.

Parameters

U
VectorArray of vectors to which the inverse adjoint operator is applied.
ind
The indices of the vectors in U to which the inverse adjoint operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the inverse adjoint operator.
source_product
See apply_adjoint.
range_product
See apply_adjoint.
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_lincomb(operators, coefficients, solver_options=None, name=None)[source]

Try to assemble a linear combination of the given operators.

This method is called in the assemble method of LincombOperator on the first of its operator. 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 returns None to indicate that assembly is not possible.

Parameters

operators
List of Operators whose linear combination is formed.
coefficients
List of the corresponding linear coefficients.
solver_options
solver_options for the assembled operator.
name
Name of the assembled operator.

Returns

The assembled Operator if assembly is possible, otherwise None.

projected(range_basis, source_basis, product=None, name=None)[source]

Project the operator to subspaces of the source and range space.

Given an inner product ( ⋅, ⋅), source vectors b_1, ..., b_N and range vectors c_1, ..., c_M, the projection op_proj of op is defined by

[ op_proj(e_j) ]_i = ( c_i, op(b_j) )

for all i,j, where e_j denotes the j-th canonical basis vector of R^N.

In particular, if the c_i are orthonormal w.r.t. the given product, then op_proj is the coordinate representation w.r.t. the b_i/c_i bases of the restriction of op to span(b_i) concatenated with the orthogonal projection onto span(c_i).

From another point of view, if op is viewed as a bilinear form (see apply2) and ( ⋅, ) is the Euclidean inner product, then op_proj represents the matrix of the bilinear form restricted span(b_i) / spanc(c_i) (w.r.t. the b_i/c_i bases).

How the projected operator is realized will depend on the implementation of the operator to project. While a projected NumpyMatrixOperator will again be a NumpyMatrixOperator, only a generic ProjectedOperator can be returned in general.

A default implementation is provided in OperatorBase.

Parameters

range_basis
The vectors c_1, ..., c_M as a VectorArray. If None, no projection in the range space is performed.
source_basis
The vectors b_1, ..., b_N as a VectorArray or None. If None, no restriction of the source space is performed.
product
An Operator representing the inner product. If None, the Euclidean inner product is chosen.
name
Name of the projected operator.

Returns

The projected Operator op_proj.

restricted(dofs)[source]

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

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

self.apply(U, mu).components(dofs)
    == restricted_op.apply(NumpyVectorArray(U.components(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 few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters

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

Returns

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

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

Obtain induced norm of an inner product.

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

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

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

Parameters

product
The inner product Operator for which the norm is to be calculated.
raise_negative
If True, raise an exception if calculated norm is negative.
tol
See above.

Returns

norm
A function norm(U, mu=None) taking a VectorArray U as input together with the Parameter mu which is 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.basic.OperatorBase

Interpolate an Operator using Empirical Operator Interpolation.

Let L be an Operator, 0 <= c_1, ..., c_M < L.range.dim indices of interpolation DOFs and let b_1, ..., b_M in R^(L.range.dim) be collateral basis vectors. If moreover ψ_j(U) denotes the j-th component of U, the empirical interpolation L_EI of L 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 calls restricted to obtain a restricted version of the operator which is used to quickly obtain the required evaluations. If the restricted 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 DOFs c_1, ..., c_M.
collateral_basis
VectorArray containing the collateral basis b_1, ..., b_M.
triangular
If True, assume that ψ_(c_i)(b_j) = 0 for i < j, which means that the interpolation matrix is triangular.
name
Name of the operator.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter 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 for which to compute the Jacobian.

Returns

Linear Operator representing the Jacobian.

projected(range_basis, source_basis, product=None, name=None)[source]

Project the operator to subspaces of the source and range space.

Given an inner product ( ⋅, ⋅), source vectors b_1, ..., b_N and range vectors c_1, ..., c_M, the projection op_proj of op is defined by

[ op_proj(e_j) ]_i = ( c_i, op(b_j) )

for all i,j, where e_j denotes the j-th canonical basis vector of R^N.

In particular, if the c_i are orthonormal w.r.t. the given product, then op_proj is the coordinate representation w.r.t. the b_i/c_i bases of the restriction of op to span(b_i) concatenated with the orthogonal projection onto span(c_i).

From another point of view, if op is viewed as a bilinear form (see apply2) and ( ⋅, ) is the Euclidean inner product, then op_proj represents the matrix of the bilinear form restricted span(b_i) / spanc(c_i) (w.r.t. the b_i/c_i bases).

How the projected operator is realized will depend on the implementation of the operator to project. While a projected NumpyMatrixOperator will again be a NumpyMatrixOperator, only a generic ProjectedOperator can be returned in general.

A default implementation is provided in OperatorBase.

Parameters

range_basis
The vectors c_1, ..., c_M as a VectorArray. If None, no projection in the range space is performed.
source_basis
The vectors b_1, ..., b_N as a VectorArray or None. If None, no restriction of the source space is performed.
product
An Operator representing the inner product. If None, the Euclidean inner product is chosen.
name
Name of the projected operator.

Returns

The projected Operator op_proj.


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.basic.OperatorBase

A projected EmpiricalInterpolatedOperator.

Not intended to be used directly. Instead use projected.

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

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter 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 for which to compute the Jacobian.

Returns

Linear Operator representing the Jacobian.

fenics module

fv module

This module provides some operators for finite volume discretizations.


class pymor.operators.fv.DiffusionOperator(grid, boundary_info, diffusion_function=None, diffusion_constant=None, solver_options=None, name=None)[source]

Bases: pymor.operators.numpy.NumpyMatrixBasedOperator

Finite Volume Diffusion Operator.

The operator is of the form

(Lu)(x) = c ∇ ⋅ [ d(x) ∇ u(x) ]

Parameters

grid
The Grid over which to assemble the operator.
boundary_info
BoundaryInfo for the treatment of Dirichlet boundary conditions.
diffusion_function
The scalar-valued Function d(x). If None, constant one is assumed.
diffusion_constant
The constant c. If None, c is set to one.
name
Name of the operator.

class pymor.operators.fv.EngquistOsherFlux(flux, flux_derivative, gausspoints=5, intervals=1)[source]

Bases: pymor.operators.fv.NumericalConvectiveFluxInterface

Engquist-Osher numerical flux.

If f is the analytical flux, and f' its derivative, the Engquist-Osher flux is given by:

F(U_in, U_out, normal, vol) = vol * [c^+(U_in, normal)  +  c^-(U_out, normal)]

                                   U_in
c^+(U_in, normal)  = f(0)⋅normal +  ∫   max(f'(s)⋅normal, 0) ds
                                   s=0

                                  U_out
c^-(U_out, normal) =                ∫   min(f'(s)⋅normal, 0) ds
                                   s=0

Parameters

flux
Function defining the analytical flux f.
flux_derivative
Function defining the analytical flux derivative f'.
gausspoints
Number of Gauss quadrature points to be used for integration.
intervals
Number of subintervals to be used for integration.

class pymor.operators.fv.L2Product(grid, solver_options=None, name=None)[source]

Bases: pymor.operators.numpy.NumpyMatrixBasedOperator

Operator representing the L2-product between finite volume functions.

Parameters

grid
The Grid for which to assemble the product.
name
The name of the product.

class pymor.operators.fv.L2ProductFunctional(grid, function=None, boundary_info=None, dirichlet_data=None, diffusion_function=None, diffusion_constant=None, neumann_data=None, order=1, name=None)[source]

Bases: pymor.operators.numpy.NumpyMatrixBasedOperator

Finite volume Functional representing the inner product with an L2-Function.

Additionally, boundary conditions can be enforced by providing dirichlet_data and neumann_data functions.

Parameters

grid
Grid for which to assemble the functional.
function
The Function with which to take the inner product or None.
boundary_info
BoundaryInfo determining the Dirichlet and Neumann boundaries or None. If None, no boundary treatment is performed.
dirichlet_data
Function providing the Dirichlet boundary values. If None, constant-zero boundary is assumed.
diffusion_function
See DiffusionOperator. Has to be specified in case dirichlet_data is given.
diffusion_constant
See DiffusionOperator. Has to be specified in case dirichlet_data is given.
neumann_data
Function providing the Neumann boundary values. If None, constant-zero is assumed.
order
Order of the Gauss quadrature to use for numerical integration.
name
The name of the functional.

class pymor.operators.fv.LaxFriedrichsFlux(flux, lxf_lambda=1.0)[source]

Bases: pymor.operators.fv.NumericalConvectiveFluxInterface

Lax-Friedrichs numerical flux.

If f is the analytical flux, the Lax-Friedrichs flux F is given by:

F(U_in, U_out, normal, vol) = vol * [normal⋅(f(U_in) + f(U_out))/2 + (U_in - U_out)/(2*λ)]

Parameters

flux
Function defining the analytical flux f.
lxf_lambda
The stabilization parameter λ.

class pymor.operators.fv.LinearAdvectionLaxFriedrichs(grid, boundary_info, velocity_field, lxf_lambda=1.0, solver_options=None, name=None)[source]

Bases: pymor.operators.numpy.NumpyMatrixBasedOperator

Linear advection finite Volume Operator using Lax-Friedrichs flux.

The operator is of the form

L(u, mu)(x) = ∇ ⋅ (v(x, mu)⋅u(x))

See LaxFriedrichsFlux for the definition of the Lax-Friedrichs flux.

Parameters

grid
Grid over which to assemble the operator.
boundary_info
BoundaryInfo determining the Dirichlet and Neumann boundaries.
velocity_field
Function defining the velocity field v.
lxf_lambda
The stabilization parameter λ.
name
The name of the operator.

class pymor.operators.fv.NonlinearAdvectionOperator(grid, boundary_info, numerical_flux, dirichlet_data=None, solver_options=None, name=None)[source]

Bases: pymor.operators.basic.OperatorBase

Nonlinear finite volume advection Operator.

The operator is of the form

L(u, mu)(x) = ∇ ⋅ f(u(x), mu)

Parameters

grid
Grid for which to evaluate the operator.
boundary_info
BoundaryInfo determining the Dirichlet and Neumann boundaries.
numerical_flux
The NumericalConvectiveFlux to use.
dirichlet_data
Function providing the Dirichlet boundary values. If None, constant-zero boundary is assumed.
name
The name of the operator.
apply(U, ind=None, mu=None)[source]

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter 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 for which to compute the Jacobian.

Returns

Linear Operator representing the Jacobian.

restricted(dofs)[source]

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

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

self.apply(U, mu).components(dofs)
    == restricted_op.apply(NumpyVectorArray(U.components(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 few source_dofs will be needed to evaluate the restricted operator which can make its evaluation very fast compared to evaluating the original operator.

Parameters

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

Returns

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

Returns a copy with changed attributes.

The default implementation is to create a new class instance with the given keyword arguments as arguments for __init__. Missing arguments are obtained form instance attributes with the same name.

Parameters

**kwargs
Names of attributes to change with their new values. Each attribute name has to be contained in with_arguments.

Returns

Copy of self with changed attributes.


class pymor.operators.fv.NumericalConvectiveFluxInterface[source]

Bases: pymor.core.interfaces.ImmutableInterface, pymor.parameters.base.Parametric

Interface for numerical convective fluxes for finite volume schemes.

Numerical fluxes defined by this interfaces are functions of the form F(U_inner, U_outer, unit_outer_normal, edge_volume, mu).

The flux evaluation is vectorized and happens in two stages:
  1. evaluate_stage1 receives a NumPy array U of all values which appear as U_inner or U_outer for all edges the flux shall be evaluated at and returns a tuple of NumPy arrays each of the same length as U.

  2. evaluate_stage2 receives the reordered stage1_data for each edge as well as the unit outer normal and the volume of the edges.

    stage1_data is given as follows: If R_l is l-th entry of the tuple returned by evaluate_stage1, the l-th entry D_l of of the stage1_data tuple has the shape (num_edges, 2) + R_l.shape[1:]. If for edge k the values U_inner and U_outer are the i-th and j-th value in the U array provided to evaluate_stage1, we have

    D_l[k, 0] == R_l[i],    D_l[k, 1] == R_l[j].
    

    evaluate_stage2 returns a NumPy array of the flux evaluations for each edge.


class pymor.operators.fv.SimplifiedEngquistOsherFlux(flux, flux_derivative)[source]

Bases: pymor.operators.fv.NumericalConvectiveFluxInterface

Engquist-Osher numerical flux. Simplified Implementation for special case.

For the definition of the Engquist-Osher flux see EngquistOsherFlux. This class provides a faster and more accurate implementation for the special case that f(0) == 0 and the derivative of f only changes sign at 0.

Parameters

flux
Function defining the analytical flux f.
flux_derivative
Function defining the analytical flux derivative f'.

pymor.operators.fv.jacobian_options(delta=1e-07)[source]

pymor.operators.fv.nonlinear_advection_engquist_osher_operator(grid, boundary_info, flux, flux_derivative, gausspoints=5, intervals=1, dirichlet_data=None, solver_options=None, name=None)[source]

Instantiate a NonlinearAdvectionOperator using EngquistOsherFlux.


pymor.operators.fv.nonlinear_advection_lax_friedrichs_operator(grid, boundary_info, flux, lxf_lambda=1.0, dirichlet_data=None, solver_options=None, name=None)[source]

Instantiate a NonlinearAdvectionOperator using LaxFriedrichsFlux.


pymor.operators.fv.nonlinear_advection_simplified_engquist_osher_operator(grid, boundary_info, flux, flux_derivative, dirichlet_data=None, solver_options=None, name=None)[source]

Instantiate a NonlinearAdvectionOperator using SimplifiedEngquistOsherFlux.

interfaces module


class pymor.operators.interfaces.OperatorInterface[source]

Bases: pymor.core.interfaces.ImmutableInterface, pymor.parameters.base.Parametric

Interface for Parameter dependent discrete operators.

An operator in pyMOR is simply a mapping which for any given Parameter maps vectors from its source VectorSpace to vectors in its range VectorSpace.

Note that there is no special distinction between functionals and operators in pyMOR. A functional is simply an operator with NumpyVectorSpace (1) as its range VectorSpace.

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 is None or a dict entry is missing or None, default options are used. The interpretation of the given solver options is up to the operator at hand. In general, values in solver_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.

__add__(other)[source]

Sum of two operators.

__mul__(other)[source]

Product of operator by a scalar.

__radd__(other)[source]

Sum of two operators.

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

Apply the operator to a VectorArray.

Parameters

U
VectorArray of vectors to which the operator is applied.
ind
The indices of the vectors in U to which the operator shall be applied (see the VectorArray documentation for further details).
mu
The Parameter for which to evaluate the operator.

Returns

VectorArray of the operator evaluations.

apply2(V, U, U_ind=None, V_ind=None, mu=None, product=None)[source]

Treat the operator as a 2-form by calculating (V, op(U)).

In general op.apply2(V, U) is equivalent to:

product.apply2(V, op.apply(U)).

In case no product has been specified, op.apply2(V, U