Namespace List

Here is a list of all documented namespaces with brief descriptions:

[detail level 1234]

►NDune	Dune namespace
►NCapabilities	Contains all capabilities classes
CcanCommunicate	Specialize with 'true' for all codims that a grid can communicate data on (default=false)
CcanCommunicate< IdentityGrid< HostGrid >, codim >	IdentityGrid can communicate when the host grid can communicate
CcanCommunicate< UGGrid< dim >, codim >	UGGrid can communicate on entities of all (existing) codimensions
CcanCommunicate< YaspGrid< dim, Coordinates >, codim >	YaspGrid can communicate on all codimensions
ChasBackupRestoreFacilities	Specialize with 'true' if implementation provides backup and restore facilities. (default=false)
ChasBackupRestoreFacilities< AlbertaGrid< dim, dimworld > >	AlbertaGrid has backup and restore facilities
ChasEntity	Specialize with 'true' for all codims that a grid implements entities for. (default=false)
ChasEntity< AlbertaGrid< dim, dimworld >, codim >	AlbertaGrid has entities for all codimensions
ChasEntity< IdentityGrid< HostGrid >, codim >	Has entities for some codimensions as host grid
ChasEntity< OneDGrid, cdim >	OneDGrid has entities for all codimension
ChasEntity< UGGrid< dim >, codim >	UGGrid has entities of all codimensions
ChasEntity< YaspGrid< dim, Coordinates >, codim >	YaspGrid has entities for all codimensions
ChasEntityIterator	Specialize with 'true' for all codims that a grid provides an iterator for (default=hasEntity<codim>::v)
ChasEntityIterator< AlbertaGrid< dim, dimworld >, codim >	AlbertaGrid can iterate over all codimensions
ChasEntityIterator< OneDGrid, codim >	OneDGrid can iterate over all codimensions
ChasEntityIterator< UGGrid< dim >, 0 >	UGGrid can iterate over codim=0 entities (elements)
ChasEntityIterator< UGGrid< dim >, codim >	Set default for hasEntityIterator to false UGGrid can currently only iterate over elements and vertices
ChasEntityIterator< UGGrid< dim >, dim >	UGGrid can iterate over codim=dim entities (vertices)
ChasEntityIterator< YaspGrid< dim, Coordinates >, codim >	YaspGrid can iterate over all codimensions
ChasGeometry	Specialize with 'false' for all codims that a grid does not implement geometries for. (default=true)
ChasSingleGeometryType	Specialize with 'true' for if the codimension 0 entity of the grid has only one possible geometry type. In this case the topologyId of this geometry type has also to be specified. (default=false, topologyId=undefined)
ChasSingleGeometryType< AlbertaGrid< dim, dimworld > >	AlbertaGrid has only one geometry type for codim 0 entities
ChasSingleGeometryType< OneDGrid >	OneDGrid has only one geometry type for codim 0 entities
ChasSingleGeometryType< YaspGrid< dim, Coordinates > >	YaspGrid has only one geometry type for codim 0 entities
CisCartesian	Specialize with 'true' if the grid is a Cartesian grid. Cartesian grids satisfy the following properties:
CisCartesian< YaspGrid< dim, Coordinates > >	YaspGrid is a Cartesian grid
CisLeafwiseConforming	Specialize with 'true' if implementation guarantees a conforming leaf grid. (default=false)
CisLeafwiseConforming< AlbertaGrid< dim, dimworld > >	AlbertaGrid is leafwise conforming
CisLeafwiseConforming< IdentityGrid< HostGrid > >	Has conforming leaf grids when host grid has
CisLeafwiseConforming< OneDGrid >	OneDGrid is leafwise conforming
CisLeafwiseConforming< UGGrid< dim > >	UGGrid may not be leafwise conforming
CisLeafwiseConforming< YaspGrid< dim, Coordinates > >	YaspGrid is leafwise conforming
CisLevelwiseConforming	Specialize with 'true' if implementation guarantees conforming level grids. (default=false)
CisLevelwiseConforming< AlbertaGrid< dim, dimworld > >	AlbertaGrid is not levelwise conforming (since it uses bisection)
CisLevelwiseConforming< IdentityGrid< HostGrid > >	Has conforming level grids when host grid has
CisLevelwiseConforming< OneDGrid >	OneDGrid is levelwise conforming
CisLevelwiseConforming< UGGrid< dim > >	UGGrid is levelwise conforming
CisLevelwiseConforming< YaspGrid< dim, Coordinates > >	YaspGrid is levelwise conforming
CthreadSafe	Specialize with 'true' if the grid implementation is thread safe. (default=false)
CviewThreadSafe	Specialize with 'true' if the grid implementation is thread safe, while it is not modified. (default=false)
►NConcept	Namespace for concepts
CRefines	Base class for refined concepts
►NFloatCmp
CDefaultEpsilon	Mapping from a value type and a compare style to a default epsilon
CEpsilonType	Mapping of value type to epsilon type
CEpsilonType< FieldVector< T, n > >	Specialization of EpsilonType for Dune::FieldVector
CEpsilonType< std::vector< T, A > >	Specialization of EpsilonType for std::vector
►NGeoGrid	Namespace containing the implementations of GeometryGrid
CEntity	DUNE-conform implementation of the entity
CEntityBase	Actual implementation of the entity
CEntityBase< codim, Grid, false >	actual implementation of the entity
CEntityBase< codim, Grid, true >	actual implementation of the entity
NGeometryTypes	Predefined GeometryTypes for common geometries
NIndices	Namespace with predefined compile time indices for the range [0,19]
►NMathOverloads	Namespace for customization of math functions with Dune-Semantics
CADLTag	Tag to make sure the functions in this namespace can be found by ADL
NPartitions	Predefined PartitionSets for commonly used combinations of parallel grid PartitionTypes
NQuadratureType	Defines an enum for currently available quadrature rules
►NRefinementImp	This namespace contains the implementation of Refinement
►NHCube	This namespace contains the Refinement implementation for hypercubes (GeometryType::cube)
CRefinementImp	Refinement implementation for hypercubes
CRefinementSubEntityIteratorSpecial	SubEntityIterator base class for hypercube refinement
NHCubeTriangulation	This namespace contains the Refinement implementation for triangulating hypercubes (GeometryType::cube -> GeometryType::simplex)
►NPrismTriangulation	This namespace contains the Refinement implementation for triangulating prisms (GeometryType::prism -> GeometryType::simplex)
CRefinementImp	Implementation of the refinement of a prism into simplices
►NPyramidTriangulation	This namespace contains the Refinement implementation for triangulating pyramids (GeometryType::pyramid -> GeometryType::simplex)
CRefinementImp	Implementation of the refinement of a pyramid into simplices
NSimplex	This namespace contains the Refinement implementation for simplices (triangles, tetrahedrons...)
CTraits	Mapping from geometryType, CoordType and coerceTo to a particular Refinement implementation
►NSimd	Namespace for vectorization interface functions used by library developers
►NOverloads	Namespace for the overloads and specializations that make up a SIMD implementation
CADLTag	Tag used to force late-binding lookup in Dune::Simd::Overloads
CLaneCount	Should be derived from a Dune::index_constant
CLaneCount< V, std::enable_if_t< VcImpl::IsVector< V >::value > >	Should be derived from an Dune::index_constant
CRebindType	Should have a member type type
CRebindType< bool, V, std::enable_if_t< VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value > >	Should have a member type type
CRebindType< S, M, std::enable_if_t< VcImpl::IsMask< M >::value &&VcImpl::IsVectorizable< S >::value &&!std::is_same< S, Scalar< typename M::Vector > >::value > >	Should have a member type type
CRebindType< S, V, std::enable_if_t< VcImpl::IsVector< V >::value &&!VcImpl::IsMask< V >::value &&VcImpl::IsVectorizable< S >::value &&!std::is_same< S, Scalar< V > >::value > >	Should have a member type type
CRebindType< S, V, std::enable_if_t< VcImpl::IsVector< V >::value &&!VcImpl::IsVectorizable< S >::value &&!std::is_same< S, bool >::value &&!std::is_same< S, Scalar< V > >::value > >	Should have a member type type
CRebindType< Scalar< typename M::Vector >, M, std::enable_if_t< VcImpl::IsMask< M >::value > >	Should have a member type type
CRebindType< Simd::Scalar< V >, V, std::enable_if_t< VcImpl::IsVector< V >::value > >	Should have a member type type
CScalarType	Should have a member type type
CScalarType< V, std::enable_if_t< VcImpl::IsVector< V >::value > >	Should have a member type type
CEndMark	Final element marker for RebindList
►NStd	Namespace for features backported from new C++ standards
Cconjunction	Forms the logical conjunction of the type traits B..
Cdisjunction	Forms the logical disjunction of the type traits B..
Cidentity	A function object type whose operator() returns its argument unchanged
Cis_callable	Traits class to check if function is callable
Cis_callable< F(Args...), R >	Traits class to check if function is callable
Cis_invocable	Traits class to check if function is invocable
Cis_invocable_r	Traits class to check if function is invocable and the return type is compatible
Cnegation	Forms the logical negation of the type traits B..
Cnonesuch	Type representing a lookup failure by std::detected_or and friends
Cto_false_type	Template mapping a type to std::false_type
Cto_true_type	Template mapping a type to std::true_type
CAdaptDataHandleInterface	Interface class for the Grid's adapt method where the parameter is a AdaptDataHandleInterface
CAdderSelector	Template meta program for choosing how to add the correction
CAdditiveSchwarzMode	Tag that the tells the Schwarz method to be additive
CAddPtrTypeEvaluator	TypeEvaluator to turn a type T into a pointer to T
CAddRefTypeEvaluator	TypeEvaluator to turn a type T into a reference to T
CAffineGeometry	Implementation of the Geometry interface for affine geometries
CAlbertaGrid	[ provides Dune::Grid ]
CAlbertaGridEntity
CAlbertaGridEntity< 0, dim, Grid >
CAlbertaGridGeometry	Geometry implementation for AlbertaGrid
CAlbertaGridHierarchicIterator
CAlbertaGridIdSet	Hierarchic index set of AlbertaGrid
CAlbertaGridTreeIterator
CAlbertaMarkerVector	Marker assigning subentities to one element containing them
CAlignedAllocator	Allocators which guarantee alignment of the memory
CAlignedBase	CRTP base mixin class to check alignment
CAllSet	A set containing everything
CAlwaysFalse	Template which always yields a false value
CAlwaysTrue	Template which always yields a true value
CAmiraMeshWriter	Provides file writing facilities in the AmiraMesh format
CAnalyticalCoordFunction	Derive an implementation of an analytical coordinate function from this class
CAnalyticalCoordFunctionInterface	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
CArPackPlusPlus_Algorithms	Wrapper to use a range of ARPACK++ eigenvalue solvers
CArrayList	A dynamically growing random access list
CArrayListIterator	A random access iterator for the Dune::ArrayList class
CAssembledLinearOperator	A linear operator exporting itself in matrix form
CAssociativePropertyMap	An adapter to turn an unique associative container into a property map
CAt	Reverse element access
CAtType	Type for reverse element access
CAutonomousValueType	Type free of internal references that T can be converted to
CAutonomousValueType< const T >	Specialization to remove const qualifiers
CAutonomousValueType< Simd::VcImpl::Proxy< V > >	Specialization of AutonomousValue for Vc proxies
CAutonomousValueType< std::vector< bool >::reference >	Specialization for the proxies of vector<bool>
CAutonomousValueType< T & >	Specialization to remove lvalue references
CAutonomousValueType< T && >	Specialization to remove rvalue references
CAutonomousValueType< volatile const T >	Specialization to remove both const and volatile qualifiers
CAutonomousValueType< volatile T >	Specialization to remove volatile qualifiers
CAxisAlignedCubeGeometry	A geometry implementation for axis-aligned hypercubes
Cb64chunk	Struct representing the three byte text as well as the four 6 bit chunks
CBackupRestoreFacility	Facility for writing and reading grids
CBackupRestoreFacility< const Grid >	BackupRestoreFacility taking const Grid as type and deriving from the version with the const
CBackupRestoreFacility< Dune::YaspGrid< dim, Coordinates > >	facility for writing and reading grids
CBackupRestoreFacility< YaspGrid< dim, TensorProductCoordinates< ctype, dim > > >	facility for writing and reading grids
CBase64Stream	Class to base64 encode a stream of data
►CBasisInterface	Interface for global-valued shape functions
CTraits	Types of domain and range
CBasisInterfaceSwitch	Switch for uniform treatment of local and global basis classes
►CBCRSMatrix	A sparse block matrix with compressed row storage
CCreateIterator	Iterator class for sequential creation of blocks
CDeallocator	Class used by shared_ptr to deallocate memory using the proper allocator
CRealRowIterator	Iterator access to matrix rows
CBCRSMatrixError	Error specific to BCRSMatrix
CBDFMCubeLocalBasis	Brezzi-Douglas-Fortin-Marini shape functions on a reference cube
CBDFMCubeLocalBasis< D, R, 2, 1 >	First order Brezzi-Douglas-Fortin-Marini shape functions on the refrence quadrialteral
CBDFMCubeLocalBasis< D, R, 2, 2 >	Second order Brezzi-Douglas-Fortin-Marini shape functions on the refrence quadrialteral
CBDFMCubeLocalBasis< D, R, 2, 3 >	Third order Brezzi-Douglas-Fortin-Marini shape functions on the refrence quadrialteral
CBDFMCubeLocalCoefficients	Layout map for Brezzi-Douglas-Fortin-Marini elements on cubes
CBDFMCubeLocalFiniteElement	Brezzi-Douglas-Fortin-Marini finite elements for cubes
CBDFMCubeLocalInterpolation	Interpolation for Brezzi-Douglas-Fortin-Marini shape functions on cubes
CBDM1Cube2DLocalBasis	First order Brezzi-Douglas-Marini shape functions on the reference quadrilateral
CBDM1Cube2DLocalCoefficients	Layout map for Brezzi-Douglas-Marini-1 elements on quadrilaterals
CBDM1Cube2DLocalFiniteElement	First order Brezzi-Douglas-Marini shape functions on quadrilaterals
CBDM1Cube2DLocalInterpolation	First order Brezzi-Douglas-Marini shape functions on the reference quadrilateral
CBDM1Cube3DLocalBasis	First order Brezzi-Douglas-Marini shape functions on the reference hexahedron
CBDM1Cube3DLocalCoefficients	Layout map for Brezzi-Douglas-Marini-1 elements on hexahedra
CBDM1Cube3DLocalFiniteElement	First order Brezzi-Douglas-Marini shape functions on hexahedron
CBDM1Cube3DLocalInterpolation	First order Brezzi-Douglas-Marini shape functions on the reference hexahedron
CBDM1Simplex2DLocalBasis	First order Brezzi-Douglas-Marini shape functions on the reference triangle
CBDM1Simplex2DLocalCoefficients	Layout map for Brezzi-Douglas-Marini-1 elements on triangles
CBDM1Simplex2DLocalFiniteElement	First order Brezzi-Douglas-Marini shape functions on triangles
CBDM1Simplex2DLocalInterpolation	First order Brezzi-Douglas-Marini shape functions on the reference triangle
CBDM2Cube2DLocalBasis	First order Brezzi-Douglas-Marini shape functions on quadrilaterals
CBDM2Cube2DLocalCoefficients	Layout map for Brezzi-Douglas-Marini-2 elements on quadrilaterals
CBDM2Cube2DLocalFiniteElement	Second order Brezzi-Douglas-Marini shape functions on quadrilaterals
CBDM2Cube2DLocalInterpolation	First order Brezzi-Douglas-Marini shape functions on quadrilaterals
CBDM2Simplex2DLocalBasis	First order Brezzi-Douglas-Marini shape functions on quadrilaterals
CBDM2Simplex2DLocalCoefficients	Layout map for Brezzi-Douglas-Marini-2 elements on triangles
CBDM2Simplex2DLocalFiniteElement	Second order Brezzi-Douglas-Marini shape functions on triangles
CBDM2Simplex2DLocalInterpolation	First order Brezzi-Douglas-Marini shape functions on triangles
CBDMatrix	A block-diagonal matrix
CBiCGSTABSolver	Bi-conjugate Gradient Stabilized (BiCG-STAB)
CBidirectionalIteratorFacade	Facade class for stl conformant bidirectional iterators
Cbigunsignedint	Portable very large unsigned integers
CBitSetVector	A dynamic array of blocks of booleans
CBitSetVectorConstReference	A proxy class that acts as a const reference to a single bitset in a BitSetVector
CBitSetVectorReference	A proxy class that acts as a mutable reference to a single bitset in a BitSetVector
CBL	Compile-time parameter for block recursion depth
CBlockPreconditioner	Block parallel preconditioner
CBlockVector	A vector of blocks with memory management
CBoundarySegment	Base class for classes implementing geometries of boundary segments
CBoundarySegmentWrapper
CBrezziDouglasMariniCubeLocalFiniteElement	Brezzi-Douglas-Marini local finite element for cubes
CBrezziDouglasMariniCubeLocalFiniteElement< D, R, 2, 1 >	Brezzi-Douglas-Marini local finite elements for cubes with dimension 2 and order 1
CBrezziDouglasMariniCubeLocalFiniteElement< D, R, 2, 2 >	Brezzi-Douglas-Marini local finite elements for cubes with dimension 2 and order 2
CBrezziDouglasMariniCubeLocalFiniteElement< D, R, 3, 1 >	Brezzi-Douglas-Marini local finite elements for cubes with dimension 3 and order 1
CBrezziDouglasMariniSimplexLocalFiniteElement	Brezzi-Douglas-Marini local finite element for simplices
CBrezziDouglasMariniSimplexLocalFiniteElement< D, R, 2, 1 >	Brezzi-Douglas-Marini local finite elements for simplices with dimension 2 and order 1
CBrezziDouglasMariniSimplexLocalFiniteElement< D, R, 2, 2 >	Brezzi-Douglas-Marini local finite elements for simplices with dimension 2 and order 2
CBTDMatrix	A block-tridiagonal matrix
CBufferedCommunicator	A communicator that uses buffers to gather and scatter the data to be send or received
CCachedMultiLinearGeometry	Implement a MultiLinearGeometry with additional caching
CCGSolver	Conjugate gradient method
CCheckIfDiagonalPresent	Check whether the a matrix has diagonal values on blocklevel recursion levels
CCloneable	An interface class for cloneable objects
CCodim	Static tag representing a codimension
CCoefficientsInterface	Interface for global-valued coefficients
CColCompMatrix	A sparse matrix in compressed-column format
►CCollectiveIterator	A collective iterator for moving over the remote indices for all processes collectively
Citerator	Iterator over the valid underlying iterators
CCombine	A set combining two other sets
CCombinedAdaptProlongRestrict	Class for combining 2 index sets together for adaptation process
CCommDataHandleIF	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 interprete data handle objects as its interface. Therefore usable data handle classes need to be derived from this class
CCommMatrixRow	Utility class for comunicating the matrix entries
CCommMatrixRowSize	Utility class to communicate and set the row sizes of a redistributed matrix
CCommMatrixSparsityPattern	Utility class to communicate and build the sparsity pattern of a redistributed matrix
Ccommon_bits	Activate if current and mask have common bits switched on
►CCommPolicy	Default policy used for communicating an indexed type
CCommunicationError	Error thrown if there was a problem with the communication
CCopyGatherScatter	GatherScatter default implementation that just copies data
CCommunication	Collective communication interface and sequential default implementation
CCommunication< MPI_Comm >	Specialization of Communication for MPI
CCompleteFCGSolver	Complete flexible conjugate gradient method
CCompressionStatistics	Statistics about compression achieved in implicit mode
Cconst_reference	Get the 'const' version of a reference to a mutable object
Cconst_reference< BitSetVectorReference< block_size, Alloc > >
CConstArrayListIterator	A constant random access iterator for the Dune::ArrayList class
CConstAssociativePropertyMap	An adaptor to turn an unique associative container into a property map
CContainerWrapperIterator	Iterator class for sparse vector-like containers
CCrouzeixRaviartLocalFiniteElement	Crouzeix-Raviart finite element
CDebugStream	Generic class to implement debug output streams
CDebugStreamError	Standard exception for the debugstream
CDebugStreamState	Intermediate class to implement tie-operation of DebugStream
CDenseIterator	Generic iterator class for dense vector and matrix implementations
CDenseMatrix	A dense n x m matrix
CDenseMatrixAssigner	You have to specialize this structure for any type that should be assignable to a DenseMatrix
CDenseVector	Interface for a class of dense vectors over a given field
CDGFBoundaryParameter	Contains types for additional features
CDGFException	Exception class for IO errors in the DGF parser
CDGFGridFactory< YaspGrid< dim, EquidistantCoordinates< ctype, dim > > >	Grid factory for YaspGrid with equidistant coordinates
CDGFGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > > >	Grid factory for YaspGrid with equidistant coordinates
CDGFGridInfo	Some simple static information for a given GridType
CDGFWriter	Write a GridView to a DGF file
CDGLocalCoefficients	A class providing local coefficients for dg spaces
CDGLocalCoefficientsFactory	A factory class for the dg local coefficients
CDGLocalFiniteElement	Takes the basis and interpolation factory from a given LocalFiniteElement (derived from GenericLocalFiniteElement) and replaces the coefficients with dg local keys, i.e., attaches all degrees of freedom to the codimension zero entity
CDiagonalMatrix	A diagonal matrix of static size
CDim	Static tag representing a dimension
CDimSpecificPQkLocalFiniteElementFactory	Factory that only creates dimension specific local finite elements
CDimSpecificPQkLocalFiniteElementFactory< D, R, 3, k >	Factory that only creates dimension specific local finite elements
CDiscreteCoordFunction	Derive an implementation of a discrete coordinate function from this class
CDiscreteCoordFunctionInterface	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
CDualP1LocalBasis	Dual Lagrange shape functions on the simplex
CDualP1LocalCoefficients	Local coefficients for dual simplex P1 elements
CDualP1LocalFiniteElement	The local dual p1 finite element on simplices
CDualQ1LocalBasis	Dual Lagrange shape functions of order 1 on the reference cube
CDualQ1LocalCoefficients	Layout map for dual Q1 elements
CDualQ1LocalFiniteElement	The local dual Q1 finite element on cubes
CDualQ1LocalInterpolation
CDuneBoundaryProjection	Interface class for vertex projection at the boundary
CDuneGridFormatParser	The DuneGridFormatParser class: reads a DGF file and stores build information in vector structures used by the MacroGrid class
CDynamicMatrix	Construct a matrix with a dynamic size
CDynamicMatrixSubdomainSolver	Exact subdomain solver using Dune::DynamicMatrix<T>::solve
CDynamicVector	Construct a vector with a dynamic size
►CEdgeS0_5Basis	Basis for order 0.5 (lowest order) edge elements on simplices
CTraits	Export type traits for function signature
CEdgeS0_5Coefficients	Coefficients for lowest order edge elements on simplices
CEdgeS0_5Common	Common base class for edge elements
CEdgeS0_5FiniteElement	FiniteElement for lowest order edge elements on simplices
CEdgeS0_5FiniteElementFactory	Factory for EdgeS0_5FiniteElement objects
CEdgeS0_5Interpolation	Interpolation for lowest order edge elements on simplices
CEmpty	Just an empty class
CEmptySet	An empty set
CEnableIfInterOperable	Enable typedef if two types are interoperable
CEntity	Wrapper class for entities
►CEntity< 0, dim, GridImp, EntityImp >	Template specialization of Dune::Entity for Elements (codim==0)
CCodim	Entity types of the different codimensions
CEntityDefaultImplementation	Default Implementations for EntityImp
CEntityDefaultImplementation< 0, dim, GridImp, EntityImp >	Default Implementations for EntityImp (Elements [cd=0])
CEntityInfo	Structure to hold statistical information about one type of entity
CEntityIterator	Interface class for an iterator over grid entities
CEntitySeed	Store a reference to an entity with a minimal memory footprint
CEnumItem	A set consisting only of one item
CEnumRange	A set representing a range including the borders
CEquidistantCoordinates	Container for equidistant coordinates in a YaspGrid
CEquidistantOffsetCoordinates	Container for equidistant coordinates in a YaspGrid with non-trivial origin
CException	Base class for Dune-Exceptions
CExceptionHook	Base class to add a hook to the Dune::Exception
CFactorial	Calculates the factorial of m at compile time
CFactorial< 0 >	End of recursion of factorial via specialization
CFakeMPIHelper	A fake mpi helper
CFieldMatrix	A dense n x m matrix
CFieldVector	Vector space out of a tensor product of fields
CFiniteElementFactoryInterface	Factory interface for global-valued finite elements
►CFiniteElementInterface	Interface for global-valued finite elements
CTraits	Types of component objects
CFiniteElementInterfaceSwitch	Switch for uniform treatment of finite element with either the local or the global interface
CFirstPredicateIndex	Finding the index of a certain type in a std::tuple
CFirstTypeIndex	Find the first occurrence of a type in a std::tuple
CFlattenTuple	Flatten a std::tuple of std::tuple's
CFloatCmpOps	Class encapsulating a default epsilon
CFMatrixError	Error thrown if operations of a FieldMatrix fail
CFMatrixPrecision	Precisions for calculations with FieldMatrix and FieldVector
CForEachType	Helper template to clone the type definition of a std::tuple with the storage types replaced by a user-defined rule
CForwardIteratorFacade	Base class for stl conformant forward iterators
►CFunction	Base class template for function classes
CTraits	Traits class containing raw types
CFuture	Type-erasure for future-like objects. A future-like object is a object satisfying the interface of FutureBase
CGcd	Calculator of the greatest common divisor
CGeneralizedPCGSolver	Generalized preconditioned conjugate gradient solver
►CGeneralVertexOrder	Class providing information on the ordering of vertices
Citerator	Iterate over the vertex indices of some sub-entity
CGenericIterator	Generic class for stl-conforming iterators for container classes with operator[]
CGenericLocalFiniteElement	A LocalFiniteElement implementation based on three TopologyFactories providing the LocalBasis, LocalCoefficients, and LocalInterpolations. Note the key type for all three factories must coincide
CGeometry	Wrapper class for geometries
CGeometryDefaultImplementation	Default implementation for class Geometry
►CGeometryGrid	Grid wrapper replacing the geometries
CCodim	Traits structure containing types for a codimension
CGeometryType	Unique label for each type of entities that can occur in DUNE grids
CGlobalGeometryTypeIndex	Compute indices for geometry types, taking the dimension into account
►CGlobalIndexSet	Calculate globally unique index over all processes in a Dune grid
CSubPartitionTypeProvider	Helper class to provide access to subentity PartitionTypes with a run-time codimension
CGlobalLookupIndexSet	Decorates an index set with the possibility to find a global index that is mapped to a specific local
CGMPField	Number class for high precision floating point number using the GMP library mpf_class implementation
CGmshReader	Read Gmsh mesh file
CGmshReaderOptions	Options for read operation
CGmshReaderParser	Dimension independent parts for GmshReaderParser
CGmshWriter	Write Gmsh mesh file
CGnuplotWriter	Writer for 1D grids in gnuplot format
CGradientSolver	Gradient method
Cgreater_or_equal	Greater or equal template test
►CGrid	Grid abstract base class
►CCodim	A Traits struct that collects all associated types of one implementation
CPartition	A struct collecting all types depending on the partition iterator type
CGridDefaultImplementation
CGridError	Base class for exceptions in Dune grid modules
CGridFactory	Provide a generic factory class for unstructured grids
CGridFactory< AlbertaGrid< dim, dimworld > >	Specialization of the generic GridFactory for AlbertaGrid
CGridFactory< UGGrid< dimworld > >	Specialization of the generic GridFactory for UGGrid
CGridFactoryInterface	Provide a generic factory class for unstructured grids
CGridPtr	Class for constructing grids from DGF files
►CGridTraits	A traits struct that collects all associated types of one grid model
►CCodim	Traits associated with a specific codim
CPartition	Traits associated with a specific grid partition type
►CGridView	Grid view abstract base class
►CCodim	A struct that collects all associated types of one implementation from the Traits class
CPartition	Define types needed to iterate over entities of a given partition type
CGridViewInfo	Structure to hold information about a certain GridView
CGridViewInfoGTCompare	Comparison object to sort GeometryType by majorly dimension
Chash	Functor for hashing objects of type T
CHasNaN	Whether this type has a value of NaN
CHelpRequest	Exception thrown if the user wants to see help string
CHierarchicalP2LocalFiniteElement
CHierarchicalP2WithElementBubbleLocalFiniteElement
CHierarchicalPrismP2LocalFiniteElement
CHierarchicalPrismP2LocalInterpolation
CHierarchicalSimplexP2LocalBasis< D, R, 1 >	Hierarchical P2 basis in 1d
CHierarchicalSimplexP2LocalBasis< D, R, 2 >	Hierarchical P2 basis in 2d
CHierarchicalSimplexP2LocalBasis< D, R, 3 >	Hierarchical P2 basis in 3d
CHierarchicalSimplexP2LocalInterpolation
CHierarchicalSimplexP2WithElementBubbleLocalBasis< D, R, 1 >	Hierarchical P2 basis in 1d
CHierarchicalSimplexP2WithElementBubbleLocalBasis< D, R, 2 >	Hierarchical P2 basis in 1d
CHierarchicalSimplexP2WithElementBubbleLocalBasis< D, R, 3 >	Hierarchical P2 basis in 1d
CHierarchicalSimplexP2WithElementBubbleLocalCoefficients	The local finite element needed for the Zou-Kornhuber estimator for Signorini problems
CHierarchicSearch	Search an IndexSet for an Entity containing a given point
CHostGridAccess	Access to host grid objects from GeometryGrid
CIdentityGrid	Provides a meta grid that is identical to its host
CIdentityGridEntity	The implementation of entities in a IdentityGrid
CIdentityGridEntity< 0, dim, GridImp >	Specialization for codim-0-entities
CIdentityGridEntitySeed	The EntitySeed class provides the minimal information needed to restore an Entity using the grid
CIdentityGridHierarchicIterator	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
CIdentityGridLeafIntersection	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!
CIdentityGridLeafIntersectionIterator	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!
CIdentityGridLeafIterator	Iterator over all entities of a given codimension and level of a grid
CIdentityGridLevelIndexSet
CIdentityGridLevelIntersection
CIdentityGridLevelIntersectionIterator
CIdentityGridLevelIterator	Iterator over all entities of a given codimension and level of a grid
CIdentityMap	A property map that applies the identity function to integers
►CIdSet	Id Set Interface
CCodim	Export the type of the entity used as parameter in the id(...) method
CILU0SubdomainSolver	Exact subdomain solver using ILU(p) with appropriate p
CILUSubdomainSolver	Base class encapsulating common algorithms of ILU0SubdomainSolver and ILUNSubdomainSolver
CImplementationDefined	Dummy struct used for documentation purposes
►CImplicitMatrixBuilder	A wrapper for uniform access to the BCRSMatrix during and after the build stage in implicit build mode
Crow_object	Proxy row object for entry access
CImplicitModeCompressionBufferExhausted	Thrown when the compression buffer used by the implicit BCRSMatrix construction is exhausted
CIndent	Utility class for handling nested indentation in output
CIndexInfoFromGrid	Information about the index distribution
CIndexPair	A pair consisting of a global and local index
►CIndexSet	Index Set Interface base class
CCodim	Export the type of the entity used as parameter in the index(...) method
CIndexSetDefaultImplementation	Provide default implementation of method if IndexSet
CIndexStack
CIndicesSyncer	Class for recomputing missing indices of a distributed index set
CIntegerSequenceEntry	Get entry of std::integer_sequence
CIntegralRange	Dynamic integer range for use in range-based for loops
CInterface	Communication interface between remote and local indices
CInterfaceBuilder	Base class of all classes representing a communication interface
CInterfaceInformation	Information describing an interface
CInterpolationInterface	Interface for global-valued interpolation
CIntersection	Intersection of a mesh entity of codimension 0 ("element") with a "neighboring" element or with the domain boundary
CIntersectionDefaultNormalVectors	Default Implementations of integrationOuterNormal and unitOuterNormal for IntersectionImp
CIntersectionIterator	Mesh entities of codimension 0 ("elements") allow to visit all intersections with "neighboring" elements and with the domain boundary
CInvalidFutureException	This exception is thrown when ready(), wait() or get() is called on an invalid future. A future is valid until get() is called and if it is not default-constructed and it was not moved from
CInvalidIndexSetState	Exception indicating that the index set is not in the expected state
CInvalidStateException	Default exception if a function was called while the object is not in a valid state for that function
CInverseOperator	Abstract base class for all solvers
CInverseOperator2Preconditioner	Turns an InverseOperator into a Preconditioner
CInverseOperatorResult	Statistics about the application of an inverse operator
CIOError	Default exception class for I/O errors
Cios_base_all_saver	Utility class for storing and resetting stream attributes
CIsCallable	Check if a type is callable with ()-operator and given arguments
CIsCallable< F(Args...), R >	Check if a type is callable with ()-operator and given arguments
CIsEmptyTypeList	Check if given type is an empty TypeList
CIsFieldVectorSizeCorrect	TMP to check the size of a DenseVectors statically, if possible
CIsIndexable	Type trait to determine whether an instance of T has an operator[](I), i.e. whether it can be indexed with an index of type I
CIsIntegralConstant	Check if T is an std::integral_constant<I, i>
CIsInteroperable	Checks whether two types are interoperable
CIsIterable	Typetrait to check that a class has begin() and end() members
CIsMatrix	Test whether a type is an ISTL Matrix
CIsNumber	Whether this type acts as a scalar in the context of (hierarchically blocked) containers
CISTLError	Derive error class from the base class in common
CIsTuple	Check if T is a std::tuple<...>
CIsTupleOrDerived	Check if T derived from a std::tuple<...>
►CIsType	Generator for predicates accepting one particular type
CPredicate	The actual predicate
CIsTypeList	Check if given type is a TypeList
CIsTypeList< TypeList< T... > >	Check if given type is a TypeList.
►CIterativeSolver	Base class for all implementations of iterative solvers
CIteration	Class for controlling iterative methods
CIteratorDirectionSelector	Helper template meta program for application of overlapping Schwarz
CIteratorPropertyMap	Adapter to turn a random access iterator into a property map
CIteratorRange	Simple range between a begin and an end iterator
CIteratorTransformationTag	Tag to enable iterator based transformations in TransformedRangeView
CJoinTuples	Join two std::tuple's
CL2LocalFiniteElement	Takes the basis factory from a given LocalFiniteElement (derived from GenericLocalFiniteElement) and replaces the coefficients with dg local keys, i.e., attaches all degrees of freedom to the codimension zero entity and uses a l2 interpolation
CLagrangeCubeLocalFiniteElement	Lagrange finite element for cubes with arbitrary compile-time dimension and polynomial order
CLagrangeLocalFiniteElement	Lagrange local finite elements for a given set of interpolation points
CLagrangePrismLocalFiniteElement	Lagrange finite element for 3d prisms with arbitrary compile-time polynomial order
CLagrangePyramidLocalFiniteElement	Lagrange finite element for 3d pyramids with compile-time polynomial order
CLagrangeSimplexLocalFiniteElement	Lagrange finite element for simplices with arbitrary compile-time dimension and polynomial order
CLcm	Calculate the least common multiple of two numbers
CLDL	Use the LDL package to directly solve linear systems – empty default class
CLDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >	The LDL direct sparse solver for matrices of type BCRSMatrix
CLeafAmiraMeshWriter	Provides file writing facilities in the AmiraMesh format for leaf grids
CLeafGnuplotWriter	GnuplotWriter on the leaf grid
CLeafMultipleCodimMultipleGeomTypeMapper	Multiple codim and multiple geometry type mapper for leaf entities
CLeafSingleCodimSingleGeomTypeMapper	Single codim and single geometry type mapper for leaf entities
CLevelAmiraMeshWriter	Provides file writing facilities in the AmiraMesh format for level grids
CLevelGnuplotWriter	GnuplotWriter on a given level grid
CLevelMultipleCodimMultipleGeomTypeMapper	Multiple codim and multiple geometry type mapper for entities of one level
CLevelSingleCodimSingleGeomTypeMapper	Single codim and single geometry type mapper for entities of one level
CLinearOperator	A linear operator
CLocalBasisTraits	Type traits for LocalBasisVirtualInterface
CLocalBasisVirtualImp	Class for wrapping a basis using the virtual interface
CLocalBasisVirtualInterface	Virtual base class for a local basis
CLocalCoefficientsVirtualImp	Class for wrapping local coefficients using the virtual interface
CLocalCoefficientsVirtualInterface	Virtual base class for local coefficients
CLocalFiniteElementFunctionBase	Return a proper base class for functions to use with LocalInterpolation
CLocalFiniteElementTraits	Traits helper struct
CLocalFiniteElementVariant	Type erasure class for wrapping LocalFiniteElement classes
CLocalFiniteElementVariantCache	A cache storing a compile time selection of local finite element implementations
CLocalFiniteElementVirtualImp	Class for wrapping a finite element using the virtual interface
CLocalFiniteElementVirtualInterface	Virtual base class for local finite elements with functions
CLocalGeometryTypeIndex	Compute per-dimension indices for geometry types
CLocalIndex	An index present on the local process
CLocalInterpolationVirtualImp	Class for wrapping a local interpolation using the virtual interface
CLocalInterpolationVirtualInterface	Virtual base class for a local interpolation
CLocalInterpolationVirtualInterfaceBase	Virtual base class for a local interpolation
CLocalKey	Describe position of one degree of freedom
CLocalL2Interpolation	A local L2 interpolation taking a test basis and a quadrature rule
CLocalL2InterpolationFactory	A factory class for the local l2 interpolations taking a basis factory
CLocalToGlobalBasisAdaptorTraits	Traits class for local-to-global basis adaptors
CLocalToGlobalInterpolationAdaptor	Convert a local interpolation into a global interpolation
CLoopSIMD
CLoopSolver	Preconditioned loop solver
Clru	LRU Cache Container
CLvaluePropertyMapTag	Tag for the category of lvalue property maps
CMakeableInterfaceObject
CMallocAllocator	Allocators implementation which simply calls malloc/free
CMapper	Mapper interface
CMathematicalConstants	Provides commonly used mathematical constants
CMathError	Default exception class for mathematical errors
CMatMultMatResult	Helper TMP to get the result type of a sparse matrix matrix multiplication ( $C=A*B$)
CMatrix	A generic dynamic dense matrix
CMatrixAdapter	Adapter to turn a matrix into a linear operator
CMatrixBlockError	Error when performing an operation on a matrix block
CMatrixIndexSet	Stores the nonzero entries in a sparse matrix
CMessageBufferIF	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
CMetaType	A type that refers to another type
CMimeticLocalCoefficients	!
CMimeticLocalFiniteElement
CMINRESSolver	Minimal Residual Method (MINRES)
CMonomialFiniteElementFactory	Factory for global-valued MonomFiniteElement objects
CMonomialLocalBasis	Constant shape function
CMonomialLocalCoefficients	Layout map for monomial finite elements
CMonomialLocalFiniteElement	Monomial basis for discontinuous Galerkin methods
CMPIFuture	Provides a future-like object for MPI communication. It contains the object that will be received and might contain also a sending object, which must be hold (keep alive) until the communication has been completed
CMPIGuard	Detects a thrown exception and communicates to all other processes
CMPIGuardError	This exception is thrown if the MPIGuard detects an error on a remote process
CMPIHelper	A real mpi helper
CMPITraits	A traits class describing the mapping of types onto MPI_Datatypes
CMPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >
CMPITraits< ParallelLocalIndex< T > >
CMultiLinearGeometry	Generic geometry implementation based on corner coordinates
►CMultiLinearGeometryTraits	Default traits class for MultiLinearGeometry
CCornerStorage	Template specifying the storage for the corners
ChasSingleGeometryType	Will there be only one geometry type for a dimension?
CMultipleCodimMultipleGeomTypeMapper	Implementation class for a multiple codim and multiple geometry type mapper
CMultiplicativeSchwarzMode	Tag that tells the Schwarz method to be multiplicative
CMultiTypeBlockMatrix	A Matrix class to support different block types
CMultiTypeBlockMatrix_Solver	Solver for MultiTypeBlockVector & MultiTypeBlockMatrix types
CMultiTypeBlockMatrix_Solver_Col	Part of solvers for MultiTypeBlockVector & MultiTypeBlockMatrix types
CMultiTypeBlockVector	A Vector class to support different block types
Cmutable_reference	Get the 'mutable' version of a reference to a const object
CNedelec1stKindCubeLocalFiniteElement	Nédélec elements of the first kind for cube elements
CNedelec1stKindSimplexLocalFiniteElement	Nédélec elements of the first kind for simplex elements
CNedelecL2Interpolation	An L2-based interpolation for Nedelec
CNegateSet	The negation of a set. An item is contained in the set if and only if it is not contained in the negated set
CNonoverlappingBlockPreconditioner	Nonoverlapping parallel preconditioner
CNonoverlappingSchwarzOperator	A nonoverlapping operator with communication object
CNonoverlappingSchwarzScalarProduct	Nonoverlapping Scalar Product with communication object
CNotImplemented	Default exception for dummy implementations
Cnull_deleter	Implements the Deleter concept of shared_ptr without deleting anything
CNullPointerInitialiser	A helper template that initializes a std::tuple consisting of pointers to nullptr
COneDGrid	One-dimensional adaptive grid
COrthonormalLocalFiniteElement	A class providing orthonormal basis functions
COutOfMemoryError	Default exception if memory allocation fails
COverlappingSchwarzInitializer	Initializer for SuperLU Matrices representing the subdomains
COverlappingSchwarzOperator	An overlapping Schwarz operator
COverlappingSchwarzScalarProduct	Scalar product for overlapping Schwarz methods
COwnerOverlapCopyAttributeSet	Attribute set for overlapping Schwarz
►COwnerOverlapCopyCommunication	A class setting up standard communication for a two-valued attribute set with owner/overlap/copy semantics
CCopyGatherScatter	Gather/scatter callback for communcation
CP0LocalBasis	Constant shape function
CP0LocalCoefficients	Layout map for P0 elements
CP0LocalFiniteElement	The local p0 finite element on all types of reference elements
CP0VTKFunction	Take a vector and interpret it as cell data for the VTKWriter
CP1VTKFunction	Take a vector and interpret it as point data for the VTKWriter
CParallelError	Default exception if an error in the parallel communication of the program occurred
►CParallelIndexSet	Manager class for the mapping between local indices and globally unique indices
Citerator	The iterator over the pairs
CParallelLocalIndex	An index present on the local process with an additional attribute flag
CParallelScalarProduct	Scalar product for overlapping Schwarz methods
CParameterizedObjectFactory	A factory class for parameterized objects
CParameterTree	Hierarchical structure of string parameters
CParameterTreeParser	Parsers to set up a ParameterTree from various input sources
CParameterTreeParserError	Report parser error while reading ParameterTree
CParSSOR	A parallel SSOR preconditioner
CPartitionSet	A set of PartitionType values
CPersistentContainer	A class for storing data during an adaptation cycle
CPersistentContainer< const Grid, T >	Refer PersistentContainer<const Grid> to the implementation of the mutable grid
CPersistentContainer< YaspGrid< dim, CoordCont >, T >	Specialization of the PersistentContainer for YaspGrid
CPersistentContainerInterface	Persistent storage of data on all entities of a grid
CPersistentContainerMap	Map-based implementation of the PersistentContainer
CPersistentContainerVector	Vector-based implementation of the PersistentContainer
CPk1DFiniteElement	Langrange finite element of arbitrary order on triangles
CPk1DFiniteElementFactory	Factory for Pk1DFiniteElement objects
CPk1dLocalFiniteElement	Define the Pk Lagrange basis functions in 1d on the reference interval
CPk2DFiniteElement	Langrange finite element of arbitrary order on triangles
CPk2DFiniteElementFactory	Factory for Pk2DFiniteElement objects
CPointerPairDeletor	Deletes all objects pointed to in a std::tuple of pointers
CPolynomialBasis
CPolynomialBasisWithMatrix
CPool	A memory pool of objects
►CPoolAllocator	An allocator managing a pool of objects for reuse
Crebind	Rebind the allocator to another type
CPower	Compute power for a run-time mantissa and a compile-time integer exponent
►CPowerBasis	Meta-basis turning a scalar basis into vector-valued basis
CTraits	Types of domain and range
CPowerCoefficients	Meta-coefficients turning a scalar coefficients into vector-valued coefficients
►CPowerFiniteElement	Meta-finite element turning a scalar finite element into vector-valued one
CTraits	Types of component objects
CPowerFiniteElementFactory	Factory for meta-finite elements turning scalar finite elements into vector-valued ones
CPowerInterpolation	Meta-interpolation turning a scalar interpolation into vector-valued interpolation
CPowerIteration_Algorithms	Iterative eigenvalue algorithms based on power iteration
CPQkLocalFiniteElementCache	A cache that stores all available Pk/Qk like local finite elements for the given dimension and order
CPQkLocalFiniteElementFactory	Factory to create any kind of Pk/Qk like element wrapped for the virtual interface
CPreconditioner	Base class for matrix free definition of preconditioners
CPriorityTag	Helper class for tagging priorities
CPriorityTag< 0 >	Helper class for tagging priorities
CPromotionTraits	Compute type of the result of an arithmetic operation involving two different number types
CPropertyMapTypeSelector	Selector for the property map type
CPseudoFuture	A wrapper-class for a object which is ready immediately
CPushBackTuple	Helper template to append a type to a std::tuple
CPushFrontTuple	Helper template to prepend a type to a std::tuple
CQ1FiniteElementFactory	Factory for global-valued Q1 elements
CQ2FiniteElementFactory	Factory for global-valued Q23D elements
CQkDGFiniteElementFactory	Factory for global-valued QkDG elements
CQkDGGLFiniteElementFactory	Factory for global-valued QkDG elements
CQkDGGLLocalFiniteElement
CQkDGLagrangeLocalFiniteElement
CQkDGLegendreFiniteElementFactory	Factory for global-valued DGLegendre elements
CQkDGLegendreLocalFiniteElement
CQuadratureOrderOutOfRange	Exception thrown if a desired QuadratureRule is not available, because the requested order is to high
CQuadraturePoint	Single evaluation point in a quadrature rule
CQuadratureRule	Abstract base class for quadrature rules
CQuadratureRuleFactory	Factory class for creation of quadrature rules, depending on GeometryType, order and QuadratureType
CQuadratureRules	A container for all quadrature rules of dimension dim
CRandomAccessIteratorFacade	Base class for stl conformant forward iterators
CRangeError	Default exception class for range errors
CRannacherTurekLocalBasis	Rannacher-Turek shape functions
CRannacherTurekLocalCoefficients	Layout for Rannacher-Turek elements
CRannacherTurekLocalFiniteElement	Rannacher-Turek shape functions
CRannacherTurekLocalInterpolation	Please doc me
CRaviartThomasCubeLocalFiniteElement	Raviart-Thomas local finite elements for cubes
CRaviartThomasCubeLocalFiniteElement< D, R, 2, 0 >	Raviart-Thomas local finite elements for cubes with dimension 2 and order 0
CRaviartThomasCubeLocalFiniteElement< D, R, 2, 1 >	Raviart-Thomas local finite elements for cubes with dimension 2 and order 1
CRaviartThomasCubeLocalFiniteElement< D, R, 2, 2 >	Raviart-Thomas local finite elements for cubes with dimension 2 and order 2
CRaviartThomasCubeLocalFiniteElement< D, R, 2, 3 >	Raviart-Thomas local finite elements for cubes with dimension 2 and order 3
CRaviartThomasCubeLocalFiniteElement< D, R, 2, 4 >	Raviart-Thomas local finite elements for cubes with dimension 2 and order 4
CRaviartThomasCubeLocalFiniteElement< D, R, 3, 0 >	Raviart-Thomas local finite elements for cubes with dimension 3 and order 0
CRaviartThomasCubeLocalFiniteElement< D, R, 3, 1 >	Raviart-Thomas local finite elements for cubes with dimension 3 and order 1
CRaviartThomasL2Interpolation	An L2-based interpolation for Raviart Thomas
CRaviartThomasSimplexLocalFiniteElement	Raviart-Thomas local finite elements of arbitrary order for simplices of arbitrary dimension
CRawStream	Write out data in binary
CReadablePropertyMapTag	Tag for the category of readable property maps
CReadWritePropertyMapTag	Tag for the category of readable and writable property maps
CReduceTuple	Apply reduce with meta binary function to template
CReduceTuple< F, Tuple, Seed, 0 >	Apply reduce with meta binary function to template
CRefinedP0LocalBasis	Uniformly refined constant shape functions on a unit simplex in R^dim
CRefinedP0LocalCoefficients	Layout map for RefinedP0 elements
CRefinedP0LocalFiniteElement	Local finite element that is piecewise P0 on a once uniformly refined reference geometry
CRefinedP0LocalFiniteElement< D, R, 1 >	Local finite element that is piecewise P0 on a once uniformly refined reference geometry
CRefinedP0LocalFiniteElement< D, R, 2 >	Local finite element that is piecewise P0 on a once uniformly refined reference geometry
CRefinedP0LocalFiniteElement< D, R, 3 >	Local finite element that is piecewise P0 on a once uniformly refined reference geometry
CRefinedP1LocalBasis< D, R, 1 >	Uniformly refined linear Lagrange shape functions in 1D
CRefinedP1LocalBasis< D, R, 2 >	Uniformly refined linear Lagrange shape functions on the triangle
CRefinedP1LocalBasis< D, R, 3 >	Uniformly refined linear Lagrange shape functions on the 3D-simplex (tetrahedron)
CRefinedP1LocalFiniteElement	Piecewise linear continuous Lagrange functions on a uniformly refined simplex element
CRefinedSimplexLocalBasis< D, 1 >	Base class for LocalBasis classes based on uniform refinement in 1D; provides numbering and local coordinates of subelements
CRefinedSimplexLocalBasis< D, 2 >	Base class for LocalBasis classes based on uniform refinement in 2D; provides numbering and local coordinates of subelements
CRefinedSimplexLocalBasis< D, 3 >	Base class for LocalBasis classes based on uniform refinement in 3D; provides numbering and local coordinates of subelements
CRefinementIntervals	Holds the number of refined intervals per axis needed for virtual and static refinement
CRemoteIndex	Information about an index residing on another processor
CRemoteIndexListModifier	Modifier for adding and/or deleting remote indices from the remote index list
CRemoteIndices	The indices present on remote processes
CReservedVector	A Vector class with statically reserved memory
CRestartedFCGSolver	Accelerated flexible conjugate gradient method
CRestartedFlexibleGMResSolver	Implements the Flexible Generalized Minimal Residual (FGMRes) method (right preconditioned)
CRestartedGMResSolver	Implements the Generalized Minimal Residual (GMRes) method
CRichardson	Richardson preconditioner
CRT02DLocalBasis	Lowest order Raviart-Thomas shape functions on the reference triangle
CRT02DLocalCoefficients	Layout map for RT0 elements
CRT02DLocalFiniteElement	Zero order Raviart-Thomas shape functions on triangles
CRT03DLocalBasis	Lowest order Raviart-Thomas shape functions on the reference tetrahedron
CRT03DLocalCoefficients	Layout map for RT0 elements
CRT03DLocalFiniteElement	Zero order Raviart-Thomas shape functions on tetrahedra
CRT0Cube2DLocalBasis	Lowest order Raviart-Thomas shape functions on the reference quadrilateral
CRT0Cube2DLocalCoefficients	Layout map for RT0 elements on quadrilaterals
CRT0Cube2DLocalFiniteElement	Zero order Raviart-Thomas shape functions on rectangles
CRT0Cube2DLocalInterpolation	Lowest order Raviart-Thomas shape functions on the reference quadrilateral
CRT0Cube3DLocalBasis	Lowest order Raviart-Thomas shape functions on the reference hexahedron
CRT0Cube3DLocalCoefficients	Layout map for RT0 elements on quadrilaterals
CRT0Cube3DLocalFiniteElement	Zero order Raviart-Thomas shape functions on cubes
CRT0Cube3DLocalInterpolation	Lowest order Raviart-Thomas shape functions on the reference hexahedron
CRT12DLocalBasis	First order Raviart-Thomas shape functions on the reference triangle
CRT12DLocalCoefficients	Layout map for Raviart-Thomas-1 elements on the reference triangle
CRT12DLocalFiniteElement	First order Raviart-Thomas shape functions on triangles
CRT12DLocalInterpolation	First order Raviart-Thomas shape functions on the reference quadrilateral
CRT1Cube2DLocalBasis	First order Raviart-Thomas shape functions on the reference quadrilateral
CRT1Cube2DLocalCoefficients	Layout map for Raviart-Thomas-1 elements on quadrilaterals
CRT1Cube2DLocalFiniteElement	First order Raviart-Thomas shape functions on quadrilaterals
CRT1Cube2DLocalInterpolation	First order Raviart-Thomas shape functions on the reference quadrilateral
CRT1Cube3DLocalBasis	First order Raviart-Thomas shape functions on the reference hexahedron
CRT1Cube3DLocalCoefficients	Layout map for Raviart-Thomas-1 elements on quadrilaterals
CRT1Cube3DLocalFiniteElement	First order Raviart-Thomas shape functions on cubes
CRT1Cube3DLocalInterpolation	First order Raviart-Thomas shape functions on the reference hexahedron
CRT2Cube2DLocalBasis	Second order Raviart-Thomas shape functions on the reference quadrilateral
CRT2Cube2DLocalCoefficients	Layout map for Raviart-Thomas-2 elements on quadrilaterals
CRT2Cube2DLocalFiniteElement	Second order Raviart-Thomas shape functions on cubes
CRT2Cube2DLocalInterpolation	Second order Raviart-Thomas shape functions on the reference triangle
CRT3Cube2DLocalBasis	Second order Raviart-Thomas shape functions on the reference quadrilateral
CRT3Cube2DLocalCoefficients	Layout map for Raviart-Thomas-3 elements on quadrilaterals
CRT3Cube2DLocalFiniteElement	Second order Raviart-Thomas shape functions on cubes
CRT3Cube2DLocalInterpolation	Second order Raviart-Thomas shape functions on the reference quadrilateral
CRT4Cube2DLocalBasis	Second order Raviart-Thomas shape functions on the reference quadrilateral
CRT4Cube2DLocalCoefficients	Layout map for Raviart-Thomas-4 elements on quadrilaterals
CRT4Cube2DLocalFiniteElement	Second order Raviart-Thomas shape functions on cubes
CRT4Cube2DLocalInterpolation	Second order Raviart-Thomas shape functions on the reference triangle
CScalarLocalToGlobalBasisAdaptor	Convert a simple scalar local basis into a global basis
CScalarLocalToGlobalFiniteElementAdaptor	Convert a simple scalar local finite element into a global finite element
CScalarLocalToGlobalFiniteElementAdaptorFactory	Factory for ScalarLocalToGlobalFiniteElementAdaptor objects
CScalarProduct	Base class for scalar product and norm computation
CScaledIdentityMatrix	A multiple of the identity matrix of static size
CSelection	A cached selection of indices
CSelectionIterator	A const iterator over an uncached selection
CSeqILDL	Sequential ILDL preconditioner
CSeqILU	Sequential ILU preconditioner
CSeqJac	The sequential jacobian preconditioner
CSeqOverlappingSchwarz	Sequential overlapping Schwarz preconditioner
CSeqOverlappingSchwarzApplier	Helper template meta program for application of overlapping Schwarz
CSeqOverlappingSchwarzDomainSize
CSeqScalarProduct	Default implementation for the scalar case
CSeqSOR	Sequential SOR preconditioner
CSeqSSOR	Sequential SSOR preconditioner
CSimdScalarTypeTraits< AlignedNumber< T, align > >	Deduce the underlying scalar data type of an AlignedNumber
CSingleCodimSingleGeomTypeMapper	Implementation class for a single codim and single geometry type mapper
CSingleton	An adapter to turn a class into a singleton
CSizeCache	Organizes the caching of sizes for one grid and one GeometryType
CSizeOf	Compute size of variadic type list
CSizeOne	Flag for marking indexed data structures where data at each index is of the same size
CSLList	A single linked list
CSLListConstIterator	A constant iterator for the SLList
CSLListIterator	A mutable iterator for the SLList
CSLListModifyIterator	A mutable iterator for the SLList
CSolverAbort	Thrown when a solver aborts due to some problem
CSolverCategory	Categories for the solvers
CSolverFactory	Factory to assembly solvers configured by a ParameterTree
►CSolverHelper	Helper class for notifying a DUNE-ISTL linear solver about a change of the iteration matrix object in a unified way, i.e. independent from the solver's type (direct/iterative)
CImplementation	Implementation that works together with iterative ISTL solvers, e.g. Dune::CGSolver or Dune::BiCGSTABSolver
CImplementation< true, Dummy >	Implementation that works together with direct ISTL solvers, e.g. Dune::SuperLU or Dune::UMFPack
CSPQR	Use the SPQR package to directly solve linear systems – empty default class
CSPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >	The SPQR direct sparse solver for matrices of type BCRSMatrix
CStandardMathematicalConstants	Standard implementation of MathematicalConstants
CStarCDReader	File reader for the Star-CD format
CStaticIntegralRange	Static integer range for use in range-based for loops
CStaticPower	Calculates m^p at compile time
►CStaticRefinement	Wrap each Refinement implementation to get a consistent interface
CCodim	The Codim struct inherited from the Refinement implementation
CStructuredGridFactory	Construct structured cube and simplex grids in unstructured grid managers
CStructuredGridFactory< AlbertaGrid< dim, dimworld > >	Specialization of the generic StructuredGridFactory for AlbertaGrid
CStructuredGridFactory< YaspGrid< dim, EquidistantCoordinates< ctype, dim > > >	Specialization of the StructuredGridFactory for YaspGrid
CStructuredGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > > >	Specialization of the StructuredGridFactory for YaspGrid<EquidistantOffsetCoordinates>
CSubsamplingVTKWriter	Writer for the output of subsampled grid functions in the vtk format
CSuperLU	SuperLu Solver
CSuperLUMatrix	Utility class for converting an ISTL Matrix into a SuperLU Matrix
CSuperLUMatrix< BCRSMatrix< B, TA > >	Converter for BCRSMatrix to SuperLU Matrix
CSymmetricMultiplicativeSchwarzMode	Tag that tells the Schwarz method to be multiplicative and symmetric
CSystemError	Default exception class for OS errors
CTensorGridFactory	A factory class for conveniently creating tensorproduct grids
CTensorProductCoordinates	Coordinate container for a tensor product YaspGrid
CTimer	A simple stop watch
CTopologyFactory	Provide a factory over the generic topologies
CTopologySingletonFactory	A wrapper for a TopologyFactory providing singleton storage. Same usage as TopologyFactory but with empty release method an internal storage
►CTorus
CProcListIterator
CTransformedRangeView	A range transforming the values of another range on-the-fly
CTransformTupleFunctor
CTransposedMatMultMatResult	Helper TMP to get the result type of a sparse matrix matrix multiplication ( $C=A*B$)
CTupleVector	A class augmenting std::tuple by element access via operator[]
CTypeListElement< i, TypeList< T... > >	Get element of TypeList
CTypeListSize< TypeList< T... > >	Get size of TypeList
CUGGrid	Front-end for the grid manager of the finite element toolbox UG3
CUMFPack	The UMFPack direct sparse solver
CUncachedSelection	An uncached selection of indices
CUnity	A class representing the unit of a given Field
CValueTransformationTag	Tag to enable value based transformations in TransformedRangeView
►CVariableBlockVector	A Vector of blocks with different blocksizes
CCreateIterator	Iterator class for sequential creation of blocks
CRealIterator	Iterator class for sequential access
CVariableSize	Flag for marking indexed data structures where the data at each index may be a variable multiple of another type
CVariableSizeCommunicator	A buffered communicator where the amount of data sent does not have to be known a priori
►CVertexOrderByIdFactory	Factory for GeneralVertexOrder objects using an IdSet
CVertexOrder	Type of vertex order object may depend on the dimension of the element
CVirtualFunction	Virtual base class template for function classes
►CVirtualRefinement	VirtualRefinement base class
CCodim	Codim database of VirtualRefinement
CVTKFunction	A base class for grid functions with any return type and dimension
CVTKSequenceWriter	Writer for the ouput of grid functions in the vtk format
CVTKSequenceWriterBase	Base class to write pvd-files which contains a list of all collected vtk-files
►CVTKWriter	Writer for the ouput of grid functions in the vtk format
CCellIterator	Iterator over the grids elements
CCornerIterator	Iterate over the elements' corners
CVertexIterator	Iterate over the grid's vertices
►CVTKLocalFunction	Type erasure wrapper for VTK data sets
CFunctionWrapper	Type erasure implementation for functions conforming to the dune-functions LocalFunction interface
CFunctionWrapperBase	Base class for polymorphic container of underlying data set
CGlobalFunctionWrapper	Type erasure implementation for C++ functions, i.e., functions that can be evaluated in global coordinates
CVTKFunctionWrapper	Type erasure implementation for legacy VTKFunctions
CWritablePropertyMapTag	Tag for the category of writable property maps
CYaspEntitySeed	Describes the minimal information necessary to create a fully functional YaspEntity
CYaspFixedSizePartitioner	Implement partitioner that gets a fixed partitioning from an array If the given partitioning doesn't match the number of processors, the grid should be distributed to, an exception is thrown
CYaspGeometry	The general version that handles all codimensions but 0 and dim
CYaspGeometry< 0, cdim, GridImp >	Specialization for dim=0, this is a vertex
CYaspGeometry< mydim, mydim, GridImp >	Specialize for dim=dimworld, i.e. a volume element
CYaspGlobalIdSet	Persistent, globally unique Ids
CYaspGrid	[ provides Dune::Grid ]
CYaspHierarchicIterator	YaspHierarchicIterator enables iteration over son entities of codim 0
CYaspIndexSet	Implementation of Level- and LeafIndexSets for YaspGrid
CYaspIntersection	YaspIntersection provides data about intersection with neighboring codim 0 entities
CYaspIntersectionIterator	YaspIntersectionIterator enables iteration over intersections with neighboring codim 0 entities
CYaspLevelIterator	Iterates over entities of one grid level
CYaspPersistentContainerIndex	Implement a consecutive index for all entities of given codim of a YaspGrid
►CYGrid	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)
CIterator	Iterator over a collection o YGrids A YGrid::Iterator is the heart of an entity in YaspGrid
►CYGridComponent
CIterator
►CYGridList	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
CIntersection	Type describing an intersection with a neighboring processor
CYLoadBalance	Base class for the yaspgrid partitioning strategy The name might be irritating. It will probably change to YaspPartitionerBase in a 3.0 release
CYLoadBalanceDefault	Implement the default load balance strategy of yaspgrid
CYLoadBalancePowerD	Implement yaspgrid load balance strategy for P=x^{dim} processors
CZero	A class representing the zero of a given Field
►Nstd	STL namespace
Ccommon_type< Dune::FieldVector< T, N >, Dune::FieldVector< R2, N > >	Specialization of common_type for two FieldVectors
Ccommon_type< Dune::FieldVector< T, N >, R2 >	Specialization of common_type for FieldVector and scalar