dune-istl  2.5.1
Modules | Files | Namespaces | Classes | Typedefs | Functions
Collaboration diagram for Preconditioners:

Modules

 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

 Dune::Amg
 

Classes

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< FieldMatrix< K, n, n >, Al >, X, Y >
 
class  Dune::OverlappingAssignerHelper< T, tag >
 
class  Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >
 
struct  Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, 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< FieldVector< T, n >, A > >
 
struct  Dune::MultiplicativeAdder< S, T >
 
struct  Dune::MultiplicativeAdder< S, BlockVector< FieldVector< T, n >, 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< FieldMatrix< K, n, n >, Al >, X, Y >, false >
 
struct  Dune::SeqOverlappingSchwarzAssemblerHelper< S< BCRSMatrix< FieldMatrix< T, m, n >, 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< FieldMatrix< T, n, m >, 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::SeqGS< M, X, Y, l >
 Sequential Gauss Seidel preconditioner. More...
 
class  Dune::SeqJac< M, X, Y, l >
 The sequential jacobian preconditioner. More...
 
class  Dune::SeqILU0< M, X, Y, l >
 Sequential ILU0 preconditioner. More...
 
class  Dune::SeqILUn< M, X, Y, l >
 Sequential ILU(n) preconditioner. More...
 
class  Dune::Richardson< X, Y >
 Richardson preconditioner. More...
 
class  Dune::ParSSOR< M, X, Y, C >
 A parallel SSOR preconditioner. More...
 
class  Dune::BlockPreconditioner< X, Y, C, T >
 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 >
 

Functions

 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. More...
 
template<class RowToDomain , class Solvers , class SubDomains >
static std::size_t Dune::SeqOverlappingSchwarzAssemblerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, 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< FieldMatrix< T, m, n >, 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)
 
virtual void Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >::apply (X &v, const X &d)
 Apply the precondtioner. More...
 
 Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::OverlappingAssignerHelper (std::size_t maxlength, const BCRSMatrix< FieldMatrix< K, n, n >, Al > &mat_, const X &b_, Y &x_)
 Constructor. More...
 
void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::deallocate ()
 Deallocates memory of the local vector. More...
 
void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::resetIndexForNextDomain ()
 Resets the local index to zero. More...
 
DynamicVector< K > & Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::lhs ()
 Get the local left hand side. More...
 
DynamicVector< K > & Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::rhs ()
 Get the local right hand side. More...
 
void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::relaxResult (field_type relax)
 relax the result. More...
 
void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::operator() (const size_type &domainIndex)
 calculate one entry of the local defect. More...
 
void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, 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. More...
 
 Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::OverlappingAssignerHelper (std::size_t maxlength, const matrix_type &mat, const range_type &b, range_type &x)
 Constructor. More...
 
void Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::deallocate ()
 Deallocates memory of the local vector. More...
 
void Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::operator() (const size_type &domain)
 calculate one entry of the local defect. More...
 
void Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::relaxResult (field_type relax)
 relax the result. More...
 
void Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, 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. More...
 
void Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::resetIndexForNextDomain ()
 
field_typeDune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::lhs ()
 Get the local left hand side. More...
 
field_typeDune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::rhs ()
 Get the local right hand side. More...
 
 Dune::OverlappingAssignerILUBase< M, X, Y >::OverlappingAssignerILUBase (std::size_t maxlength, const M &mat, const Y &b, X &x)
 Constructor. More...
 
void Dune::OverlappingAssignerILUBase< M, X, Y >::deallocate ()
 Deallocates memory of the local vector. More...
 
void Dune::OverlappingAssignerILUBase< M, X, Y >::operator() (const size_type &domain)
 calculate one entry of the local defect. More...
 
void Dune::OverlappingAssignerILUBase< M, X, Y >::relaxResult (field_type relax)
 relax the result. More...
 
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. More...
 
X & Dune::OverlappingAssignerILUBase< M, X, Y >::lhs ()
 Get the local left hand side. More...
 
Y & Dune::OverlappingAssignerILUBase< M, X, Y >::rhs ()
 Get the local right hand side. More...
 
void Dune::OverlappingAssignerILUBase< M, X, Y >::resetIndexForNextDomain ()
 Resets the local index to zero. More...
 
 Dune::AdditiveAdder< S, BlockVector< FieldVector< T, n >, A > >::AdditiveAdder (BlockVector< FieldVector< T, n >, A > &v, BlockVector< FieldVector< T, n >, A > &x, OverlappingAssigner< S > &assigner, const T &relax_)
 
void Dune::AdditiveAdder< S, BlockVector< FieldVector< T, n >, A > >::operator() (const size_type &domain)
 
void Dune::AdditiveAdder< S, BlockVector< FieldVector< T, n >, A > >::axpy ()
 
 Dune::MultiplicativeAdder< S, BlockVector< FieldVector< T, n >, A > >::MultiplicativeAdder (BlockVector< FieldVector< T, n >, A > &v, BlockVector< FieldVector< T, n >, A > &x, OverlappingAssigner< S > &assigner_, const T &relax_)
 
void Dune::MultiplicativeAdder< S, BlockVector< FieldVector< T, n >, A > >::operator() (const size_type &domain)
 
void Dune::MultiplicativeAdder< S, BlockVector< FieldVector< T, n >, 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 aditional 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 $k$ those preconditioners work as normal on the offdiagonal blocks, treating them as traditional matrix entries. For the diagonal values a special procedure applies: If $k>1$ the diagonal is treated as a matrix itself and the preconditioner is applied recursively on the matrix representing the diagonal value $D=A_{ii}$ with block level $k-1$. For the case that $k=1$ 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 = typedef OverlappingAssignerHelper<T, Dune::StoresColumnCompressed<T>::value>

◆ SeqOverlappingSchwarzAssembler

Function Documentation

◆ AdditiveAdder()

template<typename S , typename T , typename A , int n>
Dune::AdditiveAdder< S, BlockVector< FieldVector< T, n >, A > >::AdditiveAdder ( BlockVector< FieldVector< T, n >, A > &  v,
BlockVector< FieldVector< T, n >, A > &  x,
OverlappingAssigner< S > &  assigner,
const T &  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()

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 
)
virtual

Apply the precondtioner.

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 $ v = M^{-1} d $ where $ M $ is the approximate inverse of the operator $ A $ characterizing the preconditioner.

Parameters
[out]vThe update to be computed
dThe current defect.

Implements Dune::Preconditioner< X, X >.

◆ assembleLocalProblems() [1/3]

template<class K , int n, class Al , class X , class Y >
template<class RowToDomain , class Solvers , class SubDomains >
std::size_t Dune::SeqOverlappingSchwarzAssemblerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, 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 , int m, int n>
template<class RowToDomain , class Solvers , class SubDomains >
std::size_t Dune::SeqOverlappingSchwarzAssemblerHelper< S< BCRSMatrix< FieldMatrix< T, m, n >, 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 , int n, class Al , class X , class Y >
void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, 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, int n, int m, typename T , typename A >
void Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, 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 , int n>
void Dune::AdditiveAdder< S, BlockVector< FieldVector< T, n >, A > >::axpy ( )

◆ axpy() [2/2]

template<typename S , typename T , typename A , int n>
void Dune::MultiplicativeAdder< S, BlockVector< FieldVector< T, n >, 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 , int n, class Al , class X , class Y >
void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::deallocate ( )
inline

Deallocates memory of the local vector.

◆ deallocate() [2/3]

template<template< class > class S, int n, int m, typename T , typename A >
void Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, 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.

◆ 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::const_iterator Dune::OverlappingSchwarzInitializer< I, S, D >::IndexMap::find ( size_type  grow) const

◆ find() [2/2]

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

◆ 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 , int n, class Al , class X , class Y >
DynamicVector< K > & Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, 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, int n, int m, typename T , typename A >
OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::field_type * Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, 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 , int n>
Dune::MultiplicativeAdder< S, BlockVector< FieldVector< T, n >, A > >::MultiplicativeAdder ( BlockVector< FieldVector< T, n >, A > &  v,
BlockVector< FieldVector< T, n >, A > &  x,
OverlappingAssigner< S > &  assigner_,
const T &  relax_ 
)

◆ operator()() [1/5]

template<class K , int n, class Al , class X , class Y >
void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::operator() ( const size_type domainIndex)

calculate one entry of the local defect.

Parameters
domainIndexOne index of the domain.

◆ operator()() [2/5]

template<template< class > class S, int n, int m, typename T , typename A >
void Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::operator() ( const size_type domain)

calculate one entry of the local defect.

Parameters
domainOne index of the domain.

◆ operator()() [3/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
domainOne index of the domain.

◆ operator()() [4/5]

template<typename S , typename T , typename A , int n>
void Dune::AdditiveAdder< S, BlockVector< FieldVector< T, n >, A > >::operator() ( const size_type domain)

◆ operator()() [5/5]

template<typename S , typename T , typename A , int n>
void Dune::MultiplicativeAdder< S, BlockVector< FieldVector< T, n >, A > >::operator() ( const size_type domain)

◆ OverlappingAssignerHelper() [1/2]

template<class K , int n, class Al , class X , class Y >
Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::OverlappingAssignerHelper ( std::size_t  maxlength,
const BCRSMatrix< FieldMatrix< K, n, n >, Al > &  mat_,
const X &  b_,
Y &  x_ 
)

Constructor.

Parameters
maxlengthThe 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, int n, int m, typename T , typename A >
Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::OverlappingAssignerHelper ( std::size_t  maxlength,
const matrix_type mat,
const range_type b,
range_type x 
)

Constructor.

Parameters
maxlengthThe maximum entries over all subdomains.
matThe global matrix.
bthe global right hand side.
xthe 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
maxlengthThe maximum entries over all subdomains.
matThe global matrix.
bthe global right hand side.
xthe 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 , int n, class Al , class X , class Y >
void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::relaxResult ( field_type  relax)
inline

relax the result.

Parameters
relaxThe relaxation parameter.

◆ relaxResult() [2/3]

template<template< class > class S, int n, int m, typename T , typename A >
void Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::relaxResult ( field_type  relax)

relax the result.

Parameters
relaxThe 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
relaxThe relaxation parameter.

◆ resetIndexForNextDomain() [1/3]

template<class K , int n, class Al , class X , class Y >
void Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, Al >, X, Y >, false >::resetIndexForNextDomain ( )
inline

Resets the local index to zero.

◆ resetIndexForNextDomain() [2/3]

template<template< class > class S, int n, int m, typename T , typename A >
void Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, 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 , int n, class Al , class X , class Y >
DynamicVector< K > & Dune::OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< FieldMatrix< K, n, n >, 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, int n, int m, typename T , typename A >
OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, A > >, true >::field_type * Dune::OverlappingAssignerHelper< S< BCRSMatrix< FieldMatrix< T, n, m >, 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 subdomain_vector subDomains,
field_type  relaxationFactor = 1,
bool  onTheFly_ = true 
)

Construct the overlapping Schwarz method.

Parameters
matThe matrix to precondition.
subDomainsArray of sets of rowindices belonging to an overlapping subdomain
relaxationFactorrelaxation 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!

◆ 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 rowtodomain_vector rowToDomain,
field_type  relaxationFactor = 1,
bool  onTheFly_ = true 
)

Construct the overlapping Schwarz method

Parameters
matThe matrix to precondition.
rowToDomainThe mapping of the rows onto the domains.
relaxationFactorrelaxation 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.