dune-istl  2.2.1
Modules | Files | Classes | Functions
Iterative Solvers Template Library (ISTL)

Iterative Solvers supporting block recursive matrix and vector classes at compile time. More...

Modules

 Sparse Matrix and Vector classes
 Matrix and Vector classes that support a block recursive structure capable of representing the natural structure from Finite Element discretisations.
 
 Iterative Solvers
 

Files

file  superlu.hh
 Classes for using SuperLU with ISTL matrices.
 

Classes

class  Dune::ILUSubdomainSolver< M, X, Y >
 base class encapsulating common algorithms of ILU0SubdomainSolver and ILUNSubdomainSolver. More...
 
class  Dune::ILU0SubdomainSolver< M, X, Y >
 Exact subdomain solver using ILU(p) with appropriate p. More...
 
class  Dune::ILUNSubdomainSolver< M, X, Y >
 
class  Dune::ISTLError
 derive error class from the base class in common More...
 
class  Dune::SuperLU< Matrix >
 
class  Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >
 Sequential overlapping Schwarz preconditioner. More...
 
struct  Dune::SeqOverlappingSchwarzAssembler< T >
 
struct  Dune::SuperLUSolveChooser< T >
 
struct  Dune::SuperLUDenseMatChooser< T >
 
struct  Dune::SuperLUQueryChooser< T >
 
struct  Dune::QuerySpaceChooser< T >
 
struct  Dune::SuperLUDenseMatChooser< double >
 
struct  Dune::SuperLUSolveChooser< double >
 
struct  Dune::QuerySpaceChooser< double >
 
class  Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >
 SuperLu Solver. More...
 

Functions

template<class S >
std::size_t Dune::ILUSubdomainSolver< M, X, Y >::copyToLocalMatrix (const M &A, S &rowset)
 Copy the local part of the global matrix to ILU. More...
 
template<class S >
void Dune::ILU0SubdomainSolver< M, X, Y >::setSubMatrix (const M &A, S &rowset)
 Set the data of the local problem. More...
 
template<class S >
void Dune::ILUNSubdomainSolver< M, X, Y >::setSubMatrix (const M &A, S &rowset)
 Set the data of the local problem. More...
 
 Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::~SuperLU ()
 
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::free ()
 free allocated space. More...
 
 Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SuperLU (const Matrix &mat, bool verbose=false)
 Constructs the SuperLU solver. More...
 
 Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SuperLU ()
 Empty default constructor. More...
 
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setVerbosity (bool v)
 
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setMatrix (const Matrix &mat)
 Initialize data from given matrix. More...
 
template<class S >
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setSubMatrix (const Matrix &mat, const S &rowIndexSet)
 
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply (domain_type &x, range_type &b, InverseOperatorResult &res)
 Apply inverse operator,. More...
 
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply (T *x, T *b)
 Apply SuperLu to C arrays. More...
 

Detailed Description

Iterative Solvers supporting block recursive matrix and vector classes at compile time.

The Iterative Solver Template Library applies generic programming in C++ to the domain of iterative solvers of linear systems stemming from finite element discretizations. Those discretizations exhibit a lot of structure, e.g:

  1. Certain discretizations for systems of PDEs or higher order methods result in matrices where individual entries are replaced by small blocks, say of size $2\times 2$ or $4\times 4$. Dense blocks of different sizes e.g. arise in $hp$ Discontinuous Galerkin discretization methods. It is straightforward and efficient to treat these small dense blocks as fully coupled and solve them with direct methods within the iterative method.
  2. Equation-wise ordering for systems results in matrices having an $n\times n$ block structure where $n$ corresponds to the number of variables in the PDE and the blocks themselves are large and sparse. As an example we mention the Stokes system.
  3. Other discretisation, e.~g. those of reaction/diffusion systems, produce sparse matrices whose blocks are sparse matrices of small dense blocks,

Our matrix and vector interface supports a block recursive structure. Each sparse matrix entry can itself be either a sparse or a small dense matrix.

The solvers use this recursive block structure via template meta programming at compile time.

ISTL consists of the matrix and vector API and the solvers which use the Preconditioners preconditioners.

Function Documentation

template<typename T , typename A , int n, int m>
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply ( domain_type x,
range_type b,
InverseOperatorResult res 
)

Apply inverse operator,.

Warning
Note: right hand side b may be overwritten!
Parameters
xThe left hand side to store the result in.
bThe right hand side
resObject to store the statistics about applying the operator.

References Dune::InverseOperatorResult::converged, Dune::InverseOperatorResult::iterations, Dune::Matrix< T, A >::M(), mat, and Dune::Matrix< T, A >::N().

template<typename T , typename A , int n, int m>
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply ( T *  x,
T *  b 
)

Apply SuperLu to C arrays.

References Dune::Matrix< T, A >::M(), mat, and Dune::Matrix< T, A >::N().

template<class M , class X , class Y >
template<class S >
std::size_t Dune::ILUSubdomainSolver< M, X, Y >::copyToLocalMatrix ( const M &  A,
S &  rowset 
)
protected

Copy the local part of the global matrix to ILU.

Parameters
AThe global matrix.
rowsetThe global indices of the local problem.

References col.

template<typename T , typename A , int n, int m>
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::free ( )

free allocated space.

Warning
later calling apply will result in an error.

References mat.

template<typename T , typename A , int n, int m>
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setMatrix ( const Matrix mat)

Initialize data from given matrix.

References Dune::Matrix< T, A >::M(), mat, and Dune::Matrix< T, A >::N().

template<class M , class X , class Y >
template<class S >
void Dune::ILU0SubdomainSolver< M, X, Y >::setSubMatrix ( const M &  A,
S &  rowset 
)

Set the data of the local problem.

Parameters
AThe global matrix.
rowsetThe global indices of the local problem.
Template Parameters
SThe type of the set with the indices.

References Dune::bilu0_decomposition().

template<class M , class X , class Y >
template<class S >
void Dune::ILUNSubdomainSolver< M, X, Y >::setSubMatrix ( const M &  A,
S &  rowset 
)

Set the data of the local problem.

Parameters
AThe global matrix.
rowsetThe global indices of the local problem.
Template Parameters
SThe type of the set with the indices.

References Dune::bilu_decomposition().

template<typename T , typename A , int n, int m>
template<class S >
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setSubMatrix ( const Matrix mat,
const S &  rowIndexSet 
)
template<typename T , typename A , int n, int m>
void Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setVerbosity ( bool  v)
template<typename T , typename A , int n, int m>
Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SuperLU ( const Matrix mat,
bool  verbose = false 
)
explicit

Constructs the SuperLU solver.

During the construction the matrix will be decomposed. That means that in each apply call forward and backward substitutions take place (and no decomposition).

Parameters
matThe matrix of the system to solve.
verboseIf true some statistics are printed.
template<typename T , typename A , int n, int m>
Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SuperLU ( )

Empty default constructor.

Use setMatrix to tell SuperLU for what matrix it solves.

template<typename T , typename A , int n, int m>
Dune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >::~SuperLU ( )