Loading...
Searching...
No Matches
Iterative Solvers Template Library (ISTL)

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

Collaboration diagram for Iterative Solvers Template Library (ISTL):

## Topics

| Iterative Solvers
| Communication Interface
| 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.

## Files

file | ldl.hh
| Class for using LDL with ISTL matrices.
file | spqr.hh
| Class for using SPQR with ISTL matrices.
file | superlu.hh
| Classes for using SuperLU with ISTL matrices.
file | umfpack.hh
| Classes for using UMFPack with ISTL matrices.

## Namespaces

namespace | Dune::UMFPackImpl

## 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::BCRSMatrixError
| Error specific to BCRSMatrix. More...
class | Dune::ImplicitModeCompressionBufferExhausted
| Thrown when the compression buffer used by the implicit BCRSMatrix construction is exhausted. More...
class | Dune::SolverAbort
| Thrown when a solver aborts due to some problem. More...
class | Dune::MatrixBlockError
| Error when performing an operation on a matrix block. More...
class | Dune::SeqOverlappingSchwarz< M, X, TM, TD, TA >
| Sequential overlapping Schwarz preconditioner. More...
struct | Dune::SeqOverlappingSchwarzAssemblerHelper< T, tag >
class | Dune::LDL< Matrix >
| Use the LDL package to directly solve linear systems – empty default class. More...
class | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >
| The LDL direct sparse solver for matrices of type BCRSMatrix. More...
struct | Dune::IsDirectSolver< LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > > >
struct | Dune::StoresColumnCompressed< LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > > >
class | Dune::SPQR< Matrix >
| Use the SPQR package to directly solve linear systems – empty default class. More...
class | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >
| The SPQR direct sparse solver for matrices of type BCRSMatrix. More...
struct | Dune::IsDirectSolver< SPQR< BCRSMatrix< T, A > > >
struct | Dune::StoresColumnCompressed< SPQR< BCRSMatrix< T, A > > >
struct | Dune::SuperLUSolveChooser< T >
struct | Dune::SuperLUDenseMatChooser< T >
struct | Dune::SuperLUQueryChooser< T >
struct | Dune::QuerySpaceChooser< T >
class | Dune::SuperLU< M >
| SuperLu Solver. More...
struct | Dune::UMFPackMethodChooser< T >
struct | Dune::UMFPackMethodChooser< double >
struct | Dune::UMFPackMethodChooser< std::complex< double > >
class | Dune::UMFPack< M >
| The UMFPack direct sparse solver. More...
struct | Dune::IsDirectSolver< UMFPack< M > >
struct | Dune::StoresColumnCompressed< UMFPack< BCRSMatrix< T, A > > >
struct | Dune::UMFPackImpl::isValidBlock< OpTraits, class >

struct

Dune::UMFPackImpl::isValidBlock< OpTraits, std::enable_if_t< std::is_same_v< Impl::UMFPackDomainType< typename OpTraits::matrix_type >, typename OpTraits::domain_type > &&std::is_same_v< Impl::UMFPackRangeType< typename OpTraits::matrix_type >, typename OpTraits::range_type > &&std::is_same_v< typename FieldTraits< typename OpTraits::domain_type::field_type >::real_type, double > &&std::is_same_v< typename FieldTraits< typename OpTraits::range_type::field_type >::real_type, double > > >

## Typedefs

typedef Dune::BCRSMatrix< FieldMatrix< T, n, m >, A > | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::Matrix
| The matrix type.
typedef Dune::BCRSMatrix< FieldMatrix< T, n, m >, A > | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::matrix_type
typedef Dune::ISTL::Impl::BCCSMatrix< T, int > | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::LDLMatrix
| The corresponding SuperLU Matrix type.
typedef ISTL::Impl::BCCSMatrixInitializer< BCRSMatrix< FieldMatrix< T, n, m >, A >, int > | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::MatrixInitializer
| Type of an associated initializer class.
typedef Dune::BlockVector< FieldVector< T, m >, typename std::allocator_traits< A >::template rebind_alloc< FieldVector< T, m > > > | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::domain_type
| The type of the domain of the solver.
typedef Dune::BlockVector< FieldVector< T, n >, typename std::allocator_traits< A >::template rebind_alloc< FieldVector< T, n > > > | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::range_type
| The type of the range of the solver.
typedef Dune::BCRSMatrix< FieldMatrix< T, n, m >, A > | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::Matrix
| The matrix type.
typedef Dune::BCRSMatrix< FieldMatrix< T, n, m >, A > | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::matrix_type
typedef ISTL::Impl::BCCSMatrix< T, int > | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SPQRMatrix
| The corresponding SuperLU Matrix type.
typedef ISTL::Impl::BCCSMatrixInitializer< BCRSMatrix< FieldMatrix< T, n, m >, A >, int > | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::MatrixInitializer
| Type of an associated initializer class.
typedef Dune::BlockVector< FieldVector< T, m >, typename std::allocator_traits< A >::template rebind_alloc< FieldVector< T, m > > > | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::domain_type
| The type of the domain of the solver.
typedef Dune::BlockVector< FieldVector< T, n >, typename std::allocator_traits< A >::template rebind_alloc< FieldVector< T, n > > > | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::range_type
| The type of the range of the solver.
using | Dune::UMFPackMethodChooser< std::complex< double > >::size_type = SuiteSparse_long
using | Dune::UMFPack< M >::size_type = SuiteSparse_long
using | Dune::UMFPack< M >::Matrix = M
| The matrix type.
using | Dune::UMFPack< M >::matrix_type = M
using | Dune::UMFPack< M >::UMFPackMatrix = ISTL::Impl::BCCSMatrix<typename Matrix::field_type, size_type>
| The corresponding (scalar) UMFPack matrix type.
using | Dune::UMFPack< M >::MatrixInitializer = ISTL::Impl::BCCSMatrixInitializer<M, size_type>
| Type of an associated initializer class.
using | Dune::UMFPack< M >::domain_type = Impl::UMFPackDomainType<M>
| The type of the domain of the solver.
using | Dune::UMFPack< M >::range_type = Impl::UMFPackRangeType<M>
| The type of the range of the solver.

## Enumerations

enum | { Dune::IsDirectSolver< LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > > >::value = true }
enum | { Dune::StoresColumnCompressed< LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > > >::value = true }
enum | { Dune::IsDirectSolver< SPQR< BCRSMatrix< T, A > > >::value = true }
enum | { Dune::StoresColumnCompressed< SPQR< BCRSMatrix< T, A > > >::value = true }
enum | { Dune::IsDirectSolver< UMFPack< M > >::value =true }
enum | { Dune::StoresColumnCompressed< UMFPack< BCRSMatrix< T, A > > >::value = true }

## Functions

SolverCategory::Category | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::category () const override
| Category of the solver (see SolverCategory::Category).
| Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::LDL (const Matrix &matrix, int verbose=0)
| Construct a solver object from a BCRSMatrix.
| Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::LDL (const Matrix &matrix, int verbose, bool)
| Constructor for compatibility with SuperLU standard constructor.
| Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::LDL (const Matrix &matrix, const ParameterTree &config)
| Constructs the LDL solver.
| Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::LDL ()
| Default constructor.
virtual | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::~LDL ()
| Default constructor.
void | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply (domain_type &x, range_type &b, InverseOperatorResult &res) override
| Apply inverse operator,.
void | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply (domain_type &x, range_type &b, double reduction, InverseOperatorResult &res) override
| apply inverse operator, with given convergence criteria.
void | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply (T *x, T *b)
| Additional apply method with c-arrays in analogy to superlu.
void | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setOption (unsigned int option, double value)
void | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setMatrix (const Matrix &matrix)
| Initialize data from given matrix.
template<class S>
void | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setSubMatrix (const Matrix &matrix, const S &rowIndexSet)
void | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setVerbosity (int v)
| Sets the verbosity level for the solver.
LDLMatrix & | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getInternalMatrix ()
| Return the column compress matrix.
void | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::free ()
| Free allocated space.
const char * | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::name ()
| Get method name.
double * | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getD ()
| Get factorization diagonal matrix D.
int * | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getLp ()
| Get factorization Lp.
int * | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getLi ()
| Get factorization Li.
double * | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getLx ()
| Get factorization Lx.

Dune::DUNE_REGISTER_SOLVER ("ldl", [](auto opTraits, const auto &op, const Dune::ParameterTree &config) -> std::shared_ptr< typename decltype(opTraits)::solver_type > { using OpTraits=decltype(opTraits);using M=typename OpTraits::matrix_type;if constexpr(OpTraits::isParallel){ if(opTraits.getCommOrThrow(op).communicator().size() > 1) DUNE_THROW(Dune::InvalidStateException, "LDL works only for sequential operators.");} if constexpr(std::is_convertible_v< LDL< M > *, Dune::InverseOperator< typename OpTraits::domain_type, typename OpTraits::range_type > * > &&std::is_same_v< typename FieldTraits< M >::field_type, double >){ const auto &A=opTraits.getAssembledOpOrThrow(op);const M &mat=A->getmat();int verbose=config.get("verbose", 0);return std::make_shared< LDL< M > >(mat, verbose);} DUNE_THROW(UnsupportedType, "Unsupported Type in LDL (only FieldMatrix<double,...> supported)");})

SolverCategory::Category | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::category () const override
| Category of the solver (see SolverCategory::Category).
| Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SPQR (const Matrix &matrix, int verbose=0)
| Construct a solver object from a BCRSMatrix.
| Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SPQR (const Matrix &matrix, int verbose, bool)
| Constructor for compatibility with SuperLU standard constructor.
| Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SPQR (const Matrix &matrix, const ParameterTree &config)
| Constructs the SPQR solver.
| Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SPQR ()
| Default constructor.
virtual | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::~SPQR ()
| Destructor.
void | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply (domain_type &x, range_type &b, InverseOperatorResult &res) override
| Apply inverse operator,.
void | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply (domain_type &x, range_type &b, double reduction, InverseOperatorResult &res) override
| apply inverse operator, with given convergence criteria.
void | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setOption (unsigned int option, double value)
void | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setMatrix (const Matrix &matrix)
| Initialize data from given matrix.
template<class S>
void | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setSubMatrix (const Matrix &matrix, const S &rowIndexSet)
void | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setVerbosity (int v)
| Sets the verbosity level for the solver.
SuiteSparseQR_factorization< T > * | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getFactorization ()
| Return the matrix factorization.
SPQRMatrix & | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getInternalMatrix ()
| Return the column coppressed matrix.
void | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::free ()
| Free allocated space.
const char * | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::name ()
| Get method name.

Dune::DUNE_REGISTER_SOLVER ("spqr", [](auto opTraits, const auto &op, const Dune::ParameterTree &config) -> std::shared_ptr< typename decltype(opTraits)::solver_type > { using OpTraits=decltype(opTraits);using M=typename OpTraits::matrix_type;if constexpr(OpTraits::isParallel){ if(opTraits.getCommOrThrow(op).communicator().size() > 1) DUNE_THROW(Dune::InvalidStateException, "SPQR works only for sequential operators.");} if constexpr(std::is_convertible_v< SPQR< M > *, Dune::InverseOperator< typename OpTraits::domain_type, typename OpTraits::range_type > * > &&std::is_same_v< typename FieldTraits< M >::field_type, double >){ const auto &A=opTraits.getAssembledOpOrThrow(op);const M &mat=A->getmat();int verbose=config.get("verbose", 0);return std::make_shared< Dune::SPQR< M > >(mat, verbose);} DUNE_THROW(UnsupportedType, "Unsupported Type in SPQR (only FieldMatrix<double,...> supported)");})

template<typename... A>
static void | Dune::UMFPackMethodChooser< double >::defaults (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< double >::free_numeric (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< double >::free_symbolic (A... args)
template<typename... A>
static int | Dune::UMFPackMethodChooser< double >::load_numeric (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< double >::numeric (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< double >::report_info (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< double >::report_status (A... args)
template<typename... A>
static int | Dune::UMFPackMethodChooser< double >::save_numeric (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< double >::solve (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< double >::symbolic (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< std::complex< double > >::defaults (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< std::complex< double > >::free_numeric (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< std::complex< double > >::free_symbolic (A... args)
template<typename... A>
static int | Dune::UMFPackMethodChooser< std::complex< double > >::load_numeric (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< std::complex< double > >::numeric (const size_type *cs, const size_type *ri, const double *val, A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< std::complex< double > >::report_info (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< std::complex< double > >::report_status (A... args)
template<typename... A>
static int | Dune::UMFPackMethodChooser< std::complex< double > >::save_numeric (A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< std::complex< double > >::solve (size_type m, const size_type *cs, const size_type *ri, std::complex< double > *val, double *x, const double *b, A... args)
template<typename... A>
static void | Dune::UMFPackMethodChooser< std::complex< double > >::symbolic (size_type m, size_type n, const size_type *cs, const size_type *ri, const double *val, A... args)
SolverCategory::Category | Dune::UMFPack< M >::category () const override
| Category of the solver (see SolverCategory::Category).
| Dune::UMFPack< M >::UMFPack (const Matrix &matrix, int verbose=0)
| Construct a solver object from a matrix.
| Dune::UMFPack< M >::UMFPack (const Matrix &matrix, int verbose, bool)
| Constructor for compatibility with SuperLU standard constructor.
| Dune::UMFPack< M >::UMFPack (const Matrix &mat_, const ParameterTree &config)
| Construct a solver object from a matrix.
| Dune::UMFPack< M >::UMFPack ()
| default constructor
| Dune::UMFPack< M >::UMFPack (const Matrix &mat_, const char *file, int verbose=0)
| Try loading a decomposition from file and do a decomposition if unsuccessful.
| Dune::UMFPack< M >::UMFPack (const char *file, int verbose=0)
| try loading a decomposition from file
virtual | Dune::UMFPack< M >::~UMFPack ()
void | Dune::UMFPack< M >::apply (domain_type &x, range_type &b, InverseOperatorResult &res) override
| Apply inverse operator,.
void | Dune::UMFPack< M >::apply (domain_type &x, range_type &b, double reduction, InverseOperatorResult &res) override
| apply inverse operator, with given convergence criteria.
void | Dune::UMFPack< M >::apply (T *x, T *b)
| additional apply method with c-arrays in analogy to superlu
void | Dune::UMFPack< M >::setOption (unsigned int option, double value)
| Set UMFPack-specific options.
void | Dune::UMFPack< M >::saveDecomposition (const char *file)
| saves a decomposition to a file
template<class BitVector = Impl::NoBitVector>
void | Dune::UMFPack< M >::setMatrix (const Matrix &matrix, const BitVector &bitVector={})
| Initialize data from given matrix.
void | Dune::UMFPack< M >::setSubMatrix (const Matrix &_mat, const std::set< typename Matrix::size_type > &rowIndexSet)
void | Dune::UMFPack< M >::setVerbosity (int v)
| sets the verbosity level for the UMFPack solver
void * | Dune::UMFPack< M >::getFactorization ()
| Return the matrix factorization.
UMFPackMatrix & | Dune::UMFPack< M >::getInternalMatrix ()
| Return the column compress matrix from UMFPack.
void | Dune::UMFPack< M >::free ()
| free allocated space.
const char * | Dune::UMFPack< M >::name ()

Dune::DUNE_REGISTER_SOLVER ("umfpack", [](auto opTraits, const auto &op, const Dune::ParameterTree &config) -> std::shared_ptr< typename decltype(opTraits)::solver_type > { using OpTraits=decltype(opTraits);if constexpr(OpTraits::isParallel){ if(opTraits.getCommOrThrow(op).communicator().size() > 1) DUNE_THROW(Dune::InvalidStateException, "UMFPack works only for sequential operators.");} if constexpr(OpTraits::isAssembled){ using M=typename OpTraits::matrix_type;if constexpr(UMFPackImpl::isValidBlock< OpTraits >::value) { const auto &A=opTraits.getAssembledOpOrThrow(op);const M &mat=A->getmat();int verbose=config.get("verbose", 0);return std::make_shared< Dune::UMFPack< M > >(mat, verbose);} } DUNE_THROW(UnsupportedType, "Unsupported Type in UMFPack (only double and std::complex<double> supported)");return nullptr;})

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.
template<class S>
void | Dune::ILU0SubdomainSolver< M, X, Y >::setSubMatrix (const M &A, S &rowset)
| Set the data of the local problem.
template<class S>
void | Dune::ILUNSubdomainSolver< M, X, Y >::setSubMatrix (const M &A, S &rowset)
| Set the data of the local problem.
| Dune::SuperLU< M >::~SuperLU ()
void | Dune::SuperLU< M >::free ()
| free allocated space.
| Dune::SuperLU< M >::SuperLU (const Matrix &matrix, bool verbose=false, bool reusevector=true)
| Constructs the SuperLU solver.
| Dune::SuperLU< M >::SuperLU ()
| Empty default constructor.
void | Dune::SuperLU< M >::setVerbosity (bool v)
void | Dune::SuperLU< M >::setMatrix (const Matrix &mat)
| Initialize data from given matrix.
template<class S>
void | Dune::SuperLU< M >::setSubMatrix (const Matrix &mat, const S &rowIndexSet)
void | Dune::SuperLU< M >::apply (domain_type &x, range_type &b, InverseOperatorResult &res) override
| Apply inverse operator,.
void | Dune::SuperLU< M >::apply (T *x, T *b)
| Apply SuperLu to C arrays.

## Variables

static constexpr bool | Dune::UMFPackMethodChooser< T >::valid = false
static constexpr bool | Dune::UMFPackMethodChooser< double >::valid = true
static constexpr bool | Dune::UMFPackMethodChooser< std::complex< double > >::valid = true

## Friends

template<class M, class X, class TM, class TD, class T1>
class | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SeqOverlappingSchwarz
struct | Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SeqOverlappingSchwarzAssemblerHelper< LDL< Matrix >, true >
template<class M, class X, class TM, class TD, class T1>
class | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SeqOverlappingSchwarz
struct | Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SeqOverlappingSchwarzAssemblerHelper< SPQR< Matrix >, true >
template<class Mat, class X, class TM, class TD, class T1>
class | Dune::UMFPack< M >::SeqOverlappingSchwarz
struct | Dune::UMFPack< M >::SeqOverlappingSchwarzAssemblerHelper< UMFPack< Matrix >, true >

## 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 or . Dense blocks of different sizes e.g. arise in 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 block structure where 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.

## Typedef Documentation

## domain_type [1/3]

template<typename T, typename A, int n, int m>

typedef Dune::BlockVector<FieldVector<T,m>, typename std::allocator_traits<A>::template rebind_alloc<FieldVector<T,m> > > Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::domain_type

The type of the domain of the solver.

## domain_type [2/3]

template<typename T, typename A, int n, int m>

typedef Dune::BlockVector<FieldVector<T,m>, typename std::allocator_traits<A>::template rebind_alloc<FieldVector<T,m> > > Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::domain_type

The type of the domain of the solver.

## domain_type [3/3]

template<typename M>

using Dune::UMFPack< M >::domain_type = Impl::UMFPackDomainType<M>

The type of the domain of the solver.

## LDLMatrix

template<typename T, typename A, int n, int m>

typedef Dune::ISTL::Impl::BCCSMatrix<T,int> Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::LDLMatrix

The corresponding SuperLU Matrix type.

## Matrix [1/3]

template<typename T, typename A, int n, int m>

typedef Dune::BCRSMatrix<FieldMatrix<T,n,m>,A> Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::Matrix

The matrix type.

## Matrix [2/3]

template<typename T, typename A, int n, int m>

typedef Dune::BCRSMatrix<FieldMatrix<T,n,m>,A> Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::Matrix

The matrix type.

## Matrix [3/3]

template<typename M>

using Dune::UMFPack< M >::Matrix = M

The matrix type.

## matrix_type [1/3]

template<typename T, typename A, int n, int m>

typedef Dune::BCRSMatrix<FieldMatrix<T,n,m>,A> Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::matrix_type

## matrix_type [2/3]

template<typename T, typename A, int n, int m>

typedef Dune::BCRSMatrix<FieldMatrix<T,n,m>,A> Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::matrix_type

## matrix_type [3/3]

template<typename M>

using Dune::UMFPack< M >::matrix_type = M

## MatrixInitializer [1/3]

template<typename T, typename A, int n, int m>

typedef ISTL::Impl::BCCSMatrixInitializer<BCRSMatrix<FieldMatrix<T,n,m>,A>, int> Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::MatrixInitializer

Type of an associated initializer class.

## MatrixInitializer [2/3]

template<typename T, typename A, int n, int m>

typedef ISTL::Impl::BCCSMatrixInitializer<BCRSMatrix<FieldMatrix<T,n,m>,A>, int> Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::MatrixInitializer

Type of an associated initializer class.

## MatrixInitializer [3/3]

template<typename M>

using Dune::UMFPack< M >::MatrixInitializer = ISTL::Impl::BCCSMatrixInitializer<M, size_type>

Type of an associated initializer class.

## range_type [1/3]

template<typename T, typename A, int n, int m>

typedef Dune::BlockVector<FieldVector<T,n>, typename std::allocator_traits<A>::template rebind_alloc<FieldVector<T,n> > > Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::range_type

The type of the range of the solver.

## range_type [2/3]

template<typename T, typename A, int n, int m>

typedef Dune::BlockVector<FieldVector<T,n>, typename std::allocator_traits<A>::template rebind_alloc<FieldVector<T,n> > > Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::range_type

The type of the range of the solver.

## range_type [3/3]

template<typename M>

using Dune::UMFPack< M >::range_type = Impl::UMFPackRangeType<M>

The type of the range of the solver.

## size_type [1/2]

template<typename M>

using Dune::UMFPack< M >::size_type = SuiteSparse_long

## size_type [2/2]

using Dune::UMFPackMethodChooser< std::complex< double > >::size_type = SuiteSparse_long

## SPQRMatrix

template<typename T, typename A, int n, int m>

typedef ISTL::Impl::BCCSMatrix<T,int> Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SPQRMatrix

The corresponding SuperLU Matrix type.

## UMFPackMatrix

template<typename M>

using Dune::UMFPack< M >::UMFPackMatrix = ISTL::Impl::BCCSMatrix<typename Matrix::field_type, size_type>

The corresponding (scalar) UMFPack matrix type.

## Enumeration Type Documentation

## anonymous enum

template<typename T, typename A>

anonymous enum

Enumerator
value |

## anonymous enum

template<typename T, typename A, int n, int m>

anonymous enum

Enumerator
value |

## anonymous enum

template<typename T, typename A>

anonymous enum

Enumerator
value |

## anonymous enum

template<typename T, typename A>

anonymous enum

Enumerator
value |

## anonymous enum

template<typename T, typename A, int n, int m>

anonymous enum

Enumerator
value |

## anonymous enum

template<typename M>

anonymous enum

Enumerator
value |

## Function Documentation

## apply() [1/10]

template<typename T, typename A, int n, int m>

void Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply | ( | domain_type & | x,
|  | range_type & | b,
|  | double | reduction,
|  | InverseOperatorResult & | res )

inline override

apply inverse operator, with given convergence criteria.

Warning
  Right hand side b may be overwritten!

Parameters

  x | The left hand side to store the result in.
  b | The right hand side
  reduction | The minimum defect reduction to achieve.
  res | Object to store the statistics about applying the operator.

Exceptions

  SolverAbort | When the solver detects a problem and cannot continue

## apply() [2/10]

template<typename T, typename A, int n, int m>

void Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply | ( | domain_type & | x,
|  | range_type & | b,
|  | InverseOperatorResult & | res )

inline override

Apply inverse operator,.

Warning
  Note: right hand side b may be overwritten!

Parameters

  x | The left hand side to store the result in.
  b | The right hand side
  res | Object to store the statistics about applying the operator.

Exceptions

  SolverAbort | When the solver detects a problem and cannot continue

## apply() [3/10]

template<typename T, typename A, int n, int m>

void Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply | ( | T * | x,
|  | T * | b )

inline

Additional apply method with c-arrays in analogy to superlu.

Parameters

  x | solution array
  b | rhs array

## apply() [4/10]

template<typename T, typename A, int n, int m>

void Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply | ( | domain_type & | x,
|  | range_type & | b,
|  | double | reduction,
|  | InverseOperatorResult & | res )

inline override

apply inverse operator, with given convergence criteria.

Warning
  Right hand side b may be overwritten!

Parameters

  x | The left hand side to store the result in.
  b | The right hand side
  reduction | The minimum defect reduction to achieve.
  res | Object to store the statistics about applying the operator.

Exceptions

  SolverAbort | When the solver detects a problem and cannot continue

## apply() [5/10]

template<typename T, typename A, int n, int m>

void Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::apply | ( | domain_type & | x,
|  | range_type & | b,
|  | InverseOperatorResult & | res )

inline override

Apply inverse operator,.

Warning
  Note: right hand side b may be overwritten!

Parameters

  x | The left hand side to store the result in.
  b | The right hand side
  res | Object to store the statistics about applying the operator.

Exceptions

  SolverAbort | When the solver detects a problem and cannot continue

## apply() [6/10]

template<typename M>

void Dune::SuperLU< M >::apply | ( | domain_type & | x,
|  | range_type & | b,
|  | InverseOperatorResult & | res )

override

Apply inverse operator,.

Warning
  Note: right hand side b may be overwritten!

Parameters

  x | The left hand side to store the result in.
  b | The right hand side
  res | Object to store the statistics about applying the operator.

Exceptions

  SolverAbort | When the solver detects a problem and cannot continue

## apply() [7/10]

template<typename M>

void Dune::SuperLU< M >::apply | ( | T * | x,
|  | T * | b )

Apply SuperLu to C arrays.

## apply() [8/10]

template<typename M>

void Dune::UMFPack< M >::apply | ( | domain_type & | x,
|  | range_type & | b,
|  | double | reduction,
|  | InverseOperatorResult & | res )

inline override

apply inverse operator, with given convergence criteria.

Warning
  Right hand side b may be overwritten!

Parameters

  x | The left hand side to store the result in.
  b | The right hand side
  reduction | The minimum defect reduction to achieve.
  res | Object to store the statistics about applying the operator.

Exceptions

  SolverAbort | When the solver detects a problem and cannot continue

## apply() [9/10]

template<typename M>

void Dune::UMFPack< M >::apply | ( | domain_type & | x,
|  | range_type & | b,
|  | InverseOperatorResult & | res )

inline override

Apply inverse operator,.

Warning
  Note: right hand side b may be overwritten!

Parameters

  x | The left hand side to store the result in.
  b | The right hand side
  res | Object to store the statistics about applying the operator.

Exceptions

  SolverAbort | When the solver detects a problem and cannot continue

## apply() [10/10]

template<typename M>

void Dune::UMFPack< M >::apply | ( | T * | x,
|  | T * | b )

inline

additional apply method with c-arrays in analogy to superlu

Parameters

  x | solution array
  b | rhs array

NOTE If the user hands over a pure pointer, we assume that they know what they are doing, hence no copy to flat structures

## category() [1/3]

template<typename T, typename A, int n, int m>

SolverCategory::Category Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::category | ( |  | ) | const

inline override virtual

Category of the solver (see SolverCategory::Category).

Implements Dune::InverseOperator< BlockVector< FieldVector< T, m >, std::allocator_traits< A >::template rebind_alloc< FieldVector< T, m > > >, BlockVector< FieldVector< T, n >, std::allocator_traits< A >::template rebind_alloc< FieldVector< T, n > > > >.

## category() [2/3]

template<typename T, typename A, int n, int m>

SolverCategory::Category Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::category | ( |  | ) | const

inline override virtual

Category of the solver (see SolverCategory::Category).

Implements Dune::InverseOperator< BlockVector< FieldVector< T, m >, std::allocator_traits< A >::template rebind_alloc< FieldVector< T, m > > >, BlockVector< FieldVector< T, n >, std::allocator_traits< A >::template rebind_alloc< FieldVector< T, n > > > >.

## category() [3/3]

template<typename M>

SolverCategory::Category Dune::UMFPack< M >::category | ( |  | ) | const

inline override

Category of the solver (see SolverCategory::Category).

## copyToLocalMatrix()

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

  A | The global matrix.
  rowset | The global indices of the local problem.

## defaults() [1/2]

template<typename... A>

void Dune::UMFPackMethodChooser< double >::defaults | ( | A... | args | ) |

inline static

## defaults() [2/2]

template<typename... A>

void Dune::UMFPackMethodChooser< std::complex< double > >::defaults | ( | A... | args | ) |

inline static

## DUNE_REGISTER_SOLVER() [1/3]

Dune::DUNE_REGISTER_SOLVER | ( | "ldl" | ,

[] (auto opTraits, const auto &op, const Dune::ParameterTree &config) -> std::shared_ptr< typename decltype(opTraits)::solver_type > { using OpTraits=decltype(opTraits);using M=typename OpTraits::matrix_type;if constexpr(OpTraits::isParallel){ if(opTraits.getCommOrThrow(op).communicator().size() > 1) DUNE_THROW(Dune::InvalidStateException, "LDL works only for sequential operators.");} if constexpr(std::is_convertible_v< LDL< M > *, Dune::InverseOperator< typename OpTraits::domain_type, typename OpTraits::range_type > * > &&std::is_same_v< typename FieldTraits< M >::field_type, double >){ const auto &A=opTraits.getAssembledOpOrThrow(op);const M &mat=A->getmat();int verbose=config.get("verbose", 0);return std::make_shared< LDL< M > >(mat, verbose);} DUNE_THROW(UnsupportedType, "Unsupported Type in LDL (only FieldMatrix<double,...> supported)");}

)

## DUNE_REGISTER_SOLVER() [2/3]

Dune::DUNE_REGISTER_SOLVER | ( | "spqr" | ,

[] (auto opTraits, const auto &op, const Dune::ParameterTree &config) -> std::shared_ptr< typename decltype(opTraits)::solver_type > { using OpTraits=decltype(opTraits);using M=typename OpTraits::matrix_type;if constexpr(OpTraits::isParallel){ if(opTraits.getCommOrThrow(op).communicator().size() > 1) DUNE_THROW(Dune::InvalidStateException, "SPQR works only for sequential operators.");} if constexpr(std::is_convertible_v< SPQR< M > *, Dune::InverseOperator< typename OpTraits::domain_type, typename OpTraits::range_type > * > &&std::is_same_v< typename FieldTraits< M >::field_type, double >){ const auto &A=opTraits.getAssembledOpOrThrow(op);const M &mat=A->getmat();int verbose=config.get("verbose", 0);return std::make_shared< Dune::SPQR< M > >(mat, verbose);} DUNE_THROW(UnsupportedType, "Unsupported Type in SPQR (only FieldMatrix<double,...> supported)");}

)

## DUNE_REGISTER_SOLVER() [3/3]

Dune::DUNE_REGISTER_SOLVER | ( | "umfpack" | ,

[] (auto opTraits, const auto &op, const Dune::ParameterTree &config) -> std::shared_ptr< typename decltype(opTraits)::solver_type > { using OpTraits=decltype(opTraits);if constexpr(OpTraits::isParallel){ if(opTraits.getCommOrThrow(op).communicator().size() > 1) DUNE_THROW(Dune::InvalidStateException, "UMFPack works only for sequential operators.");} if constexpr(OpTraits::isAssembled){ using M=typename OpTraits::matrix_type;if constexpr(UMFPackImpl::isValidBlock< OpTraits >::value) { const auto &A=opTraits.getAssembledOpOrThrow(op);const M &mat=A->getmat();int verbose=config.get("verbose", 0);return std::make_shared< Dune::UMFPack< M > >(mat, verbose);} } DUNE_THROW(UnsupportedType, "Unsupported Type in UMFPack (only double and std::complex<double> supported)");return nullptr;}

)

## free() [1/4]

template<typename T, typename A, int n, int m>

void Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::free | ( |  | ) |

inline

Free allocated space.

Warning
  Later calling apply will result in an error.

## free() [2/4]

template<typename T, typename A, int n, int m>

void Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::free | ( |  | ) |

inline

Free allocated space.

Warning
  Later calling apply will result in an error.

## free() [3/4]

template<typename M>

void Dune::SuperLU< M >::free | ( |  | ) |

free allocated space.

Warning
  later calling apply will result in an error.

## free() [4/4]

template<typename M>

void Dune::UMFPack< M >::free | ( |  | ) |

inline

free allocated space.

Warning
  later calling apply will result in an error.

## free_numeric() [1/2]

template<typename... A>

void Dune::UMFPackMethodChooser< double >::free_numeric | ( | A... | args | ) |

inline static

## free_numeric() [2/2]

template<typename... A>

void Dune::UMFPackMethodChooser< std::complex< double > >::free_numeric | ( | A... | args | ) |

inline static

## free_symbolic() [1/2]

template<typename... A>

void Dune::UMFPackMethodChooser< double >::free_symbolic | ( | A... | args | ) |

inline static

## free_symbolic() [2/2]

template<typename... A>

void Dune::UMFPackMethodChooser< std::complex< double > >::free_symbolic | ( | A... | args | ) |

inline static

## getD()

template<typename T, typename A, int n, int m>

double * Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getD | ( |  | ) |

inline

Get factorization diagonal matrix D.

Warning
  It is up to the user to preserve consistency.

## getFactorization() [1/2]

template<typename T, typename A, int n, int m>

SuiteSparseQR_factorization< T > * Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getFactorization | ( |  | ) |

inline

Return the matrix factorization.

Warning
  It is up to the user to keep consistency.

## getFactorization() [2/2]

template<typename M>

void * Dune::UMFPack< M >::getFactorization | ( |  | ) |

inline

Return the matrix factorization.

Warning
  It is up to the user to keep consistency.

## getInternalMatrix() [1/3]

template<typename T, typename A, int n, int m>

LDLMatrix & Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getInternalMatrix | ( |  | ) |

inline

Return the column compress matrix.

Warning
  It is up to the user to keep consistency.

## getInternalMatrix() [2/3]

template<typename T, typename A, int n, int m>

SPQRMatrix & Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getInternalMatrix | ( |  | ) |

inline

Return the column coppressed matrix.

Warning
  It is up to the user to keep consistency.

## getInternalMatrix() [3/3]

template<typename M>

UMFPackMatrix & Dune::UMFPack< M >::getInternalMatrix | ( |  | ) |

inline

Return the column compress matrix from UMFPack.

Warning
  It is up to the user to keep consistency.

## getLi()

template<typename T, typename A, int n, int m>

int * Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getLi | ( |  | ) |

inline

Get factorization Li.

Warning
  It is up to the user to preserve consistency.

## getLp()

template<typename T, typename A, int n, int m>

int * Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getLp | ( |  | ) |

inline

Get factorization Lp.

Warning
  It is up to the user to preserve consistency.

## getLx()

template<typename T, typename A, int n, int m>

double * Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::getLx | ( |  | ) |

inline

Get factorization Lx.

Warning
  It is up to the user to preserve consistency.

## LDL() [1/4]

template<typename T, typename A, int n, int m>

Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::LDL | ( |  | ) |

inline

Default constructor.

## LDL() [2/4]

template<typename T, typename A, int n, int m>

Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::LDL | ( | const Matrix & | matrix,
|  | const ParameterTree & | config )

inline

Constructs the LDL solver.

Parameters

  matrix | The matrix of the system to solve.
  config | ParameterTree containing solver parameters.

ParameterTree Key | Meaning
--- | ---
verbose | The verbosity level. default=0

## LDL() [3/4]

template<typename T, typename A, int n, int m>

Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::LDL | ( | const Matrix & | matrix,
|  | int | verbose,
|  | bool | )

inline

Constructor for compatibility with SuperLU standard constructor.

This computes the matrix decomposition, and may take a long time (and use a lot of memory).

Parameters

  matrix | the matrix to solve for
  verbose | 0 or 1 set the verbosity level, defaults to 0

## LDL() [4/4]

template<typename T, typename A, int n, int m>

Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::LDL | ( | const Matrix & | matrix,
|  | int | verbose = 0 )

inline

Construct a solver object from a BCRSMatrix.

This computes the matrix decomposition, and may take a long time (and use a lot of memory).

Parameters

  matrix | the matrix to solve for
  verbose | 0 or 1 set the verbosity level, defaults to 0

## load_numeric() [1/2]

template<typename... A>

int Dune::UMFPackMethodChooser< double >::load_numeric | ( | A... | args | ) |

inline static

## load_numeric() [2/2]

template<typename... A>

int Dune::UMFPackMethodChooser< std::complex< double > >::load_numeric | ( | A... | args | ) |

inline static

## name() [1/3]

template<typename T, typename A, int n, int m>

const char * Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::name | ( |  | ) |

inline

Get method name.

## name() [2/3]

template<typename T, typename A, int n, int m>

const char * Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::name | ( |  | ) |

inline

Get method name.

## name() [3/3]

template<typename M>

const char * Dune::UMFPack< M >::name | ( |  | ) |

inline

## numeric() [1/2]

template<typename... A>

void Dune::UMFPackMethodChooser< double >::numeric | ( | A... | args | ) |

inline static

## numeric() [2/2]

template<typename... A>

void Dune::UMFPackMethodChooser< std::complex< double > >::numeric | ( | const size_type * | cs,
|  | const size_type * | ri,
|  | const double * | val,
|  | A... | args )

inline static

## report_info() [1/2]

template<typename... A>

void Dune::UMFPackMethodChooser< double >::report_info | ( | A... | args | ) |

inline static

## report_info() [2/2]

template<typename... A>

void Dune::UMFPackMethodChooser< std::complex< double > >::report_info | ( | A... | args | ) |

inline static

## report_status() [1/2]

template<typename... A>

void Dune::UMFPackMethodChooser< double >::report_status | ( | A... | args | ) |

inline static

## report_status() [2/2]

template<typename... A>

void Dune::UMFPackMethodChooser< std::complex< double > >::report_status | ( | A... | args | ) |

inline static

## save_numeric() [1/2]

template<typename... A>

int Dune::UMFPackMethodChooser< double >::save_numeric | ( | A... | args | ) |

inline static

## save_numeric() [2/2]

template<typename... A>

int Dune::UMFPackMethodChooser< std::complex< double > >::save_numeric | ( | A... | args | ) |

inline static

## saveDecomposition()

template<typename M>

void Dune::UMFPack< M >::saveDecomposition | ( | const char * | file | ) |

inline

saves a decomposition to a file

Parameters

  file | the filename to save to

## setMatrix() [1/4]

template<typename T, typename A, int n, int m>

void Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setMatrix | ( | const Matrix & | matrix | ) |

inline

Initialize data from given matrix.

## setMatrix() [2/4]

template<typename T, typename A, int n, int m>

void Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setMatrix | ( | const Matrix & | matrix | ) |

inline

Initialize data from given matrix.

## setMatrix() [3/4]

template<typename M>

void Dune::SuperLU< M >::setMatrix | ( | const Matrix & | mat | ) |

Initialize data from given matrix.

## setMatrix() [4/4]

template<typename M>
template<class BitVector = Impl::NoBitVector>

void Dune::UMFPack< M >::setMatrix | ( | const Matrix & | matrix,
|  | const BitVector & | bitVector = {} )

inline

Initialize data from given matrix.

Template Parameters

  BitVector | a compatible bitvector to the domain_type/range_type. Defaults to NoBitVector for backwards compatibility

A positive bit indices that the corresponding matrix row/column is excluded from the UMFPACK decomposition. WARNING This is an opposite behavior of the previous implementation in setSubMatrix.

## setOption() [1/3]

template<typename T, typename A, int n, int m>

void Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setOption | ( | unsigned int | option,
|  | double | value )

inline

## setOption() [2/3]

template<typename T, typename A, int n, int m>

void Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setOption | ( | unsigned int | option,
|  | double | value )

inline

## setOption() [3/3]

template<typename M>

void Dune::UMFPack< M >::setOption | ( | unsigned int | option,
|  | double | value )

inline

Set UMFPack-specific options.

This method allows to set various options that control the UMFPack solver. More specifically, it allows to set values in the UMF_Control array. Please see the UMFPack documentation for a list of possible options and values.

Parameters

  option | Entry in the UMF_Control array, e.g., UMFPACK_IRSTEP
  value | Corresponding value

Exceptions

  RangeError | If nonexisting option was requested

## setSubMatrix() [1/6]

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

  A | The global matrix.
  rowset | The global indices of the local problem.

Template Parameters

  S | The type of the set with the indices.

## setSubMatrix() [2/6]

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

  A | The global matrix.
  rowset | The global indices of the local problem.

Template Parameters

  S | The type of the set with the indices.

## setSubMatrix() [3/6]

template<typename T, typename A, int n, int m>
template<class S>

void Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setSubMatrix | ( | const Matrix & | matrix,
|  | const S & | rowIndexSet )

inline

## setSubMatrix() [4/6]

template<typename T, typename A, int n, int m>
template<class S>

void Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setSubMatrix | ( | const Matrix & | matrix,
|  | const S & | rowIndexSet )

inline

## setSubMatrix() [5/6]

template<typename M>
template<class S>

void Dune::SuperLU< M >::setSubMatrix | ( | const Matrix & | mat,
|  | const S & | rowIndexSet )

## setSubMatrix() [6/6]

template<typename M>

void Dune::UMFPack< M >::setSubMatrix | ( | const Matrix & | _mat,
|  | const std::set< typename Matrix::size_type > & | rowIndexSet )

inline

## setVerbosity() [1/4]

template<typename T, typename A, int n, int m>

void Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setVerbosity | ( | int | v | ) |

inline

Sets the verbosity level for the solver.

Parameters

  v | verbosity level: 0 only error messages, 1 a bit of statistics.

## setVerbosity() [2/4]

template<typename T, typename A, int n, int m>

void Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::setVerbosity | ( | int | v | ) |

inline

Sets the verbosity level for the solver.

Parameters

  v | verbosity level: 0 only error messages, 1 a bit of statistics.

## setVerbosity() [3/4]

template<typename M>

void Dune::SuperLU< M >::setVerbosity | ( | bool | v | ) |

## setVerbosity() [4/4]

template<typename M>

void Dune::UMFPack< M >::setVerbosity | ( | int | v | ) |

inline

sets the verbosity level for the UMFPack solver

Parameters

  v | verbosity level The following levels are implemented: 0 - only error messages 1 - a bit of statistics on decomposition and solution 2 - lots of statistics on decomposition and solution

## solve() [1/2]

template<typename... A>

void Dune::UMFPackMethodChooser< double >::solve | ( | A... | args | ) |

inline static

## solve() [2/2]

template<typename... A>

void Dune::UMFPackMethodChooser< std::complex< double > >::solve | ( | size_type | m,
|  | const size_type * | cs,
|  | const size_type * | ri,
|  | std::complex< double > * | val,
|  | double * | x,
|  | const double * | b,
|  | A... | args )

inline static

## SPQR() [1/4]

template<typename T, typename A, int n, int m>

Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SPQR | ( |  | ) |

inline

Default constructor.

## SPQR() [2/4]

template<typename T, typename A, int n, int m>

Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SPQR | ( | const Matrix & | matrix,
|  | const ParameterTree & | config )

inline

Constructs the SPQR solver.

Parameters

  matrix | The matrix of the system to solve.
  config | ParameterTree containing solver parameters.

ParameterTree Key | Meaning
--- | ---
verbose | The verbosity level. default=0

## SPQR() [3/4]

template<typename T, typename A, int n, int m>

Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SPQR | ( | const Matrix & | matrix,
|  | int | verbose,
|  | bool | )

inline

Constructor for compatibility with SuperLU standard constructor.

This computes the matrix decomposition, and may take a long time (and use a lot of memory).

Parameters

  matrix | the matrix to solve for
  verbose | 0 or 1, set the verbosity level, defaults to 0

## SPQR() [4/4]

template<typename T, typename A, int n, int m>

Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::SPQR | ( | const Matrix & | matrix,
|  | int | verbose = 0 )

inline

Construct a solver object from a BCRSMatrix.

This computes the matrix decomposition, and may take a long time (and use a lot of memory).

Parameters

  matrix | the matrix to solve for
  verbose | 0 or 1, set the verbosity level, defaults to 0

## SuperLU() [1/2]

template<typename M>

Dune::SuperLU< M >::SuperLU | ( |  | ) |

Empty default constructor.

Use setMatrix to tell SuperLU for what matrix it solves. Using this constructor no vectors will be reused.

## SuperLU() [2/2]

template<typename M>

Dune::SuperLU< M >::SuperLU | ( | const Matrix & | matrix,
|  | bool | verbose = false,
|  | bool | reusevector = true )

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

  matrix | The matrix of the system to solve.
  verbose | If true some statistics are printed.
  reusevector | Default value is true. If true the two vectors are allocate in the first call to apply. These get resused in subsequent calls to apply and are deallocated in the destructor. If false these vectors are allocated at the beginning and deallocated at the end of each apply method. This allows using the same instance of superlu from different threads.

## symbolic() [1/2]

template<typename... A>

void Dune::UMFPackMethodChooser< double >::symbolic | ( | A... | args | ) |

inline static

## symbolic() [2/2]

template<typename... A>

void Dune::UMFPackMethodChooser< std::complex< double > >::symbolic | ( | size_type | m,
|  | size_type | n,
|  | const size_type * | cs,
|  | const size_type * | ri,
|  | const double * | val,
|  | A... | args )

inline static

## UMFPack() [1/6]

template<typename M>

Dune::UMFPack< M >::UMFPack | ( |  | ) |

inline

default constructor

## UMFPack() [2/6]

template<typename M>

Dune::UMFPack< M >::UMFPack | ( | const char * | file,
|  | int | verbose = 0 )

inline

try loading a decomposition from file

Parameters

  file | the decomposition file
  verbose | the verbosity level

Exceptions

  Dune::Exception | When not being able to load the file. Does not need knowledge of the actual matrix!

## UMFPack() [3/6]

template<typename M>

Dune::UMFPack< M >::UMFPack | ( | const Matrix & | mat_,
|  | const char * | file,
|  | int | verbose = 0 )

inline

Try loading a decomposition from file and do a decomposition if unsuccessful.

Parameters

  mat_ | the matrix to decompose when no decoposition file found
  file | the decomposition file
  verbose | the verbosity level

Use saveDecomposition(char* file) for manually storing a decomposition. This constructor will decompose mat_ and store the result to file if no file wasn't found in the first place. Thus, if you always use this you will only compute the decomposition once (and when you manually deleted the decomposition file).

## UMFPack() [4/6]

template<typename M>

Dune::UMFPack< M >::UMFPack | ( | const Matrix & | mat_,
|  | const ParameterTree & | config )

inline

Construct a solver object from a matrix.

Parameters

  mat_ | the matrix to solve for
  config | ParameterTree containing solver parameters.

ParameterTree Key | Meaning
--- | ---
verbose | The verbosity level. default=0

## UMFPack() [5/6]

template<typename M>

Dune::UMFPack< M >::UMFPack | ( | const Matrix & | matrix,
|  | int | verbose,
|  | bool | )

inline

Constructor for compatibility with SuperLU standard constructor.

This computes the matrix decomposition, and may take a long time (and use a lot of memory).

Parameters

  matrix | the matrix to solve for
  verbose | [0..2] set the verbosity level, defaults to 0

## UMFPack() [6/6]

template<typename M>

Dune::UMFPack< M >::UMFPack | ( | const Matrix & | matrix,
|  | int | verbose = 0 )

inline

Construct a solver object from a matrix.

This computes the matrix decomposition, and may take a long time (and use a lot of memory).

Parameters

  matrix | the matrix to solve for
  verbose | [0..2] set the verbosity level, defaults to 0

## ~LDL()

template<typename T, typename A, int n, int m>

virtual Dune::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >::~LDL | ( |  | ) |

inline virtual

Default constructor.

## ~SPQR()

template<typename T, typename A, int n, int m>

virtual Dune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >::~SPQR | ( |  | ) |

inline virtual

Destructor.

## ~SuperLU()

template<typename M>

Dune::SuperLU< M >::~SuperLU | ( |  | ) |

## ~UMFPack()

template<typename M>

virtual Dune::UMFPack< M >::~UMFPack | ( |  | ) |

inline virtual

## Variable Documentation

## valid [1/3]

template<typename T>

bool Dune::UMFPackMethodChooser< T >::valid = false

static constexpr

## valid [2/3]

bool Dune::UMFPackMethodChooser< double >::valid = true

static constexpr

## valid [3/3]

bool Dune::UMFPackMethodChooser< std::complex< double > >::valid = true

static constexpr

## Friends

## SeqOverlappingSchwarz [1/3]

template<typename T, typename A, int n, int m>
template<class M, class X, class TM, class TD, class T1>

friend class SeqOverlappingSchwarz

friend

## SeqOverlappingSchwarz [2/3]

template<typename T, typename A, int n, int m>
template<class M, class X, class TM, class TD, class T1>

friend class SeqOverlappingSchwarz

friend

## SeqOverlappingSchwarz [3/3]

template<typename M>
template<class Mat, class X, class TM, class TD, class T1>

friend class SeqOverlappingSchwarz

friend

## SeqOverlappingSchwarzAssemblerHelper< LDL< Matrix >, true >

template<typename T, typename A, int n, int m>

friend struct SeqOverlappingSchwarzAssemblerHelper< LDL< Matrix >, true >

friend

## SeqOverlappingSchwarzAssemblerHelper< SPQR< Matrix >, true >

template<typename T, typename A, int n, int m>

friend struct SeqOverlappingSchwarzAssemblerHelper< SPQR< Matrix >, true >

friend

## SeqOverlappingSchwarzAssemblerHelper< UMFPack< Matrix >, true >

template<typename M>

friend struct SeqOverlappingSchwarzAssemblerHelper< UMFPack< Matrix >, true >

friend