pymor.operators.constructions

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

Module Contents

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

Bases: pymor.operators.interface.Operator

Represents the adjoint of a given linear Operator.

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

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

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

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

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

Parameters:

  • operator – The Operator of which the adjoint is formed.

  • source_product – If not None, inner product Operator for the source VectorSpace w.r.t. which to take the adjoint.

  • range_product – If not None, inner product Operator for the range VectorSpace w.r.t. which to take the adjoint.

  • name – If not None, name of the operator.

  • with_apply_inverse – If True, provide own apply_inverse and apply_inverse_adjoint implementations by calling these methods on the given operator. (Is set to False in the default implementation of and apply_inverse_adjoint.)

  • solver_options – When with_apply_inverse is False, the solver_options to use for the apply_inverse default implementation.

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.
linear = True[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Bases: ProxyOperator

Decompose an affine Operator into affine_shift and linear_part.

Methods

jacobian

Return the operator's Jacobian as a new Operator.
jacobian(U, mu=None)[source]

Return the operator’s Jacobian as a new Operator.

Parameters:

  • U – Length 1 VectorArray containing the vector for which to compute the Jacobian.

  • mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

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

Bases: pymor.operators.interface.Operator

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

Parameters:

  • components – List or 1D NumPy array of the indices of the vector dofs that are to be extracted by the operator.

  • source – Source VectorSpace of the operator.

  • name – Name of the operator.

Methods

apply

Apply the operator to a VectorArray.

restricted

Restrict the operator range to a given set of degrees of freedom.
linear = True[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

restricted(dofs)[source]

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

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

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

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

Parameters:

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

Returns:

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

Bases: pymor.operators.interface.Operator

Operator representing the concatenation of two Operators.

Parameters:

  • operators – Tuple of Operators to concatenate. operators[-1] is the first applied operator, operators[0] is the last applied operator.

  • solver_options – The solver_options for the operator.

  • name – Name of the operator.

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

d_mu

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

jacobian

Return the operator's Jacobian as a new Operator.

restricted

Restrict the operator range to a given set of degrees of freedom.
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

d_mu(parameter, index=0)[source]

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

Parameters:

  • parameter – The parameter w.r.t. which to return the derivative.

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

Returns:

New |Operator| representing the partial derivative.

jacobian(U, mu=None)[source]

Return the operator’s Jacobian as a new Operator.

Parameters:

  • U – Length 1 VectorArray containing the vector for which to compute the Jacobian.

  • mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

restricted(dofs)[source]

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

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

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

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

Parameters:

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

Returns:

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

Bases: pymor.operators.interface.Operator

A constant Operator always returning the same vector.

Parameters:

  • value – A VectorArray of length 1 containing the vector which is returned by the operator.

  • source – Source VectorSpace of the operator.

  • name – Name of the operator.

Methods

apply

Apply the operator to a VectorArray.

apply_inverse

Apply the inverse operator.

jacobian

Return the operator's Jacobian as a new Operator.

restricted

Restrict the operator range to a given set of degrees of freedom.
linear = False[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

jacobian(U, mu=None)[source]

Return the operator’s Jacobian as a new Operator.

Parameters:

  • U – Length 1 VectorArray containing the vector for which to compute the Jacobian.

  • mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

restricted(dofs)[source]

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

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

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

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

Parameters:

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

Returns:

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

Bases: ProxyOperator

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

Parameters:

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.

jacobian

Return the operator's Jacobian as a new Operator.
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

jacobian(U, mu=None)[source]

Return the operator’s Jacobian as a new Operator.

Parameters:

  • U – Length 1 VectorArray containing the vector for which to compute the Jacobian.

  • mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

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

Bases: pymor.operators.interface.Operator

The identity Operator.

In other words:

op.apply(U) == U
Parameters:

  • space – The VectorSpace the operator acts on.

  • name – Name of the operator.

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.

assemble

Assemble the operator for given parameter values.

restricted

Restrict the operator range to a given set of degrees of freedom.
linear = True[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

assemble(mu=None)[source]

Assemble the operator for given parameter values.

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

Parameters:

mu – The parameter values for which to assemble the operator.

Returns:

Parameter-independent, assembled |Operator|.

restricted(dofs)[source]

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

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

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

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

Parameters:

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

Returns:

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

Bases: pymor.parameters.base.ParametricObject

Instantiated by induced_norm. Do not use directly.

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

Bases: pymor.operators.interface.Operator

Represents the inverse adjoint of a given Operator.

Parameters:

  • operator – The Operator of which the inverse adjoint is formed.

  • name – If not None, name of the operator.

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.
linear = True[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Bases: pymor.operators.interface.Operator

Represents the inverse of a given Operator.

Parameters:

  • operator – The Operator of which the inverse is formed.

  • name – If not None, name of the operator.

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Bases: pymor.operators.interface.Operator

Linear combination of arbitrary Operators.

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

Parameters:

  • operators – List of Operators whose linear combination is formed.

  • coefficients – A list of linear coefficients. A linear coefficient can either be a fixed number or a ParameterFunctional.

  • solver_options – The solver_options for the operator.

  • name – Name of the operator.

Methods

apply

Apply the operator to a VectorArray.

apply2

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

apply_adjoint

Apply the adjoint operator.

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.

as_range_array

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

as_source_array

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

assemble

Assemble the operator for given parameter values.

d_mu

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

evaluate_coefficients

Compute the linear coefficients for given parameter values.

jacobian

Return the operator's Jacobian as a new Operator.

pairwise_apply2

Treat the operator as a 2-form and apply it to V and U in pairs.
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

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

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

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

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

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

Parameters:
Returns:

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

  • evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

as_range_array(mu=None)[source]

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

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

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

for all VectorArrays U.

Parameters:

mu – The parameter values for which to return the VectorArray representation.

Returns:

V – The VectorArray defined above.

as_source_array(mu=None)[source]

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

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

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

for all VectorArrays U.

Parameters:

mu – The parameter values for which to return the VectorArray representation.

Returns:

V – The VectorArray defined above.

assemble(mu=None)[source]

Assemble the operator for given parameter values.

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

Parameters:

mu – The parameter values for which to assemble the operator.

Returns:

Parameter-independent, assembled |Operator|.

d_mu(parameter, index=0)[source]

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

Parameters:

  • parameter – The parameter w.r.t. which to return the derivative.

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

Returns:

New |Operator| representing the partial derivative.

evaluate_coefficients(mu)[source]

Compute the linear coefficients for given parameter values.

Parameters:

mu – Parameter values for which to compute the linear coefficients.

Returns:

List of linear coefficients.

jacobian(U, mu=None)[source]

Return the operator’s Jacobian as a new Operator.

Parameters:

  • U – Length 1 VectorArray containing the vector for which to compute the Jacobian.

  • mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

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

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

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

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

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

Parameters:
Returns:

  • A NumPy array with shape (len(V),) == (len(U),) containing

  • the 2-form evaluations.

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

Bases: pymor.operators.interface.Operator

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

Parameters:

B – The input Operator.

Methods

apply

Apply the operator to a VectorArray.

as_range_array

Return a VectorArray representation of the operator in its range space.
linear = True[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

as_range_array(mu=None)[source]

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

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

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

for all VectorArrays U.

Parameters:

mu – The parameter values for which to return the VectorArray representation.

Returns:

V – The VectorArray defined above.

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

Bases: ProxyOperator

Mark the wrapped Operator to be linear.

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

Bases: pymor.operators.interface.Operator

Non-parametric low-rank operator.

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

Parameters:

  • left – VectorArray representing \(L\).

  • core – NumPy array representing \(C\).

  • right – VectorArray representing \(R\).

  • inverted – Whether \(C\) is inverted.

  • solver_options – The solver_options for the operator.

  • name – Name of the operator.

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.
linear = True[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Bases: LincombOperator

Operator plus LowRankOperator.

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

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

Methods

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.
apply_inverse(V, mu=None, initial_guess=None, least_squares=False)[source]

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Bases: pymor.operators.interface.Operator

Converts VectorArrays to NumpyVectorArrays.

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

Parameters:

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.
linear = True[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Bases: pymor.operators.interface.Operator

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

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

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

Parameters:

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

assemble

Assemble the operator for given parameter values.

jacobian

Return the operator's Jacobian as a new Operator.
linear = False[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

assemble(mu=None)[source]

Assemble the operator for given parameter values.

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

Parameters:

mu – The parameter values for which to assemble the operator.

Returns:

Parameter-independent, assembled |Operator|.

jacobian(U, mu=None)[source]

Return the operator’s Jacobian as a new Operator.

Parameters:

  • U – Length 1 VectorArray containing the vector for which to compute the Jacobian.

  • mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

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

Bases: pymor.operators.interface.Operator

Forwards all interface calls to given Operator.

Mainly useful as base class for other Operator implementations.

Parameters:

  • operator – The Operator to wrap.

  • name – Name of the wrapping operator.

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.

jacobian

Return the operator's Jacobian as a new Operator.

restricted

Restrict the operator range to a given set of degrees of freedom.
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

jacobian(U, mu=None)[source]

Return the operator’s Jacobian as a new Operator.

Parameters:

  • U – Length 1 VectorArray containing the vector for which to compute the Jacobian.

  • mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

restricted(dofs)[source]

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

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

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

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

Parameters:

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

Returns:

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

Bases: pymor.operators.interface.Operator

An Operator representing a quadratic functional.

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

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

operator – The Operator defining the quadratic functional.

Methods

apply

Apply the operator to a VectorArray.

d_mu

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

jacobian

Return the operator's Jacobian as a new Operator.
linear = False[source]
range[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

d_mu(parameter, index=1)[source]

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

Parameters:

  • parameter – The parameter w.r.t. which to return the derivative.

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

Returns:

New |Operator| representing the partial derivative.

jacobian(U, mu=None)[source]

Return the operator’s Jacobian as a new Operator.

Parameters:

  • U – Length 1 VectorArray containing the vector for which to compute the Jacobian.

  • mu – The parameter values for which to compute the Jacobian.

Returns:

Linear |Operator| representing the Jacobian.

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

Bases: QuadraticFunctional

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

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

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

  • left – The Operator that defines the left operator of the quadratic functional.

  • right – The Operator that defines the right operator of the quadratic functional.

  • product – The Operator that defines the inner product.

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

Bases: pymor.operators.interface.Operator

An Operator selected from a list of Operators.

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

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

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

as_range_array

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

as_source_array

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

assemble

Assemble the operator for given parameter values.
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

as_range_array(mu=None)[source]

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

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

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

for all VectorArrays U.

Parameters:

mu – The parameter values for which to return the VectorArray representation.

Returns:

V – The VectorArray defined above.

as_source_array(mu=None)[source]

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

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

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

for all VectorArrays U.

Parameters:

mu – The parameter values for which to return the VectorArray representation.

Returns:

V – The VectorArray defined above.

assemble(mu=None)[source]

Assemble the operator for given parameter values.

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

Parameters:

mu – The parameter values for which to assemble the operator.

Returns:

Parameter-independent, assembled |Operator|.

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

Bases: pymor.operators.interface.Operator

Wraps a VectorArray as an Operator.

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

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

Parameters:

  • array – The VectorArray which is to be treated as an operator.

  • adjoint – See description above.

  • name – The name of the operator.

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.

as_range_array

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

as_source_array

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

restricted

Restrict the operator range to a given set of degrees of freedom.
linear = True[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

as_range_array(mu=None)[source]

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

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

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

for all VectorArrays U.

Parameters:

mu – The parameter values for which to return the VectorArray representation.

Returns:

V – The VectorArray defined above.

as_source_array(mu=None)[source]

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

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

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

for all VectorArrays U.

Parameters:

mu – The parameter values for which to return the VectorArray representation.

Returns:

V – The VectorArray defined above.

restricted(dofs)[source]

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

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

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

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

Parameters:

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

Returns:

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

Bases: VectorArrayOperator

Wrap a vector as a linear Functional.

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

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

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

In particular, if product is None

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

If product is not none, we obtain

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

  • vector – VectorArray of length 1 containing the vector v.

  • product – Operator representing the scalar product to use.

  • name – Name of the operator.

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

Bases: VectorArrayOperator

Wrap a vector as a vector-like Operator.

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

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

In particular:

VectorOperator(vector).as_range_array() == vector
Parameters:

  • vector – VectorArray of length 1 containing the vector v.

  • name – Name of the operator.

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

Bases: pymor.operators.interface.Operator

The Operator which maps every vector to zero.

Parameters:

  • range – Range VectorSpace of the operator.

  • source – Source VectorSpace of the operator.

  • name – Name of the operator.

Methods

apply

Apply the operator to a VectorArray.

apply_adjoint

Apply the adjoint operator.

apply_inverse

Apply the inverse operator.

apply_inverse_adjoint

Apply the inverse adjoint operator.

restricted

Restrict the operator range to a given set of degrees of freedom.
linear = True[source]
apply(U, mu=None)[source]

Apply the operator to a VectorArray.

Parameters:
Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)[source]

Apply the adjoint operator.

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

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

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

Parameters:

  • V – VectorArray of vectors to which the adjoint operator is applied.

  • mu – The parameter values for which to apply the adjoint operator.

Returns:

|VectorArray| of the adjoint operator evaluations.

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

Apply the inverse operator.

Parameters:

  • V – VectorArray of vectors to which the inverse operator is applied.

  • mu – The parameter values for which to evaluate the inverse operator.

  • initial_guess – VectorArray with the same length as V containing initial guesses for the solution. Some implementations of apply_inverse may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    u = argmin ||op(u) - v||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse operator evaluations.

Raises:

InversionError – The operator could not be inverted.

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

Apply the inverse adjoint operator.

Parameters:

  • U – VectorArray of vectors to which the inverse adjoint operator is applied.

  • mu – The parameter values for which to evaluate the inverse adjoint operator.

  • initial_guess – VectorArray with the same length as U containing initial guesses for the solution. Some implementations of apply_inverse_adjoint may ignore this parameter. If None a solver-dependent default is used.

  • least_squares –

    If True, solve the least squares problem:

    v = argmin ||op^*(v) - u||_2.

    Since for an invertible operator the least squares solution agrees with the result of the application of the inverse operator, setting this option should, in general, have no effect on the result for those operators. However, note that when no appropriate solver_options are set for the operator, most operator implementations will choose a least squares solver by default which may be undesirable.

Returns:

|VectorArray| of the inverse adjoint operator evaluations.

Raises:

InversionError – The operator could not be inverted.

restricted(dofs)[source]

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

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

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

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

Parameters:

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

Returns:

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

Obtain induced norm of an inner product.

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

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

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

Parameters:

  • product – The inner product Operator for which the norm is to be calculated.

  • raise_negative – If True, raise an exception if calculated norm is negative.

  • tol – See above.

  • name – optional, if None product’s name is used

Returns:

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