Dune Namespace Reference

Include standard header files. More...

Namespaces
namespace	Alberta
namespace	AlignedNumberImpl
namespace	Capabilities
	Contains all capabilities classes.
namespace	Concept
namespace	DenseMatrixHelp
namespace	dgf
namespace	DynamicMatrixHelp
namespace	FactoryUtilities
namespace	FloatCmp
namespace	FMatrixHelp
namespace	fvmeta
namespace	Geo
namespace	GeoGrid
	namespace containing the implementations of GeometryGrid
namespace	GeometryTypes
namespace	Gmsh
namespace	Hybrid
namespace	impl
namespace	Indices
namespace	MathImpl
namespace	MathOverloads
namespace	MultiLinearGeometry
namespace	MultiLinearGeometryTraits
namespace	ParallelIndexSet
namespace	Partitions
	Predefined PartitionSets for commonly used combinations of parallel grid PartitionTypes.
namespace	QuadratureType
namespace	RefinementImp
namespace	RemoteIndexListModifier
namespace	Simd
namespace	SimdImpl
namespace	StaticRefinement
namespace	Std
namespace	Transitional
namespace	VirtualRefinement
namespace	VirtualRefinementImp
namespace	VTK
namespace	Yasp

Classes
class	AdaptDataHandle
class	AdaptDataHandleInterface
	Interface class for the Grid's adapt method where the parameter is a AdaptDataHandleInterface. More...
struct	AddPtrTypeEvaluator
struct	AddPtrTypeEvaluator< T & >
struct	AddRefTypeEvaluator
class	AffineGeometry
class	AlbertaError
class	AlbertaGrid
	[ provides Dune::Grid ] More...
struct	AlbertaGridCoordinateReader
class	AlbertaGridEntity
class	AlbertaGridEntity< 0, dim, Grid >
class	AlbertaGridEntityPointer
class	AlbertaGridEntitySeed
class	AlbertaGridEntitySeed< 0, const AlbertaGrid< dim, dimworld > >
class	AlbertaGridEntitySeed< codim, const AlbertaGrid< dim, dimworld > >
struct	AlbertaGridFamily
class	AlbertaGridGeometry
	geometry implementation for AlbertaGrid More...
class	AlbertaGridGlobalGeometry
class	AlbertaGridGlobalGeometry< dim, cdim, const AlbertaGrid< dim, cdim > >
class	AlbertaGridHierarchicIndexSet
class	AlbertaGridHierarchicIterator
class	AlbertaGridIdSet
	hierarchic index set of AlbertaGrid More...
class	AlbertaGridIndexSet
class	AlbertaGridIntersectionBase
class	AlbertaGridLeafIntersection
class	AlbertaGridLeafIntersectionIterator
class	AlbertaGridLeafIterator
class	AlbertaGridLeafIterator< codim, Ghost_Partition, GridImp >
class	AlbertaGridLevelIterator
class	AlbertaGridLevelIterator< codim, Ghost_Partition, GridImp >
class	AlbertaGridLevelProvider
class	AlbertaGridLocalGeometryProvider
class	AlbertaGridTreeIterator
class	AlbertaIOError
class	AlbertaLeafGridView
struct	AlbertaLeafGridViewTraits
class	AlbertaLevelGridView
struct	AlbertaLevelGridViewTraits
class	AlbertaMarkerVector
	marker assigning subentities to one element containing them More...
class	AlbertaReader
class	AlbertaTransformation
class	AlignedAllocator
struct	AlignedBase
class	AllSet
struct	AlwaysFalse
struct	AlwaysTrue
class	AnalyticalCoordFunction
	Derive an implementation of an analytical coordinate function from this class. More...
class	AnalyticalCoordFunctionInterface
	Interface class for using an analytical function to define the geometry of a Dune::GeometryGrid. An implementation should be derived from Dune::AnalyticalCoordFunction and the evaluate method mapping \( R^d\to R^r \) has to be supplied. More...
class	ArrayList
class	ArrayListIterator
class	AssociativePropertyMap
struct	At
struct	AtType
struct	AutonomousValueType
struct	AutonomousValueType< const T >
struct	AutonomousValueType< Simd::VcImpl::Proxy< V > >
struct	AutonomousValueType< std::vector< bool >::reference >
struct	AutonomousValueType< T & >
struct	AutonomousValueType< T && >
struct	AutonomousValueType< volatile const T >
struct	AutonomousValueType< volatile T >
class	AxisAlignedCubeGeometry
struct	b64chunk
	struct representing the three byte text as well as the four 6 bit chunks More...
class	BackupRestoreFacility
	facility for writing and reading grids More...
struct	BackupRestoreFacility< AlbertaGrid< dim, dimworld > >
struct	BackupRestoreFacility< const Grid >
	BackupRestoreFacility taking const Grid as type and deriving from the version with the const. More...
struct	BackupRestoreFacility< Dune::YaspGrid< dim, Coordinates > >
	facility for writing and reading grids More...
struct	BackupRestoreFacility< GeometryGrid< HostGrid, CoordFunction, Allocator > >
struct	BackupRestoreFacility< YaspGrid< dim, TensorProductCoordinates< ctype, dim > > >
	facility for writing and reading grids More...
class	Base64Stream
	class to base64 encode a stream of data More...
class	BidirectionalIteratorFacade
class	bigunsignedint
class	BitSetVector
class	BitSetVectorConstReference
class	BitSetVectorReference
class	BoundaryProjectionWrapper
struct	BoundarySegment
	Base class for classes implementing geometries of boundary segments. More...
class	BoundarySegmentBackupRestore
class	BoundarySegmentWrapper
class	BufferedCommunicator
class	CachedCoordFunction
class	CachedMultiLinearGeometry
struct	CircleBoundaryProjection
struct	Cloneable
struct	Codim
class	CollectiveIterator
class	Combine
class	CombinedAdaptProlongRestrict
	class for combining 2 index sets together for adaptation process More...
class	CommDataHandleIF
	CommDataHandleIF describes the features of a data handle for communication in parallel runs using the Grid::communicate methods. Here the Barton-Nackman trick is used to interpret data handle objects as its interface. Therefore usable data handle classes need to be derived from this class. More...
struct	common_bits
struct	CommPolicy
class	Communication
class	Communication< MPI_Comm >
struct	const_reference
struct	const_reference< BitSetVectorConstReference< block_size, Alloc > >
struct	const_reference< BitSetVectorReference< block_size, Alloc > >
struct	const_reference< const R & >
struct	const_reference< const R >
struct	const_reference< DiagonalRowVector< K, n > >
struct	const_reference< DiagonalRowVectorConst< K, n > >
struct	const_reference< R & >
class	ConstArrayListIterator
class	ConstAssociativePropertyMap
class	ContainerWrapperIterator
class	CopyableOptional
class	DebugStream
class	DebugStreamError
class	DebugStreamState
class	DefaultCoordFunction
class	DefaultLeafGridView
struct	DefaultLeafGridViewTraits
class	DefaultLevelGridView
struct	DefaultLevelGridViewTraits
class	DenseIterator
class	DenseMatrix
struct	DenseMatrixAssigner
struct	DenseMatrixAssigner< DenseMatrix, DiagonalMatrix< field, N > >
struct	DenseMatVecTraits
struct	DenseMatVecTraits< DynamicMatrix< K > >
struct	DenseMatVecTraits< DynamicVector< K, Allocator > >
struct	DenseMatVecTraits< FieldMatrix< K, ROWS, COLS > >
struct	DenseMatVecTraits< FieldVector< K, SIZE > >
class	DenseVector
struct	DGFBoundaryParameter
	Contains types for additional features. More...
class	DGFCoordFunction
struct	DGFCoordFunctionFactory
struct	DGFCoordFunctionFactory< HostGrid, CoordFunction, false >
struct	DGFCoordFunctionFactory< HostGrid, CoordFunction, true >
struct	DGFCoordFunctionFactory< HostGrid, DGFCoordFunction< dimD, dimR >, false >
struct	DGFEntityKey
class	DGFException
	exception class for IO errors in the DGF parser More...
struct	DGFGridFactory
struct	DGFGridFactory< AlbertaGrid< dim, dimworld > >
class	DGFGridFactory< Dune::YaspGrid< dim, Dune::TensorProductCoordinates< ctype, dim > > >
	Placeholder for grid factory for YaspGrid with tensor product coordinates. More...
struct	DGFGridFactory< GeometryGrid< HostGrid, CoordFunction, Allocator > >
struct	DGFGridFactory< IdentityGrid< HostGrid > >
struct	DGFGridFactory< OneDGrid >
struct	DGFGridFactory< UGGrid< dim > >
struct	DGFGridFactory< YaspGrid< dim, EquidistantCoordinates< ctype, dim > > >
	Grid factory for YaspGrid with equidistant coordinates. More...
struct	DGFGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > > >
	Grid factory for YaspGrid with equidistant coordinates. More...
struct	DGFGridInfo
	Some simple static information for a given GridType. More...
struct	DGFGridInfo< AlbertaGrid< dim, dimworld > >
struct	DGFGridInfo< GeometryGrid< HostGrid, CoordFunction, Allocator > >
struct	DGFGridInfo< IdentityGrid< HostGrid > >
struct	DGFGridInfo< OneDGrid >
struct	DGFGridInfo< UGGrid< dim > >
struct	DGFGridInfo< YaspGrid< dim, Coordinates > >
class	DGFPrintInfo
class	DGFWriter
	write a GridView to a DGF file More...
class	DiagonalMatrix
class	DiagonalMatrixWrapper
class	DiagonalRowVector
class	DiagonalRowVectorConst
struct	Dim
class	DiscreteCoordFunction
	Derive an implementation of a discrete coordinate function from this class. More...
class	DiscreteCoordFunctionInterface
	Interface class for using a discrete function to define the geometry of a Dune::GeometryGrid. An implementation should be derived from Dune::DiscreteCoordinateFunction and the evaluate method taking an entity of the host grid together with the number of a vertex returns the coordinate in \( R^r \) of that corner. The user must ensure continuity of this mapping. In addition an adapt method is provided which is called whenever adapt() is called on the Dune::GeometryGrid. More...
struct	DuneBoundaryProjection
	Interface class for vertex projection at the boundary. More...
class	DuneGridFormatParser
	The DuneGridFormatParser class: reads a DGF file and stores build information in vector structures used by the MacroGrid class. More...
class	DynamicMatrix
class	DynamicVector
struct	ElementFaceUtil
struct	Empty
class	EmptySet
struct	EnableIfInterOperable
class	Entity
	Wrapper class for entities. More...
class	Entity< 0, dim, GridImp, EntityImp >
	Template specialization of Dune::Entity for Elements (codim==0) More...
struct	EntityCommHelper
struct	EntityCommHelper< All_All_Interface >
struct	EntityCommHelper< InteriorBorder_All_Interface >
struct	EntityCommHelper< InteriorBorder_InteriorBorder_Interface >
struct	EntityCommHelper< Overlap_All_Interface >
struct	EntityCommHelper< Overlap_OverlapFront_Interface >
class	EntityDefaultImplementation
	Default Implementations for EntityImp. More...
class	EntityDefaultImplementation< 0, dim, GridImp, EntityImp >
	Default Implementations for EntityImp (Elements [cd=0]) More...
struct	EntityInfo
	Structure to hold statistical information about one type of entity. More...
class	EntityIterator
	interface class for an iterator over grid entities More...
class	EntitySeed
	Store a reference to an entity with a minimal memory footprint. More...
class	EnumItem
class	EnumRange
class	EquidistantCoordinates
	Container for equidistant coordinates in a YaspGrid. More...
class	EquidistantOffsetCoordinates
	Container for equidistant coordinates in a YaspGrid with non-trivial origin. More...
class	Exception
struct	ExceptionHook
struct	Factorial
struct	Factorial< 0 >
class	FakeMPIHelper
class	FieldMatrix
struct	FieldTraits
struct	FieldTraits< const T >
struct	FieldTraits< DenseMatrix< M > >
struct	FieldTraits< DenseVector< V > >
struct	FieldTraits< DiagonalMatrix< K, n > >
struct	FieldTraits< DynamicMatrix< K > >
struct	FieldTraits< DynamicVector< K, Allocator > >
struct	FieldTraits< FieldMatrix< K, ROWS, COLS > >
struct	FieldTraits< FieldVector< K, SIZE > >
struct	FieldTraits< std::complex< T > >
struct	FieldTraits< std::vector< T > >
struct	FieldTraits< T[N] >
class	FieldVector
class	FirstPredicateIndex
struct	FirstTypeIndex
struct	FlattenTuple
class	FloatCmpOps
class	FMatrixError
class	FMatrixPrecision
struct	ForEachType
struct	ForEachType< TE, std::tuple< Args... > >
class	ForwardIteratorFacade
class	Future
class	GeneralVertexOrder
class	Generic_MPI_Op
class	GenericIterator
class	Geometry
	Wrapper class for geometries. More...
class	GeometryDefaultImplementation
	Default implementation for class Geometry. More...
class	GeometryDefaultImplementation< 0, cdim, GridImp, GeometryImp >
class	GeometryGrid
	grid wrapper replacing the geometries More...
class	GeometryReference
class	GeometryType
class	GlobalGeometryReference
class	GlobalGeometryTypeIndex
class	GlobalIndexSet
	Calculate globally unique index over all processes in a Dune grid. More...
class	GlobalLookupIndexSet
class	GMPField
class	GmshReader
	Read Gmsh mesh file. More...
struct	GmshReaderOptions
	Options for read operation. More...
class	GmshReaderParser
	dimension independent parts for GmshReaderParser More...
class	GmshWriter
	Write Gmsh mesh file. More...
class	GnuplotWriter
	Writer for 1D grids in gnuplot format. More...
struct	greater_or_equal
class	Grid
	Grid abstract base class. More...
class	GridDefaultImplementation
class	GridError
	Base class for exceptions in Dune grid modules. More...
class	GridFactory
	Provide a generic factory class for unstructured grids. More...
class	GridFactory< AlbertaGrid< dim, dimworld > >
	specialization of the generic GridFactory for AlbertaGrid More...
class	GridFactory< UGGrid< dimworld > >
	Specialization of the generic GridFactory for UGGrid. More...
class	GridFactoryInterface
	Provide a generic factory class for unstructured grids. More...
struct	GridPtr
	Class for constructing grids from DGF files. More...
struct	GridTraits
	A traits struct that collects all associated types of one grid model. More...
class	GridView
	Grid view abstract base class. More...
struct	GridViewInfo
	structure to hold information about a certain GridView. More...
struct	GridViewInfoGTCompare
	Comparison object to sort GeometryType by majorly dimension. More...
struct	hash
struct	HasNaN
class	HelpRequest
class	HierarchicSearch
	Search an IndexSet for an Entity containing a given point. More...
class	HostGridAccess
	provides access to host grid objects from GeometryGrid More...
struct	HostGridAccess< GeometryGrid< HG, CoordFunction, Allocator > >
struct	HostGridAccess< IdentityGrid< HG > >
class	IdenticalCoordFunction
class	IdentityGrid
	Provides a meta grid that is identical to its host. More...
class	IdentityGridEntity
	The implementation of entities in a IdentityGrid. More...
class	IdentityGridEntity< 0, dim, GridImp >
	Specialization for codim-0-entities. More...
class	IdentityGridEntitySeed
	The EntitySeed class provides the minimal information needed to restore an Entity using the grid. More...
struct	IdentityGridFamily
class	IdentityGridGeometry
class	IdentityGridGlobalIdSet
class	IdentityGridHierarchicIterator
	Iterator over the descendants of an entity.Mesh entities of codimension 0 ("elements") allow to visit all entities of codimension 0 obtained through nested, hierarchic refinement of the entity. Iteration over this set of entities is provided by the HierarchicIterator, starting from a given entity. More...
class	IdentityGridLeafIndexSet
class	IdentityGridLeafIntersection
	An intersection with a leaf neighbor elementMesh entities of codimension 0 ("elements") allow to visit all neighbors, where a neighbor is an entity of codimension 0 which has a common entity of codimension 1 These neighbors are accessed via a IntersectionIterator. This allows the implement non-matching meshes. The number of neighbors may be different from the number of an element! More...
class	IdentityGridLeafIntersectionIterator
	Iterator over all element neighborsMesh entities of codimension 0 ("elements") allow to visit all neighbors, where a neighbor is an entity of codimension 0 which has a common entity of codimension 1 These neighbors are accessed via a IntersectionIterator. This allows the implement non-matching meshes. The number of neighbors may be different from the number of an element! More...
class	IdentityGridLeafIterator
	Iterator over all entities of a given codimension and level of a grid. More...
class	IdentityGridLevelIndexSet
class	IdentityGridLevelIntersection
class	IdentityGridLevelIntersectionIterator
class	IdentityGridLevelIterator
	Iterator over all entities of a given codimension and level of a grid. More...
class	IdentityGridLocalIdSet
struct	IdentityMap
class	IdSet
	Id Set Interface. More...
struct	ImplementationDefined
class	Indent
class	IndexedIterator
class	IndexPair
class	IndexSet
	Index Set Interface base class. More...
class	IndexSetDefaultImplementation
	Provide default implementation of method if IndexSet. More...
struct	IndexSetSortFunctor
class	IndexStack
class	IndicesSyncer
struct	IntegerSequenceEntry
class	IntegralRange
class	Interface
class	InterfaceBuilder
class	InterfaceInformation
class	Intersection
	Intersection of a mesh entity of codimension 0 ("element") with a "neighboring" element or with the domain boundary. More...
class	IntersectionDefaultNormalVectors
	Default Implementations of integrationOuterNormal and unitOuterNormal for IntersectionImp. More...
class	IntersectionIterator
	Mesh entities of codimension 0 ("elements") allow to visit all intersections with "neighboring" elements and with the domain boundary. More...
class	InvalidFutureException
class	InvalidIndexSetState
class	InvalidStateException
class	IOError
class	ios_base_all_saver
struct	IsCallable
struct	IsCallable< F(Args...), R >
struct	IsCompileTimeConstant
struct	IsEmptyTypeList
struct	IsFieldVectorSizeCorrect
struct	IsFieldVectorSizeCorrect< FieldVector< T, SIZE >, SIZE >
struct	IsFieldVectorSizeCorrect< FieldVector< T, SIZE1 >, SIZE >
struct	IsIndexable
struct	IsIntegralConstant
struct	IsInteroperable
struct	IsIterable
struct	IsNumber
struct	IsNumber< AlignedNumberImpl::AlignedNumber< T, align > >
struct	IsNumber< bigunsignedint< k > >
struct	IsNumber< GMPField< precision > >
struct	IsNumber< LoopSIMD< T, S, A > >
struct	IsNumber< Vc::SimdArray< T, N, V, Wt > >
struct	IsNumber< Vc::Vector< T, Abi > >
struct	IsTuple
struct	IsTupleOrDerived
struct	IsType
struct	IsTypeList
struct	IsTypeList< TypeList< T... > >
struct	IsVector
struct	IsVector< T, std::void_t< typename T::field_type > >
class	IteratorFacade
struct	IteratorFacadeAccess
class	IteratorPropertyMap
class	IteratorRange
struct	IteratorTransformationTag
struct	JoinTuples
class	LeafGnuplotWriter
	GnuplotWriter on the leaf grid. More...
class	LevelGnuplotWriter
	GnuplotWriter on a given level grid. More...
class	LocalFiniteElementGeometry
class	LocalGeometryReference
class	LocalGeometryTypeIndex
class	LocalIndex
struct	LocalIndexComparator
struct	LocalIndexComparator< ParallelLocalIndex< T > >
class	LoopSIMD
class	lru
struct	LvaluePropertyMapTag
class	MacroGrid
struct	MakeableInterfaceObject
class	MallocAllocator
class	MappedGeometry
class	Mapper
	Mapper interface. More...
struct	MathematicalConstants
class	MathError
struct	Max
struct	MaybeHaveOrigin
struct	MaybeHaveOrigin< Dune::EquidistantOffsetCoordinates< ctype, dim > >
class	MessageBufferIF
	Communication message buffer interface. This class describes the interface for reading and writing data to the communication message buffer. As message buffers might be deeply implemented in various packages the message buffers implementations cannot be derived from this interface class. Therefore we just apply the engine concept to wrap the message buffer call and make sure that the interface is fulfilled. More...
struct	MetaType
struct	Min
struct	MPIData
struct	MPIData< P, std::enable_if_t< std::is_same< std::remove_const_t< P >, MPIPack >::value > >
struct	MPIData< T, std::void_t< std::tuple< decltype(std::declval< T >().data()), decltype(std::declval< T >().size()), typename std::decay_t< T >::value_type > > >
struct	MPIData< void >
class	MPIFuture
class	MPIGuard
class	MPIGuardError
class	MPIHelper
class	MPIPack
struct	MPITraits
class	MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >
class	MPITraits< ParallelLocalIndex< T > >
class	MultiLinearGeometry
struct	MultiLinearGeometryTraits
class	MultipleCodimMultipleGeomTypeMapper
	Implementation class for a multiple codim and multiple geometry type mapper. More...
struct	mutable_reference
struct	mutable_reference< BitSetVectorConstReference< block_size, Alloc > >
struct	mutable_reference< BitSetVectorReference< block_size, Alloc > >
struct	mutable_reference< const R & >
struct	mutable_reference< const R >
struct	mutable_reference< DiagonalRowVector< K, n > >
struct	mutable_reference< DiagonalRowVectorConst< K, n > >
struct	mutable_reference< R & >
class	NegateSet
struct	No_Comm
class	NotImplemented
struct	null_deleter
struct	NullPointerInitialiser
struct	NullPointerInitialiser< std::tuple< Args... > >
class	OneDGrid
	One-dimensional adaptive grid. More...
struct	OneDGridFamily
class	OutOfMemoryError
class	OwnerOverlapCopyCommunication
class	P0VTKFunction
	Take a vector and interpret it as cell data for the VTKWriter. More...
class	P1VTKFunction
	Take a vector and interpret it as point data for the VTKWriter. More...
class	ParallelError
class	ParallelIndexSet
class	ParallelLocalIndex
class	ParameterizedObjectFactory
class	ParameterizedObjectFactory< TypeT(Args...), KeyT >
class	ParameterTree
class	ParameterTreeParser
class	ParameterTreeParserError
struct	PartitionSet
	A set of PartitionType values. More...
class	PersistentContainer
	A class for storing data during an adaptation cycle. More...
class	PersistentContainer< AlbertaGrid< dim, dimworld >, T >
class	PersistentContainer< const Grid, T >
	refer PersistentContainer<const Grid> to the implementation of the mutable grid More...
class	PersistentContainer< GeometryGrid< HostGrid, CoordFunction, Allocator >, T >
class	PersistentContainer< YaspGrid< dim, CoordCont >, T >
	Specialization of the PersistentContainer for YaspGrid. More...
class	PersistentContainerInterface
	Persistent storage of data on all entities of a grid. More...
class	PersistentContainerMap
	map-based implementation of the PersistentContainer More...
class	PersistentContainerVector
	vector-based implementation of the PersistentContainer More...
class	PersistentContainerWrapper
struct	PointerPairDeletor
class	Pool
class	PoolAllocator
class	PoolAllocator< void, s >
struct	PriorityTag
struct	PriorityTag< 0 >
struct	PromotionTraits
struct	PromotionTraits< GMPField< precision >, GMPField< precision > >
struct	PromotionTraits< GMPField< precision >, T >
struct	PromotionTraits< GMPField< precision1 >, GMPField< precision2 > >
struct	PromotionTraits< T, GMPField< precision > >
struct	PromotionTraits< T1, T1 >
struct	PropertyMapTraits
struct	PropertyMapTraits< const T * >
struct	PropertyMapTraits< T * >
struct	PropertyMapTypeSelector
class	ProxyArrowResult
class	PseudoFuture
class	PseudoFuture< void >
struct	PushBackTuple
struct	PushBackTuple< typename std::tuple< Args... >, T >
struct	PushFrontTuple
struct	PushFrontTuple< typename std::tuple< Args... >, T >
class	QuadratureOrderOutOfRange
class	QuadraturePoint
class	QuadratureRule
class	QuadratureRuleFactory
class	QuadratureRuleFactory< ctype, 0 >
class	QuadratureRuleFactory< ctype, 1 >
class	QuadratureRuleFactory< ctype, 2 >
class	QuadratureRuleFactory< ctype, 3 >
class	QuadratureRules
class	RandomAccessIteratorFacade
class	RangeError
struct	RAPropertyMapHelper
class	RawStream
	write out data in binary More...
struct	ReadablePropertyMapTag
struct	ReadWritePropertyMapTag
struct	ReduceTuple
struct	ReduceTuple< F, Tuple, Seed, 0 >
class	RefinementBuilder
class	RefinementBuilder< 1, CoordType >
class	RefinementBuilder< 3, CoordType >
class	RefinementIntervals
class	RemoteIndex
class	RemoteIndexListModifier
class	RemoteIndices
class	ReservedVector
class	Selection
class	SelectionIterator
struct	SimdIndexTypeTraits
struct	SimdMaskTypeTraits
struct	SimdScalarTypeTraits
struct	SimdScalarTypeTraits< AlignedNumber< T, align > >
class	SingleCodimSingleGeomTypeMapper
	Implementation class for a single codim and single geometry type mapper. More...
class	Singleton
class	SizeCache
	organizes the caching of sizes for one grid and one GeometryType More...
struct	SizeOf
struct	SizeOne
class	SLList
class	SLListConstIterator
class	SLListIterator
class	SLListModifyIterator
struct	StandardMathematicalConstants
class	StarCDReader
	File reader for the Star-CD format. More...
class	StaticIntegralRange
class	StaticRefinement
class	StreamWrap
class	StructuredGridFactory
	Construct structured cube and simplex grids in unstructured grid managers. More...
class	StructuredGridFactory< AlbertaGrid< dim, dimworld > >
	specialization of the generic StructuredGridFactory for AlbertaGrid More...
class	StructuredGridFactory< YaspGrid< dim, EquidistantCoordinates< ctype, dim > > >
	Specialization of the StructuredGridFactory for YaspGrid. More...
class	StructuredGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > > >
	Specialization of the StructuredGridFactory for YaspGrid<EquidistantOffsetCoordinates> More...
class	SubsamplingVTKWriter
	Writer for the output of subsampled grid functions in the vtk format. More...
class	SystemError
class	TensorGridFactory
	A factory class for conveniently creating tensorproduct grids. More...
class	TensorGridFactoryCreator
class	TensorGridFactoryCreator< YaspGrid< dim, TensorProductCoordinates< ctype, dim > > >
class	TensorProductCoordinates
	Coordinate container for a tensor product YaspGrid. More...
class	TestSuite
class	Timer
struct	TopologyFactory
struct	TopologySingletonFactory
class	Torus
class	TransformedRangeView
class	TransformTupleFunctor
struct	TupleAccessTraits
struct	TupleAccessTraits< T & >
struct	TupleAccessTraits< T * >
class	TupleVector
struct	TypeListElement
struct	TypeListElement< i, TypeList< T... > >
struct	TypeListSize
struct	TypeListSize< TypeList< T... > >
class	UGGrid
	Front-end for the grid manager of the finite element toolbox UG3. More...
struct	UGGridFamily
class	UncachedSelection
struct	ValueTransformationTag
struct	VariableSize
class	VariableSizeCommunicator
class	VertexOrderByIdFactory
	Factory for GeneralVertexOrder objects using an IdSet. More...
class	VirtualRefinement
class	VirtualRefinementImp
class	VirtualRefinementImpSubEntityIteratorBackSpecial
class	VirtualRefinementImpSubEntityIteratorBackSpecial< topologyId, CoordType, coerceToId, dimension, 0 >
class	VirtualRefinementImpSubEntityIteratorBackSpecial< topologyId, CoordType, coerceToId, dimension, dimension >
class	VirtualRefinementSubEntityIteratorBackSpecial
class	VirtualRefinementSubEntityIteratorBackSpecial< dimension, CoordType, 0 >
class	VirtualRefinementSubEntityIteratorBackSpecial< dimension, CoordType, dimension >
class	VirtualRefinementSubEntityIteratorSpecial
class	VirtualRefinementSubEntityIteratorSpecial< dimension, CoordType, 0 >
class	VirtualRefinementSubEntityIteratorSpecial< dimension, CoordType, dimension >
class	VTKFunction
	A base class for grid functions with any return type and dimension. More...
class	VTKSequenceWriter
	Writer for the output of grid functions in the vtk format. More...
class	VTKSequenceWriterBase
	Base class to write pvd-files which contains a list of all collected vtk-files. More...
class	VTKWriter
	Writer for the output of grid functions in the vtk format. More...
struct	WritablePropertyMapTag
class	YaspEntity
class	YaspEntity< 0, dim, GridImp >
class	YaspEntity< dim, dim, GridImp >
class	YaspEntitySeed
	Describes the minimal information necessary to create a fully functional YaspEntity. More...
class	YaspGeometry
	The general version that handles all codimensions but 0 and dim. More...
class	YaspGeometry< 0, cdim, GridImp >
	specialization for dim=0, this is a vertex More...
class	YaspGeometry< mydim, mydim, GridImp >
	specialize for dim=dimworld, i.e. a volume element More...
class	YaspGlobalIdSet
	persistent, globally unique Ids More...
class	YaspGrid
	[ provides Dune::Grid ] More...
struct	YaspGridFamily
class	YaspHierarchicIterator
	YaspHierarchicIterator enables iteration over son entities of codim 0. More...
class	YaspIndexSet
	Implementation of Level- and LeafIndexSets for YaspGrid. More...
class	YaspIntersection
	YaspIntersection provides data about intersection with neighboring codim 0 entities. More...
class	YaspIntersectionIterator
	YaspIntersectionIterator enables iteration over intersections with neighboring codim 0 entities. More...
class	YaspLevelIterator
	Iterates over entities of one grid level. More...
class	YaspPersistentContainerIndex
class	YGrid
	implements a collection of YGridComponents which form a codimension Entities of given codimension c need to be represented by d choose c YgridComponents. All entities in one such component share the same set of spanning unit vectors. A YGrid is used to iterate over the entire set of components the codimension consists of. It doesn't hold any data, but instead holds an iterator range into an array of components (which is owned by YGridLevel). More...
class	YGridComponent
class	YGridList
	implements a collection of multiple std::deque<Intersection> Intersections with neighboring processors are stored as std::deque<Intersection>. Eachsuch intersection only holds one YGridComponent. To do all communication associated with one codimension, multiple such deques have to be concatenated. YGridList manges this concatenation. As for YGrids, YGridList doesn't hold any data, but an iterator range into a data array owned by YGridLevel. More...

Typedefs
typedef std::function< void(const char *, std::size_t, const void *)>	ViolatedAlignmentHandler
typedef unsigned int	DebugLevel
typedef std::integral_constant< std::size_t, i >	index_constant
typedef Communication< T >	CollectiveCommunication
typedef std::remove_reference_t< decltype(Dune::resolveRef(std::declval< T & >()))>	ResolveRef_t
typedef typename SimdScalarTypeTraits< T >::type	SimdScalar
typedef typename SimdIndexTypeTraits< V >::type	SimdIndex
typedef typename SimdMaskTypeTraits< V >::type	SimdMask
typedef Std::detected_or_t< decltype(detail::warningIfNotDefined< Std::detected_t< Fallback, Args... > >(std::declval< const Std::detected_t< TargetType, Args... > * >())), TargetType, Args... >	detected_or_fallback_t
typedef DebugStream< VERY_VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DVVerbType
typedef DebugStream< VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DVerbType
typedef DebugStream< INFO_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DInfoType
typedef DebugStream< WARN_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DWarnType
typedef DebugStream< GRAVE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DGraveType
typedef DebugStream< 1 >	DErrType
typedef std::tuple< MetaType< T >... >	TypeList
typedef typename TypeListElement< i, T >::type	TypeListEntry_t
typedef typename Impl::UnpackTypeList< Target, TL >::type	UnpackTypeList_t
typedef typename Impl::UniqueTypesHelper< Target, TypeList< T... > >::type	UniqueTypes_t
typedef typename Impl::UniqueTypesHelper< TypeList, NonUniqueTypeList >::type	UniqueTypeList_t
typedef typename Impl::voider< Types... >::type	void_t
typedef typename FieldTraits< Type >::field_type	field_t
typedef typename FieldTraits< Type >::real_type	real_t
typedef typename AutonomousValueType< T >::type	AutonomousValue
typedef std::enable_if_t< not Impl::disableCopyMoveHelper< This, T... >::value, int >	disableCopyMove
typedef std::integral_constant< std::size_t, i >	index_constant
typedef std::tuple< MetaType< T >... >	TypeList
typedef std::enable_if_t< not Impl::disableCopyMoveHelper< This, T... >::value, int >	disableCopyMove
typedef typename Impl::voider< Types... >::type	void_t
typedef typename FieldTraits< Type >::field_type	field_t
typedef typename FieldTraits< Type >::real_type	real_t
typedef typename AutonomousValueType< T >::type	AutonomousValue
typedef unsigned int	DebugLevel
typedef DebugStream< VERY_VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DVVerbType
typedef DebugStream< VERBOSE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DVerbType
typedef DebugStream< INFO_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DInfoType
typedef DebugStream< WARN_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DWarnType
typedef DebugStream< GRAVE_DEBUG_LEVEL, MINIMAL_DEBUG_LEVEL >	DGraveType
typedef DebugStream< 1 >	DErrType
using	MCMGLayout = std::function< size_t(GeometryType, int)>
	layout function for MultipleCodimMultipleGeomTypeMapper
template<int mydim, int coorddim, class GridImp >
using	OneDGridGeometry = AxisAlignedCubeGeometry< double, mydim, coorddim >
	The type used to for OneDGrid geometries.
using	UGCommunication = Communication< No_Comm >
using	YaspCommunication = Communication< MPI_Comm >

Enumerations
enum	ParallelIndexSetState
enum	LocalIndexState
enum	ParallelIndexSetState
enum	LocalIndexState
enum	PartitionType {   InteriorEntity =0 , BorderEntity =1 , OverlapEntity =2 , FrontEntity =3 ,   GhostEntity =4 }
	Attributes used in the generic overlap model. More...
enum	InterfaceType {   InteriorBorder_InteriorBorder_Interface =0 , InteriorBorder_All_Interface =1 , Overlap_OverlapFront_Interface =2 , Overlap_All_Interface =3 ,   All_All_Interface =4 }
	Parameter to be used for the communication functions. More...
enum	PartitionIteratorType {   Interior_Partition =0 , InteriorBorder_Partition =1 , Overlap_Partition =2 , OverlapFront_Partition =3 ,   All_Partition =4 , Ghost_Partition =5 }
	Parameter to be used for the parallel level- and leaf iterators. More...
enum	CommunicationDirection { ForwardCommunication , BackwardCommunication }
	Define a type for communication direction parameter. More...

Functions
std::ostream &	operator<< (std::ostream &s, const bigunsignedint< k > &x)
bigunsignedint< k >	operator+ (const bigunsignedint< k > &x, std::uintmax_t y)
bigunsignedint< k >	operator- (const bigunsignedint< k > &x, std::uintmax_t y)
bigunsignedint< k >	operator* (const bigunsignedint< k > &x, std::uintmax_t y)
bigunsignedint< k >	operator/ (const bigunsignedint< k > &x, std::uintmax_t y)
bigunsignedint< k >	operator% (const bigunsignedint< k > &x, std::uintmax_t y)
bigunsignedint< k >	operator+ (std::uintmax_t x, const bigunsignedint< k > &y)
bigunsignedint< k >	operator- (std::uintmax_t x, const bigunsignedint< k > &y)
bigunsignedint< k >	operator* (std::uintmax_t x, const bigunsignedint< k > &y)
bigunsignedint< k >	operator/ (std::uintmax_t x, const bigunsignedint< k > &y)
bigunsignedint< k >	operator% (std::uintmax_t x, const bigunsignedint< k > &y)
std::string	className ()
std::string	className (T &&v)
constexpr auto	models ()
const T1	cond (bool b, const T1 &v1, const T2 &v2)
static void	defaultViolatedAlignment (const char *className, std::size_t expectedAlignment, const void *address)
ViolatedAlignmentHandler &	violatedAlignmentHandler ()
void	violatedAlignment (const char *className, std::size_t expectedAlignment, const void *address)
bool	isAligned (const void *p, std::size_t align)
AlignedNumber< T, align >	aligned (T value)
AlignedNumber< T, align >	cond (const AlignedNumber< bool, align > &b, const AlignedNumber< T, align > &v1, const AlignedNumber< T, align > &v2)
T	max_value (const AlignedNumber< T, align > &val)
T	min_value (const AlignedNumber< T, align > &val)
bool	any_true (const AlignedNumber< bool, align > &val)
bool	all_true (const AlignedNumber< bool, align > &val)
std::ostream &	operator<< (std::ostream &s, const DenseMatrix< MAT > &a)
auto	dot (const A &a, const B &b) -> typename std::enable_if< IsNumber< A >::value &&!IsVector< A >::value &&!std::is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type > ::value, decltype(conj(a) *b)>::type
auto	dotT (const A &a, const B &b) -> decltype(a *b)
std::ostream &	operator<< (std::ostream &os, const EnumItem< TA, i > &)
std::ostream &	operator<< (std::ostream &os, const EnumRange< TA, from, to > &)
Combine< TI1, TI2, typename TI1::Type >	combine (const TI1 &set1, const TI2 &set2)
std::ostream &	operator<< (std::ostream &os, const Combine< TI1, TI2, T > &)
std::ostream &	operator<< (std::ostream &stream, const Exception &e)
constexpr std::array< T, n >	filledArray (const T &t)
void	hash_combine (std::size_t &seed, const T &arg)
std::size_t	hash_range (It first, It last)
void	hash_range (std::size_t &seed, It first, It last)
std::ostream &	operator<< (std::ostream &s, const Indent &indent)
decltype(auto) constexpr	unpackIntegerSequence (F &&f, std::integer_sequence< I, i... > sequence)
constexpr auto	get (std::integer_sequence< T, II... >, std::integral_constant< std::size_t, pos >={})
constexpr T	get (std::integer_sequence< T, II... >, std::size_t pos)
constexpr std::integral_constant< T, I0 >	front (std::integer_sequence< T, I0, II... >)
constexpr auto	back (std::integer_sequence< T, II... > seq)
constexpr std::integral_constant< T, I0 >	head (std::integer_sequence< T, I0, II... >)
constexpr std::integer_sequence< T, II... >	tail (std::integer_sequence< T, I0, II... >)
constexpr std::integer_sequence< T, T(I0), II... >	push_front (std::integer_sequence< T, II... >, std::integral_constant< T, I0 >={})
constexpr std::integer_sequence< T, II..., T(IN)>	push_back (std::integer_sequence< T, II... >, std::integral_constant< T, IN >={})
constexpr std::integral_constant< std::size_t, sizeof...(II)>	size (std::integer_sequence< T, II... >)
constexpr std::bool_constant<(sizeof...(II)==0)>	empty (std::integer_sequence< T, II... >)
constexpr auto	sorted (std::integer_sequence< T, II... > seq, Compare comp)
constexpr auto	sorted (std::integer_sequence< T, II... > seq)
constexpr std::bool_constant<((II==value)||...)>	contains (std::integer_sequence< T, II... >, std::integral_constant< T, value >)
constexpr auto	difference (std::integer_sequence< T, II... > iSeq, std::integer_sequence< T, JJ... > jSeq)
constexpr auto	difference (std::integer_sequence< T, JJ... > jSeq)
constexpr std::is_same< std::integer_sequence< bool, true,(ST(II)==ST(JJ))... >, std::integer_sequence< bool,(ST(II)==ST(JJ))..., true > >	equal (std::integer_sequence< S, II... >, std::integer_sequence< T, JJ... >)
constexpr auto	filter (std::integer_sequence< T > jSeq)
constexpr auto	filter (std::integer_sequence< T, J0, JJ... > jSeq)
constexpr auto	filter (Filter, std::integer_sequence< T > jSeq)
constexpr auto	filter (Filter f, std::integer_sequence< T, J0, JJ... > jSeq)
EnableIfInterOperable< T1, T2, bool >::type	operator== (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator!= (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
std::enable_if< std::is_convertible< T2, T1 >::value, bool >::type	operator== (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator!= (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator== (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator!= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator< (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator<= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator> (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator>= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, D >::type	operator- (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
constexpr auto	operator== (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr bool	operator!= (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr auto	operator- (const IteratorFacade< T1, C, V1, R1, P1, D > &it1, const IteratorFacade< T2, C, V2, R2, P2, D > &it2)
constexpr bool	operator< (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr bool	operator<= (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr bool	operator> (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr bool	operator>= (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr bool	operator== (const MallocAllocator< T > &, const MallocAllocator< T > &)
constexpr bool	operator!= (const MallocAllocator< T > &, const MallocAllocator< T > &)
constexpr Base	power (Base m, Exponent p)
static constexpr T	factorial (const T &n) noexcept
static constexpr auto	factorial (std::integral_constant< T, n >) noexcept
static constexpr T	binomial (const T &n, const T &k) noexcept
static constexpr auto	binomial (std::integral_constant< T, n >, std::integral_constant< T, k >) noexcept
static constexpr auto	binomial (std::integral_constant< T, n >, std::integral_constant< T, n >) noexcept
K	conjugateComplex (const K &x)
int	sign (const T &val)
auto	overload (F &&... f)
auto	orderedOverload (F &&... f)
bool	operator== (const No_Comm &, const No_Comm &)
bool	operator!= (const No_Comm &, const No_Comm &)
std::ostream &	operator<< (std::ostream &os, const IndexPair< TG, TL > &pair)
bool	operator== (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator!= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator< (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator> (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator<= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator>= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator== (const IndexPair< TG, TL > &, const TG &)
bool	operator!= (const IndexPair< TG, TL > &, const TG &)
bool	operator< (const IndexPair< TG, TL > &, const TG &)
bool	operator> (const IndexPair< TG, TL > &, const TG &)
bool	operator<= (const IndexPair< TG, TL > &, const TG &)
bool	operator>= (const IndexPair< TG, TL > &, const TG &)
std::ostream &	operator<< (std::ostream &os, const ParallelIndexSet< TG, TL, N > &indexSet)
bool	operator< (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
bool	operator< (const std::pair< TG, TA > &i1, const IndexPair< TG, ParallelLocalIndex< TA > > &i2)
bool	operator== (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
bool	operator!= (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
bool	operator== (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)
bool	operator!= (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)
void	storeGlobalIndicesOfRemoteIndices (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, const RemoteIndices< T, A1 > &remoteIndices)
void	repairLocalIndexPointers (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, RemoteIndices< T, A1 > &remoteIndices, const T &indexSet)
std::ostream &	operator<< (std::ostream &os, const Interface &interface)
	ComposeMPIOp (std::plus, MPI_SUM)
	ComposeMPIOp (std::multiplies, MPI_PROD)
	ComposeMPIOp (Min, MPI_MIN)
	ComposeMPIOp (Max, MPI_MAX)
auto	getMPIData (T &t)
std::ostream &	operator<< (std::ostream &os, const ParallelLocalIndex< T > &index)
bool	operator== (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)
bool	operator!= (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)
std::ostream &	operator<< (std::ostream &os, const RemoteIndex< T1, T2 > &index)
std::ostream &	operator<< (std::ostream &os, const RemoteIndices< T, A > &indices)
std::ostream &	operator<< (std::ostream &os, const RemoteIndex< TG, TA > &index)
std::string	concatPaths (const std::string &base, const std::string &p)
std::string	processPath (const std::string &p)
bool	pathIndicatesDirectory (const std::string &p)
std::string	prettyPath (const std::string &p, bool isDirectory)
std::string	prettyPath (const std::string &p)
std::string	relativePath (const std::string &newbase, const std::string &p)
bool	operator== (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
bool	operator!= (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
bool	operator== (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)
bool	operator!= (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)
bool	operator== (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
bool	operator!= (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
bool	operator== (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)
bool	operator!= (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)
Reference	get (const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const Key &key)
void	put (const RAPropertyMapHelper< Reference, PropertyMap > &pmap, const Key &key, const Value &value)
pointer_or_proxy_holder	handle_proxy_member_access (T &&t)
T::value_type	max_value (const T &v)
T::value_type	min_value (const T &v)
bool	any_true (const T &v)
bool	any_true (const std::bitset< N > &b)
bool	all_true (const T &v)
bool	all_true (const std::bitset< N > &b)
static IntegralRange< std::decay_t< T > >	range (T &&from, U &&to) noexcept
static IntegralRange< std::decay_t< T > >	range (T &&to) noexcept
auto	transformedRangeView (R &&range, F &&f)
auto	iteratorTransformedRangeView (R &&range, F &&f)
auto	sparseRange (Range &&range)
constexpr T &	resolveRef (T &gf) noexcept
const auto &	resolveRef (T &&gf)=delete
constexpr T &	resolveRef (std::reference_wrapper< T > gf) noexcept
std::shared_ptr< T >	stackobject_to_shared_ptr (T &t)
auto	wrap_or_move (T &&t)
auto	wrap_or_move (T &t)
std::size_t	lanes (const T &)
T	lane (std::size_t l, const T &v)
T &	lane (std::size_t l, T &v)
void	assign (T &dst, const T &src, bool mask)
void	swap (T &v1, T &v2, bool mask)
	DUNE_SIMD_LOOP_BINARY_OP (+)
	DUNE_SIMD_LOOP_BINARY_OP (-)
DUNE_SIMD_LOOP_BINARY_OP *	DUNE_SIMD_LOOP_BINARY_OP (/);DUNE_SIMD_LOOP_BINARY_OP(%
DUNE_SIMD_LOOP_BINARY_OP &	DUNE_SIMD_LOOP_BINARY_OP (|);DUNE_SIMD_LOOP_BINARY_OP(^
	DUNE_SIMD_LOOP_BITSHIFT_OP (<<)
	DUNE_SIMD_LOOP_BITSHIFT_OP (> >)
	DUNE_SIMD_LOOP_COMPARISON_OP (<)
	DUNE_SIMD_LOOP_COMPARISON_OP (<=)
	DUNE_SIMD_LOOP_COMPARISON_OP (>=)
	DUNE_SIMD_LOOP_COMPARISON_OP (!=)
DUNE_SIMD_LOOP_BOOLEAN_OP &&	DUNE_SIMD_LOOP_BOOLEAN_OP (||);template< class T, std::size_t S, std::size_t A > std::ostream &operator<<(std::ostream &os, const LoopSIMD< T, S, A > &v
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (cos)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (sin)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (tan)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (acos)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (asin)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (atan)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (cosh)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (sinh)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (tanh)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (acosh)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (asinh)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (atanh)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (exp)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (log)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (log10)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (exp2)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (expm1)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN (ilogb, int)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (log1p)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (log2)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (logb)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (sqrt)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (cbrt)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (erf)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (erfc)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (tgamma)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (lgamma)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (ceil)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (floor)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (trunc)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (round)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN (lround, long)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN (llround, long long)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (rint)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN (lrint, long)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP_WITH_RETURN (llrint, long long)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (nearbyint)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (fabs)
	DUNE_SIMD_LOOP_CMATH_UNARY_OP (abs)
	DUNE_SIMD_LOOP_STD_UNARY_OP (real)
	DUNE_SIMD_LOOP_STD_UNARY_OP (imag)
	DUNE_SIMD_LOOP_STD_BINARY_OP (max)
	DUNE_SIMD_LOOP_STD_BINARY_OP (min)
std::ostream &	operator<< (std::ostream &os, const SLList< T, A > &sllist)
DVVerbType	dvverb (std::cout)
DVerbType	dverb (std::cout)
DInfoType	dinfo (std::cout)
DWarnType	dwarn (std::cerr)
DGraveType	dgrave (std::cerr)
DErrType	derr (std::cerr)
void	doAssertCallOnce (const char *file, int line, const char *function)
void	assertCallOnce (const char *file=nullptr, int line=-1, const char *function=nullptr)
Stream &	operator<< (Stream &stream, const std::tuple< Ts... > &t)
Stream &	operator>> (Stream &stream, std::tuple< Ts... > &t)
Stream &	operator<< (Stream &stream, const std::array< T, N > &a)
bool	hasPrefix (const C &c, const char *prefix)
bool	hasSuffix (const C &c, const char *suffix)
static std::string	formatString (const std::string &s, const T &... args)
auto	transpose (const Matrix &matrix)
auto	transpose (Matrix &&matrix)
auto	transpose (const std::reference_wrapper< Matrix > &matrix)
auto	transposedView (const Matrix &matrix)
decltype(auto)	applyPartial (F &&f, ArgTuple &&args, std::integer_sequence< I, i... >)
auto	genericTransformTuple (Tuple &&t, Functor &&f) -> decltype(genericTransformTupleBackend(t, f))
TransformTupleFunctor< TE, Args... >	makeTransformTupleFunctor (Args &&... args)
auto	transformTuple (Tuple &&orig, Args &&... args) -> decltype(genericTransformTuple(orig, makeTransformTupleFunctor< TypeEvaluator >(args...)))
constexpr auto	makeTupleVector (T &&... t)
constexpr auto	uniqueTypeList (TypeList< T... > list)
constexpr auto	integerSequenceEntry (std::integer_sequence< T, t... >, std::integral_constant< std::size_t, index > i)
constexpr AutonomousValue< T >	autoCopy (T &&v)
auto	dot (const A &a, const B &b) -> typename std::enable_if< IsNumber< A >::value &&!IsVector< A >::value &&!std::is_same< typename FieldTraits< A >::field_type, typename FieldTraits< A >::real_type > ::value, decltype(conj(a) *b)>::type
auto	dotT (const A &a, const B &b) -> decltype(a *b)
std::ostream &	operator<< (std::ostream &os, const EnumItem< TA, i > &)
std::ostream &	operator<< (std::ostream &os, const EnumRange< TA, from, to > &)
Combine< TI1, TI2, typename TI1::Type >	combine (const TI1 &set1, const TI2 &set2)
std::ostream &	operator<< (std::ostream &os, const Combine< TI1, TI2, T > &)
constexpr std::array< T, n >	filledArray (const T &t)
std::ostream &	operator<< (std::ostream &s, const Indent &indent)
decltype(auto) constexpr	unpackIntegerSequence (F &&f, std::integer_sequence< I, i... > sequence)
std::ostream &	operator<< (std::ostream &os, const SLList< T, A > &sllist)
Stream &	operator<< (Stream &stream, const std::tuple< Ts... > &t)
Stream &	operator>> (Stream &stream, std::tuple< Ts... > &t)
Stream &	operator<< (Stream &stream, const std::array< T, N > &a)
bool	operator== (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
bool	operator!= (const PoolAllocator< T1, t1 > &, const PoolAllocator< T2, t2 > &)
bool	operator== (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)
bool	operator!= (const PoolAllocator< T, t1 > &p1, const PoolAllocator< T, t2 > &p2)
bool	operator== (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
bool	operator!= (const PoolAllocator< void, t1 > &, const PoolAllocator< T, t2 > &)
bool	operator== (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)
bool	operator!= (const PoolAllocator< void, t1 > &p1, const PoolAllocator< void, t2 > &p2)
std::string	concatPaths (const std::string &base, const std::string &p)
std::string	processPath (const std::string &p)
bool	pathIndicatesDirectory (const std::string &p)
std::string	prettyPath (const std::string &p, bool isDirectory)
std::string	prettyPath (const std::string &p)
std::string	relativePath (const std::string &newbase, const std::string &p)
T::value_type	max_value (const T &v)
T::value_type	min_value (const T &v)
bool	any_true (const T &v)
bool	any_true (const std::bitset< N > &b)
bool	all_true (const T &v)
bool	all_true (const std::bitset< N > &b)
static IntegralRange< std::decay_t< T > >	range (T &&from, U &&to) noexcept
static IntegralRange< std::decay_t< T > >	range (T &&to) noexcept
static StaticIntegralRange< T, to >	range (std::integral_constant< T, to >) noexcept
auto	transformedRangeView (R &&range, F &&f)
auto	iteratorTransformedRangeView (R &&range, F &&f)
auto	sparseRange (Range &&range)
bool	hasPrefix (const C &c, const char *prefix)
bool	hasSuffix (const C &c, const char *suffix)
static std::string	formatString (const std::string &s, const T &... args)
decltype(auto)	applyPartial (F &&f, ArgTuple &&args, std::integer_sequence< I, i... >)
auto	genericTransformTuple (Tuple &&t, Functor &&f) -> decltype(genericTransformTupleBackend(t, f))
TransformTupleFunctor< TE, Args... >	makeTransformTupleFunctor (Args &&... args)
auto	transformTuple (Tuple &&orig, Args &&... args) -> decltype(genericTransformTuple(orig, makeTransformTupleFunctor< TypeEvaluator >(args...)))
auto	overload (F &&... f)
auto	orderedOverload (F &&... f)
pointer_or_proxy_holder	handle_proxy_member_access (T &&t)
constexpr T &	resolveRef (T &gf) noexcept
constexpr T &	resolveRef (std::reference_wrapper< T > gf) noexcept
constexpr auto	integerSequenceEntry (std::integer_sequence< T, t... >, std::integral_constant< std::size_t, index > i)
constexpr AutonomousValue< T >	autoCopy (T &&v)
constexpr auto	models ()
std::ostream &	operator<< (std::ostream &s, const bigunsignedint< k > &x)
bigunsignedint< k >	operator+ (const bigunsignedint< k > &x, std::uintmax_t y)
bigunsignedint< k >	operator- (const bigunsignedint< k > &x, std::uintmax_t y)
bigunsignedint< k >	operator* (const bigunsignedint< k > &x, std::uintmax_t y)
bigunsignedint< k >	operator/ (const bigunsignedint< k > &x, std::uintmax_t y)
bigunsignedint< k >	operator% (const bigunsignedint< k > &x, std::uintmax_t y)
bigunsignedint< k >	operator+ (std::uintmax_t x, const bigunsignedint< k > &y)
bigunsignedint< k >	operator- (std::uintmax_t x, const bigunsignedint< k > &y)
bigunsignedint< k >	operator* (std::uintmax_t x, const bigunsignedint< k > &y)
bigunsignedint< k >	operator/ (std::uintmax_t x, const bigunsignedint< k > &y)
bigunsignedint< k >	operator% (std::uintmax_t x, const bigunsignedint< k > &y)
std::ostream &	operator<< (std::ostream &s, const DenseMatrix< MAT > &a)
std::ostream &	operator<< (std::ostream &stream, const Exception &e)
EnableIfInterOperable< T1, T2, bool >::type	operator== (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator!= (const ForwardIteratorFacade< T1, V1, R1, D > &lhs, const ForwardIteratorFacade< T2, V2, R2, D > &rhs)
std::enable_if< std::is_convertible< T2, T1 >::value, bool >::type	operator== (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator!= (const BidirectionalIteratorFacade< T1, V1, R1, D > &lhs, const BidirectionalIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator== (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator!= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator< (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator<= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator> (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, bool >::type	operator>= (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
EnableIfInterOperable< T1, T2, D >::type	operator- (const RandomAccessIteratorFacade< T1, V1, R1, D > &lhs, const RandomAccessIteratorFacade< T2, V2, R2, D > &rhs)
constexpr auto	operator== (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr bool	operator!= (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr auto	operator- (const IteratorFacade< T1, C, V1, R1, P1, D > &it1, const IteratorFacade< T2, C, V2, R2, P2, D > &it2)
constexpr bool	operator< (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr bool	operator<= (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr bool	operator> (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
constexpr bool	operator>= (const IteratorFacade< T1, C, V1, R1, P1, D1 > &it1, const IteratorFacade< T2, C, V2, R2, P2, D2 > &it2)
std::ostream &	operator<< (std::ostream &os, const IndexPair< TG, TL > &pair)
bool	operator== (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator!= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator< (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator> (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator<= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator>= (const IndexPair< TG, TL > &, const IndexPair< TG, TL > &)
bool	operator== (const IndexPair< TG, TL > &, const TG &)
bool	operator!= (const IndexPair< TG, TL > &, const TG &)
bool	operator< (const IndexPair< TG, TL > &, const TG &)
bool	operator> (const IndexPair< TG, TL > &, const TG &)
bool	operator<= (const IndexPair< TG, TL > &, const TG &)
bool	operator>= (const IndexPair< TG, TL > &, const TG &)
std::ostream &	operator<< (std::ostream &os, const ParallelIndexSet< TG, TL, N > &indexSet)
bool	operator< (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
bool	operator< (const std::pair< TG, TA > &i1, const IndexPair< TG, ParallelLocalIndex< TA > > &i2)
bool	operator== (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
bool	operator!= (const IndexPair< TG, ParallelLocalIndex< TA > > &i1, const std::pair< TG, TA > &i2)
bool	operator== (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)
bool	operator!= (const std::pair< TG, TA > &i2, const IndexPair< TG, ParallelLocalIndex< TA > > &i1)
void	storeGlobalIndicesOfRemoteIndices (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, const RemoteIndices< T, A1 > &remoteIndices)
void	repairLocalIndexPointers (std::map< int, SLList< std::pair< typename T::GlobalIndex, typename T::LocalIndex::Attribute >, A > > &globalMap, RemoteIndices< T, A1 > &remoteIndices, const T &indexSet)
std::ostream &	operator<< (std::ostream &os, const ParallelLocalIndex< T > &index)
bool	operator== (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)
bool	operator!= (const ParallelLocalIndex< T > &p1, const ParallelLocalIndex< T > &p2)
std::ostream &	operator<< (std::ostream &os, const RemoteIndex< T1, T2 > &index)
std::ostream &	operator<< (std::ostream &os, const RemoteIndices< T, A > &indices)
std::ostream &	operator<< (std::ostream &os, const RemoteIndex< TG, TA > &index)
unspecified value type	referenceElement (T &&... t)
auto	referenceElement (const Dune::GeometryType &gt, Dune::Dim< dim >={})
auto	referenceElement (const T &, const Dune::GeometryType &gt, Dune::Dim< dim >)
RefinementIntervals	refinementIntervals (int intervals)
RefinementIntervals	refinementLevels (int levels)
template<int dim, int dimworld>
static void	checkAlbertaDimensions ()
template<int mydim, int cdim, class GridImp , template< int, int, class > class GeometryImp>
auto	referenceElement (const Geometry< mydim, cdim, GridImp, GeometryImp > &geo) -> decltype(referenceElement(geo, geo.impl()))
template<int dim, int dimworld, class ct , class GridFamily >
Grid< dim, dimworld, ct, GridFamily >::LevelGridView	levelGridView (const Grid< dim, dimworld, ct, GridFamily > &grid, int level)
	level grid view for the given grid and level.
template<int dim, int dimworld, class ct , class GridFamily >
Grid< dim, dimworld, ct, GridFamily >::LeafGridView	leafGridView (const Grid< dim, dimworld, ct, GridFamily > &grid)
	leaf grid view for the given grid
std::string	PartitionName (PartitionType type)
	Provide names for the partition types.
std::ostream &	operator<< (std::ostream &out, const PartitionType &type)
	write a PartitionType to a stream
std::ostream &	operator<< (std::ostream &out, const InterfaceType &type)
	write an InterfaceType to a stream
std::ostream &	operator<< (std::ostream &out, const PartitionIteratorType &type)
	write a PartitionIteratorType to a stream
template<class G >
void	gridinfo (const G &grid, std::string prefix="")
	A function to print some information about the grid as a whole.
template<class G >
void	gridlevellist (const G &grid, int level, std::string prefix)
	A function to print info about a grid level and its entities.
template<class G >
void	gridleaflist (const G &grid, std::string prefix)
	A function to print info about a leaf grid and its entities.
template<int dim>
MCMGLayout	mcmgLayout (Dim< dim >)
	layout for entities of dimension dim
MCMGLayout	mcmgElementLayout ()
	layout for elements (codim-0 entities)
MCMGLayout	mcmgVertexLayout ()
	layout for vertices (dim-0 entities)
template<typename GridType >
void	printGrid (const GridType &grid, const Dune::MPIHelper &helper, std::string output_file="printgrid", int size=2000, bool execute_plot=true, bool png=true, bool local_corner_indices=true, bool local_intersection_indices=true, bool outer_normals=true)
	Print a grid as a gnuplot for testing and development.
template<class GV >
void	fillGridViewInfoSerial (const GV &gv, GridViewInfo< typename GV::ctype > &gridViewInfo)
	fill a GridViewInfo structure from a serial grid
template<typename ctype , int dim>
	YaspGrid (FieldVector< ctype, dim >, std::array< int, std::size_t{dim}>, std::bitset< std::size_t{dim}>=std::bitset< std::size_t{dim}>{0ULL}, int=1, YaspCommunication=YaspCommunication(), const Yasp::Partitioning< dim > *=YaspGrid< dim, EquidistantCoordinates< ctype, dim > >::defaultPartitioner()) -> YaspGrid< dim, EquidistantCoordinates< ctype, dim > >
template<typename ctype , int dim>
	YaspGrid (FieldVector< ctype, dim >, FieldVector< ctype, dim >, std::array< int, std::size_t{dim}>, std::bitset< std::size_t{dim}>=std::bitset< std::size_t{dim}>{0ULL}, int=1, YaspCommunication=YaspCommunication(), const Yasp::Partitioning< dim > *=YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > >::defaultPartitioner()) -> YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > >
template<typename ctype , std::size_t dim>
	YaspGrid (std::array< std::vector< ctype >, dim >, std::bitset< dim >=std::bitset< dim >{0ULL}, int=1, YaspCommunication=YaspCommunication(), const Yasp::Partitioning< dim > *=YaspGrid< int{dim}, TensorProductCoordinates< ctype, int{dim}> >::defaultPartitioner()) -> YaspGrid< int
template<int d, class CC >
std::ostream &	operator<< (std::ostream &s, const YaspGrid< d, CC > &grid)
	Output operator for multigrids.
template<class ct , int dim>
std::ostream &	operator<< (std::ostream &s, EquidistantCoordinates< ct, dim > &c)
template<class ct , int dim>
std::ostream &	operator<< (std::ostream &s, EquidistantOffsetCoordinates< ct, dim > &c)
template<class ct , int dim>
std::ostream &	operator<< (std::ostream &s, TensorProductCoordinates< ct, dim > &c)
template<class Communication , int d>
std::ostream &	operator<< (std::ostream &s, const Torus< Communication, d > &t)
	Output operator for Torus.
template<class Coordinates >
std::ostream &	operator<< (std::ostream &s, YGridComponent< Coordinates > e)
	Output operator for ygrids.
template<class Coordinates >
std::ostream &	operator<< (std::ostream &s, typename YGridComponent< Coordinates >::Iterator &e)
	Output operator for ygrids.
template<class Coordinates >
std::ostream &	operator<< (std::ostream &s, const YGrid< Coordinates > &e)
	Output operator for ygrids.

Variables
	implementationDefined
	GROUND
	RESIZE
	VALID
	DELETED
static StaticIntegralRange< T, to >	range (std::integral_constant< T, to >) noexcept
static constexpr auto	debugAlignment
static StaticIntegralRange< T, to, from >	range (std::integral_constant< T, from >, std::integral_constant< T, to >) noexcept
constexpr bool	IsReferenceWrapper_v
static const DebugLevel	MINIMAL_DEBUG_LEVEL
static const DebugLevel	VERY_VERBOSE_DEBUG_LEVEL
DVVerbType	dvverb
static const DebugLevel	VERBOSE_DEBUG_LEVEL
DVerbType	dverb
static const DebugLevel	INFO_DEBUG_LEVEL
DInfoType	dinfo
static const DebugLevel	WARN_DEBUG_LEVEL
DWarnType	dwarn
static const DebugLevel	GRAVE_DEBUG_LEVEL
DGraveType	dgrave
DErrType	derr
static StaticIntegralRange< T, to, from >	range (std::integral_constant< T, from >, std::integral_constant< T, to >) noexcept
constexpr bool	IsReferenceWrapper_v
	GROUND
	RESIZE
	VALID
	DELETED
	GROUND
	RESIZE
static const DebugLevel	MINIMAL_DEBUG_LEVEL
static const DebugLevel	VERY_VERBOSE_DEBUG_LEVEL
DVVerbType	dvverb
static const DebugLevel	VERBOSE_DEBUG_LEVEL
DVerbType	dverb
static const DebugLevel	INFO_DEBUG_LEVEL
DInfoType	dinfo
static const DebugLevel	WARN_DEBUG_LEVEL
DWarnType	dwarn
static const DebugLevel	GRAVE_DEBUG_LEVEL
DGraveType	dgrave
DErrType	derr
template<int codim>
MCMGLayout	mcmgLayout (Codim< codim >)
	layout for entities of codimension codim
static const std::string	dgfid ("DGF")
const int	yaspgrid_dim_bits = 24
const int	yaspgrid_level_bits = 5
	TensorProductCoordinates< ctype, int{dim}>
const char	base64table []
	endoing table

Detailed Description

Include standard header files.

Todo:

put vtk io intro here ...

details and examples regarding the VTK file format can be found here:

http://www.earthmodels.org/software/vtk-and-paraview/vtk-file-formats

include base class functionality for the communication interface include parallel capability

Typedef Documentation

OneDGridGeometry

template<int mydim, int coorddim, class GridImp >

using Dune::OneDGridGeometry = typedef AxisAlignedCubeGeometry<double, mydim, coorddim>

The type used to for OneDGrid geometries.

If you ever want OneDGrid to use a different type for coordinates, you need to change the first argument of AxisAlignedCubeGeometry here.

UGCommunication

using Dune::UGCommunication = typedef Communication<No_Comm>

YaspCommunication

using Dune::YaspCommunication = typedef Communication<MPI_Comm>

Function Documentation

checkAlbertaDimensions()

template<int dim, int dimworld>

static void Dune::checkAlbertaDimensions ( )

static

fillGridViewInfoSerial()

template<class GV >

void Dune::fillGridViewInfoSerial	(	const GV &	gv,
		GridViewInfo< typename GV::ctype > &	gridViewInfo
	)

fill a GridViewInfo structure from a serial grid

If used on a parallel grid, it will gather information for entities of all partitions on each rank locally.

operator<<() [1/8]

template<class Communication , int d>

std::ostream & Dune::operator<< ( std::ostream &  s, const Torus< Communication, d > &  t  )

inline

Output operator for Torus.

operator<<() [2/8]

template<int d, class CC >

std::ostream & Dune::operator<<	(	std::ostream &	s,
		const YaspGrid< d, CC > &	grid
	)

Output operator for multigrids.

operator<<() [3/8]

template<class Coordinates >

std::ostream & Dune::operator<< ( std::ostream &  s, const YGrid< Coordinates > &  e  )

inline

Output operator for ygrids.

operator<<() [4/8]

template<class ct , int dim>

std::ostream & Dune::operator<< ( std::ostream &  s, EquidistantCoordinates< ct, dim > &  c  )

inline

operator<<() [5/8]

template<class ct , int dim>

std::ostream & Dune::operator<< ( std::ostream &  s, EquidistantOffsetCoordinates< ct, dim > &  c  )

inline

operator<<() [6/8]

template<class ct , int dim>

std::ostream & Dune::operator<< ( std::ostream &  s, TensorProductCoordinates< ct, dim > &  c  )

inline

operator<<() [7/8]

template<class Coordinates >

std::ostream & Dune::operator<< ( std::ostream &  s, typename YGridComponent< Coordinates >::Iterator &  e  )

inline

Output operator for ygrids.

operator<<() [8/8]

template<class Coordinates >

std::ostream & Dune::operator<< ( std::ostream &  s, YGridComponent< Coordinates >  e  )

inline

Output operator for ygrids.

printGrid()

template<typename GridType >

void Dune::printGrid	(	const GridType &	grid,
		const Dune::MPIHelper &	helper,
		std::string	output_file = "printgrid",
		int	size = 2000,
		bool	execute_plot = true,
		bool	png = true,
		bool	local_corner_indices = true,
		bool	local_intersection_indices = true,
		bool	outer_normals = true
	)

Print a grid as a gnuplot for testing and development.

Template Parameters

GridType

the type of grid to work with

Parameters

grid	the grid to print
helper	an MPIHelper to create unique output file names in parallel case
output_file	the base of the output filename
size	size of the plot in pixels; increase if plot is too cramped
execute_plot	whether to execute gnuplot automatically
png	whether to use PNG or SVG as the output format
local_corner_indices	whether to show local corner indices
local_intersection_indices	whether to show local intersection indices
outer_normals	whether to show outer normals of intersections Creates a gnuplot (one per process if parallel) showing the grid structure with indices, intersection types etc.

referenceElement()

template<int mydim, int cdim, class GridImp , template< int, int, class > class GeometryImp>

auto Dune::referenceElement

(

const Geometry< mydim, cdim, GridImp, GeometryImp > &

geo

)

-> decltype(referenceElement(geo,geo.impl()))

YaspGrid() [1/3]

template<typename ctype , int dim>

Dune::YaspGrid	(	FieldVector< ctype, dim >	,
		FieldVector< ctype, dim >	,
		std::array< int, std::size_t{dim}>	,
		std::bitset< std::size_t{dim}>	= std::bitset< std::size_t{dim}>{0ULL},
		int	= 1,
		YaspCommunication	= YaspCommunication(),
		const Yasp::Partitioning< dim > *	= YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > >::defaultPartitioner()
	)		-> YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > >

YaspGrid() [2/3]

template<typename ctype , int dim>

Dune::YaspGrid	(	FieldVector< ctype, dim >	,
		std::array< int, std::size_t{dim}>	,
		std::bitset< std::size_t{dim}>	= std::bitset< std::size_t{dim}>{0ULL},
		int	= 1,
		YaspCommunication	= YaspCommunication(),
		const Yasp::Partitioning< dim > *	= YaspGrid< dim, EquidistantCoordinates< ctype, dim > >::defaultPartitioner()
	)		-> YaspGrid< dim, EquidistantCoordinates< ctype, dim > >

YaspGrid() [3/3]

template<typename ctype , std::size_t dim>

Dune::YaspGrid	(	std::array< std::vector< ctype >, dim >	,
		std::bitset< dim >	= std::bitset<dim>{0ULL},
		int	= 1,
		YaspCommunication	= YaspCommunication(),
		const Yasp::Partitioning< dim > *	= YaspGrid<int{dim}, TensorProductCoordinates<ctype, int{dim}>>::defaultPartitioner()
	)		-> YaspGrid< int

Variable Documentation

base64table

const char Dune::base64table[]

Initial value:

=
  {
    'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M',
    'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z',
    'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm',
    'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z',
    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'
  }

endoing table

dgfid

const std::string Dune::dgfid("DGF") ( "DGF"  )

static

TensorProductCoordinates< ctype, int{dim}>

Dune::TensorProductCoordinates< ctype, int{dim}>

yaspgrid_dim_bits

const int Dune::yaspgrid_dim_bits = 24

yaspgrid_level_bits

const int Dune::yaspgrid_level_bits = 5