Class List

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

[detail level 1234]

►NDune	Dune namespace
►NAlignedNumberImpl
CAlignedNumber	Aligned wrappers for arithmetic types
►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< Richardson< X, Y > >	Policy for the construction of the Richardson smoother
CConstructionTraits< SeqILU< M, X, Y > >	Policy for the construction of the SeqILU 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 edge 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 containers (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 suitable 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< 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)
CviewThreadSafe< UGGrid< dim > >	UGGrid is thread-safe for grid views
CviewThreadSafe< YaspGrid< dim, Coordinates > >	YaspGrid is viewThreadSafe
►NConcept	Namespace for concepts
CRefines	Base class for refined concepts
►Ndgf
CGridParameterBlock	Common Grid parameters
CYaspGridParameterBlock	Grid parameters for YaspGrid
►NFem
►NCapabilities
CDefaultQuadrature	Specialize when quadrature other than the standard quadrature should be used for volume and surface integral compution
ChasFixedPolynomialOrder	Specialize with true if polynomial order does not depend on the grid (part) entity
ChasInterpolation	Determine whether a discrete function space provides a (local) interpolation
ChasStaticPolynomialOrder	Specialize with true if polynomial order fixed and compile time static
CisAdaptive	Specialize with true if space can be used with AdaptiveDiscreteFunction
CisAdaptiveIndexSet	Specialize with true if index set implements the interface for adaptive index sets
CisConsecutiveIndexSet	Specialize with true if index set implements the interface for consecutive index sets
CisContinuous	Specialize with true if space is always continuous
CisDuneFemIndexSet	Specialize with true if index set implements the dune-fem interface for index sets
CisHierarchic	Specialize with true if for a space the basis functions are sorted by the polynomial order, starting with the lowest order
CisLocalized	Specialize with true if the space is localized, * i.e., the basis function set is based on a shape function set
CisPAdaptiveSpace	Specialize with true if space can be used with p-adaptation
CisPersistentIndexSet	Capability for persistent index sets
CthreadSafe	Specialize with true if the space implementation is thread safe
CviewThreadSafe	Specialize with true if the space implementation is thread safe, while it is not modified
►NCodegen
CDefaultCodeGenerator	Default code generator methods
►Ndetail
CIsCodegenShapeFunctionSet	Selects SFS::codegenShapeFunctionSet if available, otherwise defaultValue (default is false)
CSelectPointSetId	Selects Obj::pointSetId if available, otherwise defaultValue (default is -1)
►NGridPartCapabilities
CcanCommunicate	Specialize with 'true' for all codims that a grid can communicate data on (default=false)
ChasEntity	Specialize with 'true' for all codims that a grid implements entities for (default=false)
ChasGrid	Specialize with 'false' if grid part has no underlying dune grid (default=true)
ChasSingleGeometryType	Specialize with 'true' for if the codimension 0 entity of the grid part has only one possible geometry type (default=false, topologyid=undefined)
CisCartesian	Specialize with 'true' if the grid part is cartesian (default=false)
CisConforming	Specialize with 'true' if implementation guarantees conforming level grids. (default=false)
►NhpDG
CAdaptationManager	Manages the restriction and prolongation of discrete functions in $(h)p$-adaptive computations
CAnisotropicBasisFunctionSets	A family of anisotropic local product basis function sets
CAnisotropicDiscontinuousGalerkinSpace	Implementation of an $hp$-adaptive discrete function space using anisotropic product Legendre polynomials
CBasisFunctionSets	Abstract interface class for a family of local basis function sets
CDataProjection	Abstract definition of the local restriction and prolongation of discrete functions
CDataProjectionTuple	A DataProjection wrapping an arbitrary number of projection operators
CDefaultDataProjection	Local $L^2(\Omega)$-projection for the restriction and prolongation of discrete functions
CDefaultDataProjectionTuple	A DataProjection for managing an arbitrary number of discrete functions
CDefaultDiscontinuousGalerkinSpace	Default implementation of an $hp$-adaptive discrete function space given a family of local basis function sets
CDiscontinuousGalerkinBlockMapper	An $hp$-adaptive Dune::Fem::DofMapper
CDiscontinuousGalerkinSpace	Generic implementation of a $hp$-adaptive discontinuous finite element space
CGeometryTypeMap	Associative container assigning values to each GeometryType
CGlobalGeometryTypeIndexSet	Please doc me
CGlobalGeometryTypeMap	Please doc me
CHierarchicLegendreDiscontinuousGalerkinSpace	Implementation of an $hp$-adaptive discrete function space using product Legendre polynomials
CLegendreBasisFunctionSets	A family of local product basis function sets
CLegendreDiscontinuousGalerkinSpace	Implementation of an $hp$-adaptive discrete function space using product Legendre polynomials
CLocalGeometryTypeIndexSet	Please doc me
CLocalGeometryTypeMap	Please doc me
COrthogonalBasisFunctionSets	A family of orthogonal local basis function sets
COrthogonalDiscontinuousGalerkinSpace	Implementation of an $hp$-adaptive discrete function space using orthogonal polynomials
CSingleGeometryTypeIndexSet	Please doc me
CVectorialBasisFunctionSets	A meta implemenation of a family of local basis function sets
►NSolver
CCGInverseOperator	Inverse operator base on CG method. This is the base class for the cg solver and does not imvolve any runtime parametrization
CAbstractColumnWriter	Class representing column writer in general
CAcceptElementImplicitConstruction
CAdaptationManager	This class manages the adaptation process including a load balancing after the adaptation step. This class is created by the AdaptationManager for each grid instance. See AdaptationManager for details
CAdaptationManagerBase	This class manages the adaptation process. If the method adapt is called, then the grid is adapted and also all the data belonging to the given dof manager will be rearranged for data set where it is necessary to keep the data
CAdaptationManagerInterface	AdaptationManagerInterface class
CAdaptationManagerReferenceFactory	Factory class to create adaptation manager reference counter
CAdaptationMethod	AdaptationMethod is a simple adaptation method reader class
►CAdaptiveDiscreteFunction
CDofStorageWrapper	Wrapper class to create fake DofStorage from DofType*
CAdaptiveDofMapper	Extended interface for adaptive DoF mappers
►CAdaptiveGridPartBase	A grid part with an index set specially designed for adaptive calculations
CCodim	Struct providing types of the leaf iterators on codimension codim
CAdaptiveIndexSet	Extended interface for adaptive, consecutive index sets
CAdaptiveIndexSetBase	Consecutive, persistent index set for the leaf level based on the grid's hierarchy index set
CAdaptiveLeafGridPartTraits	Type definitions for the LeafGridPart class
CAdaptiveLeafIndexSet	Consecutive, persistent index set for the leaf level based on the grid's hierarchy index set
CAgglomeration	Agglomeration is a simple quadrature for polyhedral cells based on sub triangulation
CAllGeomTypes	Default implementation uses method geomTypes of given index set. Used in DiscreteFunctionSpaces
CAMGXInverseOperator	AMGX solver context for PETSc Mat and PETSc Vec
CASCIIInStream	Input stream reading from an STL input stream using ASCII decoding
CASCIIOutStream	Output stream writing into an STL output stream using ASCII encoding
CAssembledOperator	Abstract matrix operator
CAutomaticDifferenceOperator	Operator providing a Jacobian through automatic differentiation
CAutoPersistentObject	Base class for auto persistent objects
CAuxiliaryDofs	In parallel computations the dofs of a discrete function are made up by all primary dofs. For technical reasons some dofs exists on multiply processes but are only primary on exactly one process. Dofs on processes that are not primary are called auxiliary
CBaseFunctionSetSingletonFactory	BasisFunctionSetSingletonFactory provides method createObject and deleteObject for the SingletonList
CBaseSetLocalKeyStorage	Storage class for base function set pointer and compiled local key pointers
CBasicGridFunctionAdapter	BasicGridFunctionAdapter provides local functions for a Function
CBasicGridFunctionAdapterTraits	Traits of GridFunctionAdapter
CBasicInstationaryFunction	Basic wrapper class (still a CRTP) for instationary functions
CBasicTemporaryLocalFunction	A temporary function carrying values for one entity
CBasisFunctionSet	Interface class for basis function sets
CBasisFunctionSets	Interface class representing a family of basis function sets
CBinaryFileInStream
CBinaryFileOutStream
CBlockDiagonalLinearOperator	BlockDiagonalLinearOperator
CBubbleElementSpace	[Class definition for new space]
CCacheStorage	Storage class for mappers
CCacheStorage< ct, dim, false >	Specialisation for grids without any twists (i.e. Cartesian ones)
CCacheStorage< ct, dim, true >	Specialisation for grids with twist (i.e. unstructured ones)
CCachingInterface	Interface a cachable quadrature has to implement
CCachingQuadratureImpl	Quadrature class supporting base function caching
CCachingQuadratureImpl< GridPartImp, 0, IntegrationTraits, isQuadrature >
CCachingQuadratureImpl< GridPartImp, 1, IntegrationTraits, isQuadrature >	constructor
CCGInverseOperator	Inverse operator base on CG method. Uses a runtime parameter fem.preconditioning which enables diagonal preconditioning if diagonal matrix entries are available, i.e., Op :: assembled is true
CCheckCartesian	Helper class to check whether grid is structured or not
►CCheckPointer	Implementation of the IOInterface. This class manages checkpointing
CGridPersistentObject	Call appropriate backup and restore methods on the grid class
CCheckPointerParameters	Local parameter collection for CheckPointer
CCodimensionMapper	Mapper allocating one DoF per subentity of a given codimension
CCombinedDataHandle	Combine multiple data handles into one
CCombinedDiscreteFunction
CCombinedDiscreteFunctionDofIterator	Iterator over an array of dofs
CCombinedDofConversionUtility
CCombinedDofConversionUtility< ContainedMapper, N, PointBased >
CCombinedDofConversionUtility< ContainedMapper, N, VariableBased >	Specialisation for VariableBased approach
CCombinedLocalOperator
CCombinedSpace< DiscreteFunctionSpace, N, PointBased >	Combined Space Function Space
CCommunicationManager	Use Default CommunicationManager as Communication Manager
CCommunicationManagerList	Proxy class to DependencyCache which is singleton per space
CCompiledLocalKeyContainer	Class for storage local keys for a given range of polynomial order and available geometry type
CConjugateGradientSolver	Linear solver using the CG algorithm
CConsecutiveIndexSet	Extended interface for consecutive index sets
CConstLocalDiscreteFunction	A constant local function carrying values for one entity
CDataCollector	The DataCollector is an example for a grid walk done while load balancing moves entities from one processor to another. The Communicator or grid should call the inlineData (write Data to ObjectStream) and the xtractData (read Data from Stream) and provide the macro level Entity<codim =0> and the ObjectStream. This Operator then does the hierarhic walk and calls its local pack operators which know the discrete functions to pack to the stream
CDataCollectorInterface
CDataOutput	Implementation of the Dune::Fem::IOInterface. This class manages data output. Available output formats are GRAPE, VTK and VTK Vertex projected using the VtxProjection operator. Details can be found in DiscFuncIO
CDataOutputParameters	Parameter class for Dune::Fem::DataOutput
CDataWriter	Implementation of the Dune::IOInterface. This class manages data output. Available output formats are GRAPE, VTK and VTK Vertex projected using the VtxProjection operator. Details can be found in DiscFuncIO
CDebugCounter	A counter only present if NDEBUG is not defined
CDefaultBasisFunctionSet
CDefaultBasisFunctionSets	Generate a set of default basis function sets from given set of shape function sets
CDefaultCommunicationHandlerImpl	Default communication handler for discrete functions
CDefaultCommunicationManager	Default communication manager using just the grids communicate method
CDefaultEocCalculator	Write a self contained tex table for eoc runs with timing information
►CDefaultFilterTraits	Type definitions
CCodim	Entity types
CDefaultOrderCalculator	Default Quadrature Order Calculator
CDenseMatrix	DenseMatrix based on std::vector< std::vector< T > >
►CDFCommunicationOperation	Mathematical operation apply during communication to data that is communicated enum of all avialable operations
CAdd	Sum up data
CCopy	Just copy data
CMax	Keep maximum
CMin	Keep minimum
CSub	Substract data
CDGAdaptiveLeafIndexSet	Consecutive, persistent index set for the leaf level based on the grid's hierarchy index set
CDiagonalAndNeighborStencil	Stencil contaning the entries (en,en) and (en,nb) for all entities en in the space and neighbors nb of en. Defailt for an operator over a DG space
CDiagonalPreconditioner	Precondtioner, multiplies with inverse of the diagonal works with
CDiagonalStencil	Stencil contaning the entries (en,en) for all entities in the space. Defailt for an operator over a Lagrange space or a DG mass operator
CDifferentDiscreteFunctionSpace< PowerDiscreteFunctionSpace< DiscreteFunctionSpace, N >, NewFunctionSpace >	Specialization of DifferentDiscreteFunctionSpace for PowerDiscreteFunctionSpace
CDifferentDiscreteFunctionSpace< TupleDiscreteFunctionSpaceImpl< CombineOp, DiscreteFunctionSpaces... >, NewFunctionSpace >	Specialization of DifferentDiscreteFunctionSpace for TupleDiscreteFunctionSpace
CDifferentiableOperator	Abstract differentiable operator
CDiscontinuousGalerkinLocalInterpolation
CDiscontinuousLocalFiniteElementSpace	Rannacher-Turek Space
CDiscreteFunctionDefault
CDiscreteFunctionInterface
CDiscreteFunctionSpaceAdapter	Create Obejct that behaves like a discrete function space without to provide functions with the iterator facilities
CDiscreteFunctionSpaceDefault	This is the class with default implementations for discrete function. The methods not marked with having a default in the interface class must be provided by the implementation; all other methods have a default implementation here
►CDiscreteFunctionSpaceInterface	This is the interface for discrete function spaces. All methods declared here have to be implemented by the implementation class
CCommDataHandle	Defines type of data handle for communication
CToNewDimRange	Typedef struct for defining the same discrete function space with a different dimRange
CToNewFunctionSpace	Typedef struct for defining the same discrete function space with a different function space
CDiscreteFunctionTraits	Traits class for a DiscreteFunction
CDiscreteFunctionTraits< CombinedDiscreteFunction< ContainedDiscreteFunction, N > >
CDofAlignment	Interface documentation for Dof alignment classes used in VectorialBasisFunctionSet
CDofBlockProxy	DoF block proxy for discrete functions with random access to DoFs
CDofConversionUtility
CDofConversionUtility< PointBased >	Specialisation for PointBased approach
CDofConversionUtility< VariableBased >	Specialisation for VariableBased approach
CDofIteratorDefault	Default implementation of DofManagerInterface
CDofIteratorInterface	Interface for DoF iterators of discrete functions
CDofManager
CDofManagerFactory	Singleton provider for the DofManager
CDofMapper	Interface for calculating the size of a function space for a grid on a specified level. Furthermore the local to global mapping of dof number is done. Also during grid adaptation this mapper knows about old and new indices of entities
CDofStorageInterface	Interface class for a dof storage object to be stored in discrete functions
CDomainDecomposedIterator	Thread iterators using domain decomposition
CDomainDecomposedIteratorStorage	Storage of thread iterators using domain decomposition
CDummyDataCollector	Empty data collector
CDynamicArray	An implementation of DenseVector which uses a C-array of dynamic size as storage
CDynamicNonBlockMapper
CDynamicReferenceVector	An implementation of DenseVector which uses a std::vector of references as storage
CEisenstatWalkerStrategy	Adaptive tolerance selection for linear solver
CElementPointListBase	ElementPointListBase
CElementQuadratureImpl< GridPartImp, 0, IntegrationTraits, isQuadrature >	constructor
CElementQuadratureImpl< GridPartImp, 1, IntegrationTraits, isQuadrature >	constructor
CEntityGeometryStorageImpl	Implementation of entity and geometry storage for basis function set and local functions
CExplicitFieldVector
CFemEoc	Write a self contained tex table for eoc runs with timing information
CFemEocTable	The Fem Eoc Table writer
CFemPreconditioning	Precondtioner, implementing Jacobi, Gauss-Seidel and SOR works with
CFemQuadratureKey	A simple quadrature key class for use FemPy
CFieldMatrixConverter< FieldVector< K, n *m >, FieldMatrix< K, n, m > >	Convert a FieldVector with length n * m to a FieldMatrix with n rows and m cols
CFileIOCheckError	Check if lock file exists and aborts if true
CFileIOLock	Creates and removes lock file during backup process
►CFilteredGridPart	A FilteredGridPart allows to extract a set of entities from a grid satisfying a given constrainted defined through a filter class
CCodim	Grid part typedefs, use those of traits
►CFilterInterface	Interface class for filter to use with a Dune::FilteredGridPart
CCodim	Entity types
CFlopCounter	A class wrapper for the function PAPI_flops from the package PAPI. The results are CPU time, real and process local and the number of floating point operations in MFLOP/s
CFunction	Abstract class representing a function
CFunctionSet	Global basis functions
CFunctionSetProxy	Proxy for a FunctionSet
CFunctionSpace	A vector valued function space
CFunctionSpaceInterface	Interface for an arbitrary function space
CGaussPts	One-dimensional Gauss points and their weights
CGenericDiscontinuousGalerkinSpace	Generic implementation of a Discontinuous Galerkin space based on a fixed family of basis function sets
CGenericDiscreteFunctionSpace	Please doc me
CGeometryAffinityCheck	Helper class to check affinity of the grid's geometries
CGeometryInformation	ReferenceVolume and local bary center keeper class
CGlobalRefine	A class with one static method apply to globally refine a grid. All index sets are adapted to the new grid and the managed dof storage is expanded - but no prolongation or restriction of data is performed
CGridPartDefault	Default implementation for the GridPart classes
CGridPartInterface	Interface for the GridPart classes A GridPart class allows to access only a specific subset of a grid's entities. A GridPart implementation provides the corresponding index set and a begin/end iterator pair for accessing those entities, the corresponding intersection iterators and a appropriate communication method. GridParts are used to parametrize spaces (see DiscreteFunctionSpaceDefault [in dune-fem])
CGridSolution	Creates a function with evaluate method from a check point
CGridTimeProvider	Same functionality as the Dune::TimeProvider
CGridWidth	Utility functions for calculating the maximum grid width
CGridWidthProvider	Utility functions for calculating the maximum grid width
CHasLocalFunction	Base class for determing whether a function has local functions or not
CHdivProjection	H-div Projection for discontinuous discrete functions. The projection is described in detail in:
CHorizontalDofAlignment	Implementation of DofAlignment
CIdEntity< 0, dim, GridFamily >
CIdProvider	Singleton that manages a globally unique identifier
CIndexMapperInterface	Abstract index mapper interface
CIndexSet	Interface documentation for (grid part) index sets
CInstationaryFunction	Implementation of a Dune::Fem::Function taking an instationary function
CInStreamInterface	Abstract interface for an input stream
CIntegrationPointList	Actual interface class for integration point lists
CIntegrationPointListImp	Generic implementation of an IntegrationPointList
CIntegrator	Integrator for arbitrary functions providing evaluate
CIntersectionAdaptiveLeafGridPart	A grid part with an index set specially designed for adaptive calculations including indices for intersections
CIntersectionAdaptiveLeafGridPartTraits	A grid part with an index set specially designed for adaptive calculations including indices for intersections
CIntersectionQuadrature	IntersectionQuadrature is a helper class for creating the appropriate face quadratures for integrating over intersections
CIOInterface	IOInterface to write data to hard disk
CIsBlockVectorDiscreteFunction	Tag for discrete functions using block vectors
CIsConstLocalFunction
CIsConstLocalFunction< T, std::enable_if_t<!std::is_same< T, std::decay_t< T > >{}> >
CIsConstLocalFunction< T, std::enable_if_t<(std::is_same< T, std::decay_t< T > >{} &&std::is_same< T, Fem::ConstLocalFunction< typename T::GridFunctionType > >{})> >
CIsDiscreteFunction	Base class for determing whether a class is a discrete function or not
CIsFieldType
►CISTLBlockVectorDiscreteFunction
CISTLDofStorage
CLagrangeDiscreteFunctionSpace	Lagrange discrete function space
CLagrangePoint	A single lagrange point
CLagrangePointListInterface	Set of lagrange points
CLagrangeShapeFunction	Implementation of Lagrange shape function using generic Lagrange shape functions
CLagrangeShapeFunctionFactory	Factory class
CLagrangeShapeFunctionInterface	Abstract base class for Lagrange shape functions
CLagrangeShapeFunctionSet	Lagrange shape function set
CLatexTableWriter	Writes latex tables based on user-defined row structure
CLegendreShapeFunction	Implementation of a single scalar-valued Legendre shape function
CLegendreShapeFunctionSet	Dune::Fem::ShapeFunctionSet of Legendre ansatz polynomials
CLinearOperator	Abstract affine-linear operator
CLineSegmentSampler	Samples values of a discrete function along a given line segment
CLineTwistMapperStrategy
CLoadBalanceLeafData	Check for sets of entities for the load balance procedure
CLoadBalancer	This class manages the adaptation process. If the method adapt is called, then the grid is adapted and also all the data belonging to the given dof manager will be rearranged for data set where it is necessary to keep the data
CLoadBalancerInterface	Interface class for load balancing
CLocalAnalyticalFunctionBinder	LocalAnalyticalFunctionBinder binds a C++ local analytical function (and also its Jacobian and Hessian) to an object which provides all the methods and types needed by the LocalFunctionAdapter. It stores a copy as a std::function
CLocalDataInliner	Inline DiscreteFunction data during load balancing
CLocalDataXtractor	Inline DiscreteFunction data during load balancing
CLocalFiniteElementSpace	Rannacher-Turek Space
CLocalFunction	Interface for local functions
CLocalFunctionAdapter	LocalFunctionAdapter wrapped a class with a local evaluate method into a grid function
CLocalFunctionAdapterTraits	Traits of DiscreteFunctionAdapter
CLocalFunctionConverter	Implementation of a Dune::Fem::LocalFunction on a FunctionSpace V restircted/prolongated from an other function space W
CLocalFunctionSet	Local basis functions
CLocalFunctionSetAdapter	Convert (global) function set to local function set
CLocalFunctionSetProxy	Proxy for a LocalBasisFunctionSet
CLocalL2Projection	Please doc me
CLocalMassMatrix	Local Mass Matrix for arbitrary spaces
CLocalMassMatrix< DiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, BaseFunctionStorageImp >, VolumeQuadratureImp >	Local Mass Matrix for DG space
CLocalMassMatrix< FiniteVolumeSpace< FunctionSpaceImp, GridPartImp, polOrd, BaseFunctionStorageImp >, VolumeQuadratureImp >	Local Mass Matrix for FV space
CLocalMassMatrix< HierarchicLegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, BaseFunctionStorageImp >, VolumeQuadratureImp >	Local Mass Matrix for hierarchic Legendre space
CLocalMassMatrix< hpDG::OrthogonalDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, Storage >, VolumeQuadratureImp >	Local Mass Matrix for hierarchic Legendre space
CLocalMassMatrix< LegendreDiscontinuousGalerkinSpace< FunctionSpaceImp, GridPartImp, polOrd, BaseFunctionStorageImp >, VolumeQuadratureImp >	Local Mass Matrix for Legendre space
CLocalMassMatrixImplementation	Local Mass Matrix inversion implementation, select the correct method in your implementation
CLocalMassMatrixImplementationDgOrthoNormal	DG Local Mass Matrix for arbitrary spaces
CLocalMatrixDefault	Default implementation for local matrix classes
CLocalMatrixInterface	Interface for local matrix classes
CLocalOperatorDefault	Default implementation of a local operator A local operator works on entities only and is used by a DiscreteOperator during a mesh traversal. This class implements the standard behaviour for prepareLocal(), finalizeLocal() and possibly other methods
CLocalOrthonormalL2Projection	Specialization of local L2 projection for orthonormal DG spaces
CLocalRefine	A class with one static method apply for invoking the local adaptation procedure on a given grid instance. All index sets are adapted to the new grid and the managed dof storage is expanded - but no prolongation or restriction of data is performed
CLocalRieszProjection	Interface documentation of a local Riesz projection
CLumpingQuadrature
CManagedDofStorage
CManagedDofStorageImplementation
CManagedDofStorageInterface	Interface class for a dof storage object that can be managed (resized and compressed) by the DofManager
CManagedIndexSetInterface
CMapping	A mapping from one vector space into another This class describes a general mapping from the domain vector space into the range vector space. It can also be used to construct linear combinations of mappings
CMappingOperators	Implementation of Mapping +, -, *, / operations
CMatrixFunctionSpace	A matrix valued function space
CMatrixMapping	JacobianRangeType class for matrix valued functions - derived from FieldMatrix
CMatrixSpaceTraits	Traits class for matrix valued spaces
CMetaTwistUtility	MetaTwistUtility forwards the twist calls to the TwistUtility of the underlying HostTwistUtility
CMutableLocalFunction
CNewtonInverseOperator	Inverse operator based on a newton scheme
CNonBlockMapper
CNumberColumnWriter	Gets the N th element of a provided tuple assuming its a number
CNumpyLinearOperator	NumpyLinearOperator
CObjectPointer	Models a pointer to a reference countable object
CObjectStack
CObjPointer
CObjPointerStorage
COffsetSubMapper	Index mapper which simply adds an offset to the index
COperator	Abstract operator
COrderCalculatorInterface	Quadrature Order Interface
COutStreamInterface	Abstract interface for an output stream
CPAdaptiveDGSpace	Adaptive DG discrete function space
CPAdaptiveLagrangeSpace	Lagrange discrete function space
CParallelScalarProduct
CParameter	Container for User Specified Parameters
CPersistenceManager	Class with singleton instance managing all persistent objects
CPersistentIndexSet	Please doc me
CPersistentIndexSetInterface	Virtual base class for persistent index sets
CPersistentObject	Base class for persistent objects
CPetscInverseOperatorAvailable	PETSc KSP solver context for PETSc Mat and PETSc Vec
CPODArrayAllocator
CPointBasedDofConversionUtility	Specialisation for PointBased approach
CPointGeometry	Generic geometry modelling a single point
CPointTwistMapperStrategy
CPowerMapper	Mapper allocating one DoF per subentity of a given codimension
CPreconditionerFunctionWrapper	Wrapper for functions passed from Python side that implements a preconditioner
CPrimaryDofs	In parallel computations the dofs of a discrete function are made up by all primary dofs. For technical reasons some dofs exists on multiply processes but are only primary on exactly one process
CProductGeometry	Generic geometry modelling the product of two base geometries
CProlongFunction	Prolong discrete functions between grid levels
CPyramidGeometry	Generic geometry modelling a pyramid over a base geometry
CPyramidPoints
CQuadCreator	Actual quadrature storage
CQuadPtsBase	One-dimensional quadrature points and their weights
CQuadratureImp	Generic implementation of a Dune quadrature
CQuadraturePointIterator	Iterator over quadrature points
CQuadraturePointWrapper	Wrapper for a (Quadrature,int) pair
CQuadratureProvider	Provide a single instance pool of quadratures
CQuadratureRulesFactory	Quadrature implementation based on the standard DUNE quadratures
CQuadrilateralTwistMapperStrategy
CRadialFilter	Given center x and radius r, filter is characteristic function of clos B_r( x )
CRangeMatrix	RangeType class for matrix valued functions - derived from FieldMatrix but has representation as vector
CReferenceBlockVector	This is the reference implementation of a block vector as it is expected as the second template parameter to Dune::Fem::BlockVectorDiscreteFunction
CReferenceCounterDefault	Default implementation of ReferenceCounterInterface
CReferenceCounterInterface	Interface for objects capable of reference counting
CRestrictFunction	Restrict discrete functions between grid levels
CRestrictProlongDefault	This is a wrapper for the default implemented restriction/prolongation operator, which only takes a discrete function template
CRestrictProlongDefaultTuple	Conveniently set up a tuple of Dune::Fem::RestrictProlongDefault restriction/prolongation objects created from a variadic list of discrete functions
CRestrictProlongInterface	Interface class defining the local behaviour of the restrict/prolong operation (using BN)
CRestrictProlongInterfaceDefault	Interface default implementation for derived classes
CRestrictProlongTraits	Traits class for derivation from RestrictProlongInterface
CRestrictProlongTuple	Combine a variadic number of Dune::Fem::RestrictProlongInterface instances into a single object again derived from Dune::Fem::RestrictProlongInterface
CScaledLocalOperator
CShapeFunctionSet	Interface class for shape function sets
CShapeFunctionSets	Interface class representing a family of shape function sets
CSimpleBasisFunctionSet	This class is a simple basis function set which is needed for global basis functions sets (Fourier space etc.)
CSimpleBlockVector	This is the reference implementation of a block vector as it is expected as the second template parameter to Dune::Fem::BlockVectorDiscreteFunction
CSimpleStencil	Watered down stencil providing only the upper bound for the non-zero entries per row
CSingleThreadModeError	Exception thrown when a code segment that is supposed to be only accessed in single thread mode is accessed in multi thread mode. For example, creation of quadratures or basis function caching cannot work in multi thread mode
CSingleton	Return singleton instance of given Object type
CSingletonList	Singleton list for key/object pairs
CSIONlibInStream	Input stream reading from a file in binary form
CSIONlibOutStream	Output stream writing into a single file with the SIONlib (http://www2.fz-juelich.de/jsc/sionlib/)
CSpaceOperatorInterface	Interface for time evolution operators
CSpaceOperatorPtr	Only for keeping the pointer
CSpaceOperatorStorage	Only for keeping the pointer
CSpaceOperatorWrapper	Apply wrapper
CSparseRowLinearOperator	SparseRowLinearOperator
CSparseRowMatrix	SparseRowMatrix
►CSparseRowMatrixObject	SparseRowMatrixObject
CLocalMatrix	LocalMatrix
CLocalMatrixTraits	LocalMatrixTraits
CStandardArrayAllocator	Oriented to the STL Allocator funtionality
CStandardInStream	Input stream reading from a given std::istream
CStandardOutStream	Output stream writing into a given std::ostream
CStaticArray	An implementation of DenseVector which uses a C-array of fixed size as storage
CStaticOffsetSubMapper	Index mapper with static size which simply adds an offset to the index
CStencil	Default implementation for a general operator stencil
CStencilWrapper	Simple wrapper class for sparsity patterns provide as vector< set< size_t > >
CStreamFactory	Factory class for Fem Streams to deal with different constructor parameters
CStreamFactory< SIONlibInStream >	Factory class for Fem Streams to deal with different constructor parameters
CSubDofVector	Extract Sub dof vector for single coordinate
CSubFunctionStorage
CSubVector	An implementation of DenseVector to extract a portion, not necessarly contiguos, of a vector
CTemporaryLocalFunction	A temporary function carrying values for one entity
CTemporaryLocalMatrix	A local matrix with a small array as storage
CThreadIterator	Thread iterators
CThreadIteratorStorage	Storage of thread iterators
CThreadIteratorStorageBase	Storage of thread iterators using domain decomposition
CThreadSafeValue	ThreadSafeValue realizes thread safety for a given variable by creating an instance of this variable for each thread
CTimeProvider	Manager for global simulation time of time-dependent solutions
CTimeProviderBase	General base for time providers
CToNewDimDomainFunctionSpace	Convert functions space to space with new dim domain
CToNewDimDomainFunctionSpace< FunctionSpace< DomainFieldImp, RangeFieldImp, dimDomain, dimRange >, newDimDomain >	Specialization for parameter list <domainfile,rangefield,dimDomain,dimRange,newDimDomain>
CToNewDimDomainFunctionSpace< MatrixFunctionSpace< DomainFieldImp, RangeFieldImp, n, m1, m2 >, newDimDomain >	Specialization for parameter list <domainfile,rangefield,dimDomain,dimRange,dimLocal>
CToNewDimRangeFunctionSpace	Convert functions space to space with new dim range
CToNewDimRangeFunctionSpace< FunctionSpace< DomainFieldImp, RangeFieldImp, dimDomain, dimRange >, newDimRange >	Specialization for parameter list <domainfile,rangefield,dimDomain,dimRange,dimLocal>
CTransformedBasisFunctionSet	Implementation of a basis function set for given entity
CTriangleTwistMapperStrategy
►CTupleDiscreteFunction	Forward declaration
CSubDiscreteFunction	Helper struct to get the type of the i-th sub function
CTupleMapper	Mapper allocating one DoF per subentity of a given codimension
CTwistFreeTwistUtility	TwistFreeTwistUtility provides the default implementation for twistfree grid such as Cartesian grids
CTwistMapperCreator	Helper class for TwistProvider which takes care of the creation process
CTwistMapperStrategy	This class factors out all geometry dependent stuff in a strategy class
CTwistProvider	Access point for PointMapper objects with twist information PointMapper objects get created once and are reused as often as needed. The TwistProvider serves in this context as the single point of access which is responsible for the creation and management of these objects. TwistProvider follows the monostate pattern
CTwistStorage	Identifies quadrature points on faces with twists For a given quadrature type and a face with a given twist the TwistMapper provides a mapping from the quadrature point number on the twisted face to the quadrature point number on the (untwisted) reference face. (It removes the twist from the quadrature, so to say.) This is needed in unstructured grids when a quadrature point on a reference element's face needs to be transformed to a quadrature point in the reference element itself
CTwistUtility	Utility to get twist from IntersectionIterator, if provided by grid (i.e. AlbertaGrid, ALUGrid) otherwise return default values (correct for YASP)
CTwistUtility< AlbertaGrid< dim, dimW > >	Specialization of TwistUtility for AlbertaGrid
CVectorialBasisFunctionSet	Builds a vectorial basis function set from given scalar basis function set
CVectorSpaceTraits	Traits class for vector function spaces
CVerticalDofAlignment	Implementation of DofAlignment
CVTKIOBase	Output using VTK
CVtxProjection	The Projection class which average discontinuous function using the interpolation of the space (e.g. the Lagrangepoints)
►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
►NGeo
►CReferenceElement	This class provides access to geometric and topological properties of a reference element
CCodim	Collection of types depending on the codimension
CReferenceElements	Class providing access to the singletons of the reference elements
►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
►NHybrid
CHybridFunctor	Adapter of a hybrid functor that maintains results hybrid
►NILU
CCRS	Simple compressed row storage matrix class
►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
►NMatrixImp
►CDenseMatrixBase	A Vector of blocks with different blocksizes
CConstIterator	ConstIterator class for sequential access
CIterator	Iterator class for sequential access
►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
►NMonomImp
CEvalAccess	Access output vector of evaluateFunction() and evaluate()
CEvaluate
CEvaluate< Traits, 1 >
CJacobianAccess	Access output vector of evaluateJacobian()
►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
►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
►NVcImpl
CIsMask	Specialized to true for Vc mask types
CIsVector	Specialized to true for Vc vector and mask types
CProxy	A reference-like proxy for elements of random-access vectors
CEndMark	Final element marker for RebindList
►NStd	Namespace for features backported from new C++ standards
Ccompare_three_way	A functor implementing the three-way comparison on the arguments
Cdefault_accessor	A type for indexed access to elements of mdspan
Cextents	Multidimensional index space with dynamic and static extents
Cidentity	A function object type whose operator() returns its argument unchanged
►Clayout_left	A layout where the leftmost extent has stride 1
Cmapping	A layout mapping where the leftmost extent has stride 1
►Clayout_right	A layout where the rightmost extent has stride 1, and strides increase right-to-left as the product of extents
Cmapping	A layout mapping where the rightmost extent has stride 1
►Clayout_stride	A layout mapping where the strides are user-defined
Cmapping	A layout mapping where the strides are user-defined
Cmdarray	An owning multi-dimensional array analog of mdspan
Cmdspan	A multi-dimensional non-owning array view
Cnonesuch	Type representing a lookup failure by std::detected_or and friends
Cspan	A contiguous sequence of elements with static or dynamic extent
►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
CTypesWriter	Writer for the types array
CVTKFunctionWriter	Base class for function writers
CVTUWriter	Dump a .vtu/.vtp files contents to a stream
►NYasp
CFixedSizePartitioning	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
CPartitioning	Base class for the yaspgrid partitioning strategy
CPowerDPartitioning	Implement yaspgrid load balance strategy for P=x^{dim} processors
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
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
►CArithmeticTestSuite	Test suite for arithmetic types
CArithmetic	Tag denoting any arithmetic type
CBoolean	Tag denoting boolean types
CFloating	Tag denoting floating point types
CIntegral	Tag denoting integral types
CSigned	Tag denoting signed integral types
CUnsigned	Tag denoting unsigned integral types
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
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 reference quadrialteral
CBDFMCubeLocalBasis< D, R, 2, 2 >	Second order Brezzi-Douglas-Fortin-Marini shape functions on the reference quadrialteral
CBDFMCubeLocalBasis< D, R, 2, 3 >	Third order Brezzi-Douglas-Fortin-Marini shape functions on the reference 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
CCholmod	Dune wrapper for SuiteSparse/CHOLMOD solver
CCloneable	An interface class for cloneable objects
CCodim	Static tag representing a codimension
CCoefficientsInterface	Interface for global-valued coefficients
CColCompMatrix< Fem::SparseRowMatrix< T, IndexT, ValuesVector, IndicesVector >, RowIndex >	Converter for SparseRowMatrix to column-compressed matrix. Specialization for SparseRowMatrix
►CCollectiveIterator	A collective iterator for moving over the remote indices for all processes collectively
Citerator	Iterator over the valid underlying iterators
CCollectorStream	Data collector stream
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 interpret 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
CConstTuple	Add const qualifier to all tuple elements
CContainerWrapperIterator	Iterator class for sparse vector-like containers
CCopyableOptional	A copyable type wrapper that provides copy/move assignment operations for types that are only copy/move constructible
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
CDefaultSVGMatrixOptions	Default options class to write SVG matrices
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
CDereferenceTuple	Dereference pointer tuple
CDGFBoundaryParameter	Contains types for additional features
CDGFException	Exception class for IO errors in the DGF parser
CDGFGridFactory< Dune::YaspGrid< dim, Dune::TensorProductCoordinates< ctype, dim > > >	Placeholder for grid factory for YaspGrid with tensor product coordinates
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
►CDiscontinuousLocalFiniteElement	Meta-finite element turning a finite-element into "discontinuous" finite-element by associating all basis functions to the element interior
CTraits	Types of component objects
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
CDynamicLagrangeLocalFiniteElementCache	A cache that stores Lagrange finite elements for the given dimension and order
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
CExceptionStream	Class for extending a Dune::Exception with a stream interface
CExecutionTimer	Class with a start and stop method for timing parts of a program
CExtendedEntity	Wrapper class for wrapped entities added a cast operator to the host entity
CFactorial
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
CFuture	Type-erasure for future-like objects. A future-like object is a object satisfying the interface of FutureBase
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
CGeometryTypeMap	Associative container assigning values to each GeometryType
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	Linear Lagrange functions enriched with quadratic edge bubble functions and an element bubble function
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	P1 basis in dim-d enriched by quadratic edge bubble functions and an element bubble function of order dim+1
CHierarchicalSimplexP2WithElementBubbleLocalCoefficients	The local keys of the hierarchical basis functions with element bubble
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
CIndexedIterator	An iterator mixin that adds an index() method returning an enumeration index for the traversal
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
CInstantiateTuple	Instantiate a tuple of elements with identical, simple constructors
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
CIsCompileTimeConstant	Check if T is an integral constant or any type derived from std::integral_constant
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
CIsNumber< bigunsignedint< k > >	Declare big unsigned int is a number
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
CIteratorFacade	CRTP-Mixing class for stl conformant iterators of given iterator category
CIteratorFacadeAccess	This class encapsulates access of IteratorFacade
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
CLagrangeBasisFactory	Factory for Lagrange local basis based on a Lagrange point-set
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
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
CLeafGnuplotWriter	GnuplotWriter on the leaf grid
CLevelGnuplotWriter	GnuplotWriter on a given level grid
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
CLocalFiniteElementGeometry	Geometry implementation based on local-basis function parametrization
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
CMappedGeometry	Geometry parametrized by a LocalFunction and a LocalGeometry
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 for creating 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
CMonomialLocalCoefficients
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
CNedelecBasisFactory
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
CNoAssembledOperator	This exception is thrown if the requested solver or preconditioner needs an assembled matrix
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
COperator	An abstract operator Interface class for Operators. Operators are applied to Functions and the result is a Function again
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 communication
CP0LocalBasis
CP0LocalCoefficients
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
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
CPointerTuple	Convert a tuple to a tuple of pointer types
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
►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
CProxyArrowResult	Helper to mimic a pointer for proxy objects
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
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
CReferenceTuple	Convert a tuple to a tuple of references
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
CRemoveConstTuple	Remove const qualifiers from tuple
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
CRT02DLocalCoefficients
CRT02DLocalFiniteElement	Zero order Raviart-Thomas shape functions on triangles
CRT03DLocalBasis
CRT03DLocalCoefficients
CRT03DLocalFiniteElement	Zero order Raviart-Thomas shape functions on tetrahedra
CRT0Cube2DLocalBasis
CRT0Cube2DLocalCoefficients
CRT0Cube2DLocalFiniteElement	Zero order Raviart-Thomas shape functions on rectangles
CRT0Cube2DLocalInterpolation
CRT0Cube3DLocalBasis
CRT0Cube3DLocalCoefficients
CRT0Cube3DLocalFiniteElement	Zero order Raviart-Thomas shape functions on cubes
CRT0Cube3DLocalInterpolation
CRT0PrismLocalBasis	First order Raviart-Thomas shape functions on the reference prism
CRT0PrismLocalCoefficients	Layout map for Raviart-Thomas-1 elements on prisms
CRT0PrismLocalFiniteElement	First order Raviart-Thomas shape functions on prisms
CRT0PrismLocalInterpolation	First order Raviart-Thomas shape functions on the reference prism
CRT0PyramidLocalBasis	First order Raviart-Thomas shape functions on the reference pyramid
CRT0PyramidLocalCoefficients	Layout map for Raviart-Thomas-1 elements on pyramids
CRT0PyramidLocalFiniteElement	First order Raviart-Thomas shape functions on pyramids
CRT0PyramidLocalInterpolation	First 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
CSeqDILU	Sequential DILU preconditioner
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
CSimplexP1BubbleLocalBasis	P1 basis in dim-d enriched by an (order dim+1) element bubble function
CSimplexP1BubbleLocalCoefficients	The Local keys associated to the dim-d local basis functions
CSimplexP1BubbleLocalFiniteElement	Linear Lagrange functions enriched with an element bubble function
CSimplexP1BubbleLocalInterpolation	Interpolation into the SimplexP1BubbleLocalBasis
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
►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
CStaticLagrangeLocalFiniteElementCache	A cache that stores all available Pk/Qk like local finite elements for the given dimension and order for the case that the GeometryType is fixed and has the given Id
CStaticLagrangeLocalFiniteElementCache< GeometryType::Id(~0u), Domain, Range, dim, order >	A cache that stores all available Pk/Qk like local finite elements for the given dimension and order
►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
CTestSuite	A Simple helper class to organize your test suite
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$)
CTupleToVectorConverter	Wrapper class to convert a vector of tuples of RangeTypes into something that behaves like a vector< RangeType >
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
CValidPointerTupleCheck	Check whether a pointer tuple can be dereferenced
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
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
►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 output 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 output 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
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
CZero	A class representing the zero of a given Field
►NDuneODE
CBasicImplicitRungeKuttaSolver	Implicit RungeKutta ODE solver
CBasicROWRungeKuttaSolver	ROW RungeKutta ODE solver
CExplicitMultiStepSolver	Exlicit multi step ODE solver
CExplicitRungeKuttaSolver	Exlicit RungeKutta ODE solver
CExplMultiStepBase
CImplicitRungeKuttaSolver	Implicit RungeKutta ODE solver
COdeSolverInterface	Interface class for ODE Solver
CPIDTimeStepControl	PID time step control
CROWRungeKuttaSolver	ROW RungeKutta ODE solver
CSemiImplicitRungeKuttaSolver	Implicit RungeKutta ODE solver
►Nstd	STL namespace
Ctuple_element< i, Dune::MultiTypeBlockMatrix< Args... > >	Make std::tuple_element work for MultiTypeBlockMatrix
Ctuple_element< i, Dune::MultiTypeBlockVector< Args... > >	Make std::tuple_element work for MultiTypeBlockVector
Ctuple_element< i, Dune::TupleVector< Args... > >	Make std::tuple_element work for TupleVector
Ctuple_size< Dune::MultiTypeBlockMatrix< Args... > >	Make std::tuple_size work for MultiTypeBlockMatrix
Ctuple_size< Dune::MultiTypeBlockVector< Args... > >	Make std::tuple_size work for MultiTypeBlockVector
Ctuple_size< Dune::TupleVector< Args... > >	Make std::tuple_size work for TupleVector
CBlockVectorDiscreteFunctionTraits	Traits class for a BlockVectorDiscreteFunction
CDifferentiableEllipticOperator	[Class for linearizable elliptic operator]
CDiscreteFunctionSpace	Discrete function space
CElementQuadrature	Quadrature on the codim-0 reference element
CEllipticOperator	[Class for elliptic operator]
CFemTimer	Class with singleton instance managing timing for parts of program
CFixedStepTimerProvider	Simple time provider for constant time steps
CGlobalGeometryTypeMap	Please doc me
CisAdaptiveDofeMapper	Specialize with true if the mapper supports adaptivity
CLocalGeometryTypeMap	Please doc me
CMatrixInfo	Class template which yields information related to a square matrix like its spectral (i.e. 2-norm) condition number
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)
CMisalignedAddress	Exception thrown when an object is allocated with a misaligned address
CModified	One-dimensional modified Newton-Cotes points and their weights The difference to Newton-Cotes is that the first and last interval is only h/2 instead of h in the original Newton-Cotes rule. This allows to compute integrals of DG functions on quadrature points that correspond to a finite volume submesh
CMPIError	MPI Error. Thrown when an mpi error occurs
CMyVector
CQuadrature	Actual interface class for quadratures
CSelectQuadraturePointSetId
CTestPartial	Helper class to test the 'partial' method