Class List

Here are the classes, structs, unions and interfaces with brief descriptions:

[detail level 1234]

►NALUGridSpace
CGatherScatterBaseImpl	Corresponding interface class is defined in bsinclude.hh
CGatherScatterBaseImpl< GridType, DataCollectorType, 0 >	Corresponding interface class is defined in bsinclude.hh
CGatherScatterLoadBalance	Corresponding interface class is defined in bsinclude.hh
►NDune	Dune namespace
►NAmg
CAggregate	A class for temporarily storing the vertices of an aggregate in
►CAggregatesMap	Class providing information about the mapping of the vertices onto aggregates
CDummyEdgeVisitor	A Dummy visitor that does nothing for each visited edge
CAggregatesPublisher< T, O, OwnerOverlapCopyCommunication< T1, T2 > >	Utility class for publishing the aggregate number of the DOFs in the overlap to other processors and convert them to local indices
CAggregationCriterion	Base class of all aggregation criterions
CAggregationLevelTransferPolicy	A LeveTransferPolicy that used aggregation to construct the coarse level system
CAggregationParameters	Parameters needed for the aggregation process,
CAggregator	Class for building the aggregates
CAMG	Parallel algebraic multigrid based on agglomeration
CCoarsenCriterion	The criterion describing the stop criteria for the coarsening process
CCoarseningParameters	Parameters for the complete coarsening process
CConstructionTraits	Traits class for generically constructing non default constructable types
CConstructionTraits< ParSSOR< M, X, Y, C > >	Policy for the construction of the ParSSOR smoother
CConstructionTraits< SeqILU0< M, X, Y > >	Policy for the construction of the SeqILUn smoother
CConstructionTraits< SeqILUn< M, X, Y > >	Policy for the construction of the SeqJac smoother
CConstructionTraits< SeqJac< M, X, Y, l > >	Policy for the construction of the SeqJac smoother
CConstructionTraits< SeqSOR< M, X, Y, l > >	Policy for the construction of the SeqSOR smoother
CConstructionTraits< SeqSSOR< M, X, Y, l > >	Policy for the construction of the SeqSSOR smoother
CDefaultConstructionArgs	Construction Arguments for the default smoothers
CDefaultSmootherArgs	The default class for the smoother arguments
CDependency	Dependency policy for symmetric matrices
CDependencyParameters	Parameters needed to check whether a node depends on another
CDiagonal	Norm that uses only the [N][N] entry of the block to determine couplings
CEdgeProperties	Class representing the properties of an ede in the matrix graph
CFastAMG	A fast (sequential) algebraic multigrid based on agglomeration that saves memory bandwidth
CFirstDiagonal	Norm that uses only the [0][0] entry of the block to determine couplings
CGraphEdgePropertiesSelector	Wrapper to access the internal vertex properties of a graph via operator[]()
CGraphVertexPropertiesSelector	Wrapper to access the internal edge properties of a graph via operator[]()
►CHierarchy	A hierarchy of coantainers (e.g. matrices or vectors)
CLevelIterator	Iterator over the levels in the hierarchy
CIndicesCoarsener< OwnerOverlapCopyCommunication< G, L >, E >	Coarsen Indices in the parallel case
CIndicesCoarsener< SequentialInformation, E >	Coarsen Indices in the sequential case
CKAMG	Algebraic multigrid method using a Krylov-cycle
CKAmgTwoGrid	Two grid operator for AMG with Krylov cycle
CLevelTransferPolicy	Abstract base class for transfer between levels and creation of the coarse level system
►CMatrixGraph	The (undirected) graph of a matrix
CEdgeIteratorT	Iterator over all edges starting from a vertex
CVertexIteratorT	The vertex iterator type of the graph
CMatrixHierarchy	The hierarchies build by the coarsening process
COneStepAMGCoarseSolverPolicy	A policy class for solving the coarse level system using one step of AMG
CParameters	All parameters for AMG
CPropertiesGraph	Attaches properties to the edges and vertices of a graph
CRandomAccessBundledPropertyMap	A property map that extracts one property out of a bundle using operator[]()
CRowSum	Functor using the row sum (infinity) norm to determine strong couplings
CSmootherApplier	Helper class for applying the smoothers
CSmootherTraits	Traits class for getting the attribute class of a smoother
CSparsityBuilder	Functor for building the sparsity pattern of the matrix using examineConnectivity
►CSubGraph	A subgraph of a graph
CEdgeIndexMap	An index map for mapping the edges to indices
CEdgeIterator	The edge iterator of the graph
CVertexIterator	The vertex iterator of the graph
CSymmetricCriterion	Criterion taking advantage of symmetric matrices
CSymmetricDependency	Dependency policy for symmetric matrices
CSymmetricMatrixDependency	Dependency policy for symmetric matrices
CTwoLevelMethod
CUnSymmetricCriterion	Criterion suited for unsymmetric matrices
CVertexProperties	Class representing a node in the matrix graph
CVertexPropertiesGraph	Attaches properties to the vertices of a graph
CVertexVisitedTag	Tag idnetifying the visited property of a vertex
►NCapabilities	Contains all capabilities classes
CcanCommunicate	Specialize with 'true' for all codims that a grid can communicate data on (default=false)
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< SGrid< dim, dimw >, cdim >	SGrid has entities for all codimension
ChasEntity< UGGrid< dim >, 0 >	UGGrid has codim=0 entities (elements)
ChasEntity< UGGrid< dim >, dim >	UGGrid has codim=dim entities (vertices)
ChasEntity< YaspGrid< dim, Coordinates >, codim >	YaspGrid has entities for all codimensions
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< SGrid< dim, dimw > >	SGrid 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< SGrid< dim, dimw > >	SGrid is a Cartesian grid
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< SGrid< dim, dimw > >	SGrid 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< SGrid< dim, dimw > >	SGrid is levelwise conforming
CisLevelwiseConforming< UGGrid< dim > >	UGGrid is levelwise conforming
CisLevelwiseConforming< YaspGrid< dim, Coordinates > >	YaspGrid is levelwise conforming
CisParallel	Specialize with 'true' if implementation supports parallelism. (default=false)
CisParallel< OneDGrid >	OneDGrid is not parallel
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)
►Ndgf
CGridParameterBlock	Common Grid parameters
CYaspGridParameterBlock	Grid parameters for YaspGrid
►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
►NGenericGeometry
CDuneGeometryType	Statically convert a generic topology type into a GeometryType
CDuneGeometryTypeProvider	Dynamically convert a generic topology type into a GeometryType
CSize	Statically compute the number of subentities of a given codimension
►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
►NMatrixMarketImpl
CMatrixValuesSetter	Functor to the data values of the matrix
Cmm_block_structure_header	Metaprogram for writing the ISTL block structure header
Cmm_header_printer	Meta program to write the correct Matrix Market header
Cmm_numeric_type	Helper metaprogram to get the matrix market string representation of the numeric type
CNumericWrapper	Wrapper class of numeric values
CPatternDummy	Utility class for marking the pattern type of the MatrixMarket matrices
►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
►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
CTraits	Mapping from geometryType, CoordType and coerceTo to a particular Refinement implementation
►NStd
Cindex_sequence	Function similar to std::index_sequence to be introduced in C++14
Cinteger_sequence	Implementation of std::integer_sequence to be introduced in C++14
Cto_false_type	Template mapping a type to std::false_type
Cto_true_type	Template mapping a type to std::true_type
►NVTK
CAppendedBase64DataArrayWriter	Streaming writer for data array tags, uses appended base64 format
CAppendedRawDataArrayWriter	Streaming writer for data array tags, uses appended raw format
CAsciiDataArrayWriter	Streaming writer for data array tags, uses ASCII inline format
CBinaryDataArrayWriter	Streaming writer for data array tags, uses binary inline format
CBoundaryIterator	Iterate over the GridViews boundary intersections
CConformingConnectivityWriter	Writer for the connectivity array in conforming mode
CCoordinatesWriter	Writer for the Coordinates array
CCorner	Simple class representing a corner of a cell
CCornerIterator	Iterate over the corners of some cell range
CDataArrayWriter	Base class for data array writers
CDataArrayWriterFactory	Factory for DataArrayWriters
CFieldInfo	Descriptor struct for VTK fields
CFunctionWriterBase	Base class for function writers
CNakedBase64DataArrayWriter	Streaming writer for appended data array tags, uses base64 format
CNakedRawDataArrayWriter	Streaming writer for appended data arrays, uses raw format
CNonConformingConnectivityWriter	Writer for the connectivity array in nonconforming mode
COffsetsWriter	Writer for the offsets array
CPointIterator	Iterate over the points of some corner range
CPrintType	Determine a type to safely put another type into a stream
CPVTUWriter	Dump a .vtu/.vtp files contents to a stream
CSkeletonFunctionInterface	A prototype for VTKFunctions on the skeleton
CSkeletonFunctionWriter	Function writer for skeleton functions
CTypeName	Map type to its VTK name in data array
CTypesWriter	Writer for the types array
CVTKFunctionWriter	Base class for function writers
CVTUWriter	Dump a .vtu/.vtp files contents to a stream
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 >
CAlbertaGridEntityPointer	EntityPointer implementation for AlbertaGrid
CAlbertaGridGeometry	Geometry implementation for AlbertaGrid
CAlbertaGridHierarchicIterator
CAlbertaGridIdSet	Hierarchic index set of AlbertaGrid
CAlbertaGridTreeIterator
CAlbertaMarkerVector	Marker assigning subentities to one element containing them
CAlignmentOf	Calculates the alignment requirement of a type
CAllSet	A set containing everything
CALU2dGrid	[ provides Dune::Grid ]
CALU2dGridEntity
CALU2dGridEntity< 0, dim, GridImp >
CALU2dGridEntityPointer
CALU2dGridEntitySeed< 0, GridImp >
CALU2dGridGeometry
CALU2dGridHierarchicIndexSet	Hierarchic index set of ALU2dGrid
CALU2dGridHierarchicIterator	Hierarchic Iterator of ALU2dGrid
CALU2dGridIntersectionBase
CALU2dGridLocalIdSet	Hierarchic index set of ALU3dGrid
CALU3dGrid	[ provides Dune::Grid ]
CALU3dGridEntity
CALU3dGridEntity< 0, dim, GridImp >
CALU3dGridEntityPointer< 0, GridImp >
CALU3dGridEntityPointerBase
CALU3dGridEntitySeed< 0, GridImp >
CALU3dGridGeometricFaceInfoBase
CALU3dGridGeometricFaceInfoHexa
CALU3dGridGeometricFaceInfoTetra
CALU3dGridHierarchicIndexSet	Hierarchic index set of ALU3dGrid
CALU3dGridIntersectionIterator
CALU3dGridLeafIterator	Leaf iterator
CALU3dGridLeafVertexList
CALU3dGridLevelIterator
CALU3dGridVertexList
CALUGrid	[ provides Dune::Grid ]
CALUGridBoundaryProjection	ALUGrid boundary projection implementation DuneBndProjection has to fulfil the DuneBoundaryProjection interface
CALUMemoryProvider	Organize the memory management for entitys used by the NeighborIterator
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
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
CAutoPtrStack	Stack of pointers with auto destruction if the stack is destructed
CAxisAlignedCubeGeometry	A geometry implementation for axis-aligned hypercubes
Cb64chunk	Union representing the three byte text aswell as the four 6 bit chunks
Cb64data
Cb64txt	Struct with three bytes of text
CBackupRestoreFacility	Facility for writing and reading grids
CBackupRestoreFacility< ALUGrid< dim, dimworld, elType, refineType, Comm > >	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
Cbase_array	This container extends base_array_unmanaged by memory management with the usual copy semantics providing the full range of copy constructor, destructor and assignment operators
►Cbase_array_unmanaged	A simple array container for objects of type B
CRealIterator	Iterator implementation class
Cbase_array_window	Extend base_array_unmanaged by functions to manipulate
►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
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
CBilinearMapping	A bilinear mapping
CBilinearSurfaceMapping	A bilinear surface mapping
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
Cblock_vector_unmanaged	An unmanaged vector of blocks
CBlockPreconditioner	Block parallel preconditioner
CBlockVector	A vector of blocks with memory management
CBlockVectorWindow
CBoundarySegment	Base class for classes implementing geometries of boundary segments
CBoundarySegmentWrapper
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
CColCompMatrix	Utility class for converting an ISTL Matrix into a column-compressed matrix
CColCompMatrix< BCRSMatrix< FieldMatrix< B, n, m >, TA > >	Converter for BCRSMatrix to column-compressed Matrix. specialization for BCRSMatrix
CColCompMatrixInitializer	Inititializer for the ColCompMatrix as needed by OverlappingSchwarz
CCollectiveCommunication	Collective communication interface and sequential default implementation
CCollectiveCommunication< MPI_Comm >	Specialization of CollectiveCommunication for MPI
►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
CCombinedGrapeDisplay	Combines GrapeDataDisplays to one so that visualisation for parallel grid is more easy to handle
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
►Ccompressed_base_array_unmanaged	A simple array container with non-consecutive index set
CRealIterator	Iterator class for sequential access
Ccompressed_block_vector_unmanaged
CCompressedBlockVectorWindow
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 > >
CConstantVolatileTraits	Determines wether a type is const or volatile and provides the unqualified types
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
CConversion	Checks wether a type is convertible to another
CDebugAllocator	Allocators implementation which performs different kind of memory checks
CDebugStream	Generic class to implement debug output streams
CDebugStreamError	Standard exception for the debugstream
CDebugStreamState	Intermediate class to implement tie-operation of DebugStream
CDefaultIndexSet	DefaultIndexSet creates an index set by using the grids persistent container an a given pair of iterators
►CDefaultLeafIteratorTypes	LeafIterator tpyes for all codims and partition types
CCodim	The types of the iterator
►CDefaultLevelIteratorTypes	LevelIterator tpyes for all codims and partition types
CCodim	The types
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 > >	Grid factory for YaspGrid with equidistant coordinates
CDGFGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< double, 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
CDiagonalMatrix	A diagonal matrix of static size
CDim	Static tag representing a dimension
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
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
CElementTopologyMapping
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	EntityPointer 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
►CEntityPointer	Wrapper class for pointers to entities
CCodim	EntityPointer types of the different codimensions
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
CFaceTopologyMapping
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
CFirstPredicateIndex	Finding the index of a certain type in a tuple
CFirstTypeIndex	Find the first occurance of a type in a tuple
CFlattenTuple	Flatten a tuple of tuples
CFloatCmpOps	Class encapsulating a default epsilon
Cfmatrix_assigner	Fmatrix assignment operator
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 tuple with the storage types replaced by a user-defined rule
CForEachValue	Helper template which implements iteration over all storage elements in a tuple
CForEachValuePair	Extension of ForEachValue to two tuples..
CForLoop	A static loop using TMP
CForwardIteratorFacade	Base class for stl conformant forward iterators
►CFunction	Base class template for function classes
CTraits	Traits class containing raw types
Cfvector_assigner	Fvector assignment operator
CGaussLobattoQuadratureInitHelper
CGaussLobattoQuadratureRule1D	Jacobi-Gauss quadrature for alpha=2, beta=0
CGaussQuadratureInitHelper
CGaussQuadratureRule1D	Gauss quadrature rule in 1D
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[]
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
CPartition	Types for GridView
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
CGlobalUniversalMapper	Universal mapper based on global ids
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
CGrapeDataDisplay
CGrapeGridDisplay
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
CPartition	Types for GridView
►CGridDefaultImplementation
CReturnImplementationType	Helper class to choose correct implementation return type for getRealImplementation
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
CGridObjectStreamOrDefault	Template to choose right Object stream type for a given class
CGridObjectStreamOrDefaultHelper
CGridObjectStreamOrDefaultHelper< false, GridImp, DefaultImp >
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
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
CHasHierarchicIndexSet	Tagging interface to indicate that Grid has HierarchicIndexSet
CHasObjectStream	Tagging interface to indicate that Grid provides typedef ObjectStreamType
CHelpRequest	Exception thrown if the user wants to see help string
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
CIdentityGridEntityPointer
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
CIdentityMatrix	Read-only identity matrix
CIdSet	Id Set Interface
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
CImplicitModeOverflowExhausted	The overflow error used during implicit BCRSMatrix construction was 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
CInterface	Communication interface between remote and local indices
CInterfaceBuilder	Base class of all classes representing a communication interface
CInterfaceInformation	Information describing an interface
CIntersection	Intersection of a mesh entities of codimension 0 ("elements") 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
CIntersectionIteratorWrapper	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid
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
Cis_indexable
Cis_lvalue_reference	Determine whether a type is a lvalue reference type
Cis_pointer	Is_pointer
CIsBaseOf	Checks wether a type is derived from another
CIsConst	Tests wether a type is constant
CIsDofManager	Tagging interface to indicate that class is of Type DofManager
CIsFieldVectorSizeCorrect	TMP to check the size of a DenseVectors statically, if possible
CIsInteroperable	Checks wether two types are interoperable
CIsMatrix	Test whether a type is an ISTL Matrix
CISTLError	Derive error class from the base class in common
►CIsType	Generator for predicates accepting one particular type
CPredicate	The actual predicate
CIsVolatile	Tests wether a type is volatile
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
CJacobi1QuadratureInitHelper
CJacobi1QuadratureRule1D	Jacobi-Gauss quadrature for alpha=1, beta=0
CJacobi2QuadratureInitHelper
CJacobi2QuadratureRule1D	Jacobi-Gauss quadrature for alpha=2, beta=0
CJoinTuples	Join two tuples
CLcm	Calculate the least common multiple of two numbers
CLeafAmiraMeshWriter	Provides file writing facilities in the AmiraMesh format for leaf grids
CLeafGnuplotWriter	GnuplotWriter on the leaf grid
CLeafIntersectionIteratorWrapper	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the 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
CLevelIntersectionIteratorWrapper	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid
CLevelIntersectionWrapper	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the 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
CLinearMapping	A linear mapping
CLinearOperator	A linear operator
CLocalGeometryTypeIndex	Compute per-dimension indices for geometry types
CLocalIndex	An index present on the local process
CLocalUniversalMapper	Universal mapper based on local ids
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
CMatrixIndexSet	Stores the nonzero entries in a sparse matrix
CMatrixRowSet	Provides access to an iterator over all matrix rows
►CMatrixRowSubset	Provides access to an iterator over an arbitrary subset of matrix rows
Cconst_iterator	The matrix row iterator type
CMCMGElementLayout	Layout template for elements
CMCMGVertexLayout	Layout template for vertices
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
CMINRESSolver	Minimal Residual Method (MINRES)
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
Cmutable_reference	Get the 'mutable' version of a reference to a const object
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
CNonConformingFaceMapping
CNonConformingFaceMapping< hexa, Comm >	Non-conforming face mappings for hexahedra
CNonConformingFaceMapping< tetra, Comm >	Non-conforming face mappings for tetrahedra
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 tuple consisting of pointers to NULL
COneDGrid	One-dimensional adaptive grid
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
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 programm occured
►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
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
CPointerPairDeletor	Deletes all objects pointed to in a tuple of pointers
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
CPreconditioner	Base class for matrix free definition of preconditioners
CPrismQuadraturePoints
CPrismQuadraturePoints< 3 >
CPrismQuadraturePointsSingleton	Singleton holding the Prism Quadrature points
CPrismQuadraturePointsSingleton< 3 >	Singleton holding the Prism Quadrature points
CPrismQuadratureRule	Quadrature rules for prisms
CPrismQuadratureRule< ct, 3 >	Quadrature rules for prisms
CPropertyMapTypeSelector	Selector for the property map type
CPushBackTuple	Helper template to append a type to a tuple
CPushFrontTuple	Helper template to prepend a type to a tuple
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
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
►CReferenceElement	This class provides access to geometric and topological properties of a reference element
CCodim	Collection of types depending on the codimension
CSubEntityInfo	Topological information about the subentities of a reference element
CReferenceElements	Class providing access to the singletons of the reference elements
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
Cremove_pointer	Return the type a pointer type points to
CReservedVector	A Vector class with statically reserved memory
CRestartedGMResSolver	Implements the Generalized Minimal Residual (GMRes) method
CRichardson	Richardson preconditioner
CScalarProduct	Base class for scalar product and norm computation
CScalarProductChooser	Choose the approriate scalar product for a solver category
CScaledIdentityMatrix	A multiple of the identity matrix of static size
CSelection	A cached selection of indices
CSelectionIterator	A const iterator over an uncached selection
CSEntity
CSEntity< 0, dim, GridImp >
CSEntityBase
CSEntityPointer
CSEntitySeed
CSeqGS	Sequential Gauss Seidel preconditioner
CSeqILU0	Sequential ILU0 preconditioner
CSeqILUn	Sequential ILU(n) preconditioner
CSeqJac	The sequential jacobian preconditioner
CSeqOverlappingSchwarz	Sequential overlapping Schwarz preconditioner
CSeqOverlappingSchwarzApplier	Helper template meta program for application of overlapping schwarz
CSeqOverlappingSchwarzDomainSize
CSeqPardiso	The sequential Pardiso preconditioner
CSeqScalarProduct	Default implementation for the scalar case
CSeqSOR	Sequential SOR preconditioner
CSeqSSOR	Sequential SSOR preconditioner
CSGeometry
CSGrid	[ provides Dune::Grid ]
CSGridGlobalIdSet	Persistent, globally unique Ids
CSGridLevelIndexSet	Implementation of index set
CSHierarchicStackElem
CSingleCodimSingleGeomTypeMapper	Implementation class for a single codim and single geometry type mapper
CSingleton	An adapter to turn a class into a singleton
CSingleTypeSizeCache	Organizes the caching of sizes for one grid and one GeometryType
CSIntersectionIterator
CSizeCache	Organizes the caching of sizes for one grid and one GeometryType
CSizeOne	Flag for marking indexed data structures where data at each index is of the same size
CSLevelIterator
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
CSolverCategory	Categories for the solvers
CStandardMathematicalConstants	Standard implementation of MathematicalConstants
CStarCDReader	File reader for the Star-CD format
CStaticPower	Calculates m^p at compile time
CStaticPower< m, 0 >	End of recursion via specialization
►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< SGrid< dim, dim > >	Specialization of the StructuredGridFactory for SGrid
CStructuredGridFactory< YaspGrid< dim, EquidistantCoordinates< ctype, dim > > >	Specialization of the StructuredGridFactory for YaspGrid
CStructuredGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > > >	Specialization of the StructuredGridFactory for YaspGrid
CSubsamplingVTKSequenceWriter	Writer for the ouput of grid functions in the vtk format
CSubsamplingVTKWriter	Writer for the output of subsampled grid functions in the vtk format
CSuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >	SuperLu Solver
CSuperLUMatrix	Utility class for converting an ISTL Matrix into a SuperLU Matrix
CSuperLUMatrix< BCRSMatrix< FieldMatrix< B, n, m >, TA > >	Converter for BCRSMatrix to SuperLU Matrix
CSurfaceNormalCalculator	A bilinear surface mapping
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
CTimerError	Exception thrown by the Timer class
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
►CTransformTupleFunctor	Helper class to implement transformTuple()
CTypeEvaluator	Export the TypeEvaluator template class for genericTransformTuple()
CTransposedMatMultMatResult	Helper TMP to get the result type of a sparse matrix matrix multiplication ( \(C=A*B\))
CTrilinearMapping
CTypeTraits	General type traits class to check whether type is reference or pointer type
CUGGrid	Front-end for the grid manager of the finite element toolbox UG
CUMFPack	Use the UMFPack package to directly solve linear systems – empty default class
CUMFPack< BCRSMatrix< FieldMatrix< T, n, m >, A > >	The UMFPack direct sparse solver for matrices of type BCRSMatrix
CUncachedSelection	An uncached selection of indices
CUniversalMapper	Implements a mapper for an arbitrary subset of entities
►CVariableBlockVector	A Vector of blocks with different blocksizes
CConstIterator	ConstIterator class for sequential access
CCreateIterator	Iterator class for sequential creation of blocks
CIterator	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
CVTKFunctionWrapper	Type erasure implementation for legacy VTKFunctions
CWritablePropertyMapTag	Tag for the category of writable property maps
CYaspEntityPointer	A pointer to a YaspGrid::Entity
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 doesnt 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 doesnt 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
Cdune_nullptr_t	Fallback implementation of nullptr
CMCMGElementEdgeLayout	Layout template for edges and elements This layout template is for use in the MultipleCodimMultipleGeomTypeMapper. It selects edges and elements (entities with dim=1 or dim=dimgrid)
CMPIError	MPI Error. Thrown when an mpi error occurs