`pymor.operators.interface`¶

Module Contents¶

class pymor.operators.interface.Operator[source]¶

Bases: pymor.parameters.base.ParametricObject

Interface for Parameter dependent discrete operators.

An operator in pyMOR is simply a mapping which for any given parameter values maps vectors from 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[source]¶

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[source]¶: True if the operator is linear.

source[source]¶: The source VectorSpace.

range[source]¶: The range VectorSpace.

H[source]¶

The adjoint operator, i.e.

self.H.apply(V, mu) == self.apply_adjoint(V, mu)

for all V, mu.

Methods

`_assemble_lincomb`	Try to assemble a linear combination of the given operators.
`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.
`as_vector`	Return a vector representation of a linear functional or vector operator.
`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`.
`pairwise_apply2`	Treat the operator as a 2-form and apply it to V and U in pairs.
`restricted`	Restrict the operator range to a given set of degrees of freedom.

_assemble_lincomb(operators, coefficients, identity_shift=0.0, solver_options=None, name=None)[source]¶

Try to assemble a linear combination of the given operators.

Returns a new Operator which represents the sum

c_1*O_1 + ... + c_N*O_N + s*I

where O_i are Operators, c_i, s scalar coefficients and I the identity.

This method is called in the assemble method of LincombOperator on the first of its operators. If an assembly of the given linear combination is possible, e.g. the linear combination of the system matrices of the operators can be formed, then the assembled operator is returned. Otherwise, the method returns None to indicate that assembly is not possible.

Parameters:

operators – List of Operators O_i whose linear combination is formed.
coefficients – List of the corresponding linear coefficients c_i.
identity_shift – The coefficient s.
solver_options – solver_options for the assembled operator.
name – Name of the assembled operator.

Returns:

The assembled Operator if assembly is possible, otherwise None.

abstract apply(U, mu=None)[source]¶

Apply the operator to a VectorArray.

Parameters:

U – VectorArray of vectors to which the operator is applied.
mu – The parameter values for which to evaluate the operator.

Returns:

|VectorArray| of the operator evaluations.

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

Treat the operator as a 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:

V – VectorArray of the left arguments V.
U – VectorArray of the right arguments U.
mu – The parameter values for which to evaluate the operator.

Returns:

A NumPy array with shape (len(V), len(U)) containing the 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.

as_vector(mu=None)[source]¶

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

Depending on the operator’s source and range, this method is equivalent to calling as_range_array or as_source_array respectively. The resulting VectorArray is required to have length 1.

Parameters:: mu – The parameter values for which to return the vector representation.
Returns:: V – VectorArray of length 1 containing the vector representation.

assemble(mu=None)[source]¶

Assemble the operator for given parameter values.

The result of the method strongly depends on the given operator. For instance, a 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.

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:

V – VectorArray of the left arguments V.
U – VectorArray of the right arguments U.
mu – The parameter values for which to evaluate the operator.

Returns:

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

abstract 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:

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.interface.as_array_max_length(value=100)[source]¶

pymor.operators.interface¶

Module Contents¶

`pymor.operators.interface`¶