Namespace List

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

[detail level 1234]

►NDune	Dune namespace
►NCapabilities	Contains all capabilities classes
CcanCommunicate	Specialize with 'true' for all codims that a grid can communicate data on (default=false)
ChasBackupRestoreFacilities	Specialize with 'true' if implementation provides backup and restore facilities. (default=false)
ChasBackupRestoreFacilities< AlbertaGrid< dim, dimworld > >	AlbertaGrid has backup and restore facilities
ChasBackupRestoreFacilities< ALUConformGrid< dim, dimw > >	ALUConformGrid 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< Dune::ALUConformGrid< dim, dimw >, cdim >	ALUConformGrid has entities for all codimension
ChasEntity< OneDGrid, cdim >	OneDGrid has entities for all codimension
ChasEntity< SGrid< dim, dimw >, cdim >	SGrid has entities for all codimension
ChasEntity< UGGrid< dim >, 0 >	UGGrid has codim=0 entities (elements)
ChasEntity< UGGrid< dim >, dim >	UGGrid has codim=dim entities (vertices)
ChasEntity< YaspGrid< dim >, 0 >	YaspGrid has codim=0 entities (elements)
ChasEntity< YaspGrid< dim >, dim >	YaspGrid has codim=dim entities (vertices)
ChasSingleGeometryType	Specialize with 'true' for if the codimension 0 entity of the grid has only one possible geometry type. In this case the topologyId of this geometry type has also to be specified. (default=false, topologyId=undefined)
ChasSingleGeometryType< AlbertaGrid< dim, dimworld > >	AlbertaGrid has only one geometry type for codim 0 entities
ChasSingleGeometryType< OneDGrid >	OneDGrid has only one geometry type for codim 0 entities
ChasSingleGeometryType< SGrid< dim, dimw > >	SGrid has only one geometry type for codim 0 entities
ChasSingleGeometryType< YaspGrid< dim > >	YaspGrid has only one geometry type for codim 0 entities
CisCartesian	Specialize with 'true' if the grid is a Cartesian grid. Cartesian grids satisfy the following properties:
CisCartesian< SGrid< dim, dimw > >	SGrid is a Cartesian grid
CisCartesian< YaspGrid< dim > >	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< ALUConformGrid< dim, dimw > >	ALUConformGrid has a conforming leaf grid
CisLeafwiseConforming< OneDGrid >	OneDGrid is leafwise conforming
CisLeafwiseConforming< SGrid< dim, dimw > >	SGrid is leafwise conforming
CisLeafwiseConforming< UGGrid< dim > >	UGGrid may not be leafwise conforming
CisLeafwiseConforming< YaspGrid< dim > >	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< ALUConformGrid< dim, dimw > >	ALUConformGrid has non-conforming level grids
CisLevelwiseConforming< OneDGrid >	OneDGrid is levelwise conforming
CisLevelwiseConforming< SGrid< dim, dimw > >	SGrid is levelwise conforming
CisLevelwiseConforming< UGGrid< dim > >	UGGrid is levelwise conforming
CisLevelwiseConforming< YaspGrid< dim > >	YaspGrid is levelwise conforming
CisParallel	Specialize with 'true' if implementation supports parallelism. (default=false)
CisParallel< const ALUConformGrid< dim, dimw > >	ALUConformGrid is parallel
CisParallel< OneDGrid >	OneDGrid is not parallel
CisParallel< UGGrid< dim > >	UGGrid is parallel
CisParallel< YaspGrid< dim > >	YaspGrid is parallel
CthreadSafe	Specialize with 'true' if the grid implementation is thread safe. (default=false)
CviewThreadSafe	Specialize with 'true' if the grid implementation is thread safe, while it is not modified. (default=false)
►NFloatCmp
CDefaultEpsilon	Mapping from a value type and a compare style to a default epsilon
CEpsilonType	Mapping of value type to epsilon type
CEpsilonType< FieldVector< T, n > >	Specialization of EpsilonType for Dune::FieldVector
CEpsilonType< std::vector< T, A > >	Specialization of EpsilonType for std::vector
►NGeoGrid	Namespace containing the implementations of GeometryGrid
CEntity	DUNE-conform implementation of the entity
CEntityBase	Actual implementation of the entity
CEntityBase< codim, Grid, false >	construct an uninitialized entity
CEntityBase< codim, Grid, true >	construct an uninitialized entity
NQuadratureType	Defines an enum for currently available quadrature rules
►NRefinementImp	This namespace contains the implementation of Refinement
►NHCube	This namespace contains the Refinement implementation for hypercubes (GeometryType::cube)
CRefinementImp	Refinement implementation for hypercubes
CRefinementSubEntityIteratorSpecial	SubEntityIterator base class for hypercube refinement
NHCubeTriangulation	This namespace contains the Refinement implementation for triangulating hypercubes (GeometryType::cube -> GeometryType::simplex)
►NPrismTriangulation	This namespace contains the Refinement implementation for triangulating prisms (GeometryType::prism -> GeometryType::simplex)
CRefinementImp	Implementation of the refinement of a prism into simplices
►NPyramidTriangulation	This namespace contains the Refinement implementation for triangulating pyramids (GeometryType::pyramid -> GeometryType::simplex)
CRefinementImp	Implementation of the refinement of a pyramid into simplices
NSimplex	This namespace contains the Refinement implementation for simplices (triangles, tetrahedrons...)
CTraits	Mapping from geometryType, CoordType and coerceTo to a particular Refinement implementation
CAdderSelector	Template meta program for choosing how to add the correction
CAdditiveSchwarzMode	Tag that the tells the schwarz method to be additive
CAddPtrTypeEvaluator	TypeEvaluator to turn a type T into a pointer to T
CAddRefTypeEvaluator	TypeEvaluator to turn a type T into a reference to T
CAffineGeometry	Implementation of the Geometry interface for affine geometries
CAlbertaGrid	[ provides Dune::Grid ]
CAlbertaGridEntity
CAlbertaGridEntity< 0, dim, Grid >
CAlbertaGridEntityPointer	EntityPointer implementation for AlbertaGrid
CAlbertaGridGeometry	Geometry implementation for AlbertaGrid
CAlbertaGridHierarchicIterator
CAlbertaGridIdSet	Hierarchic index set of AlbertaGrid
CAlbertaGridTreeIterator
CAlbertaMarkerVector	Marker assigning subentities to one element containing them
CAlignmentOf	Calculates the alignment requirement of a type
CAllSet	A set containing everything
CALU2dGrid	[ provides Dune::Grid ]
CALU2dGridEntity
CALU2dGridEntity< 0, dim, GridImp >
CALU2dGridEntityPointer
CALU2dGridEntitySeed< 0, GridImp >
CALU2dGridGeometry
CALU2dGridHierarchicIndexSet	Hierarchic index set of ALU2dGrid
CALU2dGridHierarchicIterator	Hierarchic Iterator of ALU2dGrid
CALU2dGridIntersectionBase
CALU2dGridLocalIdSet	Hierarchic index set of ALU3dGrid
CALU3dGrid	[ provides Dune::Grid ]
CALU3dGridEntity
CALU3dGridEntity< 0, dim, GridImp >
CALU3dGridEntityPointer< 0, GridImp >
CALU3dGridEntityPointerBase
CALU3dGridEntitySeed< 0, GridImp >
CALU3dGridGeometricFaceInfoBase
CALU3dGridGeometricFaceInfoHexa
CALU3dGridGeometricFaceInfoTetra
CALU3dGridHierarchicIndexSet	Hierarchic index set of ALU3dGrid
CALU3dGridIntersectionIterator
CALU3dGridLeafIterator	Leaf iterator
CALU3dGridLeafVertexList
CALU3dGridLevelIterator
CALU3dGridVertexList
CALUConformGrid	[ provides Dune::Grid ]
CALUConformGrid< 2, dimw >	[ provides Dune::Grid ]
CALUCubeGrid	[ provides Dune::Grid ]
CALUCubeGrid< 2, dimw >	constructor for creating ALUSimplexGrid from given macro grid file
CALUCubeGrid< 3, 3 >	constructor for creating ALUCubeGrid from given macro grid file
CALUGrid	[ provides Dune::Grid ]
CALUGridBoundaryProjection	ALUGrid boundary projection implementation DuneBndProjection has to fulfil the DuneBoundaryProjection interface
CALUMemoryProvider	Organize the memory management for entitys used by the NeighborIterator
CALUSimplexGrid	[ provides Dune::Grid ]
CALUSimplexGrid< 2, dimw >	constructor for creating ALUSimplexGrid from given macro grid file
CALUSimplexGrid< 3, 3 >	constructor for creating ALUSimplexGrid from given macro grid file
CAlwaysFalse	Template which always yields a false value
CAlwaysTrue	Template which always yields a true value
CAmiraMeshWriter	Provides file writing facilities in the AmiraMesh format
CAnalyticalCoordFunction	Derive an implementation of an analytical coordinate function from this class
CAnalyticalCoordFunctionInterface	Interface class for using an analytical function to define the geometry of a Dune::GeometryGrid. An implementation should be derived from Dune::AnalyticalCoordFunction and the evaluate method mapping \( R^d\to R^r \) has to be supplied
Carray	Simple fixed size array class. This replaces std::array, if that is not available
CArrayList	A dynamically growing random access list
CArrayListIterator	A random access iterator for the Dune::ArrayList class
CAssembledLinearOperator	A linear operator exporting itself in matrix form
CAssociativePropertyMap	An adapter to turn an unique associative container into a property map
CAt	Reverse element access
CAtType	Type for reverse element access
CAutoPtrStack	Stack of pointers with auto destruction if the stack is destructed
CAxisAlignedCubeGeometry	A geometry implementation for axis-aligned hypercubes
Cb64chunk	Union representing the three byte text aswell as the four 6 bit chunks
Cb64data
Cb64txt	Struct with three bytes of text
CBackupRestoreFacility	Facility for writing and reading grids
CBackupRestoreFacility< ALUGrid< dim, dimworld, elType, refineType, Comm > >	facility for writing and reading grids
CBackupRestoreFacility< const Grid >	BackupRestoreFacility taking const Grid as type and deriving from the version with the const
CBase64Stream	Class to base64 encode a stream of data
Cbase_array	This container extends base_array_unmanaged by memory management with the usual copy semantics providing the full range of copy constructor, destructor and assignment operators
►Cbase_array_unmanaged	A simple array container for objects of type B
CRealIterator	Iterator implementation class
Cbase_array_window	Extend base_array_unmanaged by functions to manipulate
►CBCRSMatrix	A sparse block matrix with compressed row storage
CCreateIterator	Iterator class for sequential creation of blocks
CRealRowIterator	Iterator access to matrix rows
CBCRSMatrixError	Error specific to BCRSMatrix
CBDMatrix	A block-diagonal matrix
CBiCGSTABSolver	Bi-conjugate Gradient Stabilized (BiCG-STAB)
CBidirectionalIteratorFacade	Facade class for stl conformant bidirectional iterators
Cbigunsignedint	Portable very large unsigned integers
CBilinearMapping	A bilinear mapping
CBilinearSurfaceMapping	A bilinear surface mapping
CBitSetVector	A dynamic array of blocks of booleans
CBitSetVectorConstReference	A proxy class that acts as a const reference to a single bitset in a BitSetVector
CBitSetVectorReference	A proxy class that acts as a mutable reference to a single bitset in a BitSetVector
CBL	Compile-time parameter for block recursion depth
Cblock_vector_unmanaged	An unmanaged vector of blocks
CBlockPreconditioner	Block parallel preconditioner
CBlockVector	A vector of blocks with memory management
CBlockVectorWindow
CBoundarySegment	Base class for classes implementing geometries of boundary segments
CBoundarySegmentWrapper
CBTDMatrix	A block-tridiagonal matrix
CBufferedCommunicator	A communicator that uses buffers to gather and scatter the data to be send or received
CCachedMultiLinearGeometry	Implement a MultiLinearGeometry with additional caching
CCGSolver	Conjugate gradient method
CCheckIfDiagonalPresent	Check whether the a matrix has diagonal values on blocklevel recursion levels
CCloneable	An interface class for cloneable objects
CColCompMatrix	Utility class for converting an ISTL Matrix into a column-compressed matrix
CColCompMatrix< BCRSMatrix< FieldMatrix< B, n, m >, TA > >	Converter for BCRSMatrix to column-compressed Matrix. specialization for BCRSMatrix
CColCompMatrixInitializer	Inititializer for the ColCompMatrix as needed by OverlappingSchwarz
CCollectiveCommunication	Collective communication interface and sequential default implementation
CCollectiveCommunication< MPI_Comm >	Specialization of CollectiveCommunication for MPI
►CCollectiveIterator	A collective iterator for moving over the remote indices for all processes collectively
Citerator	Iterator over the valid underlying iterators
CCombine	A set combining two other sets
CCombinedAdaptProlongRestrict	Class for combining 2 index sets together for adaptation process
CCombinedGrapeDisplay	Combines GrapeDataDisplays to one so that visualisation for parallel grid is more easy to handle
CCommDataHandleIF	CommDataHandleIF describes the features of a data handle for communication in parallel runs using the Grid::communicate methods. Here the Barton-Nackman trick is used to interprete data handle objects as its interface. Therefore usable data handle classes need to be derived from this class
CCommMatrixRow	Utility class for comunicating the matrix entries
CCommMatrixRowSize	Utility class to communicate and set the row sizes of a redistributed matrix
CCommMatrixSparsityPattern	Utility class to communicate and build the sparsity pattern of a redistributed matrix
Ccommon_bits	Activate if current and mask have common bits switched on
►CCommPolicy	Default policy used for communicating an indexed type
CCommunicationError	Error thrown if there was a problem with the communication
CCopyGatherScatter	GatherScatter default implementation that just copies data
►Ccompressed_base_array_unmanaged	A simple array container with non-consecutive index set
CRealIterator	Iterator class for sequential access
Ccompressed_block_vector_unmanaged
CCompressedBlockVectorWindow
CCompressionStatistics	Statistics about compression achieved in implicit mode
Cconditional	Select a type based on a condition
Cconst_reference	Get the 'const' version of a reference to a mutable object
Cconst_reference< BitSetVectorReference< block_size, Alloc > >
CConstantVolatileTraits	Determines wether a type is const or volatile and provides the unqualified types
CConstArrayListIterator	A constant random access iterator for the Dune::ArrayList class
CConstAssociativePropertyMap	An adaptor to turn an unique associative container into a property map
CContainerWrapperIterator	Iterator class for sparse vector-like containers
CConversion	Checks wether a type is convertible to another
CDebugAllocator	Allocators implementation which performs different kind of memory checks
CDebugStream	Generic class to implement debug output streams
CDebugStreamError	Standard exception for the debugstream
CDebugStreamState	Intermediate class to implement tie-operation of DebugStream
CDefaultIndexSet	DefaultIndexSet creates an index set by using the grids persistent container an a given pair of iterators
►CDefaultLeafIteratorTypes	LeafIterator tpyes for all codims and partition types
CCodim	The types of the iterator
►CDefaultLevelIteratorTypes	LevelIterator tpyes for all codims and partition types
CCodim	The types
CDenseIterator	Generic iterator class for dense vector and matrix implementations
CDenseMatrix	A dense n x m matrix
CDenseMatrixAssigner	You have to specialize this structure for any type that should be assignable to a DenseMatrix
CDenseVector	Interface for a class of dense vectors over a given field
CDGFBoundaryParameter	Contains types for additional features
CDGFException	Exception class for IO errors in the DGF parser
CDGFGridInfo	Some simple static information for a given GridType
CDGFWriter	Write a GridView to a DGF file
CDiagonalMatrix	A diagonal matrix of static size
CDiscreteCoordFunction	Derive an implementation of a discrete coordinate function from this class
CDiscreteCoordFunctionInterface	Interface class for using a discrete function to define the geometry of a Dune::GeometryGrid. An implementation should be derived from Dune::DiscreteCoordinateFunction and the evaluate method taking an entity of the host grid together with the number of a vertex returns the coordinate in \( R^r \) of that corner. The user must ensure continuity of this mapping. In addition an adapt method is provided which is called whenever adapt() is called on the Dune::GeometryGrid
CDuneBoundaryProjection	Interface class for vertex projection at the boundary
CDuneGridFormatParser	The DuneGridFormatParser class: reads a DGF file and stores build information in vector structures used by the MacroGrid class
CDynamicMatrix	Construct a matrix with a dynamic size
CDynamicMatrixSubdomainSolver	Exact subdomain solver using Dune::DynamicMatrix<T>::solve
CDynamicVector	Construct a vector with a dynamic size
CElement	Get the N-th element of a tuple
CElement< 0 >	Get the first element of a tuple
CElementTopologyMapping
CEmpty	Just an empty class
CEmptySet	An empty set
Cenable_if	Enable typedef if condition is met
CEnableIfInterOperable	Enable typedef if two types are interoperable
CEntity	Wrapper class for entities
►CEntity< 0, dim, GridImp, EntityImp >	Template specialization of Dune::Entity for Elements (codim==0)
CCodim	EntityPointer types of the different codimensions
CEntityDefaultImplementation	Default Implementations for EntityImp
CEntityDefaultImplementation< 0, dim, GridImp, EntityImp >	Default Implementations for EntityImp (Elements [cd=0])
CEntityInfo	Structure to hold statistical information about one type of entity
CEntityIterator	Interface class for an iterator over grid entities
CEntityPointer	Wrapper class for pointers to entities
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
CException	Base class for Dune-Exceptions
CExceptionHook	Base class to add a hook to the Dune::Exception
CFaceTopologyMapping
CFactorial	Calculates the factorial of m at compile time
CFactorial< 0 >	End of recursion of factorial via specialization
CFakeMPIHelper	A fake mpi helper
CFieldMatrix	A dense n x m matrix
CFieldVector	Vector space out of a tensor product of fields
CFirstPredicateIndex	Finding the index of a certain type in a tuple
CFirstTypeIndex	Find the first occurance of a type in a tuple
CFlattenTuple	Flatten a tuple of tuples
CFloatCmpOps	Class encapsulating a default epsilon
Cfmatrix_assigner	Fmatrix assignment operator
CFMatrixError	Error thrown if operations of a FieldMatrix fail
CFMatrixPrecision	Precisions for calculations with FieldMatrix and FieldVector
CForEachType	Helper template to clone the type definition of a tuple with the storage types replaced by a user-defined rule
CForEachValue	Helper template which implements iteration over all storage elements in a tuple
CForEachValuePair	Extension of ForEachValue to two tuples..
CForLoop	A static loop using TMP
CForwardIteratorFacade	Base class for stl conformant forward iterators
►CFunction	Base class template for function classes
CTraits	Traits class containing raw types
Cfvector_assigner	Fvector assignment operator
CGaussLobattoQuadratureInitHelper
CGaussLobattoQuadratureRule1D	Jacobi-Gauss quadrature for alpha=2, beta=0
CGaussQuadratureInitHelper
CGaussQuadratureRule1D	Gauss quadrature rule in 1D
CGcd	Calculator of the greatest common divisor
CGeneralizedPCGSolver	Generalized preconditioned conjugate gradient solver
►CGeneralVertexOrder	Class providing information on the ordering of vertices
Citerator	Iterate over the vertex indices of some sub-entity
CGenericIterator	Generic class for stl-conforming iterators for container classes with operator[]
►CGenericReferenceElement	This class provides access to geometric and topological properties of a reference element. This includes its type, the number of subentities, the volume, and a method for checking if a point is inside. The embedding of each subentity into the reference element is also provided
CCodim	Collection of types depending on the codimension
CSubEntityInfo	Topological and geometric information about the subentities of a reference element
CGenericReferenceElementContainer
CGenericReferenceElements	Class providing access to the singletons of the generic reference elements. Special methods are available for simplex and cube elements of any dimension. The method general can be used to obtain the reference element for a given geometry type
CGeometry	Wrapper class for geometries
CGeometryDefaultImplementation	Default implementation for class Geometry
►CGeometryGrid	Grid wrapper replacing the geometries
CCodim	Traits structure containing types for a codimension
CPartition	Types for GridView
CGeometryType	Unique label for each type of entities that can occur in DUNE grids
CGlobalGeometryTypeIndex	Compute indices for geometry types, taking the dimension into account
CGlobalLookupIndexSet	Decorates an index set with the possibility to find a global index that is mapped to a specific local
CGlobalUniversalMapper	Universal mapper based on global ids
CGmshReader	Read Gmsh mesh file
CGmshReaderOptions	Options for read operation
CGmshReaderParser	Dimension independent parts for GmshReaderParser
CGmshWriter	Write Gmsh mesh file
CGnuplotWriter	Writer for 1D grids in gnuplot format
CGradientSolver	Gradient method
CGrapeDataDisplay
CGrapeGridDisplay
Cgreater_or_equal	Greater or equal template test
►CGrid	Grid abstract base class
►CCodim	A Traits struct that collects all associated types of one implementation
CPartition	A struct collecting all types depending on the partition iterator type
CPartition	Types for GridView
►CGridDefaultImplementation
CReturnImplementationType	Helper class to choose correct implementation return type for getRealImplementation
CGridError	Base class for exceptions in Dune grid modules
CGridFactory	Provide a generic factory class for unstructured grids
CGridFactory< AlbertaGrid< dim, dimworld > >	Specialization of the generic GridFactory for AlbertaGrid
CGridFactory< UGGrid< dimworld > >	Specialization of the generic GridFactory for UGGrid
CGridFactoryInterface	Provide a generic factory class for unstructured grids
CGridObjectStreamOrDefault	Template to choose right Object stream type for a given class
CGridObjectStreamOrDefaultHelper
CGridObjectStreamOrDefaultHelper< false, GridImp, DefaultImp >
CGridPtr	Class for constructing grids from DGF files
►CGridTraits	A traits struct that collects all associated types of one grid model
►CCodim	Traits associated with a specific codim
CPartition	Traits associated with a specific grid partition type
CPartition	Traits associated with a specific grid partition type
►CGridView	Grid view abstract base class
►CCodim	A struct that collects all associated types of one implementation from the Traits class
CPartition	Define types needed to iterate over entities of a given partition type
CGridViewInfo	Structure to hold information about a certain GridView
CGridViewInfoGTCompare	Comparison object to sort GeometryType by majorly dimension
Chash	Functor for hashing objects of type T
CHasHierarchicIndexSet	Tagging interface to indicate that Grid has HierarchicIndexSet
CHasObjectStream	Tagging interface to indicate that Grid provides typedef ObjectStreamType
CHierarchicIterator	Enables iteration over all codim zero entities in a subtree See also the documentation of Dune::EntityPointer
CHierarchicSearch	Search an IndexSet for an Entity containing a given point
CHostGridAccess	Access to host grid objects
CIdentityMap	A property map that applies the identity function to integers
CIdentityMatrix	Read-only identity matrix
CIdSet	Id Set Interface
CILU0SubdomainSolver	Exact subdomain solver using ILU(p) with appropriate p
CILUSubdomainSolver	Base class encapsulating common algorithms of ILU0SubdomainSolver and ILUNSubdomainSolver
CImplementationDefined	Dummy struct used for documentation purposes
►CImplicitMatrixBuilder	A wrapper for uniform access to the BCRSMatrix during and after the build stage in implicit build mode
Crow_object	Proxy row object for entry access
CImplicitModeOverflowExhausted	The overflow error used during implicit BCRSMatrix construction was exhausted
CIndent	Utility class for handling nested indentation in output
CIndexInfoFromGrid	Information about the index distribution
CIndexPair	A pair consisting of a global and local index
CIndexSet	Index Set Interface base class
CIndexSetDefaultImplementation	Provide default implementation of method if IndexSet
CIndexStack
CIndicesSyncer	Class for recomputing missing indices of a distributed index set
Cintegral_constant	Generate a type for a given integral constant
CInterface	Communication interface between remote and local indices
CInterfaceBuilder	Base class of all classes representing a communication interface
CInterfaceInformation	Information describing an interface
CIntersection	Intersection of a mesh entities of codimension 0 ("elements") with a "neighboring" element or with the domain boundary
CIntersectionDefaultNormalVectors	Default Implementations of integrationOuterNormal and unitOuterNormal for IntersectionImp
CIntersectionIterator	Mesh entities of codimension 0 ("elements") allow to visit all intersections with "neighboring" elements and with the domain boundary
CIntersectionIteratorWrapper	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid
CInvalidIndexSetState	Exception indicating that the index set is not in the expected state
CInvalidStateException	Default exception if a function was called while the object is not in a valid state for that function
CInverseOperator	Abstract base class for all solvers
CInverseOperator2Preconditioner	Turns an InverseOperator into a Preconditioner
CInverseOperatorResult	Statistics about the application of an inverse operator
CIOError	Default exception class for I/O errors
Cios_base_all_saver	Utility class for storing and resetting stream attributes
Cis_lvalue_reference	Determine whether a type is a lvalue reference type
Cis_pointer	Is_pointer
Cis_same	Compile time test for testing whether two types are the same
CIsBaseOf	Checks wether a type is derived from another
CIsConst	Tests wether a type is constant
CIsDofManager	Tagging interface to indicate that class is of Type DofManager
CIsFieldVectorSizeCorrect	TMP to check the size of a DenseVectors statically, if possible
CIsInteroperable	Checks wether two types are interoperable
CIsMatrix	Test whether a type is an ISTL Matrix
CISTLError	Derive error class from the base class in common
►CIsType	Generator for predicates accepting one particular type
CPredicate	The actual predicate
CIsVolatile	Tests wether a type is volatile
CIteratorDirectionSelector	Helper template meta program for application of overlapping schwarz
CIteratorPropertyMap	Adapter to turn a random access iterator into a property map
CJacobi1QuadratureInitHelper
CJacobi1QuadratureRule1D	Jacobi-Gauss quadrature for alpha=1, beta=0
CJacobi2QuadratureInitHelper
CJacobi2QuadratureRule1D	Jacobi-Gauss quadrature for alpha=2, beta=0
CJoinTuples	Join two tuples
CLcm	Calculate the least common multiple of two numbers
CLeafAmiraMeshWriter	Provides file writing facilities in the AmiraMesh format for leaf grids
CLeafGnuplotWriter	GnuplotWriter on the leaf grid
CLeafIntersectionIteratorWrapper	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid
CLeafIterator	Enables iteration over all leaf entities of a codimension zero of a grid. See also the documentation of Dune::EntityPointer
CLeafMultipleCodimMultipleGeomTypeMapper	Multiple codim and multiple geometry type mapper for leaf entities
CLeafSingleCodimSingleGeomTypeMapper	Single codim and single geometry type mapper for leaf entities
CLevelAmiraMeshWriter	Provides file writing facilities in the AmiraMesh format for level grids
CLevelGnuplotWriter	GnuplotWriter on a given level grid
CLevelIntersectionIteratorWrapper	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid
CLevelIntersectionWrapper	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid
CLevelIterator	Enables iteration over all entities of a given codimension and level of a grid. See also the documentation of Dune::EntityPointer
CLevelMultipleCodimMultipleGeomTypeMapper	Multiple codim and multiple geometry type mapper for entities of one level
CLevelSingleCodimSingleGeomTypeMapper	Single codim and single geometry type mapper for entities of one level
CLinearMapping	A linear mapping
CLinearOperator	A linear operator
CLocalGeometryTypeIndex	Compute per-dimension indices for geometry types
CLocalIndex	An index present on the local process
CLocalUniversalMapper	Universal mapper based on local ids
CLoopSolver	Preconditioned loop solver
Clru	LRU Cache Container
CLvaluePropertyMapTag	Tag for the category of lvalue property maps
CMakeableInterfaceObject
CMallocAllocator	Allocators implementation which simply calls malloc/free
CMapper	Mapper interface
CMathematicalConstants	Provides commonly used mathematical constants
CMathError	Default exception class for mathematical errors
CMatMultMatResult	Helper TMP to get the result type of a sparse matrix matrix multiplication ( \(C=A*B\))
CMatrix	A generic dynamic dense matrix
CMatrixAdapter	Adapter to turn a matrix into a linear operator
CMatrixIndexSet	Stores the nonzero entries in a sparse matrix
CMatrixRowSet	Provides access to an iterator over all matrix rows
►CMatrixRowSubset	Provides access to an iterator over an arbitrary subset of matrix rows
Cconst_iterator	The matrix row iterator type
CMCMGElementLayout	Layout template for elements
CMCMGVertexLayout	Layout template for vertices
CMessageBufferIF	Communication message buffer interface. This class describes the interface for reading and writing data to the communication message buffer. As message buffers might be deeply implemented in various packages the message buffers implementations cannot be derived from this interface class. Therefore we just apply the engine concept to wrap the message buffer call and make sure that the interface is fulfilled
CMINRESSolver	Minimal Residual Method (MINRES)
CMockGeometry	Grid-independent geometry
CMPIGuard	Detects a thrown exception and communicates to all other processes
CMPIGuardError	This exception is thrown if the MPIGuard detects an error on a remote process
CMPIHelper	A real mpi helper
CMPITraits	A traits class describing the mapping of types onto MPI_Datatypes
CMPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >
CMPITraits< ParallelLocalIndex< T > >
CMultiLinearGeometry	Generic geometry implementation based on corner coordinates
►CMultiLinearGeometryTraits	Default traits class for MultiLinearGeometry
CCornerStorage	Template specifying the storage for the corners
ChasSingleGeometryType	Will there be only one geometry type for a dimension?
CMultipleCodimMultipleGeomTypeMapper	Implementation class for a multiple codim and multiple geometry type mapper
CMultiplicativeSchwarzMode	Tag that tells the Schwarz method to be multiplicative
Cmutable_reference	Get the 'mutable' version of a reference to a const object
CNegateSet	The negation of a set. An item is contained in the set if and only if it is not contained in the negated set
CNil	An empty class
CNonConformingFaceMapping
CNonConformingFaceMapping< hexa, Comm >	Non-conforming face mappings for hexahedra
CNonConformingFaceMapping< tetra, Comm >	Non-conforming face mappings for tetrahedra
CNonoverlappingBlockPreconditioner	Nonoverlapping parallel preconditioner
CNonoverlappingSchwarzOperator	A nonoverlapping operator with communication object
CNonoverlappingSchwarzScalarProduct	Nonoverlapping Scalar Product with communication object
CNotImplemented	Default exception for dummy implementations
Cnull_deleter	Implements the Deleter concept of shared_ptr without deleting anything
CNullPointerInitialiser	A helper template that initializes a tuple consisting of pointers to NULL
COneDGrid	One-dimensional adaptive grid
COutOfMemoryError	Default exception if memory allocation fails
COverlappingSchwarzInitializer	Initializer for SuperLU Matrices representing the subdomains
COverlappingSchwarzOperator	An overlapping schwarz operator
COverlappingSchwarzScalarProduct	Scalar product for overlapping schwarz methods
COwnerOverlapCopyAttributeSet	Attribute set for overlapping schwarz
►COwnerOverlapCopyCommunication	A class setting up standard communication for a two-valued attribute set with owner/overlap/copy semantics
CCopyGatherScatter	Gather/scatter callback for communcation
CP0VTKFunction	Take a vector and interpret it as cell data for the VTKWriter
CP1VTKFunction	Take a vector and interpret it as point data for the VTKWriter
CPair	A tuple consisting of two objects
CPair< T1, Nil >	A tuple consisting of one object. Specialization of Pair that really is a single value
CParallelError	Default exception if an error in the parallel communication of the programm occured
►CParallelIndexSet	Manager class for the mapping between local indices and globally unique indices
Citerator	The iterator over the pairs
CParallelLocalIndex	An index present on the local process with an additional attribute flag
CParameterTree	Hierarchical structure of string parameters
CParameterTreeParser	Parsers to set up a ParameterTree from various input sources
CParSSOR	A parallel SSOR preconditioner
CPersistentContainer	A class for storing data during an adaptation cycle
CPersistentContainerInterface	Persistent storage of data on all entities of a grid
CPersistentContainerMap	Map-based implementation of the PersistentContainer
CPersistentContainerVector	Vector-based implementation of the PersistentContainer
CPointerPairDeletor	Deletes all objects pointed to in a tuple of pointers
CPool	A memory pool of objects
►CPoolAllocator	An allocator managing a pool of objects for reuse
Crebind	Rebind the allocator to another type
CPower	Compute power for a run-time mantissa and a compile-time integer exponent
CPreconditioner	Base class for matrix free definition of preconditioners
CPrismQuadraturePoints
CPrismQuadraturePoints< 3 >
CPrismQuadraturePointsSingleton	Singleton holding the Prism Quadrature points
CPrismQuadraturePointsSingleton< 3 >	Singleton holding the Prism Quadrature points
CPrismQuadratureRule	Quadrature rules for prisms
CPrismQuadratureRule< ct, 3 >	Quadrature rules for prisms
CPropertyMapTypeSelector	Selector for the property map type
CPushBackTuple	Helper template to append a type to a tuple
CPushFrontTuple	Helper template to prepend a type to a tuple
CQuadratureOrderOutOfRange	Exception thrown if a desired QuadratureRule is not available, because the requested order is to high
CQuadraturePoint	Single evaluation point in a quadrature rule
CQuadratureRule	Abstract base class for quadrature rules
CQuadratureRuleFactory	Factory class for creation of quadrature rules, depending on GeometryType, order and QuadratureType
CQuadratureRules	A container for all quadrature rules of dimension dim
CRandomAccessIteratorFacade	Base class for stl conformant forward iterators
CRangeError	Default exception class for range errors
CRawStream	Write out data in binary
CReadablePropertyMapTag	Tag for the category of readable property maps
CReadWritePropertyMapTag	Tag for the category of readable and writable property maps
CReduceTuple	Apply reduce with meta binary function to template
CReduceTuple< F, Tuple, Seed, 0 >	Apply reduce with meta binary function to template
►CReferenceElement	This class provides access to geometric and topological properties of a reference element. This includes its type, the number of subentities, the volume, and a method for checking if a point is inside. The embedding of each subentity into the reference element is also provided
CCodim	Collection of types depending on the codimension
CSubEntityInfo	Topological information about the subentities of a reference element
CReferenceElements	Class providing access to the singletons of the reference elements. Special methods are available for simplex and cube elements of any dimension. The method general can be used to obtain the reference element for a given geometry type
CRemoteIndex	Information about an index residing on another processor
CRemoteIndexListModifier	Modifier for adding and/or deleting remote indices from the remote index list
CRemoteIndices	The indices present on remote processes
Cremove_const	Removes a const qualifier while preserving others
Cremove_pointer	Return the type a pointer type points to
Cremove_reference	Remove a reference from a type
CReservedVector	A Vector class with statically reserved memory
CRestartedGMResSolver	Implements the Generalized Minimal Residual (GMRes) method
CRichardson	Richardson preconditioner
CScalarProduct	Base class for scalar product and norm computation
CScalarProductChooser	Choose the approriate scalar product for a solver category
CScaledIdentityMatrix	A multiple of the identity matrix of static size
CSelection	A cached selection of indices
CSelectionIterator	A const iterator over an uncached selection
CSelectType	Select a type based on a condition
CSEntity
CSEntity< 0, dim, GridImp >
CSEntityBase
CSEntityPointer
CSEntitySeed
CSeqGS	Sequential Gauss Seidel preconditioner
CSeqILU0	Sequential ILU0 preconditioner
CSeqILUn	Sequential ILU(n) preconditioner
CSeqJac	The sequential jacobian preconditioner
CSeqOverlappingSchwarz	Sequential overlapping Schwarz preconditioner
CSeqOverlappingSchwarzApplier	Helper template meta program for application of overlapping schwarz
CSeqOverlappingSchwarzDomainSize
CSeqPardiso	The sequential Pardiso preconditioner
CSeqScalarProduct	Default implementation for the scalar case
CSeqSOR	Sequential SOR preconditioner
CSeqSSOR	Sequential SSOR preconditioner
CSGeometry
CSGrid	[ provides Dune::Grid ]
CSGridGlobalIdSet	Persistent, globally unique Ids
CSGridLevelIndexSet	Implementation of index set
Cshared_ptr	A reference counting smart pointer
CSharedCount	The object we reference
CSHierarchicStackElem
CSingleCodimSingleGeomTypeMapper	Implementation class for a single codim and single geometry type mapper
CSingleton	An adapter to turn a class into a singleton
CSingleTypeSizeCache	Organizes the caching of sizes for one grid and one GeometryType
CSIntersectionIterator
CSizeCache	Organizes the caching of sizes for one grid and one GeometryType
CSizeOne	Flag for marking indexed data structures where data at each index is of the same size
CSLevelIterator
CSLList	A single linked list
CSLListConstIterator	A constant iterator for the SLList
CSLListIterator	A mutable iterator for the SLList
CSLListModifyIterator	A mutable iterator for the SLList
CSolverCategory	Categories for the solvers
CStandardMathematicalConstants	Standard implementation of MathematicalConstants
CStarCDReader	File reader for the Star-CD format
CStaticPower	Calculates m^p at compile time
CStaticPower< m, 0 >	End of recursion via specialization
►CStaticRefinement	Wrap each Refinement implementation to get a consistent interface
CCodim	The Codim struct inherited from the Refinement implementation
CStructuredGridFactory	Construct structured cube and simplex grids in unstructured grid managers
CStructuredGridFactory< SGrid< dim, dim > >	Specialization of the StructuredGridFactory for SGrid
CStructuredGridFactory< YaspGrid< dim > >	Specialization of the StructuredGridFactory for YaspGrid
CSubsamplingVTKWriter	Writer for the output of subsampled grid functions in the vtk format
CSuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >	SuperLu Solver
CSuperLUMatrix	Utility class for converting an ISTL Matrix into a SuperLU Matrix
CSuperLUMatrix< BCRSMatrix< FieldMatrix< B, n, m >, TA > >	Converter for BCRSMatrix to SuperLU Matrix
CSurfaceNormalCalculator	A bilinear surface mapping
CSymmetricMultiplicativeSchwarzMode	Tag that tells the Schwarz method to be multiplicative and symmetric
CSystemError	Default exception class for OS errors
CTimer	A simple stop watch
CTimerError	Exception thrown by the Timer class
CTopologyFactory	Provide a factory over the generic topologies
CTopologySingletonFactory	A wrapper for a TopologyFactory providing singleton storage. Same usage as TopologyFactory but with empty release method an internal storage
►CTransformTupleFunctor	Helper class to implement transformTuple()
CTypeEvaluator	Export the TypeEvaluator template class for genericTransformTuple()
CTransposedMatMultMatResult	Helper TMP to get the result type of a sparse matrix matrix multiplication ( \(C=A*B\))
CTrilinearMapping
Ctuple	A Tuple of objects
Ctuple_element	Get the type of the N-th element of the tuple
Ctuple_element< 0, Pair< T1, T2 > >	Get the type of the first element of the tuple
Ctuple_size	Template meta_programm to query the size of a tuple
CTupleToPairs	Converts the Tuple to a list of pairs
CTupleToPairs< T1, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil >	Specialization for a tuple consisting only of one type
CTypeTraits	General type traits class to check whether type is reference or pointer type
CUGGrid	Front-end for the grid manager of the finite element toolbox UG
CUMFPack	Use the UMFPack package to directly solve linear systems – empty default class
CUMFPack< BCRSMatrix< FieldMatrix< T, n, m >, A > >	The UMFPack direct sparse solver for matrices of type BCRSMatrix
CUncachedSelection	An uncached selection of indices
CUniversalMapper	Implements a mapper for an arbitrary subset of entities
►CVariableBlockVector	A Vector of blocks with different blocksizes
CConstIterator	ConstIterator class for sequential access
CCreateIterator	Iterator class for sequential creation of blocks
CIterator	Iterator class for sequential access
CVariableSize	Flag for marking indexed data structures where the data at each index may be a variable multiple of another type
CVariableSizeCommunicator	A buffered communicator where the amount of data sent does not have to be known a priori
►CVertexOrderByIdFactory	Factory for GeneralVertexOrder objects using an IdSet
CVertexOrder	Type of vertex order object may depend on the dimension of the element
CVirtualFunction	Virtual base class template for function classes
►CVirtualRefinement	VirtualRefinement base class
CCodim	Codim database of VirtualRefinement
CVTKFunction	A base class for grid functions with any return type and dimension
CVTKSequenceWriter	Writer for the ouput of grid functions in the vtk format
►CVTKWriter	Writer for the ouput of grid functions in the vtk format
CCellIterator	Iterator over the grids elements
CCornerIterator	Iterate over the elements' corners
CVertexIterator	Iterate over the grid's vertices
CWritablePropertyMapTag	Tag for the category of writable property maps
►CYaspGrid	[ provides Dune::Grid ]
CYGridLevel	A single grid level within a YaspGrid
Nstd	STL namespace