pymor.operators.block

Module Contents

class pymor.operators.block.BlockColumnOperator(blocks, name=None)

Bases: BlockOperatorBase

A column vector of arbitrary Operators.

blocked_range = True

blocked_source = False

class pymor.operators.block.BlockDiagonalOperator(blocks, name=None)

Bases: BlockOperator

Block diagonal Operator of arbitrary Operators.

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

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.

apply(U, mu=None)

Apply the operator to a VectorArray.

Parameters:

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

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

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)

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)

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)

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)

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.block.BlockEmbeddingOperator(block_space, component, name=None)

Bases: BlockColumnOperator

A column vector of arbitrary Operators.

class pymor.operators.block.BlockOperator(blocks, name=None)

Bases: BlockOperatorBase

A matrix of arbitrary Operators.

This operator can be applied to a compatible BlockVectorArrays.

Parameters:

blocks – Two-dimensional array-like where each entry is an Operator or None.

blocked_range = True

blocked_source = True

class pymor.operators.block.BlockOperatorBase(blocks, name=None)

Bases: pymor.operators.interface.Operator

Base block Operator.

Methods

apply	Apply the operator to a VectorArray.
apply_adjoint	Apply the adjoint operator.
as_range_array	Return a VectorArray representation of the operator in its range space.
as_source_array	Return a VectorArray representation of the operator in its source space.
assemble	Assemble the operator for given parameter values.
d_mu	Return the operator's derivative with respect to a given parameter.
jacobian	Return the operator's Jacobian as a new Operator.

apply(U, mu=None)

Apply the operator to a VectorArray.

Parameters:

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

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

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)

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)

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)

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)

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)

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)

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.block.BlockProjectionOperator(block_space, component, name=None)

Bases: BlockRowOperator

A row vector of arbitrary Operators.

class pymor.operators.block.BlockRowOperator(blocks, name=None)

Bases: BlockOperatorBase

A row vector of arbitrary Operators.

blocked_range = False

blocked_source = True

class pymor.operators.block.SecondOrderModelOperator(alpha, beta, A, B, name=None)

Bases: BlockOperator

BlockOperator appearing in SecondOrderModel.to_lti().

This represents a block operator

\[\begin{split}\mathcal{A} = \begin{bmatrix} \alpha I & \beta I \\ B & A \end{bmatrix},\end{split}\]

which satisfies

\[\begin{split}\mathcal{A}^H &= \begin{bmatrix} \overline{\alpha} I & B^H \\ \overline{\beta} I & A^H \end{bmatrix}, \\ \mathcal{A}^{-1} &= \begin{bmatrix} (\alpha A - \beta B)^{-1} A & -\beta (\alpha A - \beta B)^{-1} \\ -(\alpha A - \beta B)^{-1} B & \alpha (\alpha A - \beta B)^{-1} \end{bmatrix}, \\ \mathcal{A}^{-H} &= \begin{bmatrix} A^H (\alpha A - \beta B)^{-H} & -B^H (\alpha A - \beta B)^{-H} \\ -\overline{\beta} (\alpha A - \beta B)^{-H} & \overline{\alpha} (\alpha A - \beta B)^{-H} \end{bmatrix}.\end{split}\]

Parameters:

• alpha – Scalar.

• beta – Scalar.

• A – Operator.

• B – 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.

apply(U, mu=None)

Apply the operator to a VectorArray.

Parameters:

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

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

Returns:

|VectorArray| of the operator evaluations.

apply_adjoint(V, mu=None)

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)

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)

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)

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