gko::preconditioner::Ilu#

Incomplete LU preconditioner. Given incomplete factors \(L\) and \(U\) (computed externally or via gko::factorization::Ilu / gko::factorization::ParIlu), apply(b, x) solves \(LU x = b\) by chaining a lower-triangular solve with an upper-triangular solve. The solvers for \(L\) and \(U\) are configurable, so either direct substitution or an inner iterative solve can be used.

template<typename ValueType = default_precision, bool ReverseApply = false, typename IndexType = int32>
class Ilu #

Inherits from

The Incomplete LU (ILU) preconditioner solves the equation \(LUx = b\) for a given lower triangular matrix L, an upper triangular matrix U and the right hand side b (can contain multiple right hand sides).

It allows to set both the solver for L and the solver for U independently, while providing the defaults solver::LowerTrs and solver::UpperTrs, which are direct triangular solvers. For these solvers, a factory can be provided (with with_l_solver and with_u_solver) to have more control over their behavior. In particular, it is possible to use an iterative method for solving the triangular systems.

An object of this class can be created with a matrix or a gko::Composition containing two matrices. If created with a matrix, it is factorized before creating the solver. If a gko::Composition (containing two matrices) is used, the first operand will be taken as the L matrix, the second will be considered the U matrix. ParIlu can be directly used, since it orders the factors in the correct way.

Note

When providing a gko::Composition, the first matrix must be the lower matrix ( \(L\)), and the second matrix must be the upper matrix ( \(U\)). If they are swapped, solving might crash or return the wrong result.

Note

Do not use symmetric solvers (like CG) for L or U solvers since both matrices (L and U) are, by design, not symmetric.

Note

This class is not thread safe (even a const object is not) because it uses an internal cache to accelerate multiple (sequential) applies. Using it in parallel can lead to segmentation faults, wrong results and other unwanted behavior.

Note

The default template during parse is <ValueType, IndexType> not <LowerTrs, IndexType>. Only the variants with ValueType are supported in parse.

Template Parameters:

  • ValueType – the value type used for the L and U matrices.

  • ReverseApply – default behavior (ReverseApply = false) is first to solve with L (Ly = b) and then with U (Ux = y). When set to true, it will solve first with U, and then with L.

  • IndexType – Type of the indices when ParIlu is used to generate both L and U factors. Irrelevant otherwise.

Public Functions

inline std::shared_ptr<const LinOp> get_l_solver() const#

Returns the solver which is used for the provided L matrix.

Returns:

the solver which is used for the provided L matrix

inline std::shared_ptr<const LinOp> get_u_solver() const#

Returns the solver which is used for the provided U matrix.

Returns:

the solver which is used for the provided U matrix

virtual std::unique_ptr<LinOp> transpose() const override#

Returns a LinOp representing the transpose of the Transposable object.

Returns:

a pointer to the new transposed object

virtual std::unique_ptr<LinOp> conj_transpose() const override#

Returns a LinOp representing the conjugate transpose of the Transposable object.

Returns:

a pointer to the new conjugate transposed object

Ilu &operator=(const Ilu &other)#

Copy-assigns an ILU preconditioner. Preserves the executor, shallow-copies the solvers and parameters. Creates a clone of the solvers if they are on the wrong executor.

Ilu &operator=(Ilu &&other)#

Move-assigns an ILU preconditioner. Preserves the executor, moves the solvers and parameters. Creates a clone of the solvers if they are on the wrong executor. The moved-from object is empty (0x0 with nullptr solvers and default parameters)

Ilu(const Ilu &other)#

Copy-constructs an ILU preconditioner. Inherits the executor, shallow-copies the solvers and parameters.

Ilu(Ilu &&other)#

Move-constructs an ILU preconditioner. Inherits the executor, moves the solvers and parameters. The moved-from object is empty (0x0 with nullptr solvers and default parameters)

Public Static Functions

static parameters_type parse(
const config::pnode &config,
const config::registry &context,
const config::type_descriptor &td_for_child = config::make_type_descriptor<value_type, index_type>(),
)#

Create the parameters from the property_tree. Because this is directly tied to the specific type, the value/index type settings within config are ignored and type_descriptor is only used for children configs.

Note

only support the following when using <ValueType, ValueType, ReverseApply, IndexType> not <LSolverType, USolverType, ReverseApply, IndexType> variants

Parameters:

  • config – the property tree for setting

  • context – the registry

  • td_for_child – the type descriptor for children configs. The default uses the value/index type of this class.

Returns:

parameters

struct parameters_type #

Inherits from

Public Functions

parameters_type &with_l_solver(
deferred_factory_parameter<const LinOpFactory> solver,
)#

When LSolverTypeOrValueType is a concrete solver type, this only accepts the factory from the same concrete solver type. When LSolverTypeOrValueType is a value type, it accepts any LinOpFactory.

inline parameters_type &with_u_solver(
deferred_factory_parameter<const LinOpFactory> solver,
)#

When USolverTypeOrValueType is a concrete solver type, this only accepts the factory from the same concrete solver type. When USolverTypeOrValueType is a value type, it accepts any LinOpFactory.

Public Members

std::shared_ptr<const LinOpFactory> l_solver_factory = {}#

Factory for the L solver

std::shared_ptr<const LinOpFactory> u_solver_factory = {}#

Factory for the U solver

std::shared_ptr<const LinOpFactory> factorization_factory = {}#

Factory for the factorization