The Incomplete Cholesky (IC) preconditioner solves the equation for a given lower triangular matrix L and the right hand side b (can contain multiple right hand sides). More...

#include <ginkgo/core/preconditioner/ic.hpp>

Inheritance diagram for gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >:

[legend]

Collaboration diagram for gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >:

[legend]

Classes
struct	parameters_type
class	Factory

Public Types
using	l_solver_type
using	value_type = gko::detail::get_value_type<LSolverTypeOrValueType>
using	lh_solver_type = gko::detail::transposed_type<l_solver_type>
using	index_type = IndexType
using	transposed_type = Ic<LSolverTypeOrValueType, IndexType>
Public Types inherited from gko::EnablePolymorphicAssignment< Ic< solver::LowerTrs<>, int32 > >
using	result_type

Public Member Functions
const parameters_type &	get_parameters () const
std::shared_ptr< const l_solver_type >	get_l_solver () const
	Returns the solver which is used for the provided L matrix.
std::shared_ptr< const lh_solver_type >	get_lh_solver () const
	Returns the solver which is used for the L^H matrix.
std::unique_ptr< LinOp >	transpose () const override
	Returns a LinOp representing the transpose of the Transposable object.
std::unique_ptr< LinOp >	conj_transpose () const override
	Returns a LinOp representing the conjugate transpose of the Transposable object.
Ic &	operator= (const Ic &other)
	Copy-assigns an IC preconditioner.
Ic &	operator= (Ic &&other)
	Move-assigns an IC preconditioner.
	Ic (const Ic &other)
	Copy-constructs an IC preconditioner.
	Ic (Ic &&other)
	Move-constructs an IC preconditioner.
Public Member Functions inherited from gko::EnableLinOp< Ic< solver::LowerTrs<>, int32 > >
const Ic< solver::LowerTrs<>, int32 > *	apply (ptr_param< const LinOp > b, ptr_param< LinOp > x) const
Public Member Functions inherited from gko::EnablePolymorphicAssignment< Ic< solver::LowerTrs<>, int32 > >
void	convert_to (result_type *result) const override
void	move_to (result_type *result) override

Static Public Member Functions
static auto	build () -> decltype(Factory::create())
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.

Friends
class	EnableLinOp< Ic >
class	EnablePolymorphicObject< Ic, LinOp >

Detailed Description

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>
class gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >

The Incomplete Cholesky (IC) preconditioner solves the equation for a given lower triangular matrix L and the right hand side b (can contain multiple right hand sides).

It allows to set both the solver for L defaulting to solver::LowerTrs, which is a direct triangular solvers. The solver for L^H is the conjugate-transposed solver for L, ensuring that the preconditioner is symmetric and positive-definite. For this L solver, a factory can be provided (using with_l_solver) to have more control over their behavior. In particular, it is possible to use an iterative method for solving the triangular systems. The default parameters for an iterative triangluar solver are:

reduction factor = 1e-4
max iteration = <number of rows of the matrix given to the solver> Solvers without such criteria can also be used, in which case none are set.

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 L^H matrix, which helps to avoid the otherwise necessary transposition of L inside the solver. ParIc 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 ( ), and the second matrix must be its conjugate-transpose ( ). If they are swapped, solving might crash or return the wrong result.; Do not use symmetric solvers (like CG) for the L solver since both matrices (L and L^H) are, by design, not symmetric.; 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.; The default template during parse is <ValueType, IndexType> not <LowerTrs, IndexType>. Only the variants with ValueType are supported in parse.

Template Parameters

LSolverTypeOrValueType	type of the solver or the value type used for the L matrix. Defaults to solver::LowerTrs
IndexType	type of the indices when ParIc is used to generate the L and L^H factors. Irrelevant otherwise.

Member Typedef Documentation

◆ l_solver_type

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

using gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::l_solver_type

Initial value:

 
        std::conditional_t<gko::detail::is_ginkgo_linop<LSolverTypeOrValueType>,
                           LSolverTypeOrValueType, LinOp>

Constructor & Destructor Documentation

◆ Ic() [1/2]

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::Ic ( const Ic< LSolverTypeOrValueType, IndexType > & other )

inline

Copy-constructs an IC preconditioner.

Inherits the executor, shallow-copies the solvers and parameters.

◆ Ic() [2/2]

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::Ic ( Ic< LSolverTypeOrValueType, IndexType > && other )

inline

Move-constructs an IC preconditioner.

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

Member Function Documentation

◆ conj_transpose()

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

std::unique_ptr< LinOp > gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::conj_transpose ( ) const

inlineoverridevirtual

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

Returns: a pointer to the new conjugate transposed object

Implements gko::Transposable.

Referenced by conj_transpose().

◆ get_l_solver()

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

std::shared_ptr< const l_solver_type > gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::get_l_solver ( ) const

inline

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

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

Referenced by conj_transpose(), and transpose().

◆ get_lh_solver()

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

std::shared_ptr< const lh_solver_type > gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::get_lh_solver ( ) const

inline

Returns the solver which is used for the L^H matrix.

Returns: the solver which is used for the L^H matrix

Referenced by conj_transpose(), and transpose().

◆ operator=() [1/2]

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

Ic & gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::operator= ( const Ic< LSolverTypeOrValueType, IndexType > & other )

inline

Copy-assigns an IC preconditioner.

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

◆ operator=() [2/2]

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

Ic & gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::operator= ( Ic< LSolverTypeOrValueType, IndexType > && other )

inline

Move-assigns an IC 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)

◆ parse()

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

parameters_type gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::parse	(	const config::pnode &	config,
		const config::registry &	context,
		const config::type_descriptor &	td_for_child = config::make_type_descriptor<value_type, index_type>() )

inlinestatic

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.

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. When l_solver_type uses LinOp not concrete type, it will use the default_precision in ginkgo.

Returns: parameters

Note: only support the following when using <ValueType, IndexType> not <LSolverType, IndexType> variants

◆ transpose()

template<typename LSolverTypeOrValueType = solver::LowerTrs<>, typename IndexType = int32>

std::unique_ptr< LinOp > gko::preconditioner::Ic< LSolverTypeOrValueType, IndexType >::transpose ( ) const

inlineoverridevirtual

Returns a LinOp representing the transpose of the Transposable object.

Returns: a pointer to the new transposed object

Implements gko::Transposable.

Referenced by transpose().

The documentation for this class was generated from the following file:

ginkgo/core/preconditioner/ic.hpp

Classes

Public Types

Public Member Functions

Static Public Member Functions

Friends

Detailed Description

Member Typedef Documentation

◆ l_solver_type

Constructor & Destructor Documentation

◆ Ic() [1/2]

◆ Ic() [2/2]

Member Function Documentation

◆ conj_transpose()

◆ get_l_solver()

◆ get_lh_solver()

◆ operator=() [1/2]

◆ operator=() [2/2]

◆ parse()

◆ transpose()