Loading...
Searching...
No Matches
Preconditioners
Iterative Solvers Template Library (ISTL) » Iterative Solvers
Collaboration diagram for Preconditioners:

## Topics

| Parallel Algebraic Multigrid
| A Parallel Algebraic Multigrid based on Agglomeration.
| Fast (sequential) Algebraic Multigrid
| An Algebraic Multigrid based on Agglomeration that saves memory bandwidth.

## Files

file | overlappingschwarz.hh
| Contains one level overlapping Schwarz preconditioners.
file | preconditioners.hh
| Define general preconditioner interface.

## Namespaces

namespace | Dune::Amg

## Classes

class | Dune::NonoverlappingBlockPreconditioner< C, P >
| Nonoverlapping parallel preconditioner. More...
class | Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >
| Sequential overlapping Schwarz preconditioner. More...
class | Dune::OverlappingSchwarzInitializer< I, S, D >
| Initializer for SuperLU Matrices representing the subdomains. More...
struct | Dune::AdditiveSchwarzMode
| Tag that the tells the Schwarz method to be additive. More...
struct | Dune::MultiplicativeSchwarzMode
| Tag that tells the Schwarz method to be multiplicative. More...
struct | Dune::SymmetricMultiplicativeSchwarzMode
| Tag that tells the Schwarz method to be multiplicative and symmetric. More...
class | Dune::DynamicMatrixSubdomainSolver< M, X, Y >
| Exact subdomain solver using Dune::DynamicMatrix<T>::solve. More...
class | Dune::DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >
class | Dune::OverlappingAssignerHelper< T, tag >
class | Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >
struct | Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >
class | Dune::OverlappingAssignerILUBase< M, X, Y >
class | Dune::OverlappingAssignerHelper< ILU0SubdomainSolver< M, X, Y >, false >
class | Dune::OverlappingAssignerHelper< ILUNSubdomainSolver< M, X, Y >, false >
struct | Dune::AdditiveAdder< S, T >
struct | Dune::AdditiveAdder< S, BlockVector< T, A > >
struct | Dune::MultiplicativeAdder< S, T >
struct | Dune::MultiplicativeAdder< S, BlockVector< T, A > >
struct | Dune::AdderSelector< T, X, S >
| template meta program for choosing how to add the correction. More...
struct | Dune::AdderSelector< AdditiveSchwarzMode, X, S >
struct | Dune::AdderSelector< MultiplicativeSchwarzMode, X, S >
struct | Dune::AdderSelector< SymmetricMultiplicativeSchwarzMode, X, S >
struct | Dune::IteratorDirectionSelector< T1, T2, forward >
| Helper template meta program for application of overlapping Schwarz. More...
struct | Dune::IteratorDirectionSelector< T1, T2, false >
struct | Dune::SeqOverlappingSchwarzApplier< T >
| Helper template meta program for application of overlapping Schwarz. More...
struct | Dune::SeqOverlappingSchwarzApplier< SeqOverlappingSchwarz< M, X, SymmetricMultiplicativeSchwarzMode, TD, TA > >
struct | Dune::SeqOverlappingSchwarzAssemblerHelper< T, tag >
struct | Dune::SeqOverlappingSchwarzAssemblerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >
struct | Dune::SeqOverlappingSchwarzAssemblerHelper< S< BCRSMatrix< T, A > >, true >
struct | Dune::SeqOverlappingSchwarzAssemblerILUBase< M, X, Y >
struct | Dune::SeqOverlappingSchwarzAssemblerHelper< ILU0SubdomainSolver< M, X, Y >, false >
struct | Dune::SeqOverlappingSchwarzAssemblerHelper< ILUNSubdomainSolver< M, X, Y >, false >
struct | Dune::SeqOverlappingSchwarzDomainSize< M >
struct | Dune::SeqOverlappingSchwarzDomainSize< BCRSMatrix< T, A > >
class | Dune::Preconditioner< X, Y >
| Base class for matrix free definition of preconditioners. More...
class | Dune::InverseOperator2Preconditioner< O, c >
| Turns an InverseOperator into a Preconditioner. More...
class | Dune::SeqSSOR< M, X, Y, l >
| Sequential SSOR preconditioner. More...
class | Dune::SeqSOR< M, X, Y, l >
| Sequential SOR preconditioner. More...
class | Dune::SeqJac< M, X, Y, l >
| The sequential jacobian preconditioner. More...
class | Dune::SeqDILU< M, X, Y, l >
| Sequential DILU preconditioner. More...
class | Dune::SeqILU< M, X, Y, l >
| Sequential ILU preconditioner. More...
class | Dune::Richardson< X, Y >
| Richardson preconditioner. More...
class | Dune::SeqILDL< M, X, Y >
| sequential ILDL preconditioner More...
class | Dune::ParSSOR< M, X, Y, C >
| A parallel SSOR preconditioner. More...
class | Dune::BlockPreconditioner< X, Y, C, P >
| Block parallel preconditioner. More...

## Typedefs

template<typename T>
using | Dune::OverlappingAssigner = OverlappingAssignerHelper<T, Dune::StoresColumnCompressed<T>::value>
template<class T>
using | Dune::SeqOverlappingSchwarzAssembler = SeqOverlappingSchwarzAssemblerHelper<T,Dune::StoresColumnCompressed<T>::value>
template<class M, class X, class Y, int l = 1>
using | Dune::SeqGS = SeqSOR<M,X,Y,l>
| Sequential Gauss Seidel preconditioner.

## Functions

| Dune::DUNE_REGISTER_PRECONDITIONER ("ssor", defaultPreconditionerBlockLevelCreator< Dune::SeqSSOR >())
| Dune::DUNE_REGISTER_PRECONDITIONER ("sor", defaultPreconditionerBlockLevelCreator< Dune::SeqSOR >())
| Dune::DUNE_REGISTER_PRECONDITIONER ("gs", defaultPreconditionerBlockLevelCreator< Dune::SeqGS >())
| Dune::DUNE_REGISTER_PRECONDITIONER ("jac", defaultPreconditionerBlockLevelCreator< Dune::SeqJac >())
| Dune::DUNE_REGISTER_PRECONDITIONER ("dilu", defaultPreconditionerBlockLevelCreator< Dune::SeqDILU >())
| Dune::DUNE_REGISTER_PRECONDITIONER ("ilu", defaultPreconditionerBlockLevelCreator< Dune::SeqILU >())
| Dune::DUNE_REGISTER_PRECONDITIONER ("richardson", [](auto opTraits, const auto &, const ParameterTree &config){ using OpTraits=std::decay_t< decltype(opTraits)>;using D=typename OpTraits::domain_type;using R=typename OpTraits::range_type;return std::make_shared< Richardson< D, R > >(config);})
| Dune::DUNE_REGISTER_PRECONDITIONER ("ildl", defaultPreconditionerCreator< Dune::SeqILDL >())
| Dune::OverlappingSchwarzInitializer< I, S, D >::OverlappingSchwarzInitializer (InitializerList &il, const IndexSet &indices, const subdomain_vector &domains)
void | Dune::OverlappingSchwarzInitializer< I, S, D >::addRowNnz (const Iter &row)
void | Dune::OverlappingSchwarzInitializer< I, S, D >::allocate ()
void | Dune::OverlappingSchwarzInitializer< I, S, D >::countEntries (const Iter &row, const CIter &col) const
void | Dune::OverlappingSchwarzInitializer< I, S, D >::calcColstart () const
void | Dune::OverlappingSchwarzInitializer< I, S, D >::copyValue (const Iter &row, const CIter &col) const
void | Dune::OverlappingSchwarzInitializer< I, S, D >::createMatrix () const
| Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::IndexMap ()
void | Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::insert (size_type grow)
const_iterator | Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::find (size_type grow) const
iterator | Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::find (size_type grow)
const_iterator | Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::end () const
iterator | Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::end ()
const_iterator | Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::begin () const
iterator | Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::begin ()
| Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >::SeqOverlappingSchwarz (const matrix_type &mat, const rowtodomain_vector &rowToDomain, field_type relaxationFactor=1, bool onTheFly_=true)
| Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >::SeqOverlappingSchwarz (const matrix_type &mat, const subdomain_vector &subDomains, field_type relaxationFactor=1, bool onTheFly_=true)
| Construct the overlapping Schwarz method.
template<class RowToDomain, class Solvers, class SubDomains>
static std::size_t | Dune::SeqOverlappingSchwarzAssemblerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::assembleLocalProblems (const RowToDomain &rowToDomain, const matrix_type &mat, Solvers &solvers, const SubDomains &domains, bool onTheFly)
template<class RowToDomain, class Solvers, class SubDomains>
static std::size_t | Dune::SeqOverlappingSchwarzAssemblerHelper< S< BCRSMatrix< T, A > >, true >::assembleLocalProblems (const RowToDomain &rowToDomain, const matrix_type &mat, Solvers &solvers, const SubDomains &domains, bool onTheFly)
template<class RowToDomain, class Solvers, class SubDomains>
static std::size_t | Dune::SeqOverlappingSchwarzAssemblerILUBase< M, X, Y >::assembleLocalProblems (const RowToDomain &rowToDomain, const matrix_type &mat, Solvers &solvers, const SubDomains &domains, bool onTheFly)
void | Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >::apply (X &v, const X &d) override
| Apply the preconditioner.
template<bool forward>
void | Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >::apply (X &v, const X &d)
| Apply one step of the preconditioner to the system A(v)=d.
| Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::OverlappingAssignerHelper (std::size_t maxlength, const BCRSMatrix< K, Al > &mat_, const X &b_, Y &x_)
| Constructor.
void | Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::deallocate ()
| Deallocates memory of the local vector.
void | Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::resetIndexForNextDomain ()
| Resets the local index to zero.
DynamicVector< field_type > & | Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::lhs ()
| Get the local left hand side.
DynamicVector< field_type > & | Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::rhs ()
| Get the local right hand side.
void | Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::relaxResult (field_type relax)
| relax the result.
void | Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::operator() (const size_type &domainIndex)
| calculate one entry of the local defect.
void | Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::assignResult (block_type &res)
| Assigns the block to the current local index. At the same time the local defect is calculated for the index and stored in the rhs. Afterwards the is incremented for the next block.
| Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::OverlappingAssignerHelper (std::size_t maxlength, const matrix_type &mat, const range_type &b, range_type &x)
| Constructor.
void | Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::deallocate ()
| Deallocates memory of the local vector.
void | Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::operator() (const size_type &domain)
| calculate one entry of the local defect.
void | Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::relaxResult (field_type relax)
| relax the result.
void | Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::assignResult (block_type &res)
| Assigns the block to the current local index. At the same time the local defect is calculated for the index and stored in the rhs. Afterwards the is incremented for the next block.
void | Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::resetIndexForNextDomain ()
field_type * | Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::lhs ()
| Get the local left hand side.
field_type * | Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::rhs ()
| Get the local right hand side.
| Dune::OverlappingAssignerILUBase< M, X, Y >::OverlappingAssignerILUBase (std::size_t maxlength, const M &mat, const Y &b, X &x)
| Constructor.
void | Dune::OverlappingAssignerILUBase< M, X, Y >::deallocate ()
| Deallocates memory of the local vector.
void | Dune::OverlappingAssignerILUBase< M, X, Y >::operator() (const size_type &domain)
| calculate one entry of the local defect.
void | Dune::OverlappingAssignerILUBase< M, X, Y >::relaxResult (field_type relax)
| relax the result.
void | Dune::OverlappingAssignerILUBase< M, X, Y >::assignResult (block_type &res)
| Assigns the block to the current local index. At the same time the local defect is calculated for the index and stored in the rhs. Afterwards the is incremented for the next block.
X & | Dune::OverlappingAssignerILUBase< M, X, Y >::lhs ()
| Get the local left hand side.
Y & | Dune::OverlappingAssignerILUBase< M, X, Y >::rhs ()
| Get the local right hand side.
void | Dune::OverlappingAssignerILUBase< M, X, Y >::resetIndexForNextDomain ()
| Resets the local index to zero.
| Dune::AdditiveAdder< S, BlockVector< T, A > >::AdditiveAdder (BlockVector< T, A > &v, BlockVector< T, A > &x, OverlappingAssigner< S > &assigner, const field_type &relax_)
void | Dune::AdditiveAdder< S, BlockVector< T, A > >::operator() (const size_type &domain)
void | Dune::AdditiveAdder< S, BlockVector< T, A > >::axpy ()
| Dune::MultiplicativeAdder< S, BlockVector< T, A > >::MultiplicativeAdder (BlockVector< T, A > &v, BlockVector< T, A > &x, OverlappingAssigner< S > &assigner_, const field_type &relax_)
void | Dune::MultiplicativeAdder< S, BlockVector< T, A > >::operator() (const size_type &domain)
void | Dune::MultiplicativeAdder< S, BlockVector< T, A > >::axpy ()

## Detailed Description

All of our Krylow solvers are preconditioned versions. There are sequential preconditioners (e,g. SeqJacobi, SeqSOR, SeqSSOR) as well as parallel preconditioners (e.g. AMG, BlockPreconditioner) available for plugging them into the solvers together with matching ScalarProducts.

Some of the available preconditioners (e.g. SeqJacobi, SeqSOR, SeqSSOR)) may be given an additional int as a template parameter, the block recursion level. These preconditioners can be used on block-recursive matrices with an arbitrary hierarchy depth (eg. BCRSMatrix<BCRSMatrix<FieldMatrix,n,m> > >. Given a block recursion level those preconditioners work as normal on the offdiagonal blocks, treating them as traditional matrix entries. For the diagonal values a special procedure applies: If the diagonal is treated as a matrix itself and the preconditioner is applied recursively on the matrix representing the diagonal value with block level . For the case that the diagonal is treated as a matrix entry resulting in a linear solve or an identity operation depending on the algorithm.

## Typedef Documentation

## OverlappingAssigner

template<typename T>

using Dune::OverlappingAssigner = OverlappingAssignerHelper<T, Dune::StoresColumnCompressed<T>::value>

## SeqGS

template<class M, class X, class Y, int l = 1>

using Dune::SeqGS = SeqSOR<M,X,Y,l>

Sequential Gauss Seidel preconditioner.

Wraps the naked ISTL generic block Gauss-Seidel preconditioner into the solver framework.

Template Parameters

  M | The matrix type to operate on
  X | Type of the update
  Y | Type of the defect
  l | The block level to invert. Default is 1

## SeqOverlappingSchwarzAssembler

template<class T>

using Dune::SeqOverlappingSchwarzAssembler = SeqOverlappingSchwarzAssemblerHelper<T,Dune::StoresColumnCompressed<T>::value>

## Function Documentation

## AdditiveAdder()

template<typename S, typename T, typename A>

Dune::AdditiveAdder< S, BlockVector< T, A > >::AdditiveAdder | ( | BlockVector< T, A > & | v,
|  | BlockVector< T, A > & | x,
|  | OverlappingAssigner< S > & | assigner,
|  | const field_type & | relax_ )

## addRowNnz()

template<class I, class S, class D>

void Dune::OverlappingSchwarzInitializer< I, S, D >::addRowNnz | ( | const Iter & | row | ) |

## allocate()

template<class I, class S, class D>

void Dune::OverlappingSchwarzInitializer< I, S, D >::allocate | ( |  | ) |

## apply() [1/2]

template<class M, class X, class TM, class TD, class TA>
template<bool forward>

void Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >::apply | ( | X & | v,
|  | const X & | d )

virtual

Apply one step of the preconditioner to the system A(v)=d.

On entry v=0 and d=b-A(x) (although this might not be computed in that way. On exit v contains the update, i.e one step computes where is the approximate inverse of the operator characterizing the preconditioner.

Parameters

  [out] | v | The update to be computed
  | d | The current defect.

Implements Dune::Preconditioner< X, X >.

## apply() [2/2]

template<class M, class X, class TM, class TD, class TA>

void Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >::apply | ( | X & | v,
|  | const X & | d )

override virtual

Apply the preconditioner.

Apply one step of the preconditioner to the system A(v)=d.

On entry v=0 and d=b-A(x) (although this might not be computed in that way. On exit v contains the update, i.e one step computes where is the approximate inverse of the operator characterizing the preconditioner.

Parameters

  [out] | v | The update to be computed
  | d | The current defect.

Implements Dune::Preconditioner< X, X >.

## assembleLocalProblems() [1/3]

template<class K, class Al, class X, class Y>
template<class RowToDomain, class Solvers, class SubDomains>

std::size_t Dune::SeqOverlappingSchwarzAssemblerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::assembleLocalProblems | ( | const RowToDomain & | rowToDomain,
|  | const matrix_type & | mat,
|  | Solvers & | solvers,
|  | const SubDomains & | domains,
|  | bool | onTheFly )

static

## assembleLocalProblems() [2/3]

template<template< class > class S, typename T, typename A>
template<class RowToDomain, class Solvers, class SubDomains>

std::size_t Dune::SeqOverlappingSchwarzAssemblerHelper< S< BCRSMatrix< T, A > >, true >::assembleLocalProblems | ( | const RowToDomain & | rowToDomain,
|  | const matrix_type & | mat,
|  | Solvers & | solvers,
|  | const SubDomains & | domains,
|  | bool | onTheFly )

static

## assembleLocalProblems() [3/3]

template<class M, class X, class Y>
template<class RowToDomain, class Solvers, class SubDomains>

std::size_t Dune::SeqOverlappingSchwarzAssemblerILUBase< M, X, Y >::assembleLocalProblems | ( | const RowToDomain & | rowToDomain,
|  | const matrix_type & | mat,
|  | Solvers & | solvers,
|  | const SubDomains & | domains,
|  | bool | onTheFly )

static

## assignResult() [1/3]

template<class K, class Al, class X, class Y>

void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::assignResult | ( | block_type & | res | ) |

inline

Assigns the block to the current local index. At the same time the local defect is calculated for the index and stored in the rhs. Afterwards the is incremented for the next block.

## assignResult() [2/3]

template<template< class > class S, typename T, typename A>

void Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::assignResult | ( | block_type & | res | ) |

Assigns the block to the current local index. At the same time the local defect is calculated for the index and stored in the rhs. Afterwards the is incremented for the next block.

## assignResult() [3/3]

template<class M, class X, class Y>

void Dune::OverlappingAssignerILUBase< M, X, Y >::assignResult | ( | block_type & | res | ) |

Assigns the block to the current local index. At the same time the local defect is calculated for the index and stored in the rhs. Afterwards the is incremented for the next block.

## axpy() [1/2]

template<typename S, typename T, typename A>

void Dune::AdditiveAdder< S, BlockVector< T, A > >::axpy | ( |  | ) |

## axpy() [2/2]

template<typename S, typename T, typename A>

void Dune::MultiplicativeAdder< S, BlockVector< T, A > >::axpy | ( |  | ) |

## begin() [1/2]

template<class I, class S, class D>

OverlappingSchwarzInitializer< I, S, D >::IndexMap::iterator Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::begin | ( |  | ) |

## begin() [2/2]

template<class I, class S, class D>

OverlappingSchwarzInitializer< I, S, D >::IndexMap::const_iterator Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::begin | ( |  | ) | const

## calcColstart()

template<class I, class S, class D>

void Dune::OverlappingSchwarzInitializer< I, S, D >::calcColstart | ( |  | ) | const

## copyValue()

template<class I, class S, class D>

void Dune::OverlappingSchwarzInitializer< I, S, D >::copyValue | ( | const Iter & | row,
|  | const CIter & | col ) const

## countEntries()

template<class I, class S, class D>

void Dune::OverlappingSchwarzInitializer< I, S, D >::countEntries | ( | const Iter & | row,
|  | const CIter & | col ) const

## createMatrix()

template<class I, class S, class D>

void Dune::OverlappingSchwarzInitializer< I, S, D >::createMatrix | ( |  | ) | const

## deallocate() [1/3]

template<class K, class Al, class X, class Y>

void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::deallocate | ( |  | ) |

inline

Deallocates memory of the local vector.

## deallocate() [2/3]

template<template< class > class S, typename T, typename A>

void Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::deallocate | ( |  | ) |

Deallocates memory of the local vector.

Warning
  memory is released by the destructor as this Functor is copied and the copy needs to still have the data.

## deallocate() [3/3]

template<class M, class X, class Y>

void Dune::OverlappingAssignerILUBase< M, X, Y >::deallocate | ( |  | ) |

Deallocates memory of the local vector.

Warning
  memory is released by the destructor as this Functor is copied and the copy needs to still have the data.

## DUNE_REGISTER_PRECONDITIONER() [1/8]

Dune::DUNE_REGISTER_PRECONDITIONER | ( | "dilu" | ,
|  | defaultPreconditionerBlockLevelCreator< Dune::SeqDILU > | () )

## DUNE_REGISTER_PRECONDITIONER() [2/8]

Dune::DUNE_REGISTER_PRECONDITIONER | ( | "gs" | ,
|  | defaultPreconditionerBlockLevelCreator< Dune::SeqGS > | () )

## DUNE_REGISTER_PRECONDITIONER() [3/8]

Dune::DUNE_REGISTER_PRECONDITIONER | ( | "ildl" | ,
|  | defaultPreconditionerCreator< Dune::SeqILDL > | () )

## DUNE_REGISTER_PRECONDITIONER() [4/8]

Dune::DUNE_REGISTER_PRECONDITIONER | ( | "ilu" | ,
|  | defaultPreconditionerBlockLevelCreator< Dune::SeqILU > | () )

## DUNE_REGISTER_PRECONDITIONER() [5/8]

Dune::DUNE_REGISTER_PRECONDITIONER | ( | "jac" | ,
|  | defaultPreconditionerBlockLevelCreator< Dune::SeqJac > | () )

## DUNE_REGISTER_PRECONDITIONER() [6/8]

Dune::DUNE_REGISTER_PRECONDITIONER | ( | "richardson" | ,
|  | [] (auto opTraits, const auto &, const ParameterTree &config){ using OpTraits=std::decay_t< decltype(opTraits)>;using D=typename OpTraits::domain_type;using R=typename OpTraits::range_type;return std::make_shared< Richardson< D, R > >(config);} | )

## DUNE_REGISTER_PRECONDITIONER() [7/8]

Dune::DUNE_REGISTER_PRECONDITIONER | ( | "sor" | ,
|  | defaultPreconditionerBlockLevelCreator< Dune::SeqSOR > | () )

## DUNE_REGISTER_PRECONDITIONER() [8/8]

Dune::DUNE_REGISTER_PRECONDITIONER | ( | "ssor" | ,
|  | defaultPreconditionerBlockLevelCreator< Dune::SeqSSOR > | () )

## end() [1/2]

template<class I, class S, class D>

OverlappingSchwarzInitializer< I, S, D >::IndexMap::iterator Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::end | ( |  | ) |

## end() [2/2]

template<class I, class S, class D>

OverlappingSchwarzInitializer< I, S, D >::IndexMap::const_iterator Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::end | ( |  | ) | const

## find() [1/2]

template<class I, class S, class D>

OverlappingSchwarzInitializer< I, S, D >::IndexMap::iterator Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::find | ( | size_type | grow | ) |

## find() [2/2]

template<class I, class S, class D>

OverlappingSchwarzInitializer< I, S, D >::IndexMap::const_iterator Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::find | ( | size_type | grow | ) | const

## IndexMap()

template<class I, class S, class D>

Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::IndexMap | ( |  | ) |

## insert()

template<class I, class S, class D>

void Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::insert | ( | size_type | grow | ) |

## lhs() [1/3]

template<class K, class Al, class X, class Y>

DynamicVector< typename X::field_type > & Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::lhs | ( |  | ) |

inline

Get the local left hand side.

Returns
  The local left hand side.

## lhs() [2/3]

template<template< class > class S, typename T, typename A>

OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::field_type * Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::lhs | ( |  | ) |

Get the local left hand side.

Returns
  The local left hand side.

## lhs() [3/3]

template<class M, class X, class Y>

X & Dune::OverlappingAssignerILUBase< M, X, Y >::lhs | ( |  | ) |

Get the local left hand side.

Returns
  The local left hand side.

## MultiplicativeAdder()

template<typename S, typename T, typename A>

Dune::MultiplicativeAdder< S, BlockVector< T, A > >::MultiplicativeAdder | ( | BlockVector< T, A > & | v,
|  | BlockVector< T, A > & | x,
|  | OverlappingAssigner< S > & | assigner_,
|  | const field_type & | relax_ )

## operator()() [1/5]

template<typename S, typename T, typename A>

void Dune::AdditiveAdder< S, BlockVector< T, A > >::operator() | ( | const size_type & | domain | ) |

## operator()() [2/5]

template<typename S, typename T, typename A>

void Dune::MultiplicativeAdder< S, BlockVector< T, A > >::operator() | ( | const size_type & | domain | ) |

## operator()() [3/5]

template<class K, class Al, class X, class Y>

void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::operator() | ( | const size_type & | domainIndex | ) |

calculate one entry of the local defect.

Parameters

  domainIndex | One index of the domain.

## operator()() [4/5]

template<template< class > class S, typename T, typename A>

void Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::operator() | ( | const size_type & | domain | ) |

calculate one entry of the local defect.

Parameters

  domain | One index of the domain.

## operator()() [5/5]

template<class M, class X, class Y>

void Dune::OverlappingAssignerILUBase< M, X, Y >::operator() | ( | const size_type & | domain | ) |

calculate one entry of the local defect.

Parameters

  domain | One index of the domain.

## OverlappingAssignerHelper() [1/2]

template<class K, class Al, class X, class Y>

Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::OverlappingAssignerHelper | ( | std::size_t | maxlength,
|  | const BCRSMatrix< K, Al > & | mat_,
|  | const X & | b_,
|  | Y & | x_ )

Constructor.

Parameters

  maxlength | The maximum entries over all subdomains.
  mat_ | The global matrix.
  b_ | the global right hand side.
  x_ | the global left hand side.

## OverlappingAssignerHelper() [2/2]

template<template< class > class S, typename T, typename A>

Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::OverlappingAssignerHelper | ( | std::size_t | maxlength,
|  | const matrix_type & | mat,
|  | const range_type & | b,
|  | range_type & | x )

Constructor.

Parameters

  maxlength | The maximum entries over all subdomains.
  mat | The global matrix.
  b | the global right hand side.
  x | the global left hand side.

## OverlappingAssignerILUBase()

template<class M, class X, class Y>

Dune::OverlappingAssignerILUBase< M, X, Y >::OverlappingAssignerILUBase | ( | std::size_t | maxlength,
|  | const M & | mat,
|  | const Y & | b,
|  | X & | x )

Constructor.

Parameters

  maxlength | The maximum entries over all subdomains.
  mat | The global matrix.
  b | the global right hand side.
  x | the global left hand side.

## OverlappingSchwarzInitializer()

template<class I, class S, class D>

Dune::OverlappingSchwarzInitializer< I, S, D >::OverlappingSchwarzInitializer | ( | InitializerList & | il,
|  | const IndexSet & | indices,
|  | const subdomain_vector & | domains )

## relaxResult() [1/3]

template<class K, class Al, class X, class Y>

void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::relaxResult | ( | field_type | relax | ) |

inline

relax the result.

Parameters

  relax | The relaxation parameter.

## relaxResult() [2/3]

template<template< class > class S, typename T, typename A>

void Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::relaxResult | ( | field_type | relax | ) |

relax the result.

Parameters

  relax | The relaxation parameter.

## relaxResult() [3/3]

template<class M, class X, class Y>

void Dune::OverlappingAssignerILUBase< M, X, Y >::relaxResult | ( | field_type | relax | ) |

relax the result.

Parameters

  relax | The relaxation parameter.

## resetIndexForNextDomain() [1/3]

template<class K, class Al, class X, class Y>

void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::resetIndexForNextDomain | ( |  | ) |

inline

Resets the local index to zero.

## resetIndexForNextDomain() [2/3]

template<template< class > class S, typename T, typename A>

void Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::resetIndexForNextDomain | ( |  | ) |

## resetIndexForNextDomain() [3/3]

template<class M, class X, class Y>

void Dune::OverlappingAssignerILUBase< M, X, Y >::resetIndexForNextDomain | ( |  | ) |

Resets the local index to zero.

## rhs() [1/3]

template<class K, class Al, class X, class Y>

DynamicVector< typename X::field_type > & Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >::rhs | ( |  | ) |

inline

Get the local right hand side.

Returns
  The local right hand side.

## rhs() [2/3]

template<template< class > class S, typename T, typename A>

OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::field_type * Dune::OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >::rhs | ( |  | ) |

Get the local right hand side.

Returns
  The local right hand side.

## rhs() [3/3]

template<class M, class X, class Y>

Y & Dune::OverlappingAssignerILUBase< M, X, Y >::rhs | ( |  | ) |

Get the local right hand side.

Returns
  The local right hand side.

## SeqOverlappingSchwarz() [1/2]

template<class M, class X, class TM, class TD, class TA>

Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >::SeqOverlappingSchwarz | ( | const matrix_type & | mat,
|  | const rowtodomain_vector & | rowToDomain,
|  | field_type | relaxationFactor = 1,
|  | bool | onTheFly_ = true )

Construct the overlapping Schwarz method

Parameters

  mat | The matrix to precondition.
  rowToDomain | The mapping of the rows onto the domains.
  relaxationFactor | relaxation factor
  onTheFly_ | If true the decomposition of the exact local solvers is computed on the fly for each subdomain and iteration step. If false all decompositions are computed in pre and only forward and backward substitution takes place in the iteration steps.

## SeqOverlappingSchwarz() [2/2]

template<class M, class X, class TM, class TD, class TA>

Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >::SeqOverlappingSchwarz | ( | const matrix_type & | mat,
|  | const subdomain_vector & | subDomains,
|  | field_type | relaxationFactor = 1,
|  | bool | onTheFly_ = true )

Construct the overlapping Schwarz method.

Parameters

  mat | The matrix to precondition.
  subDomains | Array of sets of rowindices belonging to an overlapping subdomain
  relaxationFactor | relaxation factor
  onTheFly_ | If true the decomposition of the exact local solvers is computed on the fly for each subdomain and iteration step. If false all decompositions are computed in pre and only forward and backward substitution takes place in the iteration steps.

Warning
  Each rowindex should be part of at least one subdomain!