API

Operators

lfa_lab.operator.from_periodic_stencil(stencils, grid)

Create an operator from a periodic stencil.

Parameters:stencils (NdArray) – An \(n\)-D array of stencils.
lfa_lab.operator.from_stencil(stencil, grid)

Create an operator from a stencil.

See also Defining Stencil Operators.

Parameters:
  • stencil – The stencil that should be transformed into an operator. This parameter has to be assigned to either a SparseStencil or a list of tuples, where each tuple consists of an offset and a value.
  • grid (Grid) – The grid where the operator is defined.
lfa_lab.operator.hp_filter(fine_grid, coarse_grid)

Create a high-pass filter.

Parameters:
  • fine_grid (Grid) – The grid corresponding to all frequencies.
  • coarse_grid (Grid) – The grid of the low modes.
lfa_lab.operator.identity(grid)

The identity operator.

Parameters:grid (Grid) – The grid where the operator is defined.
lfa_lab.operator.injection_interpolation(fine_grid, coarse_grid)

Create an injection interpolation operator.

Parameters:
  • fine_grid (Grid) – The codomain of the operator.
  • coarse_grid (Grid) – The domain of the operator.
lfa_lab.operator.injection_restriction(fine_grid, coarse_grid)

Create an injection restriction operator.

Parameters:
  • fine_grid (Grid) – The domain of the operator.
  • coarse_grid (Grid) – The codomain of the operator.
lfa_lab.operator.lp_filter(fine_grid, coarse_grid)

Create a low-pass filter.

Parameters:
  • fine_grid (Grid) – The grid corresponding to all frequencies.
  • coarse_grid (Grid) – The grid of the low modes.
lfa_lab.operator.zero(grid)

The zero operator.

Parameters:grid (Grid) – The grid where the operator is defined.
class lfa_lab.dag.Node

This node represents general operators whose symbols can be computed.

The addition, multiplication and power operators exist for this class.

This class should not be instanciated directly.

__add__(other)

The sum of self and other.

__mul__(other)

The composition of self and other.

__pow__(p)

Compute the power of an operator.

__rmul__(other)

Scalar multiplication of self and other.

__sub__(other)

The difference of self and other.

__weakref__

list of weak references to the object (if defined)

adjoint()

The adjoint of the operator.

Return type:Node
inverse()

The inverse of the operator.

Return type:Node
symbol(desired_resolution=None)

The symbol of the operator.

Return type:Symbol
class lfa_lab.dag.StencilNode(stencil, grid)

An Operator given by a stencil.

To construct a stencil node, use the lfa_lab.operator.from_stencil() method.

Parameters:
  • stencil (SparseStencil) – The stencil that should be turned into an operator.
  • grid (Grid) – The corresponding grid.
Variables:
  • stencil – The stencil of the operator.
  • grid – The grid of the operator.
diag()

A stencil operator that was constructed using the diagonal entries of the stencil of this operator.

lower()

A stencil operator that was constructed using the strictly lower triangular part of the stencil of this operator.

upper()

A stencil operator that was constructed using the strictly upper triangular part of the stencil of this operator.

Smoother

lfa_lab.smoother.jacobi(op, weight=1.0)

The Jacobi smoother.

Given by

\[I - \omega D^{-1} A \,.\]

where \(D\) is the diagonal part of \(A\).

Parameters:
  • op (StencilNode) – The original operator \(A\).
  • weight – The weight \(\omega\).
lfa_lab.smoother.gs_lex(op)

The Gauss-Seidel lexicographic smoother.

Given by

\[I - (D + L)^{-1} A\]

where \(D\) is the diagonal part and \(L\) the strictly lower triangular part of \(A\).

Parameters:op (StencilNode) – The original operator \(A\).
lfa_lab.smoother.rb_jacobi(stencil, weight=1.0)

The red-black Jacobi method.

Parameters:

This module contains methods for construction block smoothers.

lfa_lab.block_smoother.block_jacobi(op, block_size, weight=1.0)

Returns the operator of the block jacobi method.

Parameters:
  • op (StencilNode) – The original operator.
  • block_size (tuple) – A tuple containing the block size per dimension.
  • weight – The weight applied to the correction.
lfa_lab.block_smoother.rb_block_jacobi(op, block_size, weight=1.0)

The red-black block Jacobi method.

Parameters:
  • op (StencilNode) – The original operator.
  • block_size (tuple) – A tuple containing the block size per dimension.
  • weight – The weight applied to the correction.
Returns:

The error propagation operator of the method.

Return type:

Node

Multigrid

lfa_lab.two_grid.coarse_grid_correction(operator, coarse_operator, interpolation, restriction, coarse_error=None)

The error propagator of a coarse grid correction.

See Coarse Grid Correction.

Parameters:
  • operator (Node) – The operator of the linear system.
  • coarse_operator (Node) – The operator of the coarse linear system.
  • interpolation (Node) – The interpolation operator.
  • restriction (Node) – The restriction operator.
  • coarse_error (Node) – The coarse error propagation operation. This entry is optional. It can be specified when the coarse grid system is solved inexactly.
Returns:

The error propagator of the coarse grid correction.

Return type:

Node

lfa_lab.two_grid.galerkin_coarsening(operator, interpolation, restriction)

The error propagator of the Galerkin coarse grid approximation (GCA).

The GCA is defined as

\[L_c = R L P \,.\]
Parameters:
  • operator (Node) – The fine grid operator \(L\).
  • interpolation (Node) – The interpolation operator \(P\).
  • restriction (Node) – The restriction operator \(R\).
Returns:

The error propagation operator.

Return type:

Node

lfa_lab.two_grid.two_grid(pre_smoother, post_smoother, coarse_grid_correction)

The error propagator of a two-grid method.

Gallery

lfa_lab.gallery.fw_restriction(fine_grid, coarse_grid)

Return full weighting restriction operator.

Return type:Node
lfa_lab.gallery.ml_interpolation_stencil(fine_grid, coarse_grid)

Return the stencil of a multilinear interpolation.

Return type:SparseStencil
lfa_lab.gallery.ml_interpolation(fine_grid, coarse_grid)

Multilinear interpolation

Return type:Node
lfa_lab.gallery.fw_restriction_stencil(fine_grid, coarse_grid)

Return the stencil of a full weighting restriction.

Return type:SparseStencil
lfa_lab.gallery.poisson_2d(grid, eps=1.0)

The stencil of the discrete Poisson equation in 2D.

This operator is the discrete version of the operator \(L\) given by

\[L u = -\left( \epsilon \frac{\partial^2 u}{\partial x^2} + \frac{\partial^2 u}{\partial y^2} \right) \,.\]

Using finite differences leads to the discrete operator \(L_h\), which is computed by this function (see Poisson Equation).

Return type:StencilNode

Stencil

class lfa_lab.stencil.SparseStencil(entries=None)

Storage for a stencil.

A (constant) stencil is a map \(s: \mathbb{Z}^d \to \mathbb{C}\). We assume that only finitely many function values are non-zero. Therefore, we can represent the stencil by a list containing of pairs consisting of the function argument and the corresponding value.

Parameters:entries (list of (tuple of (tuple, double))) – The entries of the stencil. This argument is supposed to be a list of entries. Each entry is a tuple consisting of the offset (a tuple) and the corresponding scalar.
class lfa_lab.stencil.PeriodicStencil(entries)

Storage for a periodic stencil.

A periodic stencil is a family of stencils \(\{ s_\mathbf{x} \}_\mathbf{x \in \mathbb{Z}^d}\) such that \(s_\mathbf{x} = s_{\mathbf{x}'}\) for \((\mathbf{x} - \mathbf{x}') \in \mathbf{p} \mathbb{Z}^d\). We call \(\mathbf{p}\) the period of the stencil. We store a periodic stencil by storing the stencils for \(0 \le \mathbf{x} < \mathbf{p}\) in an instance of lfa_tool.util.NdArray.

Parameters:entries – The entries as an lfa_tool.util.NdArray or as a proper argument to the constructor of lfa_tool.util.NdArray.

Plotting

Plotting commands for Fourier symbols.

lfa_lab.plot.plot_2d(sym, **kwargs)

Plot the sampling of a symbol.

Parameters:
  • sym (Symbol) – The symbol that should be plotted.
  • norm_type (str) – The type of the norm. Possible values: ‘rows’, ‘output’, ‘columns’, and ‘input’.
  • style_2d (str) – The plotting style for 2D symbols. It can be set to ‘mesh’, ‘image’, or ‘contour’.
lfa_lab.plot.plot_1d(op, **kwargs)

Plot a 1d symbol.

Parameters:norm_type (str) – The type of the norm. Possible values: ‘rows’, ‘output’, ‘columns’, and ‘input’.
lfa_lab.plot.default_options

The default options that will be used when no option argument is provided to a plotting call.

Printing Reports

Produces a report for an operator

lfa_lab.report.print_report(E, title='')

Print a report about the operator E on the screen.

This opens a figure. You may have to call matplotlib.pyplot.show() to show it.

lfa_lab.report.save_report(E, file_name_prefix, title='', standalone=False)

Store a report about an operator as a LaTeX file.

Parameters:
  • file_name_prefix (str) – The file name without file extension.
  • title (str) – A short description of the operator.
  • standalone (bool) – Whether the TeX file contains the preamble or is suitable for embedding into another document.

Util

class lfa_lab.util.NdArray(entries=None, dim=None, bottom_p=None, shape=None)

An \(n\)-D array.

When constructing an NdArray either entires or shape must be given. When entries is given, either dim of bottom_p must be defined.

Here is a simple example for the usage of this class:

x = lfa_lab.util.NdArray([[1,2,3],[4,5,6]], dim=2)
print(x[1,2]) # prints 6
x[1,2] = 7
print(x)      # prints NdArray: [[1, 2, 3], [4, 5, 7]]
Parameters:
  • entries (list of (list of ... (list of object) ... )) – The entries of the n-D array as a nested list.
  • dim (int) – The dimension \(n\) of the array.
  • bottom_p (object -> bool) – A predicate to determine the dimension of the array.
  • shape (tuple) – The number of entries per dimension.
__getitem__(pos)

Return the element at position pos.

Parameters:pos (tuple) – The index of the entry.
lfa_lab.util.lex_less(a, b)

Lexicographical comparison.

Core Classes and Functions