AMDiS Namespace Reference

Contains all classes needed for solving linear and non linear equation systems. More...

Classes
class	AdaptBase
	Interface for adaption loops. More...
class	AdaptInfo
	Holds adapt parameters and infos about the problem. More...
class	AdaptInstationary
	AdaptInstationary implements the adaptive procedure for time dependent problems (see ProblemInstat). It contains a pointer to a ProblemInstat object. More...
class	AdaptionInterface
	Interface for transfer between grid changes. More...
class	AdaptiveGrid
	Wrapper class for Dune-grids that allows automatic signalling of events during grid adaptation. More...
class	AdaptiveGridFamily
class	AdaptStationary
	Contains all classes needed for space and time adaption. More...
struct	AMGCreator
struct	AMGCreator< Dune::Amg::AMG, Traits >
struct	AMGCreator< Dune::Amg::FastAMG, Traits >
struct	AMGCreator< Dune::Amg::KAMG, Traits >
class	AMGPrecon
class	AMGPreconCreator
	A creator for AMGPrecon, reads the smoother type from initfile: More...
class	AnalyticGridFunction
	A Gridfunction that evaluates a function with global coordinates. More...
class	AnalyticLocalFunction
class	AnalyticLocalFunction< R(D), LC, Function >
struct	AnalyticPreGridFunction
class	Assembler
	Implementation of interface AssemblerBase. More...
class	AssemblerInterface
	Abstract base-class of a Assembler. More...
struct	AssemblerTriple
struct	AttributeSet
struct	AttributeSet< Dune::ParallelIndexSet< TG, TL, N > >
struct	AttributeSet< Dune::ParallelLocalIndex< A > >
class	BackupRestoreByGridFactory
class	BackupWriter
class	bicg_solver_type
	ITL_Solver <bicg_solver_type> implementation of bi-conjugate gradient method. More...
class	bicgstab2_type
	ITL_Solver <bicgstab2_type> implementation of BiCGStab(l) method with l=2. More...
class	bicgstab_ell_type
	ITL_Solver <bicgstab_ell_type> implementation of stabilized BiCG(ell) method. More...
class	bicgstab_type
	ITL_Solver <bicgstab_type> implementation of stabilized bi-conjugate gradient method. More...
class	BiLinearForm
struct	BlockMatrixType
struct	BlockMatrixType< T, typename T::field_type >
struct	BlockVectorType
struct	BlockVectorType< T, typename T::field_type >
class	BoundaryCondition
	Interface class for boundary conditions. More...
class	BoundaryManager
	Manage boundary ids of boundary segments in a grid. More...
class	BoundaryManagerBase
class	BoundarySubset
	Class defining a subset of a domain boundary. More...
class	cg_solver_type
	ITL_Solver <cg_solver_type> implementation of conjugate gradient method. More...
class	cgs_solver_type
	ITL_Solver <cgs_solver_type> implementation of squared conjugate gradient method. More...
struct	CheckNumCols
struct	CheckNumRows
struct	CheckSize
struct	CommunicationCreator
	Implementation of a creator pattern for Communication types. More...
struct	CommunicationCreator< DistributedCommunication< G, L > >
struct	CommunicationCreator< ISTLCommunication< G, L > >
class	CompositeNodeCache
class	ConcurrentCache
	The class template ConcurrentCache describes an associative static container that allows the concurrent access to the stored data. More...
struct	ConsecutivePolicy
	Store cache in instance. More...
class	ConstantGridFunction
	Gridfunction returning a constant value. More...
class	ConstantLocalFunction
class	ConstantLocalFunction< R(D), LC, T >
	LocalFunction of a Gridfunction returning a constant value. More...
class	Constraints
struct	Constraints< BiLinearForm< RB, CB, T, Traits > >
struct	Constraints< EigenSparseMatrix< T, O > >
struct	Constraints< ISTLBCRSMatrix< T, C > >
struct	Constraints< MTLSparseMatrix< T > >
struct	Constraints< PetscMatrix< DofMap > >
struct	ContextGeometry
	Wrapper class for element and geometry. More...
class	ConvectionDiffusionOperator
class	CreatorInterface
	Interface for the implementation of the factory method pattern. The creation of an object of a sub class of BaseClass is deligated to a corresponding sub class of Creator<BaseClass>. So it is possible to manage a CreatorMap, which can be extended at run-time. An example is the LinearSolverInterfaceMap: If you write your own LinearSolverInterface sub class and a corresponding Creator<LinearSolverInterface<T> >, you can add the creator together with a key string to the LinearSolverInterfaceMap. Then you can create an LinearSolverInterface depending of a key string read from the init file, which can also be your own new solver. More...
class	CreatorInterfaceName
	Interface for creators with name. More...
class	CreatorMap
	A CreatorMap is used to construct objects, which types depends on key words determined at run time. For example the LinearSolverInterfaceMap can create the different solver types depending on the solver parameter of the init file. The benefit of such creator maps is, that you can extend them only by writing an creator class for your own new class and give the creator together with a key word to the map. More...
class	DataTransfer
class	DataTransferFactory
	Factory to create DataTransfer objects based on the DataTransferOperation. More...
class	DataTransferInterface
	Interface for Containers allowing data transfer between grid changes. More...
class	DataTransferWrapper
struct	DefaultAssemblerTraits
struct	DefaultAttributeSet
struct	DefaultBasisCreator
	Generator for a basis and default problem traits. More...
struct	DefaultCommunicationCreator
class	DefaultCreators
class	DefaultCreators< ISTLPreconCreatorInterface< Traits > >
	Adds default creators for preconditioners for ISTL. More...
class	DefaultCreators< ISTLSolverCreatorInterface< Traits > >
class	DefaultCreators< LinearSolverInterface< Mat, Vec > >
	Adds default creators for linear solvers based on Eigen::SparseMatrix. More...
class	DefaultCreators< PreconditionerInterface< Mat, Vec > >
class	DefaultLeafGridView
struct	DefaultLeafGridViewTraits
class	DefaultLevelGridView
struct	DefaultLevelGridViewTraits
struct	DefaultProblemTraits
	Wrapper around a global basis providing default traits. More...
class	DefaultSolverCreators
	Adds default creators for linear solvers based on Dune::BCRSMatrix. More...
class	DerivativeGridFunction
	A Gridfunction that returns the derivative when calling localFunction. More...
struct	DerivativePreGridFunction
struct	DerivativeTraits
struct	DerivativeTraits< Dune::FieldMatrix< K, n, m >(FieldVector< K, n >), tag::divergence >
struct	DerivativeTraits< Dune::FieldVector< K, 1 >(Dune::FieldVector< K, n >), tag::gradient >
struct	DerivativeTraits< Dune::FieldVector< K, n >(Dune::FieldVector< K, n >), tag::divergence >
struct	DerivativeTraits< K(Dune::FieldVector< K, n >), tag::gradient >
struct	DerivativeTraits< R(D), tag::gradient >
struct	DerivativeTraits< R(D), tag::jacobian >
struct	DerivativeTraits< R(D), tag::value >
struct	DerivativeTraits< R(Dune::FieldVector< K, n >), tag::partial >
class	DiagonalPreconditioner
	ITL_Preconditioner implementation of diagonal (jacobi) preconditioner,. More...
class	DirectRunner
struct	DirectSolverCreator
	Default creator for direct solvers. More...
class	DirichletBC
	Implements a boundary condition of Dirichlet-type. More...
class	DiscreteFunction
	A mutable view on the subspace of a DOFVector,. More...
class	DiscreteFunction< Coeff const, GB, TreePath, R >
	A Const DiscreteFunction. More...
class	DistributedCommunication
class	DOFVector
	The basic container that stores a base vector and a corresponding basis. More...
class	EigenSparseMatrix
	The basic container that stores a base matrix and a corresponding row/column feSpace. More...
struct	EigenTraits
class	EigenVector
	The basic container that stores a base vector and a corresponding basis. More...
class	Environment
	Establishes an environment for sequential and parallel AMDiS programs. More...
class	ESMarker
	Equidistribution strategy. More...
class	EstimatorMarker
	Base class for all estimator-based markers. More...
struct	FaceTransformation
	Affine transformation x := A*x + b. More...
struct	FakeAssigner
class	FakeContainer
	A container-like data-structure not storing anything and with empty implementations in many container-interface functions. More...
class	fgmres_type
	ITL_Solver <fgmres_type> implementation of flexible GMRes method. More...
class	FileWriterBase
	Base class for filewriters. More...
class	FileWriterCreator
	Creator class for filewriters depending on a given type name. More...
class	FileWriterInterface
	Interface class for filewriters. More...
class	Flag
	The Flag class encapsulates flags which represents simple information. Used e.g. while mesh traversal to specify, which elements should be visited. More...
class	FlatMatrix
	Dense matrix with row-wise storage in flat data vector. More...
struct	FlatPreBasis
struct	FlatPreBasis< Dune::Functions::CompositePreBasis< MI, IMS, SPB... >, MultiIndex >
struct	FlatPreBasis< Dune::Functions::LagrangePreBasis< GV,-1, MI, R >, MultiIndex >
struct	FlatPreBasis< Dune::Functions::PowerPreBasis< MI, Dune::Functions::BasisFactory::BlockedInterleaved, SPB, C >, MultiIndex >
struct	FlatPreBasis< Dune::Functions::PowerPreBasis< MI, Dune::Functions::BasisFactory::BlockedLexicographic, SPB, C >, MultiIndex >
struct	FlatPreBasis< Dune::Functions::PowerPreBasis< MI, IMS, SPB, C >, MultiIndex >
class	FlatVector
	Flat data vector to be used in assembling as element vector. More...
class	FunctorGridFunction
	A Gridfunction that applies a functor to the evaluated Gridfunctions. More...
class	FunctorLocalFunction
class	FunctorLocalFunction< R(D), Functor, LocalFunctions... >
struct	FunctorPreGridFunction
class	gcr_type
	ITL_Solver <gcr_type> implementation of generalized conjugate residual method. More...
class	GERSMarker
	Guaranteed error reduction strategy. More...
class	GlobalBasis
	Global basis defined on a pre-basis. More...
class	GlobalBasisIdSet
	Provide global ids for all DOFs in a global basis. More...
class	GlobalBasisIdSet< Basis, std::void_t< typename Basis::RootBasis > >
class	GlobalIdType
	Type of a global used used to represent DOFs uniquely. More...
class	gmres_type
	ITL_Solver <gmres_type> implementation of generalized minimal residual method. More...
class	GmshWriter
	The GmshWriter just writes the grid of a given gridView to a gmsh compatible .msh file. More...
struct	GridFunctionCreator
struct	GridFunctionCreator< Function, std::enable_if_t< Concepts::CallableDomain< Function > > >
struct	GridFunctionCreator< Value, std::enable_if_t< Concepts::ConstantToGridFunction< Value > > >
class	GridFunctionMarker
	Marker based on an indicator given as grid-function. More...
class	GridFunctionOperator
	The base-template for GridFunctionOperators. More...
class	GridFunctionOperator< tag::divtestvec, LC, GridFct >
	first-order operator \( \langle\nabla\cdot\Psi, c\rangle \) More...
class	GridFunctionOperator< tag::divtestvec_divtrialvec, LC, GridFct >
	second-order operator \( \langle\nabla\cdot\Psi, c\,\nabla\cdot\Phi\rangle \) More...
class	GridFunctionOperator< tag::divtestvec_trial, LC, GridFct >
	first-order operator \( \langle\nabla\cdot\Psi, c\,\phi\rangle \) More...
class	GridFunctionOperator< tag::gradtest, LC, GridFct >
	first-order operator \( \langle\nabla\psi, b\rangle \) More...
class	GridFunctionOperator< tag::gradtest_gradtrial, LC, GridFct >
	second-order operator \( \langle\nabla\psi, c\,\nabla\phi\rangle \), or \( \langle\nabla\psi, A\,\nabla\phi\rangle \) More...
class	GridFunctionOperator< tag::gradtest_trial, LC, GridFct >
	first-order operator \( \langle\nabla\psi, \mathbf{b}\,\phi\rangle \) More...
class	GridFunctionOperator< tag::gradtest_trialvec, LC, GridFct >
	first-order operator \( \langle\nabla\psi, c\,\Phi\rangle \) More...
class	GridFunctionOperator< tag::partialtest, LC, GridFct >
	first-order operator \( \langle\partial_i\psi, c\rangle \) More...
class	GridFunctionOperator< tag::partialtest_partialtrial, LC, GridFct >
	second-order operator \( \langle\partial_i\psi, c\,\partial_j\phi\rangle \) More...
class	GridFunctionOperator< tag::partialtest_trial, LC, GridFct >
	first-order operator \( \langle\partial_i\psi, c\,\phi\rangle \) More...
class	GridFunctionOperator< tag::stokes, LC, ViscosityExpr >
	Stokes operator \( \langle\nabla\mathbf{v}, \nu \nabla\mathbf{u}\rangle + \langle\nabla\cdot\mathbf{v}, p\rangle + \langle q, \langle\nabla\cdot\mathbf{u}\rangle \). More...
class	GridFunctionOperator< tag::test, LC, GridFct >
	zero-order vector-operator \( (c\, \psi) \) More...
class	GridFunctionOperator< tag::test_divtrialvec, LC, GridFct >
	first-order operator \( \langle\psi, c\,\nabla\cdot\Phi\rangle \) More...
class	GridFunctionOperator< tag::test_gradtrial, LC, GridFct >
	first-order operator \( \langle\psi, \mathbf{b}\cdot\nabla\phi\rangle \) More...
class	GridFunctionOperator< tag::test_partialtrial, LC, GridFct >
	first-order operator \( \langle\psi, c\,\partial_i\phi\rangle \) More...
class	GridFunctionOperator< tag::test_trial, LC, GridFct >
	zero-order operator \( \langle\psi, c\,\phi\rangle \) More...
class	GridFunctionOperator< tag::test_trialvec, LC, GridFct >
	zero-order operator \( \langle\psi, \mathbf{b}\cdot\Phi\rangle \) More...
class	GridFunctionOperator< tag::testvec, LC, GridFct >
	zero-order vector-operator \( (\mathbf{b}\cdot\Psi) \) More...
class	GridFunctionOperator< tag::testvec_gradtrial, LC, GridFct >
	first-order operator \( \langle\Psi, c\,\nabla\phi\rangle \) More...
class	GridFunctionOperator< tag::testvec_trial, LC, GridFct >
	zero-order operator \( \langle\Psi, \mathbf{b}\,\phi\rangle \) More...
class	GridFunctionOperator< tag::testvec_trialvec, LC, GridFct >
	zero-order operator \( \langle\Psi, c\,\Phi\rangle \), or \( \langle\Psi, A\,\Phi\rangle \) More...
class	GridFunctionOperatorBase
	The main implementation of an CRTP-base class for operators using a grid-function coefficient to be used in an Assembler. More...
class	GridFunctionOperatorTransposed
	The transposed operator, implemented in term of its transposed by calling getElementMatrix with inverted arguments. More...
class	GRMarker
	Global refinement. More...
struct	HierarchicNodeToRangeMap
	A simple node to range map using the nested tree indices. More...
class	ICPreconditioner
	ITL_Preconditioner implementation of IC (Incomplete Cholesky factorization) preconditioner. More...
class	IdentityPreconditioner
	ITL_Preconditioner implementation of identity preconditioner,. More...
class	idr_s_type
	ITL_Solver <idr_s_type> implementation of Induced Dimension Reduction method. More...
class	ILUPreconditioner
	ITL_Preconditioner implementation of ILU (Incomplete LU factorization) preconditioner. More...
struct	IndexMapTuple
struct	IndexMapTuple< std::index_sequence< I... >, Map >
class	Initfile
class	InitfileParser
	Parser for AMDiS initfile format. More...
class	ISTLBCRSMatrix
class	ISTLBlockVector
class	ISTLIterativeSolverCreator
	Base solver creator for iterative solvers. More...
class	ISTLLinearOperatorCreator
	Creator to create Linear Operator objects. More...
class	ISTLParallelPreconditionerCreator
	Creator to create parallel Preconditioners. More...
struct	ISTLPreconCreator
	Base class for precon creators,. More...
struct	ISTLPreconCreatorInterface
class	ISTLScalarProductCreator
	Creator to create ScalarProduct objects. More...
class	ISTLSolver
	Implementation of RunnerInterface for ISTL solvers. More...
struct	ISTLSolverCreator
	Base class for solver creators,. More...
struct	ISTLSolverCreatorInterface
struct	ISTLTraits
class	IterativeRunner
class	IterativeSolverCreator
	Default solver creator for iterative solvers. More...
struct	IterativeSolverCreator< tag::gmres< Solver >, Traits >
	Solver creator for iterative GMRes-like solvers. More...
struct	IterativeSolverCreator< tag::pcg< Solver >, Traits >
	Solver creator for iterative CG-like solvers. More...
class	IterativeSolverWrapper
class	KrylovRunner
	Wrapper class for different MTL4 itl-solvers. These solvers are parametrized by Matrix and Vector. More...
struct	LagrangeBasis
	ProblemStatTraits for a (composite) basis composed of lagrange bases of different degree. More...
class	LeafNodeCache
	Cache of LocalBasis evaluations and jacobians at local points. More...
class	LinearForm
	The basic container that stores a base vector and a corresponding basis. More...
class	LinearSolver
	Wrapper class for various solvers. These solvers are parametrized by MatrixType and VectorType. The different algorithms, like krylov subspace methods or other external solvers where the backend provides an interface, can be assigned by different Runner objects. More...
class	LinearSolverInterface
	Abstract base class for linear solvers. More...
class	LocalOperator
	The main implementation of an operator to be used in a Assembler. More...
class	LocalToGlobalBasisAdapter
	Convert a simple (scalar) local basis into a global basis. More...
struct	LocalToGlobalBasisAdapterTraits
	Traits class for local-to-global basis adaptors. More...
class	LocalView
	The restriction of a finite element basis to a single element. More...
class	MacroGridFactory
class	MappedRangeView
	A range transforming the values of another range on-the-fly. More...
struct	MapTuple
struct	MapTuple< std::tuple< T... >, Map >
class	Marker
	Base class for all markers. More...
class	MatrixFacade
class	MatrixNnzStructure
	Sparsity pattern used to create PETSc matrices. More...
class	MatrixSize
struct	MeshCreator
	A creator class for dune grids. More...
class	minres_solver_type
	ITL_Solver <minres_solver_type> implementation of minimal residual method. More...
class	MSMarker
	Maximum strategy. More...
class	MTLSparseMatrix
	The basic container that stores a base matrix. More...
struct	MTLTraits
class	MTLVector
	The basic container that stores a base vector data. More...
class	NoDataTransfer
	Implementation of DataTransferInterface that does not interpolate, but just resizes the containers to the dimension of the basis. More...
class	NodeDataTransfer
class	NodeIdSet
class	NodeIdSet< Dune::Functions::LagrangeDGPreBasis< GV, k, MI >, TP >
class	NodeIdSet< Dune::Functions::TaylorHoodPreBasis< GV, MI, HI >, TP, Dune::TypeTree::CompositeNodeTag >
class	NodeIdSet< PreBasis, TP, Dune::TypeTree::CompositeNodeTag >
class	NodeIdSet< PreBasis, TP, Dune::TypeTree::PowerNodeTag >
class	NodeWrapper
struct	NoOp
	A functor with no operation. More...
class	Notifier
	Mixin for signaling of certain events. More...
class	Notifier< Event >
class	Observer
	Implementation of the ObserverInterface. More...
class	ObserverInterface
class	OperatorLists
class	PeriodicBC
	Implements a periodic boundary condition. More...
class	PetscMatrix
	The basic container that stores a base matrix. More...
class	PetscRunner
	Wrapper around PETSc KSP and PC objects to solve a linear system. More...
struct	PetscTraits
class	PetscVector
	The basic container that stores a base vector data. More...
class	PowerNodeCache
struct	PreconConfig
struct	PreconConfig< Eigen::IncompleteLUT< T, I > >
struct	PreconCreator
	Default precon creator. More...
struct	PreconCreator< Dune::ParSSOR< M, X, Y, Comm >, Traits >
	Precon creator for the ParSSOR preconditioner.
struct	PreconCreator< Dune::Richardson< X, Y >, Traits >
	Precon creator for the Richardson preconditioner.
struct	PreconCreator< Dune::SeqILDL< M, X, Y >, Traits >
	Precon creator for the SeqILDL preconditioner.
struct	PreconCreator< tag::bjacobi, Traits >
	Precon creator for the BJacobi preconditioner. More...
struct	PreconCreator< tag::solver, Traits >
	Precon creator for the InverseOperator2Preconditioner preconditioner. More...
class	Preconditioner
	Wrapper for using ITL preconditioners in AMDiS. More...
class	PreconditionerInterface
	Interface for Preconditioner y = M*x. More...
struct	PreConvectionDiffusionOperator
class	PreconWrapper
struct	PreGridFunctionOperator
class	preonly_type
	ITL_Solver <preonly_type> implementation of preconditioner as. More...
struct	PreQuadFactoryFromLocalFunction
struct	PreQuadFactoryFromOrder
struct	PreQuadFactoryFromRule
class	ProblemInstat
	Standard implementation of ProblemTimeInterface for a time dependent problems. More...
class	ProblemInstatBase
	Base class for ProblemInstat. More...
class	ProblemIterationInterface
	Interface for master problems needed by the adaption loop. A master problem can handle one single or multiple coupled problems. In the latter case, the master problem can determine the execution order of the build, solve, estimate, and adapt steps of the single problems in oneIteration(). More...
class	ProblemStat
class	ProblemStatBase
	Interface for time independent problems. Concrete problems must override all pure virtual methods. The method adaptMethodStat() should initiate the adaption loop which in turn uses the other pure virtual functions. The default stationary adaption loop is implemented in the class AdaptStationary. More...
class	ProblemTimeInterface
	Interface for time dependent problems. Concrete problems must override all pure virtual methods. More...
class	qmr_solver_type
	ITL_Solver <qmr_solver_type> implementation of Quasi-Minimal Residual method. More...
class	QuadFactoryFromLocalFunction
	Factory for quadrature rule, that calculates the coefficient order from a localFunction passed to the bind method. More...
class	QuadFactoryFromOrder
	Factory for quadrature rule, that takes to order of the localFunction and a quadrature-type. More...
class	QuadFactoryFromRule
	Factory for quadrature rule, that is based on an existing rule. More...
class	QuadratureFactory
	Base class for quadrature factories for localFunctions. More...
struct	remove_cvref
	Remove cv and ref qualifiers of type T. More...
class	RunnerInterface
	Interface for Runner / Worker types used in solver classes. More...
struct	SeqSolverTraits
class	SequentialCommunication
	Dummy implementation for sequential communication. More...
class	SequentialDofMapping
	Fallback for ParallelDofMapping in case there is only one mpi core. More...
class	SequentialISTLCommunication
	Dummy implementation for ISTL-specific communication when no MPI is found. More...
class	SlotSize
struct	SolverConfig
struct	SolverConfig< Eigen::DGMRES< M, P > >
struct	SolverConfig< Eigen::GMRES< M, P > >
class	SolverInfo
class	SolverPrecon
	Use a LinearSolver as Preconditioner. More...
struct	SolverTraits
class	SparsityPattern
	A general sparsity pattern implementation using the full pattern of the basis by adding all local indices. More...
class	StandardProblemIteration
	A master problem for a single non coupled problem. More...
class	StandardProblemIterationAdaptor
	StandardProblemIteration when derived from ProblemStat. More...
struct	StaticLockedPolicy
	Stores cache global static, requires locking on write access. More...
struct	TaylorHoodBasis
	ProblemStatTraits of Taylor-Hood basis of lagrange-type with pressure degree k. More...
class	tfqmr_solver_type
	ITL_Solver <tfqmr_solver_type> implementation of Transposed-Free Quasi-Minimal Residual method. More...
struct	ThreadLocalPolicy
	Store cache thread local, requires no locking. More...
class	TransposedMatrix
	The transposed view onto a matrix. More...
class	Twist
	Permutate the dof indices w.r.t. a global entity orientation. More...
struct	Types
	A variadic type list. More...
class	UmfpackRunner
class	UniqueBorderPartition
	Determine for each border entity which processor owns it. More...
struct	ValueCategory
	Category of type T, e.g. scalar, vector matrix, specified by a tag. More...
struct	ValueCategory< Dune::FieldMatrix< K, 1, 1 > >
struct	ValueCategory< Dune::FieldMatrix< K, ROWS, COLS > >
struct	ValueCategory< Dune::FieldVector< K, 1 > >
struct	ValueCategory< Dune::FieldVector< K, SIZE > >
struct	ValueCategory< std::reference_wrapper< T > >
struct	ValueCategory< T, std::enable_if_t< std::is_arithmetic_v< T > > >
class	VectorBase
	CRTP base class for flat vector backends. More...
class	VectorFacade
	The basic container that stores a base vector and a corresponding basis. More...
class	VTKSequenceWriter
	class to write pvd-files which contains a list of all collected vtk-files More...
class	VTKWriter
	Adapter for the dune-grid VTKWriter. More...
struct	YaspGridBasis
	Specialization of LagrangeBasis for Grid type Dune::YaspGrid for a given dimension. More...

Typedefs
template<class HostGrid >
using	AdaptiveGrid_t = typename Impl::AdaptiveGridImpl< HostGrid >::type
using	BoundaryType = int
using	Parameters = Initfile
template<class Event , std::size_t N>
using	ObserverSequence = Impl::ObserverSequenceImpl< Event, std::make_index_sequence< N > >
template<class RowBasis , class ColBasis , class ElementMatrix >
using	MatrixOperators = TypeTree::TreeMatrix< OperatorLists< typename RowBasis::GridView, ElementMatrix >::template MatData, typename RowBasis::LocalView::TreeCache, typename ColBasis::LocalView::TreeCache >
template<class Basis , class ElementVector >
using	VectorOperators = TypeTree::TreeContainer< OperatorLists< typename Basis::GridView, ElementVector >::template VecData, typename Basis::LocalView::TreeCache >
template<class T , class GV >
using	HasCreate = decltype(T::create(std::declval< GV >()))
template<class G >
using	HasGlobalRefineADHI = decltype(std::declval< G >().globalRefine(1, std::declval< typename G::ADHI & >()))
template<int I>
using	int_t = std::integral_constant< int, I >
	A wrapper for int type.
template<int... I>
using	Ints = std::integer_sequence< int, I... >
	class that represents a sequence of integers
template<std::size_t I>
using	index_t = std::integral_constant< std::size_t, I >
	A wrapper for std::size_t type.
template<std::size_t... I>
using	Indices = std::index_sequence< I... >
	class that represents a sequence of indices
template<bool B>
using	bool_t = std::integral_constant< bool, B >
	A wrapper for bool types.
template<bool... Bs>
using	all_of_t = bool_t< all_of_v< Bs... > >
template<bool... Bs>
using	and_t = all_of_t< Bs... >
template<bool... Bs>
using	any_of_t = bool_t< any_of_v< Bs... > >
template<bool... Bs>
using	or_t = any_of_t< Bs... >
template<bool... Bs>
using	none_of_t = bool_t< none_of_v< Bs... > >
template<bool B>
using	not_t = bool_t<!B >
template<class T , T... values>
using	IsEqual = Impl::IsEqualImpl< T, values... >
template<class T , class... Ts>
using	is_one_of = or_t< std::is_same_v< T, Ts >... >
template<std::size_t I, std::size_t J>
using	range_t = Impl::range_impl< std::size_t, I, J >
template<class Tuple , template< class > class Map>
using	MapTuple_t = typename MapTuple< Tuple, Map >::type
template<class Indices , template< std::size_t > class Map>
using	IndexMapTuple_t = typename IndexMapTuple< Indices, Map >::type
template<class T >
using	remove_cvref_t = typename remove_cvref< T >::type
	Helper alias template for remove_cvref.
template<class T >
using	Underlying_t = typename Impl::UnderlyingType< T >::type
template<class... Ts>
using	Types_t = Types< remove_cvref_t< Ts >... >
template<class T >
using	owner = T
	Alias that indicates ownership of resources.
template<bool... b>
using	enable_if_all_t = std::enable_if_t<(b &&...)>
template<class T >
using	ValueCategory_t = typename ValueCategory< remove_cvref_t< T > >::type
template<class PreBasis , class MultiIndex = Dune::Functions::FlatMultiIndex<std::size_t>>
using	FlatPreBasis_t = typename FlatPreBasis< PreBasis, MultiIndex >::type
template<class PreBasisFactory , class PBF = remove_cvref_t<PreBasisFactory>>
using	MultiIndex_t = std::conditional_t<(PBF::requiredMultiIndexSize==1), Dune::Functions::FlatMultiIndex< std::size_t >, Dune::ReservedVector< std::size_t, PBF::requiredMultiIndexSize > >
template<class Basis >
using	GlobalIdType_t = GlobalIdType< typename Basis::GridView::Grid::GlobalIdSet::IdType >
template<class Node >
using	NodeCache_t = typename Impl::NodeCacheFactory< Node >::type
	Defines the type of a node cache associated to a given Node.
template<class PB , class TP >
using	Node_t = typename PB::Node
template<class PB , class TP >
using	NodeIndexSet_t = typename PB::IndexSet
template<class IS , class GI >
using	DofMapping = SequentialDofMapping< IS, GI >
template<class T , class Facade >
using	VectorType_t = typename Impl::VectorTypeImpl< T, Facade >::type
	Type transformation changing the value type of the vector.
template<class >
using	BackendTraits = EigenTraits
template<class Smoother >
using	SmootherArgs = typename Dune::Amg::SmootherTraits< Smoother >::Arguments
template<class G , class L >
using	ISTLCommunication = SequentialISTLCommunication< G, L >
template<class B >
using	ISTLCommunication_t = ISTLCommunication< GlobalIdType_t< B >, typename B::size_type >
template<class Matrix >
using	DiagonalPreconditioner = itl::pc::diagonal< Matrix >
template<class Matrix >
using	MassLumpingPreconditioner = itl::pc::masslumping< Matrix >
template<class Matrix >
using	IdentityPreconditioner = itl::pc::identity< Matrix >
template<class Matrix >
using	ILUPreconditioner = itl::pc::ilu_0< Matrix >
template<class Matrix >
using	ICPreconditioner = itl::pc::ic_0< Matrix >
template<class B >
using	DistributedCommunication_t = DistributedCommunication< GlobalIdType_t< B >, typename B::size_type >
template<class Node >
using	FiniteElementType = Impl::FiniteElementTypeImpl< Node, typename Node::NodeTag >
template<class Node >
using	FiniteElementType_t = typename FiniteElementType< Node >::type
template<class Node , class R = double>
using	RangeType_t = typename Impl::RangeTypeImpl< Node, R, typename Node::NodeTag >::type
	Range type of a node in the basis tree, composed of the leaf basis range types. More...
using	RootTreePath = Dune::TypeTree::HybridTreePath<>

Enumerations
enum	DataTransferOperation { NO_OPERATION = 0, INTERPOLATE = 1 }
enum	SymmetryStructure {   unknown, spd, symmetric, hermitian,   structurally_symmetric }

Functions
template<class HostGrid >
	AdaptiveGrid (HostGrid const &) -> AdaptiveGrid< HostGrid >
template<class HostGrid >
unsigned long	changeIndex (HostGrid const &)
	Return a change index of a grid that is not an AdaptiveGrid.
template<class HostGrid >
unsigned long	changeIndex (AdaptiveGrid< HostGrid > const &grid)
	Return a change index of an AdaptiveGrid.
void	init (int &argc, char **&argv, std::string const &initFileName="")
	Initialized the Environment for MPI. More...
void	finalize ()
	Closes the MPI environment. More...
template<class Traits , class Operator , class... Nodes>
auto	makeAssembler (Operator &&op, Nodes const &...)
	Generate a Assembler on a given LocalContext LC (element or intersection)
template<class RB , class CB >
	BiLinearForm (RB &&, CB &&) -> BiLinearForm< Underlying_t< RB >, Underlying_t< CB >>
template<class RB >
	BiLinearForm (RB &&) -> BiLinearForm< Underlying_t< RB >, Underlying_t< RB >>
template<class T = double, class RB , class CB >
auto	makeBiLinearForm (RB &&rowBasis, CB &&colBasis)
template<class T = double, class RB >
auto	makeBiLinearForm (RB &&rowBasis)
template<class BaseClass >
CreatorInterfaceName< BaseClass > *	named (CreatorInterface< BaseClass > *ptr)
	cast a ptr of CreatorInterface to CreatorInterfaceName
template<class B , class TP , class Values >
	DirichletBC (Dune::Functions::SubspaceBasis< B, TP >, BoundarySubset< typename B::GridView::Intersection >, Values const &) -> DirichletBC< Dune::Functions::SubspaceBasis< B, TP >, Underlying_t< Values >>
template<class B , class TP , class Values , REQUIRES(Concepts::GlobalBasis< B >) >
	DirichletBC (B const &, TP const &, BoundarySubset< typename B::GridView::Intersection >, Values const &) -> DirichletBC< Dune::Functions::SubspaceBasis< B, TP >, Underlying_t< Values >>
template<class B , class Values , REQUIRES(Concepts::GlobalBasis< B >) >
	DirichletBC (B const &, BoundarySubset< typename B::GridView::Intersection >, Values const &) -> DirichletBC< Dune::Functions::SubspaceBasis< B, TYPEOF(makeTreePath())>, Underlying_t< Values >>
template<class GB >
	DOFVector (GB &&basis, DataTransferOperation op=DataTransferOperation::INTERPOLATE) -> DOFVector< Underlying_t< GB >>
template<class GV , class PBF >
	DOFVector (GV const &gridView, PBF const &pbf, DataTransferOperation op=DataTransferOperation::INTERPOLATE) -> DOFVector< decltype(GlobalBasis
template<class ValueType = double, class GB >
DOFVector< Underlying_t< GB >, ValueType >	makeDOFVector (GB &&basis, DataTransferOperation op=DataTransferOperation::INTERPOLATE)
	Create a DOFVector from a basis. More...
template<class Tag , class Expr , class... QuadratureArgs>
auto	makeOperator (Tag tag, Expr &&expr, QuadratureArgs &&... args)
	Store tag and expression into a PreGridFunctionOperator to create a GridFunctionOperator.
template<class Context , class Tag , class GF , class QF >
auto	makeGridFunctionOperator (Tag tag, GF &&gf, QF &&qf)
template<class Expr , class GridView >
auto	integrate (Expr &&expr, GridView const &gridView)
	Integrate expression with quadrature rule determined by polynomial order of expression. More...
template<class Expr , class GridView , class QuadratureRule = Dune::QuadratureRule<typename GridView::ctype, GridView::dimension>>
auto	integrate (Expr &&expr, GridView const &gridView, QuadratureRule const &quad)
	Integrate expression with quadrature rule provided. More...
template<class Expr , class GridView >
auto	integrate (Expr &&expr, GridView const &gridView, int degree, Dune::QuadratureType::Enum qt=Dune::QuadratureType::GaussLegendre)
	Integrate expression with quadrature rule determined by provided polynomial degree More...
template<class GB >
	LinearForm (GB &&basis) -> LinearForm< Underlying_t< GB >>
template<class T = double, class GB >
auto	makeLinearForm (GB &&basis)
template<class Derived , class LC , class GV >
auto	makeLocalOperator (LocalOperator< Derived, LC > const &localOp, GV const &)
	Generate a LocalOperator from a PreOperator. More...
template<class Grid , class GF >
	GridFunctionMarker (std::string const &name, std::shared_ptr< Grid > const &grid, GF &&gf) -> GridFunctionMarker< Grid, TYPEOF(makeGridFunction(FWD(gf), grid->leafGridView()))>
template<class... Args>
void	msg (std::string const &str, Args &&... args)
	print a message More...
template<class... Args>
void	info (int noInfoLevel, std::string const &str, Args &&... args)
	prints a message, if Environment::infoLevel() >= noInfoLevel
template<class... Args>
void	msg_ (std::string const &str, Args &&... args)
	print a message (without appended newline) More...
template<class... Args>
void	info_ (int noInfoLevel, std::string const &str, Args &&... args)
	prints a message, if Environment::infoLevel() >= noInfoLevel
template<class... Args>
void	error_exit (std::string const &str, Args &&... args)
	print a message and exit More...
template<class... Args>
void	test_exit (bool condition, std::string const &str, Args &&... args)
	test for condition and in case of failure print message and exit More...
template<class... Args>
void	warning (std::string const &str, Args &&... args)
template<class... Args>
void	test_warning (bool condition, std::string const &str, Args &&... args)
	test for condition and in case of failure print message More...
template<class... Args>
void	msg_dbg (Args &&... args)
	print message, in debug mode only More...
template<class... Args>
void	test_exit_dbg (bool condition, Args &&... args)
	call assert_msg, in debug mode only More...
template<class B , class TP >
auto	makePeriodicBC (Dune::Functions::SubspaceBasis< B, TP > basis, BoundarySubset< typename B::GridView::Intersection > boundarySubset, Impl::FaceTrafo< B > trafo)
	Make a PeriodicBC from a subspacebasis.
template<class B , class TP , REQUIRES(Concepts::GlobalBasis< B >) >
auto	makePeriodicBC (B const &basis, TP const &tp, BoundarySubset< typename B::GridView::Intersection > boundarySubset, Impl::FaceTrafo< B > trafo)
	Make a PeriodicBC from a global basis and treepath.
template<class B , REQUIRES(Concepts::GlobalBasis< B >) >
auto	makePeriodicBC (B const &basis, BoundarySubset< typename B::GridView::Intersection > boundarySubset, Impl::FaceTrafo< B > trafo)
	Make a PeriodicBC from a global basis.
template<class Traits >
	ProblemInstat (std::string const &name, ProblemStat< Traits > &prob) -> ProblemInstat< Traits >
template<class Traits >
	ProblemInstat (std::string const &name, ProblemStat< Traits > &prob, ProblemStatBase &initialProb) -> ProblemInstat< Traits >
template<class Grid , class Basis >
	ProblemStat (std::string name, Grid &&grid, Basis &&globalBasis) -> ProblemStat< Impl::DeducedProblemTraits_t< Underlying_t< Grid >, Underlying_t< Basis >>>
template<class InputIter , class Tp , class BinaryFunc >
void	split (InputIter first, InputIter last, Tp sep, BinaryFunc f)
	Split a sequence [first,last) by the separators sep and pass the tokens as begin-end iterator pair to the provided functor f = void(InputIterator, InputIterator)
template<class InputIter , class SeparaterIter , class BinaryFunc >
void	split (InputIter first, InputIter last, SeparaterIter s_first, SeparaterIter s_last, BinaryFunc f)
	Split a sequence [first,last) by any of the separators [s_first, s_last) and pass the tokens as begin-end iterator pair to the provided functor f = void(InputIterator, InputIterator)
template<class Range , class Iter = decltype(std::begin(std::declval<Range>())), class = decltype(std::end(std::declval<Range>()))>
constexpr auto	enumerate (Range &&range)
	Provide python-like indexing iterator that returns a pair of [i,element].
template<std::size_t I, int... J>
auto	get (Ints< J... >)
template<std::size_t I, std::size_t... J>
auto	get (Indices< J... >)
template<char... digits>
constexpr auto	operator"" _c ()
	Literal to create integer compile-time constant, e.g. 0_c -> index_<0>
template<bool B0, bool B1>
constexpr bool_t< B0 &&B1 >	operator && (bool_t< B0 >, bool_t< B1 >)
template<bool B0, bool B1>
constexpr bool_t< B0||B1 >	operator|| (bool_t< B0 >, bool_t< B1 >)
template<bool B>
constexpr bool_t<!B >	operator! (bool_t< B >)
template<class F >
auto	order (F const &f) -> decltype(&F::operator(), f.order())
	polynomial order of functions
template<class T >
std::shared_ptr< T >	wrap_or_share (T &t)
template<class T >
std::shared_ptr< T >	wrap_or_share (T &&t)
template<class T >
std::shared_ptr< T >	wrap_or_share (T *t)
template<class T >
std::shared_ptr< T >	wrap_or_share (std::shared_ptr< T > t)
template<class T >
std::shared_ptr< T >	wrap_or_share (std::unique_ptr< T > t)
template<class Container >
constexpr auto	static_size (Container const &container)
	Return a static constant size of the container. More...
template<class Matrix >
constexpr auto	static_num_rows (Matrix const &matrix)
	Return a static constant rows of the matrix. More...
template<class Matrix >
constexpr auto	static_num_cols (Matrix const &matrix)
	Return a static constant columns of the matrix. More...
std::string	to_upper (std::string input)
	convert all characters in a string to upper case
std::string	to_lower (std::string input)
	convert all characters in a string to upper case
std::string &	ltrim (std::string &str)
	trim a string from the left
std::string &	rtrim (std::string &str)
	trim a string from the right
std::string &	trim (std::string &str)
	trim a string from both sides
std::string	trim_copy (std::string const &str)
	trim a (copy of the) string from both sides
void	replaceAll (std::string &str, std::string const &from, std::string const &to)
	Replace all occurences of substring from with to in source str.
template<class T , T to, T from, class Value , class Then , class Else >
decltype(auto) constexpr	switchCases (const Dune::StaticIntegralRange< T, to, from > &cases, const Value &value, Then &&thenBranch, Else &&elseBranch)
template<class T , class Value , class Then , class Else >
decltype(auto) constexpr	switchCases (const Dune::IntegralRange< T > &cases, const Value &value, Then &&thenBranch, Else &&elseBranch)
template<class T , T to, T from, class Value , class Then >
constexpr void	switchCases (const Dune::StaticIntegralRange< T, to, from > &cases, const Value &value, Then &&thenBranch)
template<class T , class Value , class Then >
constexpr void	switchCases (const Dune::IntegralRange< T > &cases, const Value &value, Then &&thenBranch)
template<class Matrix >
auto	transposed (Matrix &&matrix)
template<class Obj >
auto	makeUniquePtr (Obj &&obj)
	Create a unique_ptr by copy/move construction.
template<class Obj >
auto	makeSharedPtr (Obj &&obj)
template<class V >
constexpr bool	isVector (V const &)
template<class V >
constexpr bool	isNotVector (V const &)
template<class PreBasis >
auto	flatPreBasis (PreBasis const &preBasis)
template<class SigTraits , class F >
F	functionFromCallable (F const &f)
template<class GV , class PBF >
	GlobalBasis (std::string const &name, GV const &gridView, PBF const &preBasisFactory) -> GlobalBasis< decltype(flatPreBasis(preBasisFactory.template makePreBasis< MultiIndex_t< PBF >>(gridView)))>
template<class GV , class PBF >
	GlobalBasis (GV const &gridView, PBF const &preBasisFactory) -> GlobalBasis< decltype(flatPreBasis(preBasisFactory.template makePreBasis< MultiIndex_t< PBF >>(gridView)))>
template<class T , class Default >
decltype(auto)	value_or (T &&value, Default &&)
template<class Default >
decltype(auto)	value_or (tag::defaulted, Default &&def)
template<class Basis , class Vec , class GF , class TP , class C , class BV , class Assign >
void	interpolate (Basis const &basis, Vec &vec, GF const &gf, TP const &tp_, C &&c_, BV &&bv_, Assign &&a_)
	Interpolate given function in discrete function space. More...
template<class B , class Vec , class GF , class TP , class C , class BV >
void	interpolate (B const &basis, Vec &vec, GF const &gf, TP &&tp, C &&c, BV const &bitVec)
template<class B , class Vec , class GF , class TP , class C >
void	interpolate (B const &basis, Vec &vec, GF const &gf, TP &&tp, C &counter)
template<class B , class Vec , class GF , class TreePath >
void	interpolate (B const &basis, Vec &vec, GF const &gf, TreePath const &treePath)
template<class B , class Vec , class GF >
void	interpolate (B const &basis, Vec &vec, GF const &gf)
template<class Node >
auto	makeNodeCache (Node const &node)
	Construct a new local-basis cache from a basis-node.
template<class LocalView , class Node >
auto	nodeIndices (LocalView const &localView, Node const &node)
	Returns a range over (flat) DOF indices on a node, given by the localView.
template<class LocalView >
auto	nodeIndices (LocalView const &localView)
	Returns a range over (flat) DOF indices on the basis tree, given by the localView.
template<class LocalView , class Node >
std::size_t	nodeIndexCount (LocalView const &, Node const &node)
	Returns the number of DOF indices on a node, given by the localView.
template<class LocalView >
std::size_t	nodeIndexCount (LocalView const &localView)
	Returns the number of DOF indices on the basis tree, given by the localView.
template<class PB , class TP >
auto	makeNode (PB const &preBasis, [[maybe_unused]] TP const &treePath)
template<class PB , class TP >
auto	makeNodeIndexSet (PB const &preBasis, [[maybe_unused]] TP const &treePath)
template<class N , class = typename N::NodeTag>
int	order (N const &node)
	Polynomial order of local basis-node.
template<class R , class D , class LC , class F , class Type >
auto	derivativeOf (AnalyticLocalFunction< R(D), LC, F > const &lf, Type const &type)
auto	X ()
	Generator for CoordsFunction.
auto	X (int comp)
	Generator for CoordsCompFunction.
template<class LocalFunction , class Type , REQUIRES(std::is_convertible_v< tag::derivative_type, Type >) >
auto	derivativeOf (LocalFunction const &lf, Type const &type) -> decltype(lf.makeDerivative(type))
	The derivative of a localfunction as localfunction itself.
template<class LocalFunction >
auto	derivative (LocalFunction const &lf) -> decltype(lf.makeDerivative(tag::gradient
template<class GridFct , class Type , class LocalFct = decltype( localFunction(std::declval<GridFct>()) ), REQUIRES(not GridFct::hasDerivative) >
auto	derivativeOf (GridFct const &gridFct, Type const &type)
template<class Expr >
auto	gradientOf (Expr const &expr)
template<class Expr >
auto	divergenceOf (Expr const &expr)
	Generates a Gridfunction representing the divergence of a vector-valued GridFunction.
template<class Expr >
auto	partialDerivativeOf (Expr const &expr, std::size_t i)
	Generates a Gridfunction representing the partial derivative of a GridFunction.
template<class C , class Basis , class... Indices, class GB = Underlying_t<Basis>, class TP = TYPEOF(makeTreePath(std::declval<Indices>()...)), REQUIRES(Concepts::GlobalBasis< GB >) >
	DiscreteFunction (C &, Basis const &, Indices...) -> DiscreteFunction< C, GB, TP >
template<class DV , class... Indices, class C = decltype(std::declval<DV>().coefficients()), class GB = decltype(std::declval<DV>().basis()), class TP = TYPEOF(makeTreePath(std::declval<Indices>()...))>
	DiscreteFunction (DV &, Indices...) -> DiscreteFunction< std::remove_reference_t< C >, Underlying_t< GB >, TP >
template<class Range = void, class C , class GB , class TP , class R , class... Indices>
auto	valueOf (DiscreteFunction< C, GB, TP, R > &df, Indices... ii)
	A Generator for the childs of a mutable DiscreteFunction.
template<class Range = void, class C , class GB , class TP , class R , class... Indices>
auto	valueOf (DiscreteFunction< C, GB, TP, R > const &df, Indices... ii)
	A Generator for the childs of a const DiscreteFunction.
template<class Range = void, class DV , class... Indices, class C = decltype(std::declval<DV>().coefficients()), class GB = decltype(std::declval<DV>().basis()), class TP = TYPEOF(makeTreePath(std::declval<Indices>()...))>
auto	valueOf (DV &dofVec, Indices... ii)
	A Generator to transform a DOFVector into a DiscreteFunction.
template<class Sig , class F , class... LFs, class Type , REQUIRES(Concepts::HasPartial< F >) >
auto	derivativeOf (FunctorLocalFunction< Sig, F, LFs... > const &lf, Type const &type)
template<class Sig , class F , class... LFs, REQUIRES(Concepts::HasFunctorOrder< F, sizeof...(LFs)> &&(Concepts::Polynomial< LFs > &&...)) >
int	order (FunctorLocalFunction< Sig, F, LFs... > const &lf)
template<class Functor , class... GridFcts>
auto	makeFunctorGridFunction (Functor const &f, GridFcts const &... gridFcts)
template<class GridFunction >
auto	localFunction (GridFunction const &gf) -> decltype(gf.makeLocalFunction())
template<class PreGridFct , class GridView >
decltype(auto)	makeGridFunction (PreGridFct const &preGridFct, GridView const &gridView)
	Generator for Gridfunctions from Expressions (PreGridfunctions) More...
template<class T , REQUIRES(Concepts::AnyGridFunction< T >) >
auto	abs (T &&value)
template<class Mat , class Sol , class Rhs , class BitVec >
void	dirichletBC (Mat &matrix, Sol &solution, Rhs &rhs, BitVec const &nodes, bool setDiagonal=true)
template<class Mat , class Sol , class Rhs , class BitVec , class Assoc >
void	periodicBC (Mat &matrix, Sol &solution, Rhs &rhs, BitVec const &left, Assoc const &association, bool setDiagonal=true)
template<class Basis , class PIS >
void	buildParallelIndexSet (Basis const &basis, PIS &parallelIndexSet)
	Fills a parallelIndexSet with indices from a basis.
SymmetryStructure	symmetryStructure (std::string str)
std::string	to_string (SymmetryStructure symmetry)
template<class Mat , class Vec , class X >
itl::pc::solver< PreconditionerInterface< Mat, Vec >, X, false >	solve (PreconditionerInterface< Mat, Vec > const &P, X const &vin)
template<class Mat , class Vec , class X >
itl::pc::solver< PreconditionerInterface< Mat, Vec >, X, true >	adjoint_solve (PreconditionerInterface< Mat, Vec > const &P, X const &vin)
template<class PreGridFctA , class PreGridFctB , class PreGridFctC , class PreGridFctF , bool conserving = true>
auto	convectionDiffusion (PreGridFctA const &gridFctA, PreGridFctB const &gridFctB, PreGridFctC const &gridFctC, PreGridFctF const &gridFctF, bool_t< conserving >={})
template<class Context , class... T, class GridView >
auto	makeLocalOperator (PreConvectionDiffusionOperator< T... > pre, GridView const &gridView)
template<class Expr , class... QuadratureArgs>
auto	fot (Expr &&expr, tag::grad_test, QuadratureArgs &&... args)
	Create a first-order term with derivative on trial-function.
template<class Expr , class... QuadratureArgs>
auto	fot (Expr &&expr, tag::partial_test t, QuadratureArgs &&... args)
	Create a first-order term with derivative on trial-function.
template<class Expr , class... QuadratureArgs>
auto	fot (Expr &&expr, tag::grad_trial, QuadratureArgs &&... args)
	Create a first-order term with derivative on test-function.
template<class Expr , class... QuadratureArgs>
auto	fot (Expr &&expr, tag::partial_trial t, QuadratureArgs &&... args)
	Create a first-order term with derivative on trial-function.
template<class Expr , class... QuadratureArgs>
auto	sot (Expr &&expr, QuadratureArgs &&... args)
	Create a second-order term.
template<class Expr , class... QuadratureArgs>
auto	sot_ij (Expr &&expr, std::size_t comp_test, std::size_t comp_trial, QuadratureArgs &&... args)
	Create a second-order term of partial derivatives.
template<class Expr , class... QuadratureArgs>
auto	zot (Expr &&expr, QuadratureArgs &&... args)
	Create a zero-order term.
std::size_t	flatMultiIndex (std::size_t idx)
std::size_t	flatMultiIndex (Dune::Functions::FlatMultiIndex< std::size_t > const &idx)
std::size_t	flatMultiIndex (Dune::ReservedVector< std::size_t, 1 > const &idx)
template<class... Indices>
auto	makeTreePath (Indices... ii) -> decltype(Dune::TypeTree::hybridTreePath(Impl::treePathIndex(ii)...))
auto	makeTreePath ()
template<class Index , Index... I>
auto	makeTreePath (std::integer_sequence< Index, I... >)
template<class... T>
auto	makeTreePath (std::tuple< T... > const &tp)
template<class... T>
auto const &	makeTreePath (Dune::TypeTree::HybridTreePath< T... > const &tp)
template<std::size_t... I>
auto	makeTreePath (Dune::TypeTree::StaticTreePath< I... >)
template<char... digits>
constexpr auto	operator"" _tp ()
	Literal to create treepath, e.g. 021_tp -> HybridTreePath<index_t<0>,index_t<2>,index_t<1>>
template<class... T>
std::string	to_string (Dune::TypeTree::HybridTreePath< T... > const &tp)
std::string	to_string (Dune::TypeTree::HybridTreePath<> const &)
template<class... T>
auto	to_array (Dune::TypeTree::HybridTreePath< T... > const &tp)
template<class T0 , class... T>
auto	pop_front (Dune::TypeTree::HybridTreePath< T0, T... > const &tp)
	Extract the first entry in the treepath.
template<class... T, class TN >
auto	pop_back (Dune::TypeTree::HybridTreePath< T..., TN > const &tp)
	Extract the last entry in the treepath.
template<class... S, class... T>
auto	cat (Dune::TypeTree::HybridTreePath< S... > const &tp0, Dune::TypeTree::HybridTreePath< T... > const &tp1)
	Concatenate two treepaths.
template<class EA , class IA , class BA >
AssemblerTriple< EA, IA, BA >	makeAssemblerTriple (EA const &ea, IA const &ia, BA const &ba)
template<class GV , class Element , class Operators , class EA , class IA , class BA >
void	assembleOperators (GV const &gridView, Element const &element, Operators &operators, AssemblerTriple< EA, IA, BA > const &assemblerTriple)
template<class Node , class Vec >
auto	makeVectorAssembler (Node const &node, Vec &elementVector)
template<class RN , class CN , class Mat >
auto	makeMatrixAssembler (RN const &rowNode, CN const &colNode, Mat &elementMatrix)
template<class R , class F >
auto	mappedRangeView (R &&range, F const &f)
	Create a MappedRangeView. More...
template<class Iter , class F >
auto	mappedIterator (Iter it, F const *f)
template<class ConstIter , class F >
auto	mappedConstIterator (ConstIter it, F const *f)
auto	makePreQuadratureFactory ()
auto	makePreQuadratureFactory (int order, Dune::QuadratureType::Enum qt=Dune::QuadratureType::GaussLegendre)
template<class ctype , int dim>
auto	makePreQuadratureFactory (Dune::QuadratureRule< ctype, dim > const &rule)
template<class Context , class... Args, class GridView >
auto	makeLocalOperator (PreGridFunctionOperator< Args... > op, GridView const &gridView)
template<class Context , class... Args, class GridView >
auto	makeLocalOperator (std::reference_wrapper< PreGridFunctionOperator< Args... >> op_ref, GridView const &gridView)

Variables
const Flag	BUILD = 1
const Flag	BUILD_RHS = 2
const Flag	ADAPT = 4
const Flag	SOLVE = 8
const Flag	SOLVE_RHS = 16
const Flag	ESTIMATE = 32
const Flag	MARK = 64
const Flag	FULL_ITERATION = BUILD | ADAPT | SOLVE | ESTIMATE | MARK
const Flag	NO_ADAPTION = BUILD | SOLVE | ESTIMATE
const Flag	INIT_FE_SPACE = 0x01L
const Flag	INIT_MESH = 0x02L
const Flag	CREATE_MESH = 0x04L
const Flag	INIT_SYSTEM = 0x08L
const Flag	INIT_SOLVER = 0x10L
const Flag	INIT_ESTIMATOR = 0x20L
const Flag	INIT_MARKER = 0x40L
const Flag	INIT_ADAPT = 0x80L
const Flag	INIT_FILEWRITER = 0x100L
const Flag	INIT_GLOBAL_REFINES = 0x1000L
const Flag	INIT_INITIAL_PROBLEM = 0x200L
const Flag	INIT_UH_OLD = 0x400L
const Flag	INIT_UPDATER = 0x800L
const Flag	INIT_NONLIN_SOLVER = 0x1000L
const Flag	INIT_NOTHING = 0x00L
const Flag	INIT_ALL
const Flag	MESH_ADAPTED = 1
template<int I>
constexpr int_t< I >	int_ = {}
	Variable template to generate int-type.
template<std::size_t I>
constexpr index_t< I >	index_ = {}
	Variable template to generate std::size_t-type.
template<bool B>
constexpr bool_t< B >	bool_ = {}
	Variable template to generate bool type.
template<bool... Bs>
constexpr bool	all_of_v = (Bs && ...)
template<bool... Bs>
constexpr bool	any_of_v = (Bs || ...)
template<bool... Bs>
constexpr bool	none_of_v = !(Bs || ...)
template<bool... Bs>
constexpr all_of_t< Bs... >	and_ = {}
template<bool... Bs>
constexpr any_of_t< Bs... >	or_ = {}
template<bool B>
constexpr bool_t<!B >	not_ = {}
template<class T >
constexpr T	threshold = std::numeric_limits<T>::epsilon()
template<std::size_t I, std::size_t J>
constexpr range_t< I, J >	range_ = {}
template<class Container >
constexpr std::size_t	static_size_v = decltype(static_size(std::declval<remove_cvref_t<Container>>()))::value
template<class Matrix >
constexpr std::size_t	static_num_rows_v = decltype(static_num_rows(std::declval<remove_cvref_t<Matrix>>()))::value
template<class Matrix >
constexpr std::size_t	static_num_cols_v = decltype(static_num_cols(std::declval<remove_cvref_t<Matrix>>()))::value

Detailed Description

Contains all classes needed for solving linear and non linear equation systems.

Typedef Documentation

AdaptiveGrid_t

using AdaptiveGrid_t = typename Impl::AdaptiveGridImpl<HostGrid>::type

Always returning an AdaptiveGrid. Returns the grid itself if it is already an AdaptiveGrid.

RangeType_t

using RangeType_t = typename Impl::RangeTypeImpl<Node, R, typename Node::NodeTag>::type

Range type of a node in the basis tree, composed of the leaf basis range types.

Generate the range type by recursively combining leaf range types to a hybrid node range type. Range types for PowerNodes are thereby constructed as Dune::FieldVector of child range types. CompositeNodes produce a TupleVector of the difference child range types.

Template Parameters

Node	Type of a basis-tree node
R	Coefficient type [double]

Function Documentation

derivative()

auto AMDiS::derivative

(

LocalFunction const &

lf

)

-> decltype(lf.makeDerivative(tag::gradient

Implementation of local-function derivative interface of dune-functions. Implements the jacobian derivative type.

derivativeOf() [1/3]

auto AMDiS::derivativeOf	(	AnalyticLocalFunction< R(D), LC, F > const &	lf,
		Type const &	type
	)

In order to differentiate the local function, the functor must be differentiable, i.e. a free function partial(fct,_0) must exist.

Requirements:

• The functor F must fulfill the concept Concepts::HasDerivative

Referenced by DerivativeGridFunction< GridFunction, Type >::makeLocalFunction().

derivativeOf() [2/3]

auto AMDiS::derivativeOf	(	FunctorLocalFunction< Sig, F, LFs... > const &	lf,
		Type const &	type
	)

\( d_x(f(lf(x)...)) = \sum_i d_i(f)[lf(x)...] * derivativeOf(lf[i]) \)

Requirements:

• The Functor F must model Concepts::HasPartial

derivativeOf() [3/3]

auto AMDiS::derivativeOf	(	GridFct const &	gridFct,
		Type const &	type
	)

A GridFunction can be differentiated if the corresponding LocalFunction provides a free function derivativeOf()

Requirements:

• The type GridFct models the concept of a GridFunction
• The GridFct has no own derivativeOf() function, i.e. it holds GridFct::hasDerivative == false.
• The localFunction of the GridFct models Concepts::HasDerivative.

error_exit()

void AMDiS::error_exit	(	std::string const &	str,
		Args &&...	args
	)

print a message and exit

If the preprocessor constant AMDIS_NO_THROW is defined, the c-assert macro is called, otherwise an exception of type std::runtime_Error is thrown.

Referenced by PreconditionerInterface< Mat, Vec >::adjoint_solve(), SolverPrecon< Mat, Vec >::adjoint_solve(), RunnerInterface< Matrix, Vector >::adjointSolve(), buildParallelIndexSet(), GlobalBasis< PB >::communicator(), CreatorInterfaceName< ISTLPreconCreatorInterface< Traits > >::create(), FileWriterCreator< SystemVector >::create(), MeshCreator< G >::create(), AMGPrecon< AMGCreator, Smoother, Traits >::create(), EstimatorMarker< Grid >::createMarker(), AMGPreconCreator< AMGSolver, Traits >::createWithString(), MeshCreator< G >::elementIds(), NodeIdSet< PreBasis, TreePath >::fillIn(), AdaptInstationary::oneTimestep(), InitfileParser::readInitfile(), ProblemStat< Traits >::restore(), LinearSolverInterface< Mat, Vec >::solve(), UmfpackRunner< Mat, Vec >::solve(), and test_exit().

finalize()

void AMDiS::finalize ( )

inline

Closes the MPI environment.

Deprecated:

The Environment is closed automatically on destruction.

init()

void AMDiS::init ( int &  argc, char **&  argv, std::string const &  initFileName = ""  )

inline

Initialized the Environment for MPI.

Deprecated:

Use Environment at the beginning of the main() instead:

int main(int argc, char** argv) { Environment env(argc, argv); // do somthing. }

Referenced by DataTransfer< Container, Basis >::adapt(), LinearForm< GB, T, Traits >::assemble(), BiLinearForm< RB, CB, T, Traits >::assemble(), NodeDataTransfer< Node, Container, Basis >::cacheLocal(), FakeContainer< T, value >::const_iterator::operator==(), PeriodicBC< Basis, TP >::PeriodicBC(), DataTransfer< Container, Basis >::preAdapt(), and DOFVector< GB, T, TraitsType >::restore().

integrate() [1/3]

auto AMDiS::integrate	(	Expr &&	expr,
		GridView const &	gridView
	)

Integrate expression with quadrature rule determined by polynomial order of expression.

Example:

double i1 = integrate(prob.solution(0), prob.gridView());
double i2 = integrate(X(0) + X(1), prob.gridView());
double i3 = integrate([](auto const& x) { return x[0] + x[1]; }, prob.gridView()); // ERROR

References makeGridFunction(), and order().

integrate() [2/3]

auto AMDiS::integrate	(	Expr &&	expr,
		GridView const &	gridView,
		QuadratureRule const &	quad
	)

Integrate expression with quadrature rule provided.

Example:

auto quad = Dune::QuadratureRules<double,DIM>::rule(Dune::GeometryTypes::triangle, 1);
double i4 = integrate([](auto const& x) { return x[0]; }, prob.gridView(), quad); // OK

References makeGridFunction().

integrate() [3/3]

auto AMDiS::integrate	(	Expr &&	expr,
		GridView const &	gridView,
		int	degree,
		Dune::QuadratureType::Enum	qt = Dune::QuadratureType::GaussLegendre
	)

Integrate expression with quadrature rule determined by provided polynomial degree

Example:

double i5 = integrate([](auto const& x) { return x[0]; }, prob.gridView(), 1); // OK

References makeGridFunction().

interpolate()

void AMDiS::interpolate	(	Basis const &	basis,
		Vec &	vec,
		GF const &	gf,
		TP const &	tp_,
		C &&	c_,
		BV &&	bv_,
		Assign &&	a_
	)

Interpolate given function in discrete function space.

Interpolation is done wrt the leaf node of the ansatz tree corresponding to the given tree path.

Notice that this will only work if the range type of f and the block type of coeff are compatible and supported by flatVectorView.

Parameters

basis	Global function space basis of discrete function space
vec	Coefficient vector to represent the interpolation
gf	GridFunction to interpolate
tp_	Tree path specifying the part of the ansatz tree to use [RootTreePath]
c_	Vector that counts for the number of value assignments [FakeContainer]
bv_	A vector with flags marking all DOFs that should be interpolated [FakeContainer]
a_	Assignment mode [Assigner::assign]

Referenced by DirichletBC< SubBasis, ValueGridFct >::apply(), and DiscreteFunction< Coeff, GB, TreePath, R >::interpolate_noalias().

makeDOFVector()

DOFVector<Underlying_t<GB>, ValueType> AMDiS::makeDOFVector	(	GB &&	basis,
		DataTransferOperation	op = DataTransferOperation::INTERPOLATE
	)

Create a DOFVector from a basis.

This generator function accepts the basis as reference, temporary, or shared_ptr. Internally the reference is wrapped into a non-destroying shared_ptr and the temporary is moved into a new shared_ptr.

The DataTransferOperation controls what is done during grid changes with the DOFVector. The default is interpolation of the data to the new grid. See DataTransferOperation for more options.

makeLocalOperator()

auto AMDiS::makeLocalOperator	(	PreGridFunctionOperator< Args... >	op,
		GridView const &	gridView
	)

Generate an GridFunctionOperator from a PreOperator (tag, expr).

References makeGridFunction().

mappedRangeView()

auto AMDiS::mappedRangeView	(	R &&	range,
		F const &	f
	)

Create a MappedRangeView.

Parameters

range	The range the transform
f	Unary function that should the applied to the entries of the range.

This behaves like a range providing begin() and end(). The iterators over this range internally iterate over the wrapped range. When dereferencing the iterator, the value is transformed on-the-fly using a given transformation function leaving the underlying range unchanged.

The transformation may either return temporary values or l-value references. In the former case the range behaves like a proxy-container. In the latter case it forwards these references allowing, e.g., to sort a subset of some container by applying a transformation to an index-range for those values.

The iterators of the MappedRangeView have the same iterator_category as the ones of the wrapped container.

If range is an r-value, then the MappedRangeView stores it by value, if range is an l-value, then the MappedRangeView stores it by reference.

Referenced by VectorBase< EigenVector< T > >::forEach(), PetscVector< DofMap >::forEach(), and nodeIndices().

msg()

void AMDiS::msg	(	std::string const &	str,
		Args &&...	args
	)

print a message

Example:

msg("Hello {}: {}", "World", 123); // prints "Hello World: 123\n"

Referenced by ProblemStat< Traits >::adaptGrid(), StandardProblemIteration::beginIteration(), ProblemStat< Traits >::buildAfterAdapt(), StandardProblemIteration::endIteration(), AdaptInstationary::explicitTimeStrategy(), Marker< Grid >::finishMarking(), ProblemStat< Traits >::globalCoarsen(), ProblemStat< Traits >::globalRefine(), AdaptInstationary::implicitTimeStrategy(), MSMarker< Grid >::initMarking(), ESMarker< Grid >::initMarking(), Marker< Grid >::mark(), ProblemStat< Traits >::markElements(), GERSMarker< Grid >::markGrid(), msg_dbg(), AdaptInstationary::simpleAdaptiveTimeStrategy(), IterativeRunner< Mat, Vec, IterativeSolver >::solve(), ProblemStat< Traits >::solve(), LinearSolver< Mat, Vec, Runner >::solveImpl(), BackupWriter< SystemVector >::write(), GmshWriter< GV >::write(), and ProblemStat< Traits >::writeFiles().

msg_()

void AMDiS::msg_	(	std::string const &	str,
		Args &&...	args
	)

print a message (without appended newline)

Example:

msg_("Hello {}: {}", "World", 123); // prints "Hello World: 123"

msg_dbg()

void AMDiS::msg_dbg

(

Args &&...

args

)

print message, in debug mode only

Same as MSG, but is available only if preprocessor constant AMDIS_ENABLE_MSG_DBG is set to 1, otherwise the function is empty.

References msg().

Referenced by test_exit_dbg().

order()

int AMDiS::order

(

FunctorLocalFunction< Sig, F, LFs... > const &

lf

)

Requirements:

• The functor F must model Concepts::HasFunctorOrder
• All localFunctions LFs... must model Concepts::Polynomial

References AMDiS::Concepts::Functor, and order().

static_num_cols()

constexpr auto AMDiS::static_num_cols

(

Matrix const &

matrix

)

Return a static constant columns of the matrix.

Parameters

container

Matrix whose number of columns is queried

Returns

Number of columns of matrix

If the size of matrix is known at compile time the number if cols is returned as std::integral_constant<std::size_t, size>. Otherwise 0 is returned by default, or 1 for arithmetic types.

static_num_rows()

constexpr auto AMDiS::static_num_rows

(

Matrix const &

matrix

)

Return a static constant rows of the matrix.

Parameters

container

Matrix whose number of rows is queried

Returns

Number of rows of matrix

If the size of t is known at compile time the number of rows is returned as std::integral_constant<std::size_t, size>. Otherwise 0 is returned by default, or 1 for arithmetic types.

static_size()

constexpr auto AMDiS::static_size

(

Container const &

container

)

Return a static constant size of the container.

Parameters

container

Container whose size is queried

Returns

Size of t

If the size of t is known at compile time the size is returned as std::integral_constant<std::size_t, size>. Otherwise 0 is returned by default, or 1 for arithmetic types.

test_exit()

void AMDiS::test_exit	(	bool	condition,
		std::string const &	str,
		Args &&...	args
	)

test for condition and in case of failure print message and exit

This function is equivalent to

if (condition == false) error_exit(text);

where text correspond to the arguments passed after the condition argument.

References error_exit().

Referenced by AdaptInstationary::adapt(), CreatorMap< BaseClass >::addCreator(), SolverPrecon< Mat, Vec >::adjoint_solve(), KrylovRunner< Mat, Vec, ITLSolver >::adjointSolve(), FileWriterBase::FileWriterBase(), VectorFacade< T, Traits::template VectorImpl >::gather(), Twist< typename Grid::GlobalIdSet, GridView::dimension >::get(), CreatorMap< BaseClass >::getCreator(), IterativeRunner< Mat, Vec, IterativeSolver >::init(), DirectRunner< Mat, Vec, Solver >::init(), MTLSparseMatrix< T >::init(), PeriodicBC< Basis, TP >::init(), ProblemStat< Traits >::initialize(), Marker< Grid >::markGrid(), GridFunctionMarker< Grid, GridFct >::markGrid(), InitfileParser::readInitfile(), ProblemStat< Traits >::restore(), VectorFacade< T, Traits::template VectorImpl >::scatter(), BoundaryManager< G >::setBoundaryId(), KrylovRunner< Mat, Vec, ITLSolver >::solve(), UmfpackRunner< Mat, Vec >::solve(), SolverPrecon< Mat, Vec >::solve(), ProblemStat< Traits >::solve(), test_exit_dbg(), and ProblemInstat< Traits >::transferInitialSolution().

test_exit_dbg()

void AMDiS::test_exit_dbg	(	bool	condition,
		Args &&...	args
	)

call assert_msg, in debug mode only

Same as TEST_EXIT, but is available only if preprocessor constant AMDIS_ENABLE_MSG_DBG is set to 1, otherwise the function is empty.

References msg_dbg(), and test_exit().

Referenced by Preconditioner< Mat, Vec, PreconImpl >::adjoint_solve(), SolverPrecon< Mat, Vec >::adjoint_solve(), MTLVector< T >::at(), EigenVector< T >::at(), EigenSparseMatrix< T, Orientation >::insert(), ISTLBCRSMatrix< T, C >::insert(), MTLSparseMatrix< T >::insert(), VectorFacade< T, Traits::template VectorImpl >::insert(), named(), ProblemInstat< Traits >::oldSolution(), ProblemInstat< Traits >::oldSolutionVector(), StandardProblemIteration::problem(), Preconditioner< Mat, Vec, PreconImpl >::solve(), and SolverPrecon< Mat, Vec >::solve().

test_warning()

void AMDiS::test_warning	(	bool	condition,
		std::string const &	str,
		Args &&...	args
	)

test for condition and in case of failure print message

Same as TEST_EXIT but does not throw an exception, or call assert. It just tests for the condition and prints a message with prepended string "WARNING".

Referenced by LocalOperator< GridFunctionOperator< tag::gradtest, LC, GridFct >, LC >::getDegree(), and ProblemStat< Traits >::removeMarker().

wrap_or_share()

std::shared_ptr<T> AMDiS::wrap_or_share

(

T &

t

)

Helper function converting the argument into a shared_ptr. The following cases are handled:

• objects passed as rvalue references are used to construct a new shared_ptr
• objects passed as references are used to construct a shared_ptr with a null deleter that does nothing when the pointer is destroyed, using the stored base pointer in case of a unique_ptr argument
• shared_ptr are simply forwarded

Referenced by ProblemStat< Traits >::addMarker(), ProblemStat< Traits >::ProblemStat(), ProblemStat< Traits >::setGrid(), and ProblemStat< Traits >::setSolver().

Variable Documentation

INIT_ALL

const Flag INIT_ALL

Initial value:

= INIT_FE_SPACE | INIT_MESH | CREATE_MESH | INIT_SYSTEM |
                               INIT_SOLVER | INIT_ESTIMATOR | INIT_MARKER |
                               INIT_ADAPT | INIT_FILEWRITER | INIT_INITIAL_PROBLEM |
                               INIT_UH_OLD | INIT_UPDATER | INIT_NONLIN_SOLVER