Loading...
Searching...
No Matches
Dune Namespace Reference
Iterative Solvers Template Library (ISTL) » Iterative Solvers » Preconditioners » Parallel Algebraic Multigrid

## Namespaces

namespace | ISTL
namespace | CounterImpl
namespace | DILU
namespace | ForEach
namespace | ILU
namespace | MatrixImp
namespace | MatrixMarketImpl
namespace | Amg
namespace | Metis
namespace | UMFPackImpl

## Classes

struct | exists
struct | DefaultAllocatorTraits
struct | DefaultAllocatorTraits< T, std::void_t< typename T::allocator_type > >
struct | AllocatorTraits
class | OverlappingSchwarzInitializer
| Initializer for SuperLU Matrices representing the subdomains. More...
struct | MatrixDimension
struct | CompressionStatistics
| Statistics about compression achieved in implicit mode. More...
class | ImplicitMatrixBuilder
| A wrapper for uniform access to the BCRSMatrix during and after the build stage in implicit build mode. More...
class | BCRSMatrix
| A sparse block matrix with compressed row storage. More...
struct | FieldTraits< BCRSMatrix< B, A > >
class | BDMatrix
| A block-diagonal matrix. More...
struct | FieldTraits< BDMatrix< B, A > >
class | MultiTypeBlockVector
| A Vector class to support different block types. More...
class | MultiTypeBlockMatrix
| A Matrix class to support different block types. More...
class | BTDMatrix
| A block-tridiagonal matrix. More...
struct | FieldTraits< BTDMatrix< B, A > >
class | BlockVector
| A vector of blocks with memory management. More...
struct | FieldTraits< BlockVector< B, A > >
struct | AutonomousValueType< Imp::BlockVectorWindow< B, A > >
| Specialization for the proxies of BlockVectorWindow.
class | Cholmod
| Dune wrapper for SuiteSparse/CHOLMOD solver. More...
class | ArPackPlusPlus_Algorithms
| Wrapper to use a range of ARPACK++ eigenvalue solvers. More...
class | PowerIteration_Algorithms
| Iterative eigenvalue algorithms based on power iteration. More...
struct | BL
| compile-time parameter for block recursion depth More...
struct | algmeta_btsolve
struct | algmeta_btsolve< 0, withdiag, withrelax >
struct | algmeta_btsolve< 0, withdiag, norelax >
struct | algmeta_btsolve< 0, nodiag, withrelax >
struct | algmeta_btsolve< 0, nodiag, norelax >
struct | algmeta_bdsolve
struct | algmeta_bdsolve< 0, withrelax >
struct | algmeta_bdsolve< 0, norelax >
struct | algmeta_itsteps
struct | algmeta_itsteps< 0, M >
struct | algmeta_itsteps< I, MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > >
class | ILUSubdomainSolver
| base class encapsulating common algorithms of ILU0SubdomainSolver and ILUNSubdomainSolver. More...
class | ILU0SubdomainSolver
| Exact subdomain solver using ILU(p) with appropriate p. More...
class | ILUNSubdomainSolver
struct | DefaultSVGMatrixOptions
| Default options class to write SVG matrices. More...
class | ISTLError
| derive error class from the base class in common More...
class | BCRSMatrixError
| Error specific to BCRSMatrix. More...
class | ImplicitModeCompressionBufferExhausted
| Thrown when the compression buffer used by the implicit BCRSMatrix construction is exhausted. More...
class | SolverAbort
| Thrown when a solver aborts due to some problem. More...
class | MatrixBlockError
| Error when performing an operation on a matrix block. More...
class | SeqOverlappingSchwarz
| Sequential overlapping Schwarz preconditioner. More...
struct | SeqOverlappingSchwarzAssemblerHelper
class | LDL
| Use the LDL package to directly solve linear systems – empty default class. More...
class | LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >
| The LDL direct sparse solver for matrices of type BCRSMatrix. More...
struct | IsDirectSolver< LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > > >
struct | StoresColumnCompressed< LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > > >
class | Matrix
| A generic dynamic dense matrix. More...
struct | FieldTraits< Matrix< T, A > >
class | MatrixIndexSet
| Stores the nonzero entries for creating a sparse matrix. More...
class | MatrixMarketFormatError
struct | MatMultMatResult
| Helper TMP to get the result type of a sparse matrix matrix multiplication ( ). More...
struct | MatMultMatResult< FieldMatrix< T, n, k >, FieldMatrix< T, k, m > >
struct | MatMultMatResult< BCRSMatrix< FieldMatrix< T, n, k >, A >, BCRSMatrix< FieldMatrix< T, k, m >, A1 > >
struct | TransposedMatMultMatResult
| Helper TMP to get the result type of a sparse matrix matrix multiplication ( ). More...
struct | TransposedMatMultMatResult< FieldMatrix< T, k, n >, FieldMatrix< T, k, m > >
struct | TransposedMatMultMatResult< BCRSMatrix< FieldMatrix< T, k, n >, A >, BCRSMatrix< FieldMatrix< T, k, m >, A1 > >
struct | RedistributeInformation
class | RedistributeInformation< OwnerOverlapCopyCommunication< T, T1 > >
struct | CommMatrixRowSize
| Utility class to communicate and set the row sizes of a redistributed matrix. More...
struct | CommMatrixSparsityPattern
| Utility class to communicate and build the sparsity pattern of a redistributed matrix. More...
struct | CommPolicy< CommMatrixSparsityPattern< M, I > >
struct | CommMatrixRow
| Utility class for comunicating the matrix entries. More...
struct | CommPolicy< CommMatrixRow< M, I > >
struct | MatrixRowSizeGatherScatter
struct | MatrixCopyRowSizeGatherScatter
struct | MatrixSparsityPatternGatherScatter
struct | MatrixRowGatherScatter
class | FieldMatrix
struct | CheckIfDiagonalPresent
| Check whether the a matrix has diagonal values on blocklevel recursion levels. More...
struct | CheckIfDiagonalPresent< Matrix, 0, l >
struct | CheckIfDiagonalPresent< MultiTypeBlockMatrix< T1, Args... >, blocklevel, l >
struct | MatrixDimension< Matrix< B, TA > >
struct | MatrixDimension< BCRSMatrix< B, TA > >
struct | MatrixDimension< BCRSMatrix< FieldMatrix< B, n, m >, TA > >
struct | MatrixDimension< FieldMatrix< K, n, m > >
struct | MatrixDimension< Dune::DynamicMatrix< T > >
struct | MatrixDimension< Matrix< FieldMatrix< K, n, m >, TA > >
struct | MatrixDimension< DiagonalMatrix< K, n > >
struct | MatrixDimension< ScaledIdentityMatrix< K, n > >
struct | IsMatrix
| Test whether a type is an ISTL Matrix. More...
struct | IsMatrix< DenseMatrix< T > >
struct | IsMatrix< BCRSMatrix< T, A > >
struct | PointerCompare
class | MultiTypeBlockMatrix_Solver
| solver for MultiTypeBlockVector & MultiTypeBlockMatrix types More...
struct | FieldTraits< MultiTypeBlockMatrix< Rows... > >
class | MultiTypeBlockMatrix_Solver_Col
| part of solvers for MultiTypeBlockVector & MultiTypeBlockMatrix types More...
class | MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, 0 >
class | MultiTypeBlockMatrix_Solver< I, crow, 0 >
struct | FieldTraits< MultiTypeBlockVector< Args... > >
class | NonoverlappingSchwarzOperator
| A nonoverlapping operator with communication object. More...
class | NonoverlappingBlockPreconditioner
| Nonoverlapping parallel preconditioner. More...
class | LinearOperator
| A linear operator. More...
class | AssembledLinearOperator
| A linear operator exporting itself in matrix form. More...
class | MatrixAdapter
| Adapter to turn a matrix into a linear operator. More...
struct | AdditiveSchwarzMode
| Tag that the tells the Schwarz method to be additive. More...
struct | MultiplicativeSchwarzMode
| Tag that tells the Schwarz method to be multiplicative. More...
struct | SymmetricMultiplicativeSchwarzMode
| Tag that tells the Schwarz method to be multiplicative and symmetric. More...
class | DynamicMatrixSubdomainSolver
| Exact subdomain solver using Dune::DynamicMatrix<T>::solve. More...
class | DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >
class | OverlappingAssignerHelper
class | OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >
struct | OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >
class | OverlappingAssignerILUBase
class | OverlappingAssignerHelper< ILU0SubdomainSolver< M, X, Y >, false >
class | OverlappingAssignerHelper< ILUNSubdomainSolver< M, X, Y >, false >
struct | AdditiveAdder
struct | AdditiveAdder< S, BlockVector< T, A > >
struct | MultiplicativeAdder
struct | MultiplicativeAdder< S, BlockVector< T, A > >
struct | AdderSelector
| template meta program for choosing how to add the correction. More...
struct | AdderSelector< AdditiveSchwarzMode, X, S >
struct | AdderSelector< MultiplicativeSchwarzMode, X, S >
struct | AdderSelector< SymmetricMultiplicativeSchwarzMode, X, S >
struct | IteratorDirectionSelector
| Helper template meta program for application of overlapping Schwarz. More...
struct | IteratorDirectionSelector< T1, T2, false >
struct | SeqOverlappingSchwarzApplier
| Helper template meta program for application of overlapping Schwarz. More...
struct | SeqOverlappingSchwarzApplier< SeqOverlappingSchwarz< M, X, SymmetricMultiplicativeSchwarzMode, TD, TA > >
struct | SeqOverlappingSchwarzAssemblerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >
struct | SeqOverlappingSchwarzAssemblerHelper< S< BCRSMatrix< T, A > >, true >
struct | SeqOverlappingSchwarzAssemblerILUBase
struct | SeqOverlappingSchwarzAssemblerHelper< ILU0SubdomainSolver< M, X, Y >, false >
struct | SeqOverlappingSchwarzAssemblerHelper< ILUNSubdomainSolver< M, X, Y >, false >
struct | SeqOverlappingSchwarzDomainSize
struct | SeqOverlappingSchwarzDomainSize< BCRSMatrix< T, A > >
struct | OwnerOverlapCopyAttributeSet
| Attribute set for overlapping Schwarz. More...
class | IndexInfoFromGrid
| Information about the index distribution. More...
class | OwnerOverlapCopyCommunication
| A class setting up standard communication for a two-valued attribute set with owner/overlap/copy semantics. More...
struct | AMGCreator
class | OverlappingSchwarzOperator
| An overlapping Schwarz operator. More...
struct | PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > >
struct | CommPolicy< Amg::GlobalAggregatesMap< T, TI > >
class | Preconditioner
| Base class for matrix free definition of preconditioners. More...
class | InverseOperator2Preconditioner
| Turns an InverseOperator into a Preconditioner. More...
class | SeqSSOR
| Sequential SSOR preconditioner. More...
class | SeqSOR
| Sequential SOR preconditioner. More...
class | SeqJac
| The sequential jacobian preconditioner. More...
class | SeqDILU
| Sequential DILU preconditioner. More...
class | SeqILU
| Sequential ILU preconditioner. More...
class | Richardson
| Richardson preconditioner. More...
class | SeqILDL
| sequential ILDL preconditioner More...
struct | RedistributeInterface
class | ScalarProduct
| Base class for scalar product and norm computation. More...
class | ParallelScalarProduct
| Scalar product for overlapping Schwarz methods. More...
class | SeqScalarProduct
| Default implementation for the scalar case. More...
class | NonoverlappingSchwarzScalarProduct
| Nonoverlapping Scalar Product with communication object. More...
class | OverlappingSchwarzScalarProduct
| Scalar product for overlapping Schwarz methods. More...
class | ScaledIdentityMatrix
| A multiple of the identity matrix of static size. More...
struct | DenseMatrixAssigner< DenseMatrix, ScaledIdentityMatrix< field, N > >
struct | FieldTraits< ScaledIdentityMatrix< K, n > >
class | ParSSOR
| A parallel SSOR preconditioner. More...
class | BlockPreconditioner
| Block parallel preconditioner. More...
struct | InverseOperatorResult
| Statistics about the application of an inverse operator. More...
class | InverseOperator
| Abstract base class for all solvers. More...
class | IterativeSolver
| Base class for all implementations of iterative solvers. More...
class | SolverHelper
| Helper class for notifying a DUNE-ISTL linear solver about a change of the iteration matrix object in a unified way, i.e. independent from the solver's type (direct/iterative). More...
struct | SolverCategory
| Categories for the solvers. More...
class | InvalidSolverCategory
struct | OperatorTraits
class | UnknownSolverCategory
class | NoAssembledOperator
| This exception is thrown if the requested solver or preconditioner needs an assembled matrix. More...
class | UnsupportedType
class | InvalidSolverFactoryConfiguration
class | LoopSolver
| Preconditioned loop solver. More...
class | GradientSolver
| gradient method More...
class | CGSolver
| conjugate gradient method More...
class | BiCGSTABSolver
| Bi-conjugate Gradient Stabilized (BiCG-STAB). More...
class | MINRESSolver
| Minimal Residual Method (MINRES). More...
class | RestartedGMResSolver
| implements the Generalized Minimal Residual (GMRes) method More...
class | RestartedFlexibleGMResSolver
| implements the Flexible Generalized Minimal Residual (FGMRes) method (right preconditioned) More...
class | GeneralizedPCGSolver
| Generalized preconditioned conjugate gradient solver. More...
class | RestartedFCGSolver
| Accelerated flexible conjugate gradient method. More...
class | CompleteFCGSolver
| Complete flexible conjugate gradient method. More...
struct | IsDirectSolver
struct | StoresColumnCompressed
class | SPQR
| Use the SPQR package to directly solve linear systems – empty default class. More...
class | SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >
| The SPQR direct sparse solver for matrices of type BCRSMatrix. More...
struct | IsDirectSolver< SPQR< BCRSMatrix< T, A > > >
struct | StoresColumnCompressed< SPQR< BCRSMatrix< T, A > > >
struct | SuperLUSolveChooser
struct | SuperLUDenseMatChooser
struct | SuperLUQueryChooser
struct | QuerySpaceChooser
class | SuperLU
| SuperLu Solver. More...
struct | IsDirectSolver< SuperLU< BCRSMatrix< T, A > > >
struct | StoresColumnCompressed< SuperLU< BCRSMatrix< T, A > > >
struct | SuperMatrixCreateSparseChooser
struct | SuperMatrixPrinter
struct | BaseGetSuperLUType
struct | GetSuperLUType
struct | GetSuperLUType< double >
struct | GetSuperLUType< float >
struct | GetSuperLUType< std::complex< double > >
struct | GetSuperLUType< std::complex< float > >
struct | SuperLUMatrix
| Utility class for converting an ISTL Matrix into a SuperLU Matrix. More...
struct | SuperMatrixInitializer
class | SuperLUMatrix< BCRSMatrix< B, TA > >
| Converter for BCRSMatrix to SuperLU Matrix. More...
class | SuperMatrixInitializer< BCRSMatrix< B, A > >
struct | UMFPackMethodChooser
struct | UMFPackMethodChooser< double >
struct | UMFPackMethodChooser< std::complex< double > >
class | UMFPack
| The UMFPack direct sparse solver. More...
struct | IsDirectSolver< UMFPack< M > >
struct | StoresColumnCompressed< UMFPack< BCRSMatrix< T, A > > >
class | VariableBlockVector
| A Vector of blocks with different blocksizes. More...
struct | FieldTraits< VariableBlockVector< B, A > >

## Typedefs

template<typename T>
using | AllocatorType = typename AllocatorTraits<T>::type
template<typename T, typename X>
using | ReboundAllocatorType = typename std::allocator_traits<typename AllocatorTraits<T>::type>::template rebind_alloc<X>
template<typename T>
using | OverlappingAssigner = OverlappingAssignerHelper<T, Dune::StoresColumnCompressed<T>::value>
template<class T>
using | SeqOverlappingSchwarzAssembler = SeqOverlappingSchwarzAssemblerHelper<T,Dune::StoresColumnCompressed<T>::value>
template<class M, class X, class Y, int l = 1>
using | SeqGS = SeqSOR<M,X,Y,l>
| Sequential Gauss Seidel preconditioner.
template<class OP>
using | PreconditionerSignature = std::shared_ptr<Preconditioner<typename OP::domain_type,typename OP::range_type>>(const std::shared_ptr<OP>&, const ParameterTree&)
template<class OP>
using | PreconditionerFactory = Singleton<ParameterizedObjectFactory<PreconditionerSignature<OP>>>
template<class OP>
using | SolverSignature = std::shared_ptr<InverseOperator<typename OP::domain_type,typename OP::range_type>>(const std::shared_ptr<OP>&, const ParameterTree&)
template<class OP>
using | SolverFactory = Singleton<ParameterizedObjectFactory<SolverSignature<OP>>>

## Enumerations

enum | WithDiagType { withdiag =1 , nodiag =0 }
enum | WithRelaxType { withrelax =1 , norelax =0 }

## Functions

template<typename T>
constexpr std::size_t | maxBlockLevel ()
| Determine the maximum block level of a possibly nested vector/matrix type.
template<typename T>
constexpr std::size_t | minBlockLevel ()
| Determine the minimum block level of a possibly nested vector/matrix type.
template<typename T>
constexpr bool | hasUniqueBlockLevel ()
| Determine if a vector/matrix has a uniquely determinable block level.
template<typename T>
constexpr std::size_t | blockLevel ()
| Determine the block level of a possibly nested vector/matrix type.
template<class K, class A>
std::ostream & | operator<< (std::ostream &s, const BlockVector< K, A > &v)
| Send BlockVector to an output stream.

DUNE_REGISTER_SOLVER ("cholmod", [](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;using D=typename OpTraits::domain_type;if constexpr(OpTraits::isParallel){ if(opTraits.getCommOrThrow(op).communicator().size() > 1) DUNE_THROW(Dune::InvalidStateException, "CholMod works only for sequential operators.");} if constexpr(OpTraits::isAssembled &&(std::is_same_v< typename FieldTraits< D >::field_type, double >||std::is_same_v< typename FieldTraits< D >::field_type, float >)){ const auto &A=opTraits.getAssembledOpOrThrow(op);const M &mat=A->getmat();auto solver=std::make_shared< Dune::Cholmod< D > >();solver->setMatrix(mat);return solver;} DUNE_THROW(UnsupportedType, "Unsupported Type in Cholmod (only double and float supported)");})

template<class Vector, class F>
std::size_t | flatVectorForEach (Vector &&vector, F &&f, std::size_t offset=0)
| Traverse a blocked vector and call a functor at each scalar entry.
template<class Matrix, class F>
std::pair< std::size_t, std::size_t > | flatMatrixForEach (Matrix &&matrix, F &&f, std::size_t rowOffset=0, std::size_t colOffset=0)
| Traverse a blocked matrix and call a functor at each scalar entry.
template<class M, class X, class Y>
void | bltsolve (const M &A, X &v, const Y &d)
| block lower triangular solve
template<class M, class X, class Y, class K>
void | bltsolve (const M &A, X &v, const Y &d, const K &w)
| relaxed block lower triangular solve
template<class M, class X, class Y>
void | ubltsolve (const M &A, X &v, const Y &d)
| unit block lower triangular solve
template<class M, class X, class Y, class K>
void | ubltsolve (const M &A, X &v, const Y &d, const K &w)
| relaxed unit block lower triangular solve
template<class M, class X, class Y>
void | butsolve (const M &A, X &v, const Y &d)
| block upper triangular solve
template<class M, class X, class Y, class K>
void | butsolve (const M &A, X &v, const Y &d, const K &w)
| relaxed block upper triangular solve
template<class M, class X, class Y>
void | ubutsolve (const M &A, X &v, const Y &d)
| unit block upper triangular solve
template<class M, class X, class Y, class K>
void | ubutsolve (const M &A, X &v, const Y &d, const K &w)
| relaxed unit block upper triangular solve
template<class M, class X, class Y, int l>
void | bltsolve (const M &A, X &v, const Y &d, BL< l >)
| block lower triangular solve
template<class M, class X, class Y, class K, int l>
void | bltsolve (const M &A, X &v, const Y &d, const K &w, BL< l >)
| relaxed block lower triangular solve
template<class M, class X, class Y, int l>
void | ubltsolve (const M &A, X &v, const Y &d, BL< l >)
| unit block lower triangular solve
template<class M, class X, class Y, class K, int l>
void | ubltsolve (const M &A, X &v, const Y &d, const K &w, BL< l >)
| relaxed unit block lower triangular solve
template<class M, class X, class Y, int l>
void | butsolve (const M &A, X &v, const Y &d, BL< l >)
| block upper triangular solve
template<class M, class X, class Y, class K, int l>
void | butsolve (const M &A, X &v, const Y &d, const K &w, BL< l >)
| relaxed block upper triangular solve
template<class M, class X, class Y, int l>
void | ubutsolve (const M &A, X &v, const Y &d, BL< l >)
| unit block upper triangular solve
template<class M, class X, class Y, class K, int l>
void | ubutsolve (const M &A, X &v, const Y &d, const K &w, BL< l >)
| relaxed unit block upper triangular solve
template<class M, class X, class Y>
void | bdsolve (const M &A, X &v, const Y &d)
| block diagonal solve, no relaxation
template<class M, class X, class Y, class K>
void | bdsolve (const M &A, X &v, const Y &d, const K &w)
| block diagonal solve, with relaxation
template<class M, class X, class Y, int l>
void | bdsolve (const M &A, X &v, const Y &d, BL< l >)
| block diagonal solve, no relaxation
template<class M, class X, class Y, class K, int l>
void | bdsolve (const M &A, X &v, const Y &d, const K &w, BL< l >)
| block diagonal solve, with relaxation
template<class M, class X, class Y, class K>
void | dbgs (const M &A, X &x, const Y &b, const K &w)
| GS step.
template<class M, class X, class Y, class K, int l>
void | dbgs (const M &A, X &x, const Y &b, const K &w, BL< l >)
| GS step.
template<class M, class X, class Y, class K>
void | bsorf (const M &A, X &x, const Y &b, const K &w)
| SOR step.
template<class M, class X, class Y, class K, int l>
void | bsorf (const M &A, X &x, const Y &b, const K &w, BL< l >)
| SOR step.
template<class M, class X, class Y, class K>
void | bsorb (const M &A, X &x, const Y &b, const K &w)
| SSOR step.
template<class M, class X, class Y, class K, int l>
void | bsorb (const M &A, X &x, const Y &b, const K &w, BL< l >)
| Backward SOR step.
template<class M, class X, class Y, class K>
void | dbjac (const M &A, X &x, const Y &b, const K &w)
| Jacobi step.
template<class M, class X, class Y, class K, int l>
void | dbjac (const M &A, X &x, const Y &b, const K &w, BL< l >)
| Jacobi step.
template<class K, int m, int n>
static void | bildl_subtractBCT (const FieldMatrix< K, m, n > &B, const FieldMatrix< K, m, n > &CT, FieldMatrix< K, m, n > &A)
template<class K>
static void | bildl_subtractBCT (const K &B, const K &CT, K &A, typename std::enable_if_t< Dune::IsNumber< K >::value > *=nullptr)
template<class Matrix>
static void | bildl_subtractBCT (const Matrix &B, const Matrix &CT, Matrix &A, typename std::enable_if_t<!Dune::IsNumber< Matrix >::value > *=nullptr)
template<class Matrix>
void | bildl_decompose (Matrix &A)
| compute ILDL decomposition of a symmetric matrix A
template<class Matrix, class X, class Y>
void | bildl_backsolve (const Matrix &A, X &v, const Y &d, bool isLowerTriangular=false)
template<class V>
void | recursive_printvector (std::ostream &s, const V &v, std::string rowtext, int &counter, int columns, int width)
| Recursively print a vector.
template<class V>
void | printvector (std::ostream &s, const V &v, std::string title, std::string rowtext, int columns=1, int width=10, int precision=2)
| Print an ISTL vector.
void | fill_row (std::ostream &s, int m, int width, int precision)
| Print a row of zeros for a non-existing block.
template<class K, std::enable_if_t< Dune::IsNumber< K >::value, int > = 0>
void | print_row (std::ostream &s, const K &value, typename FieldMatrix< K, 1, 1 >::size_type I, typename FieldMatrix< K, 1, 1 >::size_type J, typename FieldMatrix< K, 1, 1 >::size_type therow, int width, int precision)
| Print one row of a matrix, specialization for number types.
template<class M, std::enable_if_t< not Dune::IsNumber< M >::value, int > = 0>
void | print_row (std::ostream &s, const M &A, typename M::size_type I, typename M::size_type J, typename M::size_type therow, int width, int precision)
| Print one row of a matrix.
template<class M>
void | printmatrix (std::ostream &s, const M &A, std::string title, std::string rowtext, int width=10, int precision=2)
| Print a generic block matrix.
template<class A, class InnerMatrixType>
void | printSparseMatrix (std::ostream &s, const BCRSMatrix< InnerMatrixType, A > &mat, std::string title, std::string rowtext, int width=3, int precision=2)
| Prints a BCRSMatrix with fixed sized blocks.
template<class FieldType, std::enable_if_t< Dune::IsNumber< FieldType >::value, int > = 0>
void | writeMatrixToMatlabHelper (const FieldType &value, int rowOffset, int colOffset, std::ostream &s)
| Helper method for the writeMatrixToMatlab routine.
template<class MatrixType, std::enable_if_t< not Dune::IsNumber< MatrixType >::value, int > = 0>
void | writeMatrixToMatlabHelper (const MatrixType &matrix, int externalRowOffset, int externalColOffset, std::ostream &s)
| Helper method for the writeMatrixToMatlab routine.
template<class MatrixType>
void | writeMatrixToMatlab (const MatrixType &matrix, const std::string &filename, int outputPrecision=18)
| Writes sparse matrix in a Matlab-readable format.
template<class V>
void | writeVectorToMatlabHelper (const V &v, std::ostream &stream)
template<class VectorType>
void | writeVectorToMatlab (const VectorType &vector, const std::string &filename, int outputPrecision=18)
| Writes vectors in a Matlab-readable format.
template<class Mat, class SVGOptions = DefaultSVGMatrixOptions>
void | writeSVGMatrix (std::ostream &out, const Mat &mat, SVGOptions opts={})
| Writes the visualization of matrix in the SVG format.

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)");})

void | mm_read_header (std::size_t &rows, std::size_t &cols, MatrixMarketImpl::MMHeader &header, std::istream &istr, bool isVector)
template<typename T, typename A>
void | mm_read_vector_entries (Dune::BlockVector< T, A > &vector, std::size_t size, std::istream &istr, size_t lane)
template<typename T, typename A, int entries>
void | mm_read_vector_entries (Dune::BlockVector< Dune::FieldVector< T, entries >, A > &vector, std::size_t size, std::istream &istr, size_t lane)
template<typename T, typename A>
void | readMatrixMarket (Dune::BlockVector< T, A > &vector, std::istream &istr)
| Reads a BlockVector from a matrix market file.
template<typename T, typename A>
void | readMatrixMarket (Dune::BCRSMatrix< T, A > &matrix, std::istream &istr)
| Reads a sparse matrix from a matrix market file.
template<typename B>
void | mm_print_entry (const B &entry, std::size_t rowidx, std::size_t colidx, std::ostream &ostr)
template<typename V>
void | mm_print_vector_entry (const V &entry, std::ostream &ostr, const std::integral_constant< int, 1 > &, size_t lane)
template<typename V>
void | mm_print_vector_entry (const V &vector, std::ostream &ostr, const std::integral_constant< int, 0 > &, size_t lane)
template<typename T, typename A>
std::size_t | countEntries (const BlockVector< T, A > &vector)
template<typename T, typename A, int i>
std::size_t | countEntries (const BlockVector< FieldVector< T, i >, A > &vector)
template<typename V>
void | writeMatrixMarket (const V &vector, std::ostream &ostr, const std::integral_constant< int, 0 > &)
template<typename M>
void | writeMatrixMarket (const M &matrix, std::ostream &ostr, const std::integral_constant< int, 1 > &)
template<typename M>
void | writeMatrixMarket (const M &matrix, std::ostream &ostr)
| writes a ISTL matrix or vector to a stream in matrix market format.
template<typename M>
void | storeMatrixMarket (const M &matrix, std::string filename, int prec=default_precision)
| Stores a parallel matrix/vector in matrix market format in a file.
template<typename M, typename G, typename L>
void | storeMatrixMarket (const M &matrix, std::string filename, const OwnerOverlapCopyCommunication< G, L > &comm, bool storeIndices=true, int prec=default_precision)
| Stores a parallel matrix/vector in matrix market format in a file.
template<typename M, typename G, typename L>
void | loadMatrixMarket (M &matrix, const std::string &filename, OwnerOverlapCopyCommunication< G, L > &comm, bool readIndices=true)
| Load a parallel matrix/vector stored in matrix market format.
template<typename M>
void | loadMatrixMarket (M &matrix, const std::string &filename)
| Load a matrix/vector stored in matrix market format.
template<class T, class A, class A1, class A2, int n, int m, int k>
void | matMultTransposeMat (BCRSMatrix< FieldMatrix< T, n, k >, A > &res, const BCRSMatrix< FieldMatrix< T, n, m >, A1 > &mat, const BCRSMatrix< FieldMatrix< T, k, m >, A2 > &matt, bool=false)
| Calculate product of a sparse matrix with a transposed sparse matrices ( ).
template<class T, class A, class A1, class A2, int n, int m, int k>
void | matMultMat (BCRSMatrix< FieldMatrix< T, n, m >, A > &res, const BCRSMatrix< FieldMatrix< T, n, k >, A1 > &mat, const BCRSMatrix< FieldMatrix< T, k, m >, A2 > &matt, bool=false)
| Calculate product of two sparse matrices ( ).
template<class T, class A, class A1, class A2, int n, int m, int k>
void | transposeMatMultMat (BCRSMatrix< FieldMatrix< T, n, m >, A > &res, const BCRSMatrix< FieldMatrix< T, k, n >, A1 > &mat, const BCRSMatrix< FieldMatrix< T, k, m >, A2 > &matt, bool=false)
| Calculate product of a transposed sparse matrix with another sparse matrices ( ).
template<typename M, typename C>
void | redistributeSparsityPattern (M &origMatrix, M &newMatrix, C &origComm, C &newComm, RedistributeInformation< C > &ri)
template<typename M, typename C>
void | redistributeMatrixEntries (M &origMatrix, M &newMatrix, C &origComm, C &newComm, RedistributeInformation< C > &ri)
template<typename M, typename C>
void | redistributeMatrix (M &origMatrix, M &newMatrix, C &origComm, C &newComm, RedistributeInformation< C > &ri)
| Redistribute a matrix according to given domain decompositions.
template<typename M>
void | redistributeMatrixEntries (M &origMatrix, M &newMatrix, Dune::Amg::SequentialInformation &origComm, Dune::Amg::SequentialInformation &newComm, RedistributeInformation< Dune::Amg::SequentialInformation > &ri)
template<typename M>
void | redistributeMatrix (M &origMatrix, M &newMatrix, Dune::Amg::SequentialInformation &origComm, Dune::Amg::SequentialInformation &newComm, RedistributeInformation< Dune::Amg::SequentialInformation > &ri)
template<class M>
auto | countNonZeros (const M &, typename std::enable_if_t< Dune::IsNumber< M >::value > *sfinae=nullptr)
| Get the number of nonzero fields in the matrix.
template<class M>
auto | countNonZeros (const M &matrix, typename std::enable_if_t<!Dune::IsNumber< M >::value > *sfinae=nullptr)
template<class M, class C>
void | printGlobalSparseMatrix (const M &mat, C &ooc, std::ostream &os)
template<typename T1, typename... Args>
std::ostream & | operator<< (std::ostream &s, const MultiTypeBlockMatrix< T1, Args... > &m)
| << operator for a MultiTypeBlockMatrix
template<typename... Args>
std::ostream & | operator<< (std::ostream &s, const MultiTypeBlockVector< Args... > &v)
| Send MultiTypeBlockVector to an outstream.
| DUNE_REGISTER_PRECONDITIONER ("amg", AMGCreator())
template<typename G, typename EP, typename VM, typename EM>
PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > >::Type | get (const Amg::VertexVisitedTag &tag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > &graph)
| DUNE_REGISTER_PRECONDITIONER ("ssor", defaultPreconditionerBlockLevelCreator< Dune::SeqSSOR >())
| DUNE_REGISTER_PRECONDITIONER ("sor", defaultPreconditionerBlockLevelCreator< Dune::SeqSOR >())
| DUNE_REGISTER_PRECONDITIONER ("gs", defaultPreconditionerBlockLevelCreator< Dune::SeqGS >())
| DUNE_REGISTER_PRECONDITIONER ("jac", defaultPreconditionerBlockLevelCreator< Dune::SeqJac >())
| DUNE_REGISTER_PRECONDITIONER ("dilu", defaultPreconditionerBlockLevelCreator< Dune::SeqDILU >())
| DUNE_REGISTER_PRECONDITIONER ("ilu", defaultPreconditionerBlockLevelCreator< Dune::SeqILU >())
| DUNE_REGISTER_PRECONDITIONER ("richardson", [](auto opTraits, const auto &, const ParameterTree &config){ using OpTraits=std::decay_t< decltype(opTraits)>;using D=typename OpTraits::domain_type;using R=typename OpTraits::range_type;return std::make_shared< Richardson< D, R > >(config);})
| DUNE_REGISTER_PRECONDITIONER ("ildl", defaultPreconditionerCreator< Dune::SeqILDL >())
template<class G, class T1, class T2>
void | fillIndexSetHoles (const G &graph, Dune::OwnerOverlapCopyCommunication< T1, T2 > &oocomm)
| Fills the holes in an index set.
template<class G, class T1, class T2>
bool | buildCommunication (const G &graph, std::vector< int > &realparts, Dune::OwnerOverlapCopyCommunication< T1, T2 > &oocomm, std::shared_ptr< Dune::OwnerOverlapCopyCommunication< T1, T2 > > &outcomm, RedistributeInterface &redistInf, bool verbose=false)
template<class S, class T>
void | print_carray (S &os, T *array, std::size_t l)
template<class S, class T>
bool | isValidGraph (std::size_t noVtx, std::size_t gnoVtx, S noEdges, T *xadj, T *adjncy, bool checkSymmetry)
template<class M, class T1, class T2>
bool | commGraphRepartition (const M &mat, Dune::OwnerOverlapCopyCommunication< T1, T2 > &oocomm, Metis::idx_t nparts, std::shared_ptr< Dune::OwnerOverlapCopyCommunication< T1, T2 > > &outcomm, RedistributeInterface &redistInf, bool verbose=false)
template<class G, class T1, class T2>
bool | graphRepartition (const G &graph, Dune::OwnerOverlapCopyCommunication< T1, T2 > &oocomm, Metis::idx_t nparts, std::shared_ptr< Dune::OwnerOverlapCopyCommunication< T1, T2 > > &outcomm, RedistributeInterface &redistInf, bool verbose=false)
| execute a graph repartition for a giving graph and indexset.
template<class X, class Comm>
std::shared_ptr< ScalarProduct< X > > | makeScalarProduct (std::shared_ptr< const Comm > comm, SolverCategory::Category category)
| Choose the appropriate scalar product for a solver category.
template<class X, class Comm>
std::shared_ptr< ScalarProduct< X > > | createScalarProduct (const Comm &comm, SolverCategory::Category category)
template<class Operator>
std::shared_ptr< InverseOperator< typename Operator::domain_type, typename Operator::range_type > > | getSolverFromFactory (std::shared_ptr< Operator > op, const ParameterTree &config, std::shared_ptr< Preconditioner< typename Operator::domain_type, typename Operator::range_type > > prec=nullptr)
| Instantiates an InverseOperator from an Operator and a configuration given as a ParameterTree.
template<class Operator>
std::shared_ptr< Preconditioner< typename Operator::domain_type, typename Operator::range_type > > | getPreconditionerFromFactory (std::shared_ptr< Operator > op, const ParameterTree &config)
| Construct a Preconditioner for a given Operator.
template<template< class, class, class, int >class Preconditioner, int blockLevel = 1>
auto | defaultPreconditionerBlockLevelCreator ()
template<template< class, class, class >class Preconditioner>
auto | defaultPreconditionerCreator ()
template<template< class... >class Solver>
auto | defaultIterativeSolverCreator ()
| DUNE_REGISTER_SOLVER ("loopsolver", defaultIterativeSolverCreator< Dune::LoopSolver >())
| DUNE_REGISTER_SOLVER ("gradientsolver", defaultIterativeSolverCreator< Dune::GradientSolver >())
| DUNE_REGISTER_SOLVER ("cgsolver", defaultIterativeSolverCreator< Dune::CGSolver >())
| DUNE_REGISTER_SOLVER ("bicgstabsolver", defaultIterativeSolverCreator< Dune::BiCGSTABSolver >())
| DUNE_REGISTER_SOLVER ("minressolver", defaultIterativeSolverCreator< Dune::MINRESSolver >())
| DUNE_REGISTER_SOLVER ("restartedgmressolver", defaultIterativeSolverCreator< Dune::RestartedGMResSolver >())
| DUNE_REGISTER_SOLVER ("restartedflexiblegmressolver", defaultIterativeSolverCreator< Dune::RestartedFlexibleGMResSolver >())
| DUNE_REGISTER_SOLVER ("generalizedpcgsolver", defaultIterativeSolverCreator< Dune::GeneralizedPCGSolver >())
| DUNE_REGISTER_SOLVER ("restartedfcgsolver", defaultIterativeSolverCreator< Dune::RestartedFCGSolver >())
| DUNE_REGISTER_SOLVER ("completefcgsolver", defaultIterativeSolverCreator< Dune::CompleteFCGSolver >())

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 ("superlu", [](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, "SuperLU works only for sequential operators.");} if constexpr(OpTraits::isAssembled &&std::is_same_v< typename FieldTraits< M >::real_type, double >){ if constexpr(std::is_convertible_v< SuperLU< M > *, Dune::InverseOperator< typename OpTraits::domain_type, typename OpTraits::range_type > * >){ const auto &A=opTraits.getAssembledOpOrThrow(op);const M &mat=A->getmat();int verbose=config.get("verbose", 0);return std::make_shared< Dune::SuperLU< M > >(mat, verbose);} } DUNE_THROW(UnsupportedType, "Unsupported Type in SuperLU (only double and std::complex<double> supported)");})

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;})

## Variables

static const int | default_precision = -1
template<class M, class I>
MatrixSparsityPatternGatherScatter< M, I >::ColIter | MatrixSparsityPatternGatherScatter< M, I >::col
template<class M, class I>
MatrixSparsityPatternGatherScatter< M, I >::GlobalIndex | MatrixSparsityPatternGatherScatter< M, I >::numlimits
template<class M, class I>
MatrixRowGatherScatter< M, I >::ColIter | MatrixRowGatherScatter< M, I >::col
template<class M, class I>
MatrixRowGatherScatter< M, I >::Data | MatrixRowGatherScatter< M, I >::datastore
template<class M, class I>
MatrixRowGatherScatter< M, I >::GlobalIndex | MatrixRowGatherScatter< M, I >::numlimits
template<class T>
const Dtype_t | BaseGetSuperLUType< T >::type

## Typedef Documentation

## AllocatorType

template<typename T>

using Dune::AllocatorType = typename AllocatorTraits<T>::type

## ReboundAllocatorType

template<typename T, typename X>

using Dune::ReboundAllocatorType = typename std::allocator_traits<typename AllocatorTraits<T>::type>::template rebind_alloc<X>

## Function Documentation

## bildl_backsolve()

template<class Matrix, class X, class Y>

void Dune::bildl_backsolve | ( | const Matrix & | A,
|  | X & | v,
|  | const Y & | d,
|  | bool | isLowerTriangular = false )

inline

## bildl_decompose()

template<class Matrix>

void Dune::bildl_decompose | ( | Matrix & | A | ) |

inline

compute ILDL decomposition of a symmetric matrix A

Author
  Martin Nolte

Parameters

  [in,out] | A | Matrix to decompose

Note
  A is overwritten by the factorization.
  Only the lower half of A is used.

## bildl_subtractBCT() [1/3]

template<class K, int m, int n>

void Dune::bildl_subtractBCT | ( | const FieldMatrix< K, m, n > & | B,
|  | const FieldMatrix< K, m, n > & | CT,
|  | FieldMatrix< K, m, n > & | A )

inline static

## bildl_subtractBCT() [2/3]

template<class K>

void Dune::bildl_subtractBCT | ( | const K & | B,
|  | const K & | CT,
|  | K & | A,
|  | typename std::enable_if_t< Dune::IsNumber< K >::value > * | = nullptr )

inline static

## bildl_subtractBCT() [3/3]

template<class Matrix>

void Dune::bildl_subtractBCT | ( | const Matrix & | B,
|  | const Matrix & | CT,
|  | Matrix & | A,
|  | typename std::enable_if_t<!Dune::IsNumber< Matrix >::value > * | = nullptr )

inline static

## blockLevel()

template<typename T>

std::size_t Dune::blockLevel | ( |  | ) |

constexpr

Determine the block level of a possibly nested vector/matrix type.

## buildCommunication()

template<class G, class T1, class T2>

bool Dune::buildCommunication | ( | const G & | graph,
|  | std::vector< int > & | realparts,
|  | Dune::OwnerOverlapCopyCommunication< T1, T2 > & | oocomm,
|  | std::shared_ptr< Dune::OwnerOverlapCopyCommunication< T1, T2 > > & | outcomm,
|  | RedistributeInterface & | redistInf,
|  | bool | verbose = false )

## commGraphRepartition()

template<class M, class T1, class T2>

bool Dune::commGraphRepartition | ( | const M & | mat,
|  | Dune::OwnerOverlapCopyCommunication< T1, T2 > & | oocomm,
|  | Metis::idx_t | nparts,
|  | std::shared_ptr< Dune::OwnerOverlapCopyCommunication< T1, T2 > > & | outcomm,
|  | RedistributeInterface & | redistInf,
|  | bool | verbose = false )

## createScalarProduct()

template<class X, class Comm>

std::shared_ptr< ScalarProduct< X > > Dune::createScalarProduct | ( | const Comm & | comm,
|  | SolverCategory::Category | category )

Note
  Using this helper, you are responsible for the life-time management of comm

## DUNE_REGISTER_PRECONDITIONER()

Dune::DUNE_REGISTER_PRECONDITIONER | ( | "amg" | ,
|  | AMGCreator() | )

## DUNE_REGISTER_SOLVER() [1/2]

Dune::DUNE_REGISTER_SOLVER | ( | "cholmod" | ,

[] (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;using D=typename OpTraits::domain_type;if constexpr(OpTraits::isParallel){ if(opTraits.getCommOrThrow(op).communicator().size() > 1) DUNE_THROW(Dune::InvalidStateException, "CholMod works only for sequential operators.");} if constexpr(OpTraits::isAssembled &&(std::is_same_v< typename FieldTraits< D >::field_type, double >||std::is_same_v< typename FieldTraits< D >::field_type, float >)){ const auto &A=opTraits.getAssembledOpOrThrow(op);const M &mat=A->getmat();auto solver=std::make_shared< Dune::Cholmod< D > >();solver->setMatrix(mat);return solver;} DUNE_THROW(UnsupportedType, "Unsupported Type in Cholmod (only double and float supported)");}

)

## DUNE_REGISTER_SOLVER() [2/2]

Dune::DUNE_REGISTER_SOLVER | ( | "superlu" | ,

[] (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, "SuperLU works only for sequential operators.");} if constexpr(OpTraits::isAssembled &&std::is_same_v< typename FieldTraits< M >::real_type, double >){ if constexpr(std::is_convertible_v< SuperLU< M > *, Dune::InverseOperator< typename OpTraits::domain_type, typename OpTraits::range_type > * >){ const auto &A=opTraits.getAssembledOpOrThrow(op);const M &mat=A->getmat();int verbose=config.get("verbose", 0);return std::make_shared< Dune::SuperLU< M > >(mat, verbose);} } DUNE_THROW(UnsupportedType, "Unsupported Type in SuperLU (only double and std::complex<double> supported)");}

)

## fillIndexSetHoles()

template<class G, class T1, class T2>

void Dune::fillIndexSetHoles | ( | const G & | graph,
|  | Dune::OwnerOverlapCopyCommunication< T1, T2 > & | oocomm )

Fills the holes in an index set.

In general the index set only needs to know those indices where communication my occur. In usual FE computations these are just those near the processor boundaries.

For the repartitioning we need to know all all indices for which data is stored. The missing indices will be created in this method.

Parameters

  graph | The graph to reparition.
  oocomm | The communication information.

## flatMatrixForEach()

template<class Matrix, class F>

std::pair< std::size_t, std::size_t > Dune::flatMatrixForEach | ( | Matrix && | matrix,
|  | F && | f,
|  | std::size_t | rowOffset = 0,
|  | std::size_t | colOffset = 0 )

Traverse a blocked matrix and call a functor at each scalar entry.

The functor f is assumed to have the signature

void(auto&& entry, std::size_t rowOffset, std::size_t colOffset)

taking a scalar entry and the current flat offset (index) of both row and column.

The restrictions on the matrix are:

- well aligned blocks (otherwise there is no sense in the total number of scalar rows/cols)
- all blocks have positive non-zero column / row number
- at least one entry must be present if dynamic matrix types are wrapped within other dynamic matrix types
- if the block size of a sparse matrix is statically known at compile time, the matrix can be empty

The return value is a pair of the total number of scalar rows and columns of the matrix.

## flatVectorForEach()

template<class Vector, class F>

std::size_t Dune::flatVectorForEach | ( | Vector && | vector,
|  | F && | f,
|  | std::size_t | offset = 0 )

Traverse a blocked vector and call a functor at each scalar entry.

The functor f is assumed to have the signature

void(auto&& entry, std::size_t offset)

taking a scalar entry and the current flat offset (index) of this position.

It returns the total number of scalar entries. Similar to dimension() for some DUNE vector types.

## get()

template<typename G, typename EP, typename VM, typename EM>

PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > >::Type Dune::get | ( | const Amg::VertexVisitedTag & | tag,
|  | Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > & | graph )

## graphRepartition()

template<class G, class T1, class T2>

bool Dune::graphRepartition | ( | const G & | graph,
|  | Dune::OwnerOverlapCopyCommunication< T1, T2 > & | oocomm,
|  | Metis::idx_t | nparts,
|  | std::shared_ptr< Dune::OwnerOverlapCopyCommunication< T1, T2 > > & | outcomm,
|  | RedistributeInterface & | redistInf,
|  | bool | verbose = false )

execute a graph repartition for a giving graph and indexset.

This function provides repartition functionality using the PARMETIS library

Parameters

  | graph | The given graph to repartition
  | oocomm | The parallel information about the graph.
  | nparts | The number of domains the repartitioning should achieve.
  [out] | outcomm | Pointer store the parallel information of the redistributed domains in.
  | redistInf | Redistribute interface
  | verbose | Verbosity flag to give out additional information.

## hasUniqueBlockLevel()

template<typename T>

bool Dune::hasUniqueBlockLevel | ( |  | ) |

constexpr

Determine if a vector/matrix has a uniquely determinable block level.

## isValidGraph()

template<class S, class T>

bool Dune::isValidGraph | ( | std::size_t | noVtx,
|  | std::size_t | gnoVtx,
|  | S | noEdges,
|  | T * | xadj,
|  | T * | adjncy,
|  | bool | checkSymmetry )

inline

## makeScalarProduct()

template<class X, class Comm>

std::shared_ptr< ScalarProduct< X > > Dune::makeScalarProduct | ( | std::shared_ptr< const Comm > | comm,
|  | SolverCategory::Category | category )

Choose the appropriate scalar product for a solver category.

Todo
  this helper function should be replaced by a proper factory

As there is only one scalar product for each solver category it is possible to choose the appropriate product at compile time.

In each specialization of the this struct there will be a typedef ScalarProduct available the defines the type of the scalar product.

## maxBlockLevel()

template<typename T>

std::size_t Dune::maxBlockLevel | ( |  | ) |

constexpr

Determine the maximum block level of a possibly nested vector/matrix type.

## minBlockLevel()

template<typename T>

std::size_t Dune::minBlockLevel | ( |  | ) |

constexpr

Determine the minimum block level of a possibly nested vector/matrix type.

## operator<<()

template<class K, class A>

std::ostream & Dune::operator<< | ( | std::ostream & | s,
|  | const BlockVector< K, A > & | v )

Send BlockVector to an output stream.

## print_carray()

template<class S, class T>

void Dune::print_carray | ( | S & | os,
|  | T * | array,
|  | std::size_t | l )

inline

## printGlobalSparseMatrix()

template<class M, class C>

void Dune::printGlobalSparseMatrix | ( | const M & | mat,
|  | C & | ooc,
|  | std::ostream & | os )

## redistributeMatrix() [1/2]

template<typename M, typename C>

void Dune::redistributeMatrix | ( | M & | origMatrix,
|  | M & | newMatrix,
|  | C & | origComm,
|  | C & | newComm,
|  | RedistributeInformation< C > & | ri )

Redistribute a matrix according to given domain decompositions.

All the parameters for this function can be obtained by calling graphRepartition with the graph of the original matrix.

Parameters

  origMatrix | The matrix on the original partitioning.
  newMatrix | An empty matrix to store the new redistributed matrix in.
  origComm | The parallel information of the original partitioning.
  newComm | The parallel information of the new partitioning.
  ri | The remote index information between the original and the new partitioning. Upon exit of this method it will be prepared for copying from owner to owner vertices for data redistribution.

Template Parameters

  M | The matrix type. It is assumed to be sparse. E.g. BCRSMatrix.
  C | The type of the parallel information, see OwnerOverlapCopyCommunication.

## redistributeMatrix() [2/2]

template<typename M>

void Dune::redistributeMatrix | ( | M & | origMatrix,
|  | M & | newMatrix,
|  | Dune::Amg::SequentialInformation & | origComm,
|  | Dune::Amg::SequentialInformation & | newComm,
|  | RedistributeInformation< Dune::Amg::SequentialInformation > & | ri )

## redistributeMatrixEntries() [1/2]

template<typename M, typename C>

void Dune::redistributeMatrixEntries | ( | M & | origMatrix,
|  | M & | newMatrix,
|  | C & | origComm,
|  | C & | newComm,
|  | RedistributeInformation< C > & | ri )

## redistributeMatrixEntries() [2/2]

template<typename M>

void Dune::redistributeMatrixEntries | ( | M & | origMatrix,
|  | M & | newMatrix,
|  | Dune::Amg::SequentialInformation & | origComm,
|  | Dune::Amg::SequentialInformation & | newComm,
|  | RedistributeInformation< Dune::Amg::SequentialInformation > & | ri )

## redistributeSparsityPattern()

template<typename M, typename C>

void Dune::redistributeSparsityPattern | ( | M & | origMatrix,
|  | M & | newMatrix,
|  | C & | origComm,
|  | C & | newComm,
|  | RedistributeInformation< C > & | ri )

## Variable Documentation

## BaseGetSuperLUType< T >::type

template<class T>

const Dtype_t Dune::BaseGetSuperLUType< T >::type

Initial value:
=
std::is_same<T,float>::value ? SLU_S :
( std::is_same<T,std::complex<double> >::value ? SLU_Z :
( std::is_same<T,std::complex<float> >::value ? SLU_C : SLU_D ))

## MatrixRowGatherScatter< M, I >::col

template<class M, class I>

MatrixRowGatherScatter<M,I>::ColIter Dune::MatrixRowGatherScatter< M, I >::col

## MatrixRowGatherScatter< M, I >::datastore

template<class M, class I>

MatrixRowGatherScatter<M,I>::Data Dune::MatrixRowGatherScatter< M, I >::datastore

## MatrixRowGatherScatter< M, I >::numlimits

template<class M, class I>

MatrixRowGatherScatter<M,I>::GlobalIndex Dune::MatrixRowGatherScatter< M, I >::numlimits

## MatrixSparsityPatternGatherScatter< M, I >::col

template<class M, class I>

MatrixSparsityPatternGatherScatter<M,I>::ColIter Dune::MatrixSparsityPatternGatherScatter< M, I >::col

## MatrixSparsityPatternGatherScatter< M, I >::numlimits

template<class M, class I>

MatrixSparsityPatternGatherScatter<M,I>::GlobalIndex Dune::MatrixSparsityPatternGatherScatter< M, I >::numlimits