Namespaces
namespace	Amg

namespace	CounterImpl

namespace	ForEach

namespace	ILU

namespace	ISTL

namespace	MatrixImp

namespace	MatrixMarketImpl

namespace	Metis

Classes
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	AdditiveAdder

struct	AdditiveAdder< S, BlockVector< T, A > >

struct	AdditiveSchwarzMode
	Tag that the tells the Schwarz method to be additive. More...

struct	algmeta_bdsolve

struct	algmeta_bdsolve< 0, norelax >

struct	algmeta_bdsolve< 0, withrelax >

struct	algmeta_btsolve

struct	algmeta_btsolve< 0, nodiag, norelax >

struct	algmeta_btsolve< 0, nodiag, withrelax >

struct	algmeta_btsolve< 0, withdiag, norelax >

struct	algmeta_btsolve< 0, withdiag, withrelax >

struct	algmeta_itsteps

struct	algmeta_itsteps< 0, M >

struct	algmeta_itsteps< I, MultiTypeBlockMatrix< T1, MultiTypeMatrixArgs... > >

struct	AllocatorTraits

struct	AMGCreator

class	ArPackPlusPlus_Algorithms
	Wrapper to use a range of ARPACK++ eigenvalue solvers. More...

class	AssembledLinearOperator
	A linear operator exporting itself in matrix form. More...

struct	AutonomousValueType< Imp::BlockVectorWindow< B, A > >
	Specialization for the proxies of `BlockVectorWindow`

struct	BaseGetSuperLUType

class	BCRSMatrix
	A sparse block matrix with compressed row storage. More...

class	BCRSMatrixError
	Error specific to BCRSMatrix. More...

class	BDMatrix
	A block-diagonal matrix. More...

class	BiCGSTABSolver
	Bi-conjugate Gradient Stabilized (BiCG-STAB) More...

struct	BL
	compile-time parameter for block recursion depth More...

class	BlockPreconditioner
	Block parallel preconditioner. More...

class	BlockVector
	A vector of blocks with memory management. More...

class	BTDMatrix
	A block-tridiagonal matrix. More...

class	CGSolver
	conjugate gradient method More...

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	CommMatrixRow
	Utility class for comunicating the matrix entries. More...

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< Amg::GlobalAggregatesMap< T, TI > >

struct	CommPolicy< CommMatrixRow< M, I > >

struct	CommPolicy< CommMatrixSparsityPattern< M, I > >

class	CompleteFCGSolver
	Complete flexible conjugate gradient method. More...

struct	CompressionStatistics
	Statistics about compression achieved in implicit mode. More...

struct	DefaultAllocatorTraits

struct	DefaultAllocatorTraits< T, std::void_t< typename T::allocator_type > >

struct	DefaultSVGMatrixOptions
	Default options class to write SVG matrices. More...

struct	DenseMatrixAssigner< DenseMatrix, ScaledIdentityMatrix< field, N > >

class	DynamicMatrixSubdomainSolver
	Exact subdomain solver using Dune::DynamicMatrix<T>::solve. More...

class	DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >

struct	exists

class	FieldMatrix

struct	FieldTraits< BCRSMatrix< B, A > >

struct	FieldTraits< BDMatrix< B, A > >

struct	FieldTraits< BlockVector< B, A > >

struct	FieldTraits< BTDMatrix< B, A > >

struct	FieldTraits< Matrix< T, A > >

struct	FieldTraits< MultiTypeBlockVector< Args... > >

struct	FieldTraits< ScaledIdentityMatrix< K, n > >

class	GeneralizedPCGSolver
	Generalized preconditioned conjugate gradient solver. More...

struct	GetSuperLUType

struct	GetSuperLUType< double >

struct	GetSuperLUType< float >

struct	GetSuperLUType< std::complex< double > >

struct	GetSuperLUType< std::complex< float > >

class	GradientSolver
	gradient method More...

class	ILU0SubdomainSolver
	Exact subdomain solver using ILU(p) with appropriate p. More...

class	ILUNSubdomainSolver

class	ILUSubdomainSolver
	base class encapsulating common algorithms of ILU0SubdomainSolver and ILUNSubdomainSolver. More...

class	ImplicitMatrixBuilder
	A wrapper for uniform access to the BCRSMatrix during and after the build stage in implicit build mode. More...

class	ImplicitModeCompressionBufferExhausted
	Thrown when the compression buffer used by the implicit BCRSMatrix construction is exhausted. More...

class	IndexInfoFromGrid
	Information about the index distribution. More...

class	InvalidSolverCategory

class	InvalidSolverFactoryConfiguration

class	InverseOperator
	Abstract base class for all solvers. More...

class	InverseOperator2Preconditioner
	Turns an InverseOperator into a Preconditioner. More...

struct	InverseOperatorResult
	Statistics about the application of an inverse operator. More...

struct	IsDirectSolver

struct	IsDirectSolver< LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > > >

struct	IsDirectSolver< SPQR< BCRSMatrix< T, A > > >

struct	IsDirectSolver< SuperLU< BCRSMatrix< T, A > > >

struct	IsDirectSolver< UMFPack< BCRSMatrix< FieldMatrix< T, n, m >, A > > >

struct	IsMatrix
	Test whether a type is an ISTL Matrix. More...

struct	IsMatrix< BCRSMatrix< T, A > >

struct	IsMatrix< DenseMatrix< T > >

class	ISTLError
	derive error class from the base class in common More...

class	IterativeSolver
	Base class for all implementations of iterative solvers. More...

struct	IteratorDirectionSelector
	Helper template meta program for application of overlapping Schwarz. More...

struct	IteratorDirectionSelector< T1, T2, false >

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	LDLCreator

class	LinearOperator
	A linear operator. More...

class	LoopSolver
	Preconditioned loop solver. More...

struct	MatMultMatResult
	Helper TMP to get the result type of a sparse matrix matrix multiplication ( ) More...

struct	MatMultMatResult< BCRSMatrix< FieldMatrix< T, n, k >, A >, BCRSMatrix< FieldMatrix< T, k, m >, A1 > >

struct	MatMultMatResult< FieldMatrix< T, n, k >, FieldMatrix< T, k, m > >

class	Matrix
	A generic dynamic dense matrix. More...

class	MatrixAdapter
	Adapter to turn a matrix into a linear operator. More...

class	MatrixBlockError
	Error when performing an operation on a matrix block. More...

struct	MatrixCopyRowSizeGatherScatter

struct	MatrixDimension

struct	MatrixDimension< BCRSMatrix< B, TA > >

struct	MatrixDimension< BCRSMatrix< FieldMatrix< B, n, m >, TA > >

struct	MatrixDimension< DiagonalMatrix< K, n > >

struct	MatrixDimension< Dune::DynamicMatrix< T > >

struct	MatrixDimension< FieldMatrix< K, n, m > >

struct	MatrixDimension< Matrix< B, TA > >

struct	MatrixDimension< Matrix< FieldMatrix< K, n, m >, TA > >

struct	MatrixDimension< ScaledIdentityMatrix< K, n > >

class	MatrixIndexSet
	Stores the nonzero entries in a sparse matrix. More...

class	MatrixMarketFormatError

struct	MatrixRowGatherScatter

struct	MatrixRowSizeGatherScatter

struct	MatrixSparsityPatternGatherScatter

class	MINRESSolver
	Minimal Residual Method (MINRES) More...

struct	MultiplicativeAdder

struct	MultiplicativeAdder< S, BlockVector< T, A > >

struct	MultiplicativeSchwarzMode
	Tag that tells the Schwarz method to be multiplicative. More...

class	MultiTypeBlockMatrix
	A Matrix class to support different block types. More...

class	MultiTypeBlockMatrix_Solver
	solver for MultiTypeBlockVector & MultiTypeBlockMatrix types More...

class	MultiTypeBlockMatrix_Solver< I, crow, 0 >

class	MultiTypeBlockMatrix_Solver_Col
	part of solvers for MultiTypeBlockVector & MultiTypeBlockMatrix types More...

class	MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, 0 >

class	MultiTypeBlockVector
	A Vector class to support different block types. More...

class	NonoverlappingBlockPreconditioner
	Nonoverlapping parallel preconditioner. More...

class	NonoverlappingSchwarzOperator
	A nonoverlapping operator with communication object. More...

class	NonoverlappingSchwarzScalarProduct
	Nonoverlapping Scalar Product with communication object. More...

class	OverlappingAssignerHelper

class	OverlappingAssignerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >

class	OverlappingAssignerHelper< ILU0SubdomainSolver< M, X, Y >, false >

class	OverlappingAssignerHelper< ILUNSubdomainSolver< M, X, Y >, false >

struct	OverlappingAssignerHelper< S< BCRSMatrix< T, A > >, true >

class	OverlappingAssignerILUBase

class	OverlappingSchwarzInitializer
	Initializer for SuperLU Matrices representing the subdomains. More...

class	OverlappingSchwarzOperator
	An overlapping Schwarz operator. More...

class	OverlappingSchwarzScalarProduct
	Scalar product for overlapping Schwarz methods. More...

struct	OwnerOverlapCopyAttributeSet
	Attribute set for overlapping Schwarz. More...

class	OwnerOverlapCopyCommunication
	A class setting up standard communication for a two-valued attribute set with owner/overlap/copy semantics. More...

class	ParallelScalarProduct
	Scalar product for overlapping Schwarz methods. More...

class	ParSSOR
	A parallel SSOR preconditioner. More...

struct	PointerCompare

class	PowerIteration_Algorithms
	Iterative eigenvalue algorithms based on power iteration. More...

class	Preconditioner
	Base class for matrix free definition of preconditioners. More...

struct	PropertyMapTypeSelector< Amg::VertexVisitedTag, Amg::PropertiesGraph< G, Amg::VertexProperties, EP, VM, EM > >

struct	QuerySpaceChooser

struct	RedistributeInformation

class	RedistributeInformation< OwnerOverlapCopyCommunication< T, T1 > >

struct	RedistributeInterface

class	RestartedFCGSolver
	Accelerated flexible conjugate gradient method. More...

class	RestartedFlexibleGMResSolver
	implements the Flexible Generalized Minimal Residual (FGMRes) method (right preconditioned) More...

class	RestartedGMResSolver
	implements the Generalized Minimal Residual (GMRes) method More...

class	Richardson
	Richardson preconditioner. More...

class	ScalarProduct
	Base class for scalar product and norm computation. More...

class	ScaledIdentityMatrix
	A multiple of the identity matrix of static size. More...

class	SeqILDL
	sequential ILDL preconditioner More...

class	SeqILU
	Sequential ILU preconditioner. More...

class	SeqJac
	The sequential jacobian preconditioner. More...

class	SeqOverlappingSchwarz
	Sequential overlapping Schwarz preconditioner. More...

struct	SeqOverlappingSchwarzApplier
	Helper template meta program for application of overlapping Schwarz. More...

struct	SeqOverlappingSchwarzApplier< SeqOverlappingSchwarz< M, X, SymmetricMultiplicativeSchwarzMode, TD, TA > >

struct	SeqOverlappingSchwarzAssemblerHelper

struct	SeqOverlappingSchwarzAssemblerHelper< DynamicMatrixSubdomainSolver< BCRSMatrix< K, Al >, X, Y >, false >

struct	SeqOverlappingSchwarzAssemblerHelper< ILU0SubdomainSolver< M, X, Y >, false >

struct	SeqOverlappingSchwarzAssemblerHelper< ILUNSubdomainSolver< M, X, Y >, false >

struct	SeqOverlappingSchwarzAssemblerHelper< S< BCRSMatrix< T, A > >, true >

struct	SeqOverlappingSchwarzAssemblerILUBase

struct	SeqOverlappingSchwarzDomainSize

struct	SeqOverlappingSchwarzDomainSize< BCRSMatrix< T, A > >

class	SeqScalarProduct
	Default implementation for the scalar case. More...

class	SeqSOR
	Sequential SOR preconditioner. More...

class	SeqSSOR
	Sequential SSOR preconditioner. More...

class	SolverAbort
	Thrown when a solver aborts due to some problem. More...

struct	SolverCategory
	Categories for the solvers. More...

class	SolverFactory
	Factory to assembly solvers configured by a `ParameterTree`. 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...

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	SPQRCreator

struct	StoresColumnCompressed

struct	StoresColumnCompressed< LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > > >

struct	StoresColumnCompressed< SPQR< BCRSMatrix< T, A > > >

struct	StoresColumnCompressed< SuperLU< BCRSMatrix< T, A > > >

struct	StoresColumnCompressed< UMFPack< BCRSMatrix< T, A > > >

class	SuperLU
	SuperLu Solver. More...

struct	SuperLUCreator

struct	SuperLUDenseMatChooser

struct	SuperLUMatrix
	Utility class for converting an ISTL Matrix into a SuperLU Matrix. More...

class	SuperLUMatrix< BCRSMatrix< B, TA > >
	Converter for BCRSMatrix to SuperLU Matrix. More...

struct	SuperLUQueryChooser

struct	SuperLUSolveChooser

struct	SuperMatrixCreateSparseChooser

struct	SuperMatrixInitializer

class	SuperMatrixInitializer< BCRSMatrix< B, A > >

struct	SuperMatrixPrinter

struct	SymmetricMultiplicativeSchwarzMode
	Tag that tells the Schwarz method to be multiplicative and symmetric. More...

struct	TransposedMatMultMatResult
	Helper TMP to get the result type of a sparse matrix matrix multiplication ( ) More...

struct	TransposedMatMultMatResult< BCRSMatrix< FieldMatrix< T, k, n >, A >, BCRSMatrix< FieldMatrix< T, k, m >, A1 > >

struct	TransposedMatMultMatResult< FieldMatrix< T, k, n >, FieldMatrix< T, k, m > >

class	UMFPack
	The UMFPack direct sparse solver. More...

struct	UMFPackCreator

struct	UMFPackMethodChooser

struct	UMFPackMethodChooser< double >

struct	UMFPackMethodChooser< std::complex< double > >

class	UnsupportedType

class	VariableBlockVector
	A Vector of blocks with different blocksizes. More...

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. More...

template<class M , class X , class Y >
using	DirectSolverSignature = std::shared_ptr< InverseOperator< X, Y > >(const M &, const ParameterTree &)

template<class M , class X , class Y >
using	DirectSolverFactory = Singleton< ParameterizedObjectFactory< DirectSolverSignature< M, X, Y > > >

template<class M , class X , class Y >
using	PreconditionerSignature = std::shared_ptr< Preconditioner< X, Y > >(const std::shared_ptr< M > &, const ParameterTree &)

template<class M , class X , class Y >
using	PreconditionerFactory = Singleton< ParameterizedObjectFactory< PreconditionerSignature< M, X, Y > > >

template<class X , class Y >
using	IterativeSolverSignature = std::shared_ptr< InverseOperator< X, Y > >(const std::shared_ptr< LinearOperator< X, Y > > &, const std::shared_ptr< ScalarProduct< X > > &, const std::shared_ptr< Preconditioner< X, Y > >, const ParameterTree &)

template<class X , class Y >
using	IterativeSolverFactory = Singleton< ParameterizedObjectFactory< IterativeSolverSignature< X, Y > > >

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. More...

template<typename T >
constexpr std::size_t	minBlockLevel ()
	Determine the minimum block level of a possibly nested vector/matrix type. More...

template<typename T >
constexpr bool	hasUniqueBlockLevel ()
	Determine if a vector/matrix has a uniquely determinable block level. More...

template<typename T >
constexpr std::size_t	blockLevel ()
	Determine the block level of a possibly nested vector/matrix type. More...

template<class K , class A >
std::ostream &	operator<< (std::ostream &s, const BlockVector< K, A > &v)
	Send BlockVector to an output stream. More...

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. More...

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. More...

template<class M , class X , class Y >
void	bltsolve (const M &A, X &v, const Y &d)
	block lower triangular solve More...

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 More...

template<class M , class X , class Y >
void	ubltsolve (const M &A, X &v, const Y &d)
	unit block lower triangular solve More...

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 More...

template<class M , class X , class Y >
void	butsolve (const M &A, X &v, const Y &d)
	block upper triangular solve More...

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 More...

template<class M , class X , class Y >
void	ubutsolve (const M &A, X &v, const Y &d)
	unit block upper triangular solve More...

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 More...

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 More...

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 More...

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 More...

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 More...

template<class M , class X , class Y , int l>
void	butsolve (const M &A, X &v, const Y &d, BL< l > bl)
	block upper triangular solve More...

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 > bl)
	relaxed block upper triangular solve More...

template<class M , class X , class Y , int l>
void	ubutsolve (const M &A, X &v, const Y &d, BL< l > bl)
	unit block upper triangular solve More...

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 > bl)
	relaxed unit block upper triangular solve More...

template<class M , class X , class Y >
void	bdsolve (const M &A, X &v, const Y &d)
	block diagonal solve, no relaxation More...

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 More...

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 More...

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 More...

template<class M , class X , class Y , class K >
void	dbgs (const M &A, X &x, const Y &b, const K &w)
	GS step. More...

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. More...

template<class M , class X , class Y , class K >
void	bsorf (const M &A, X &x, const Y &b, const K &w)
	SOR step. More...

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. More...

template<class M , class X , class Y , class K >
void	bsorb (const M &A, X &x, const Y &b, const K &w)
	SSOR step. More...

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. More...

template<class M , class X , class Y , class K >
void	dbjac (const M &A, X &x, const Y &b, const K &w)
	Jacobi step. More...

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. More...

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 > *sfinae=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 > *sfinae=nullptr)

template<class Matrix >
void	bildl_decompose (Matrix &A)
	compute ILDL decomposition of a symmetric matrix A More...

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. More...

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. More...

void	fill_row (std::ostream &s, int m, int width, int precision)
	Print a row of zeros for a non-existing block. More...

template<class K >
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, typename std::enable_if_t< Dune::IsNumber< K >::value > *sfinae=nullptr)
	Print one row of a matrix, specialization for number types. More...

template<class M >
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, typename std::enable_if_t<!Dune::IsNumber< M >::value > *sfinae=nullptr)
	Print one row of a matrix. More...

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. More...

template<class B , int n, int m, class A >
void	printSparseMatrix (std::ostream &s, const BCRSMatrix< FieldMatrix< B, n, m >, A > &mat, std::string title, std::string rowtext, int width=3, int precision=2)
	Prints a BCRSMatrix with fixed sized blocks. More...

template<class FieldType >
void	writeMatrixToMatlabHelper (const FieldType &value, int rowOffset, int colOffset, std::ostream &s, typename std::enable_if_t< Dune::IsNumber< FieldType >::value > *sfinae=nullptr)
	Helper method for the writeMatrixToMatlab routine. More...

template<class MatrixType >
void	writeMatrixToMatlabHelper (const MatrixType &matrix, int externalRowOffset, int externalColOffset, std::ostream &s, typename std::enable_if_t<!Dune::IsNumber< MatrixType >::value > *sfinae=nullptr)
	Helper method for the writeMatrixToMatlab routine. More...

template<class MatrixType >
void	writeMatrixToMatlab (const MatrixType &matrix, const std::string &filename, int outputPrecision=18)
	Writes sparse matrix in a Matlab-readable format. More...

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. More...

template<class Mat , class SVGOptions = DefaultSVGMatrixOptions>
void	writeSVGMatrix (const Mat &mat, std::ostream &out, SVGOptions opts={})
	Writes the visualization of matrix in the SVG format. More...

	DUNE_REGISTER_DIRECT_SOLVER ("ldl", Dune::LDLCreator())

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. More...

template<typename T , typename A >
void	readMatrixMarket (Dune::BCRSMatrix< T, A > &matrix, std::istream &istr)
	Reads a sparse matrix from a matrix market file. More...

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. More...

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. More...

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. More...

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. More...

template<typename M >
void	loadMatrixMarket (M &matrix, const std::string &filename)
	Load a matrix/vector stored in matrix market format. More...

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 tryHard=false)
	Calculate product of a sparse matrix with a transposed sparse matrices ( ). More...

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 tryHard=false)
	Calculate product of two sparse matrices ( ). More...

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 tryHard=false)
	Calculate product of a transposed sparse matrix with another sparse matrices ( ). More...

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. More...

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. More...

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 More...

template<typename... Args>
std::ostream &	operator<< (std::ostream &s, const MultiTypeBlockVector< Args... > &v)
	Send MultiTypeBlockVector to an outstream. More...

	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 ("ilu", defaultPreconditionerBlockLevelCreator< Dune::SeqILU >())

	DUNE_REGISTER_PRECONDITIONER ("richardson", [](auto tl, const auto &, const ParameterTree &config){ using D=typename Dune::TypeListElement< 1, decltype(tl)>::type;using R=typename Dune::TypeListElement< 2, decltype(tl)>::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. More...

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. More...

template<class X , class Comm >
std::shared_ptr< ScalarProduct< X > >	makeScalarProduct (std::shared_ptr< const Comm > comm, SolverCategory::Category category)
	Choose the approriate scalar product for a solver category. More...

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

template<class O , class Preconditioner >
std::shared_ptr< Preconditioner >	wrapPreconditioner4Parallel (const std::shared_ptr< Preconditioner > &prec, const O &)

template<class M , class X , class Y , class C , class Preconditioner >
std::shared_ptr< Preconditioner >	wrapPreconditioner4Parallel (const std::shared_ptr< Preconditioner > &prec, const std::shared_ptr< OverlappingSchwarzOperator< M, X, Y, C > > &op)

template<class M , class X , class Y , class C , class Preconditioner >
std::shared_ptr< Preconditioner >	wrapPreconditioner4Parallel (const std::shared_ptr< Preconditioner > &prec, const std::shared_ptr< NonoverlappingSchwarzOperator< M, X, Y, C > > &op)

template<class M , class X , class Y >
std::shared_ptr< ScalarProduct< X > >	createScalarProduct (const std::shared_ptr< MatrixAdapter< M, X, Y > > &)

template<class M , class X , class Y , class C >
std::shared_ptr< ScalarProduct< X > >	createScalarProduct (const std::shared_ptr< OverlappingSchwarzOperator< M, X, Y, C > > &op)

template<class M , class X , class Y , class C >
std::shared_ptr< ScalarProduct< X > >	createScalarProduct (const std::shared_ptr< NonoverlappingSchwarzOperator< M, X, Y, C > > &op)

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. More...

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_ITERATIVE_SOLVER ("loopsolver", defaultIterativeSolverCreator< Dune::LoopSolver >())

	DUNE_REGISTER_ITERATIVE_SOLVER ("gradientsolver", defaultIterativeSolverCreator< Dune::GradientSolver >())

	DUNE_REGISTER_ITERATIVE_SOLVER ("cgsolver", defaultIterativeSolverCreator< Dune::CGSolver >())

	DUNE_REGISTER_ITERATIVE_SOLVER ("bicgstabsolver", defaultIterativeSolverCreator< Dune::BiCGSTABSolver >())

	DUNE_REGISTER_ITERATIVE_SOLVER ("minressolver", defaultIterativeSolverCreator< Dune::MINRESSolver >())

	DUNE_REGISTER_ITERATIVE_SOLVER ("restartedgmressolver", defaultIterativeSolverCreator< Dune::RestartedGMResSolver >())

	DUNE_REGISTER_ITERATIVE_SOLVER ("restartedflexiblegmressolver", defaultIterativeSolverCreator< Dune::RestartedFlexibleGMResSolver >())

	DUNE_REGISTER_ITERATIVE_SOLVER ("generalizedpcgsolver", defaultIterativeSolverCreator< Dune::GeneralizedPCGSolver >())

	DUNE_REGISTER_ITERATIVE_SOLVER ("restartedfcgsolver", defaultIterativeSolverCreator< Dune::RestartedFCGSolver >())

	DUNE_REGISTER_ITERATIVE_SOLVER ("completefcgsolver", defaultIterativeSolverCreator< Dune::CompleteFCGSolver >())

	DUNE_REGISTER_DIRECT_SOLVER ("spqr", Dune::SPQRCreator())

	DUNE_REGISTER_DIRECT_SOLVER ("superlu", SuperLUCreator())

	DUNE_REGISTER_DIRECT_SOLVER ("umfpack", Dune::UMFPackCreator())

Variables
static const int	default_precision = -1

Typedef Documentation

◆ AllocatorType

template<typename T >

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

◆ ReboundAllocatorType

template<typename T , typename X >

using Dune::ReboundAllocatorType = typedef 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>

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

inlinestatic

◆ bildl_subtractBCT() [2/3]

template<class K >

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

inlinestatic

◆ bildl_subtractBCT() [3/3]

template<class Matrix >

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

inlinestatic

◆ blockLevel()

template<typename T >

constexpr 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_DIRECT_SOLVER()

Dune::DUNE_REGISTER_DIRECT_SOLVER	(	"superlu"	,
		SuperLUCreator()
	)

◆ DUNE_REGISTER_PRECONDITIONER()

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

◆ 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 >

constexpr 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 approriate 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 >

constexpr std::size_t Dune::maxBlockLevel ( )

constexpr

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

◆ minBlockLevel()

template<typename T >

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

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ AllocatorType

◆ ReboundAllocatorType

Function Documentation

◆ bildl_backsolve()

◆ bildl_decompose()

◆ bildl_subtractBCT() [1/3]

◆ bildl_subtractBCT() [2/3]

◆ bildl_subtractBCT() [3/3]

◆ blockLevel()

◆ buildCommunication()

◆ commGraphRepartition()

◆ createScalarProduct()

◆ DUNE_REGISTER_DIRECT_SOLVER()

◆ DUNE_REGISTER_PRECONDITIONER()

◆ fillIndexSetHoles()

◆ flatMatrixForEach()

◆ flatVectorForEach()

◆ get()

◆ graphRepartition()

◆ hasUniqueBlockLevel()

◆ isValidGraph()

◆ makeScalarProduct()

◆ maxBlockLevel()

◆ minBlockLevel()

◆ operator<<()

◆ print_carray()

◆ printGlobalSparseMatrix()

◆ redistributeMatrix() [1/2]

◆ redistributeMatrix() [2/2]

◆ redistributeMatrixEntries() [1/2]

◆ redistributeMatrixEntries() [2/2]

◆ redistributeSparsityPattern()