Class Hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:

[detail level 1234567]

CDune::AdderSelector< T, X, S >	Template meta program for choosing how to add the correction
CDune::AdditiveSchwarzMode	Tag that the tells the schwarz method to be additive
CDune::AddPtrTypeEvaluator< T >	TypeEvaluator to turn a type T into a pointer to T
CDune::AddRefTypeEvaluator< T >	TypeEvaluator to turn a type T into a reference to T
CDune::AffineGeometry< ct, mydim, cdim >	Implementation of the Geometry interface for affine geometries
CDune::Amg::Aggregate< G, S >	A class for temporarily storing the vertices of an aggregate in
CDune::Amg::Aggregate< MatrixGraph, VertexSet >
CDune::Amg::AggregatesMap< V >	Class providing information about the mapping of the vertices onto aggregates
CDune::Amg::AggregatesMap< Vertex >
CDune::Amg::AggregatesPublisher< 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
CDune::Amg::AggregationCriterion< T >	Base class of all aggregation criterions
CDune::Amg::Aggregator< G >	Class for building the aggregates
►CDune::AlbertaGridEntityPointer< codim, GridImp >	EntityPointer implementation for AlbertaGrid
CDune::AlbertaGridTreeIterator< codim, GridImp, true >
CDune::AlbertaGridTreeIterator< codim, GridImp, false >
CDune::AlbertaGridTreeIterator< codim, GridImp, leafIterator >
►CDune::AlbertaGridEntityPointer< 0, GridImp >
CDune::AlbertaGridHierarchicIterator< GridImp >
CDune::AlbertaGridGeometry< mydim, cdim, GridImp >	Geometry implementation for AlbertaGrid
CDune::AlbertaMarkerVector< dim, dimworld >	Marker assigning subentities to one element containing them
CDune::AlbertaMarkerVector< dim, Alberta::dimWorld >
CDune::AlignmentOf< T >	Calculates the alignment requirement of a type
CDune::AllSet< TA >	A set containing everything
CDune::ALU2dGridEntityPointer< codim, GridImp >
►CDune::ALU2dGridEntityPointer< 0, GridImp >
CDune::ALU2dGridHierarchicIterator< GridImp >	Hierarchic Iterator of ALU2dGrid
CDune::ALU2dGridEntityPointer< 1, GridImp >
CDune::ALU2dGridEntityPointer< 2, GridImp >
CDune::ALU2dGridEntityPointer< cdim, GridImp >
CDune::ALU2dGridEntitySeed< 0, GridImp >
CDune::ALU2dGridIntersectionBase< GridImp >
CDune::ALU3dGridEntityPointerBase< codim, GridImp >
►CDune::ALU3dGridEntityPointerBase< 0, GridImp >
CDune::ALU3dGridEntityPointer< 0, GridImp >
CDune::ALU3dGridEntityPointerBase< cd, GridImp >
CDune::ALU3dGridEntitySeed< 0, GridImp >
CDune::ALU3dGridGeometricFaceInfoBase< type, Comm >
►CDune::ALU3dGridGeometricFaceInfoBase< hexa, Comm >
CDune::ALU3dGridGeometricFaceInfoHexa< Comm >
►CDune::ALU3dGridGeometricFaceInfoBase< tetra, Comm >
CDune::ALU3dGridGeometricFaceInfoTetra< Comm >
CDune::ALU3dGridIntersectionIterator< GridImp >
CDune::ALU3dGridLeafVertexList< Comm >
CDune::ALU3dGridVertexList< Comm >
CDune::ALUConformGrid< dim, dimworld >	[ provides Dune::Grid ]
CDune::ALUCubeGrid< dim, dimworld >	[ provides Dune::Grid ]
CDune::ALUGrid< dim, dimworld, elType, refineType, Comm >	[ provides Dune::Grid ]
CDune::ALUGridBoundaryProjection< GridImp, ctype >	ALUGrid boundary projection implementation DuneBndProjection has to fulfil the DuneBoundaryProjection interface
CDune::ALUMemoryProvider< Object >	Organize the memory management for entitys used by the NeighborIterator
CDune::ALUMemoryProvider< EdgeObject >
CDune::ALUMemoryProvider< EntityObject >
CDune::ALUMemoryProvider< FaceObject >
CDune::ALUMemoryProvider< LeafIntersectionIteratorImp >
CDune::ALUMemoryProvider< LevelIntersectionIteratorImp >
CDune::ALUMemoryProvider< VertexObject >
CDune::ALUSimplexGrid< dim, dimworld >	[ provides Dune::Grid ]
CDune::AlwaysFalse< T >	Template which always yields a false value
CDune::AlwaysTrue< T >	Template which always yields a true value
CDune::AmiraMeshWriter< GridView >	Provides file writing facilities in the AmiraMesh format
►CDune::AmiraMeshWriter< GridType::LeafGridView >
CDune::LeafAmiraMeshWriter< GridType >	Provides file writing facilities in the AmiraMesh format for leaf grids
►CDune::AmiraMeshWriter< GridType::LevelGridView >
CDune::LevelAmiraMeshWriter< GridType >	Provides file writing facilities in the AmiraMesh format for level grids
►CDune::AnalyticalCoordFunctionInterface< ct, dimD, dimR, Impl >	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
CDune::AnalyticalCoordFunction< ct, dimD, dimR, Impl >	Derive an implementation of an analytical coordinate function from this class
►CDune::AnalyticalCoordFunctionInterface< ctype, dimD, dimR, IdenticalCoordFunction< ctype, dim > >
CDune::AnalyticalCoordFunction< ctype, dim, dim, IdenticalCoordFunction< ctype, dim > >
►CDune::AnalyticalCoordFunctionInterface< double, dimD, dimR, DGFCoordFunction< dimD, dimR > >
CDune::AnalyticalCoordFunction< double, dimD, dimR, DGFCoordFunction< dimD, dimR > >
►CDune::AnalyticalCoordFunctionInterface< HostGrid::ctype, dimD, dimR, IdenticalCoordFunction< HostGrid::ctype, dim > >
CDune::AnalyticalCoordFunction< HostGrid::ctype, dim, dim, IdenticalCoordFunction< HostGrid::ctype, dim > >
CDune::array< T, N >	Simple fixed size array class. This replaces std::array, if that is not available
CDune::array< alu3d_ctype, SIZE >
CDune::array< ct, SIZE >
CDune::array< ctype, SIZE >
CDune::array< CubeMapper< dim-1 >, dim >
CDune::array< double, SIZE >
CDune::array< Dune::FieldVector, numCorners >
CDune::array< Dune::FieldVector, numNormals >
CDune::array< Dune::FieldVector< alu3d_ctype, COLS >, ROWS >
CDune::array< Dune::FieldVector< ctype, COLS >, ROWS >
CDune::array< Dune::FieldVector< K, COLS >, ROWS >
CDune::array< Dune::FieldVector< Real, COLS >, ROWS >
CDune::array< Dune::FieldVector< T, COLS >, ROWS >
CDune::array< int, dim >
CDune::array< int, dimworld *2-2 >
CDune::array< int, SIZE >
CDune::array< K, SIZE >
CDune::array< MemberType, chunkSize_ >
CDune::array< Real, SIZE >
CDune::array< std::vector< double >, 2 >
CDune::array< T, SIZE >
CDune::array< unsigned int, dim >
CDune::array< unsigned int, dim+2 >
CDune::ArrayList< T, N, A >	A dynamically growing random access list
CDune::ArrayList< Dune::IndexPair, 100 >
CDune::ArrayList< Dune::IndexPair, N >
CDune::ArrayList< IndexPair< TG, TL >, N, std::allocator< Dune::IndexPair< TG, TL > > >
CDune::ArrayList< T, N, A >
CDune::AssociativePropertyMap< T >	An adapter to turn an unique associative container into a property map
CDune::At< N >	Reverse element access
CDune::AtType< N, Tuple >	Type for reverse element access
CDune::AxisAlignedCubeGeometry< CoordType, dim, coorddim >	A geometry implementation for axis-aligned hypercubes
►CDune::AxisAlignedCubeGeometry< GridImp::ctype, mydim, cdim >
CDune::SGeometry< mydim, cdim, GridImp >
CDune::b64chunk	Union representing the three byte text aswell as the four 6 bit chunks
CDune::b64data
CDune::b64txt	Struct with three bytes of text
►CDune::BackupRestoreFacility< Grid >	Facility for writing and reading grids
CDune::BackupRestoreFacility< const Grid >	BackupRestoreFacility taking const Grid as type and deriving from the version with the const
CDune::BackupRestoreFacility< ALUGrid< dim, dimworld, elType, refineType, Comm > >	facility for writing and reading grids
CDune::Base64Stream	Class to base64 encode a stream of data
CDune::base_array_unmanaged< B, A >	A simple array container for objects of type B
►CDune::base_array_unmanaged< B, std::allocator< B > >
►CDune::block_vector_unmanaged< B, std::allocator< B > >
CDune::BlockVector< B, A >	A vector of blocks with memory management
CDune::BlockVectorWindow< B, A >
CDune::VariableBlockVector< B, A >	A Vector of blocks with different blocksizes
CDune::base_array< B, A >	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
CDune::base_array_window< B, A >	Extend base_array_unmanaged by functions to manipulate
CDune::block_vector_unmanaged< B, A >	An unmanaged vector of blocks
►CDune::base_array_unmanaged< double, std::allocator< double > >
►CDune::block_vector_unmanaged< double, std::allocator< double > >
CDune::VariableBlockVector< double, std::allocator< double > >
►CDune::base_array_unmanaged< Dune::FieldVector< T, n >, A >
►CDune::block_vector_unmanaged< Dune::FieldVector< T, n >, A >
CDune::BlockVector< Dune::FieldVector< T, n >, A >
►CDune::base_array_unmanaged< T, std::allocator< T > >
►CDune::block_vector_unmanaged< T, std::allocator< T > >
CDune::VariableBlockVector< T, std::allocator< T > >
CDune::GenericGeometry::BasicGeometry< mydim, Traits >	Generic implementation of DUNE geometries
►CDune::GenericGeometry::BasicGeometry< mydim, GenericGeometry::DefaultGeometryTraits< ctype, coorddim, coorddim > >
CDune::MockGeometry< ctype, mydim, coorddim >	Grid-independent geometry
►CDune::GenericGeometry::BasicGeometry< mydim, GlobalGeometryTraits< Grid > >
CDune::GenericGeometry::Geometry< mydim, cdim, Grid >	Generic implementation of a DUNE (global) geometry
►CDune::GenericGeometry::BasicGeometry< mydim, LocalGeometryTraits< Grid > >
CDune::GenericGeometry::LocalGeometry< mydim, cdim, Grid >	Generic implementation of a DUNE (local) geometry
CDune::BCRSMatrix< B, A >	A sparse block matrix with compressed row storage
►CDune::BCRSMatrix< B, std::allocator< B > >
CDune::BDMatrix< B, A >	A block-diagonal matrix
CDune::BTDMatrix< B, A >	A block-tridiagonal matrix
CDune::BidirectionalIteratorFacade< T, V, R, D >	Facade class for stl conformant bidirectional iterators
►CDune::BidirectionalIteratorFacade< ContainerWrapperIterator< CW, T, R >, T, R, int >
CDune::ContainerWrapperIterator< CW, T, R >	Iterator class for sparse vector-like containers
►CDune::BidirectionalIteratorFacade< LevelIterator< C, T1 >, T1, T1 & >
CDune::Amg::Hierarchy< T, A >::LevelIterator< C, T1 >	Iterator over the levels in the hierarchy
►CDune::BidirectionalIteratorFacade< RealIterator< T >, T >
CDune::compressed_base_array_unmanaged< B, A >::RealIterator< T >	Iterator class for sequential access
CDune::bigunsignedint< k >	Portable very large unsigned integers
CDune::BilinearMapping< cdim >	A bilinear mapping
►CDune::BitSetVectorConstReference< block_size, Alloc >	A proxy class that acts as a const reference to a single bitset in a BitSetVector
CDune::BitSetVectorReference< block_size, Alloc >	A proxy class that acts as a mutable reference to a single bitset in a BitSetVector
CDune::BL< l >	Compile-time parameter for block recursion depth
CDune::BoundarySegment< dim, dimworld >	Base class for classes implementing geometries of boundary segments
CDune::BufferedCommunicator	A communicator that uses buffers to gather and scatter the data to be send or received
CDune::GenericGeometry::DefaultGeometryTraits< ctype, dimG, dimW, alwaysAffine >::Caching	How constant values are to be cached
CDune::Capabilities::canCommunicate< Grid, codim >	Specialize with 'true' for all codims that a grid can communicate data on (default=false)
CDune::VTKWriter< GridView >::CellIterator	Iterator over the grids elements
CDune::CheckIfDiagonalPresent< Matrix, blocklevel, l >	Check whether the a matrix has diagonal values on blocklevel recursion levels
CDune::Cloneable	An interface class for cloneable objects
CDune::Amg::CoarsenCriterion< T >	The criterion describing the stop criteria for the coarsening process
CDune::AlbertaLeafGridView< GridImp, pitype >::Codim< cd >	Codim Structure
CDune::AlbertaLevelGridView< GridImp, pitype >::Codim< cd >	Codim Structure
CDune::DefaultLeafGridView< GridImp, pitype >::Codim< cd >	Codim Structure
CDune::DefaultLeafIteratorTypes< GridImp >::Codim< cd >	The types of the iterator
CDune::DefaultLevelGridView< GridImp, pitype >::Codim< cd >	Codim Structure
CDune::DefaultLevelIteratorTypes< GridImp >::Codim< cd >	The types
CDune::Entity< 0, dim, GridImp, EntityImp >::Codim< cd >	EntityPointer types of the different codimensions
CDune::GenericReferenceElement< ctype, dim >::Codim< codim >	Collection of types depending on the codimension
CDune::GeometryGrid< HostGrid, CoordFunction, Allocator >::Codim< codim >	Traits structure containing types for a codimension
CDune::Grid< dim, dimworld, ct, GridFamily >::Codim< cd >	A Traits struct that collects all associated types of one implementation
CDune::GridTraits< dim, dimw, GridImp, GeometryImp, EntityImp, EntityPointerImp, LevelIteratorImp, LeafIntersectionImp, LevelIntersectionImp, LeafIntersectionIteratorImp, LevelIntersectionIteratorImp, HierarchicIteratorImp, LeafIteratorImp, LevelIndexSetImp, LeafIndexSetImp, GlobalIdSetImp, GIDType, LocalIdSetImp, LIDType, CCType, LevelGridViewTraits, LeafGridViewTraits, EntitySeedImp, LocalGeometryImp >::Codim< cd >	Traits associated with a specific codim
CDune::GridView< ViewTraits >::Codim< cd >	A struct that collects all associated types of one implementation from the Traits class
CDune::HostGridAccess< GeometryGrid< HG, CoordFunction, Allocator > >::Codim< codim >	A Traits struct that collects return types of class member methods
CDune::ReferenceElement< ctype, dim >::Codim< codim >	Collection of types depending on the codimension
CDune::StaticRefinement< topologyId, CoordType, coerceToId, dimension_ >::Codim< codimension >	The Codim struct inherited from the Refinement implementation
CDune::VirtualRefinement< dimension, CoordType >::Codim< codimension >	Codim database of VirtualRefinement
CDune::ColCompMatrix< M >	Utility class for converting an ISTL Matrix into a column-compressed matrix
►CDune::ColCompMatrix< BCRSMatrix< FieldMatrix< B, n, m >, TA > >	Converter for BCRSMatrix to column-compressed Matrix. specialization for BCRSMatrix
CDune::SuperLUMatrix< BCRSMatrix< FieldMatrix< B, n, m >, TA > >	Converter for BCRSMatrix to SuperLU Matrix
CDune::ColCompMatrix< Matrix >
CDune::ColCompMatrixInitializer< M >	Inititializer for the ColCompMatrix as needed by OverlappingSchwarz
CDune::ColCompMatrixInitializer< BCRSMatrix< FieldMatrix< T, n, m >, A > >
CDune::CollectiveCommunication< C >	Collective communication interface and sequential default implementation
CDune::CollectiveCommunication< Dune::SGrid >
CDune::CollectiveCommunication< Dune::UGGrid >
CDune::CollectiveCommunication< MPI_Comm >	Specialization of CollectiveCommunication for MPI
CDune::CollectiveCommunication< No_Comm >
CDune::CollectiveCommunication< void * >
CDune::CollectiveIterator< T, A >	A collective iterator for moving over the remote indices for all processes collectively
CDune::Combine< TI1, TI2, TA >	A set combining two other sets
CDune::CombinedAdaptProlongRestrict< A, B >	Class for combining 2 index sets together for adaptation process
CDune::CombinedGrapeDisplay< DisplayType >	Combines GrapeDataDisplays to one so that visualisation for parallel grid is more easy to handle
CDune::CommDataHandleIF< DataHandleImp, DataTypeImp >	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
CDune::CommDataHandleIF< CommDataHandle< Grid, WrappedHandle >, WrappedHandle::DataType >
CDune::CommDataHandleIF< DataHandle, double >
CDune::CommMatrixRow< M, I >	Utility class for comunicating the matrix entries
CDune::CommMatrixRowSize< M, RI >	Utility class to communicate and set the row sizes of a redistributed matrix
CDune::CommMatrixSparsityPattern< M, I >	Utility class to communicate and build the sparsity pattern of a redistributed matrix
CDune::common_bits< current, mask >	Activate if current and mask have common bits switched on
CDune::CommPolicy< V >	Default policy used for communicating an indexed type
CDune::compressed_base_array_unmanaged< B, A >	A simple array container with non-consecutive index set
►CDune::compressed_base_array_unmanaged< B, A >
►CDune::compressed_block_vector_unmanaged< B, A >
CDune::CompressedBlockVectorWindow< B, A >
►CDune::compressed_base_array_unmanaged< B, std::allocator< B > >
►CDune::compressed_block_vector_unmanaged< B, std::allocator< B > >
CDune::CompressedBlockVectorWindow< B, A >
CDune::compressed_block_vector_unmanaged< B, A >
CDune::CompressionStatistics< size_type >	Statistics about compression achieved in implicit mode
CDune::conditional< first, T1, T2 >	Select a type based on a condition
CDune::conditional< dim==coorddim, DiagonalMatrix< ctype, dim >, FieldMatrix< ctype, coorddim, dim > >
CDune::conditional< dim==coorddim, DiagonalMatrix< ctype, dim >, FieldMatrix< ctype, dim, coorddim > >
CDune::conditional< isMutable &&C::mutableMatrix, typenameMatrix::row_type::Iterator, typenameMatrix::row_type::ConstIterator >
CDune::conditional< storeReference, constImplementation &, Implementation >
CDune::conditional< tetra==GridImp::elementType, ALU3dGridGeometricFaceInfoTetra< Comm >, ALU3dGridGeometricFaceInfoHexa< Comm > >
CDune::Amg::BaseConnectivityConstructor::ConnectedBuilder< G, S, V >	Visitor for identifying connected aggregates during a breadthFirstSearch
CDune::const_reference< R >	Get the 'const' version of a reference to a mutable object
CDune::const_reference< BitSetVectorReference< block_size, Alloc > >
CDune::ConstantVolatileTraits< T >	Determines wether a type is const or volatile and provides the unqualified types
CDune::ConstAssociativePropertyMap< T >	An adaptor to turn an unique associative container into a property map
CDune::VariableBlockVector< B, A >::ConstIterator	ConstIterator class for sequential access
CDune::Amg::ConstructionTraits< T >	Traits class for generically constructing non default constructable types
CDune::Amg::ConstructionTraits< ParSSOR< M, X, Y, C > >	Policy for the construction of the ParSSOR smoother
CDune::Amg::ConstructionTraits< SeqILU0< M, X, Y > >	Policy for the construction of the SeqILUn smoother
CDune::Amg::ConstructionTraits< SeqILUn< M, X, Y > >	Policy for the construction of the SeqJac smoother
CDune::Amg::ConstructionTraits< SeqJac< M, X, Y, l > >	Policy for the construction of the SeqJac smoother
CDune::Amg::ConstructionTraits< SeqSOR< M, X, Y, l > >	Policy for the construction of the SeqSOR smoother
CDune::Amg::ConstructionTraits< SeqSSOR< M, X, Y, l > >	Policy for the construction of the SeqSSOR smoother
CDune::Conversion< From, To >	Checks wether a type is convertible to another
CDune::CommPolicy< V >::CopyGatherScatter< T >	GatherScatter default implementation that just copies data
CDune::OwnerOverlapCopyCommunication< GlobalIdType, LocalIdType >::CopyGatherScatter< T >	Gather/scatter callback for communcation
CDune::VTK::Corner< Cell >	Simple class representing a corner of a cell
CDune::VTK::Corner< typename remove_const< typename std::iterator_traits< CellIterator >::value_type >::type >
CDune::GenericGeometry::CornerMapping< CoordTraits, Topo, dimW, CStorage, affine >	Implementation of GenericGeometry::Mapping for first order lagrange type reference mappings
CDune::MultiLinearGeometryTraits< ct >::CornerStorage< mydim, cdim >	Template specifying the storage for the corners
CDune::BCRSMatrix< B, A >::CreateIterator	Iterator class for sequential creation of blocks
CDune::VariableBlockVector< B, A >::CreateIterator	Iterator class for sequential creation of blocks
►CDune::VTK::DataArrayWriter< T >	Base class for data array writers
CDune::VTK::AppendedBase64DataArrayWriter< T >	Streaming writer for data array tags, uses appended base64 format
CDune::VTK::AppendedRawDataArrayWriter< T >	Streaming writer for data array tags, uses appended raw format
CDune::VTK::AsciiDataArrayWriter< T >	Streaming writer for data array tags, uses ASCII inline format
CDune::VTK::BinaryDataArrayWriter< T >	Streaming writer for data array tags, uses binary inline format
CDune::VTK::NakedBase64DataArrayWriter< T >	Streaming writer for appended data array tags, uses base64 format
CDune::VTK::NakedRawDataArrayWriter< T >	Streaming writer for appended data arrays, uses raw format
CDune::VTK::DataArrayWriter< float >
CDune::VTK::DataArrayWriter< RF >
CDune::VTK::DataArrayWriter< unsigned >
CDune::VTK::DataArrayWriter< unsigned char >
CDune::VTK::DataArrayWriterFactory	Factory for DataArrayWriters
CDune::DebugAllocator< T >	Allocators implementation which performs different kind of memory checks
►CDune::DebugStreamState	Intermediate class to implement tie-operation of DebugStream
CDune::DebugStream< thislevel, dlevel, alevel, activator >	Generic class to implement debug output streams
CDune::Amg::DefaultConstructionArgs< T >	Construction Arguments for the default smoothers
CDune::Amg::DefaultConstructionArgs< SeqILUn< M, X, Y > >
CDune::Amg::DefaultConstructionArgs< SeqOverlappingSchwarz< M, X, TM, TS, TA > >
CDune::FloatCmp::DefaultEpsilon< T, style >	Mapping from a value type and a compare style to a default epsilon
CDune::GenericGeometry::DefaultGeometryTraits< ctype, dimG, dimW, alwaysAffine >	Default settings for BasicGeometry
CDune::GenericGeometry::DefaultGeometryTraits< ctype, dim, dim >
CDune::DefaultLeafIteratorTypes< GridImp >	LeafIterator tpyes for all codims and partition types
CDune::DefaultLevelIteratorTypes< GridImp >	LevelIterator tpyes for all codims and partition types
CDune::Amg::DefaultSmootherArgs< T >	The default class for the smoother arguments
CDune::DenseMatrix< MAT >	A dense n x m matrix
►CDune::DenseMatrix< DynamicMatrix< K > >
CDune::DynamicMatrix< K >	Construct a matrix with a dynamic size
►CDune::DenseMatrix< FieldMatrix< alu3d_ctype, ROWS, COLS > >
CDune::FieldMatrix< alu3d_ctype, numVerticesPerFace, dimworld >
CDune::FieldMatrix< alu3d_ctype, 3, 3 >
CDune::FieldMatrix< alu3d_ctype, 3, 2 >
CDune::FieldMatrix< alu3d_ctype, 2, 3 >
►CDune::DenseMatrix< FieldMatrix< ctype, ROWS, COLS > >
CDune::FieldMatrix< ctype, mydimension, coorddimension >
CDune::FieldMatrix< ctype, coorddimension, mydimension >
CDune::FieldMatrix< ctype, mydim, cdim >
CDune::FieldMatrix< ctype, cdim, mydim >
CDune::FieldMatrix< ctype, numCorners, coorddimension >
CDune::FieldMatrix< ctype, 2, cdim >
CDune::FieldMatrix< ctype, cdim, 2 >
►CDune::DenseMatrix< FieldMatrix< K, ROWS, COLS > >
CDune::FieldMatrix< K, ROWS, COLS >	A dense n x m matrix
►CDune::DenseMatrix< FieldMatrix< Real, ROWS, COLS > >
CDune::FieldMatrix< Real, dim, dimWorld >
CDune::FieldMatrix< Real, dimWorld, dim >
►CDune::DenseMatrix< FieldMatrix< T, ROWS, COLS > >
CDune::FieldMatrix< T, n, m >
CDune::DenseMatrixAssigner< DenseMatrix, RHS >	You have to specialize this structure for any type that should be assignable to a DenseMatrix
CDune::DenseVector< V >	Interface for a class of dense vectors over a given field
►CDune::DenseVector< DynamicVector< field_type > >
CDune::DynamicVector< field_type >
►CDune::DenseVector< DynamicVector< K > >
CDune::DynamicVector< K >	Construct a vector with a dynamic size
►CDune::DenseVector< FieldVector< alu3d_ctype, SIZE > >
CDune::FieldVector< alu3d_ctype, COLS >
CDune::FieldVector< alu3d_ctype, 3 >
CDune::FieldVector< alu3d_ctype, dimworld >
►CDune::DenseVector< FieldVector< ct, SIZE > >
CDune::FieldVector< ct, dim >
►CDune::DenseVector< FieldVector< ctype, SIZE > >
CDune::FieldVector< ctype, COLS >
CDune::FieldVector< ctype, cdim >
CDune::FieldVector< ctype, coorddim >
CDune::FieldVector< ctype, coorddimension >
CDune::FieldVector< ctype, dimension >
CDune::FieldVector< ctype, dim >
►CDune::DenseVector< FieldVector< double, SIZE > >
CDune::FieldVector< double, dw >
CDune::FieldVector< double, dimworld >
CDune::FieldVector< double, 3 >
►CDune::DenseVector< FieldVector< int, SIZE > >
CDune::FieldVector< int, dimension >
CDune::FieldVector< int, dim >
►CDune::DenseVector< FieldVector< K, SIZE > >
CDune::FieldVector< K, n >
CDune::FieldVector< K, COLS >
CDune::FieldVector< K, SIZE >	Vector space out of a tensor product of fields
►CDune::DenseVector< FieldVector< Real, SIZE > >
CDune::FieldVector< Real, COLS >
►CDune::DenseVector< FieldVector< T, SIZE > >
CDune::FieldVector< T, n >
CDune::FieldVector< T, COLS >
CDune::FieldVector< T, s >
►CDune::Amg::DependencyParameters	Parameters needed to check whether a node depends on another
►CDune::Amg::AggregationParameters	Parameters needed for the aggregation process,
►CDune::Amg::CoarseningParameters	Parameters for the complete coarsening process
►CDune::Amg::Parameters	All parameters for AMG
►CDune::Amg::Dependency< M, Norm >
►CDune::Amg::AggregationCriterion< Dependency< M, Norm > >
CDune::Amg::UnSymmetricCriterion< M, Norm >	Criterion suited for unsymmetric matrices
►CDune::Amg::SymmetricDependency< M, Norm >
►CDune::Amg::AggregationCriterion< SymmetricDependency< M, Norm > >
CDune::Amg::SymmetricCriterion< M, Norm >	Criterion taking advantage of symmetric matrices
CDune::Amg::Dependency< M, N >	Dependency policy for symmetric matrices
CDune::Amg::SymmetricDependency< M, N >	Dependency policy for symmetric matrices
CDune::Amg::SymmetricMatrixDependency< M, N >	Dependency policy for symmetric matrices
CDune::DGFBoundaryParameter	Contains types for additional features
CDune::DGFGridInfo< GridType >	Some simple static information for a given GridType
CDune::DGFWriter< GV >	Write a GridView to a DGF file
CDune::Amg::Diagonal< N >	Norm that uses only the [N][N] entry of the block to determine couplings
►CDune::Amg::Diagonal< 0 >
CDune::Amg::FirstDiagonal	Norm that uses only the [0][0] entry of the block to determine couplings
CDune::DiagonalMatrix< K, n >	A diagonal matrix of static size
►CDune::DiscreteCoordFunctionInterface< ct, dimR, Impl >	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
CDune::DiscreteCoordFunction< ct, dimR, Impl >	Derive an implementation of a discrete coordinate function from this class
►CDune::DiscreteCoordFunctionInterface< CoordFunction::ctype, dimR, CachedCoordFunction< HostGrid, CoordFunction > >
CDune::DiscreteCoordFunction< CoordFunction::ctype, CoordFunction::dimRange, CachedCoordFunction< HostGrid, CoordFunction > >
CDune::Amg::AggregatesMap< V >::DummyEdgeVisitor	A Dummy visitor that does nothing for each visited edge
Cdune_nullptr_t	Fallback implementation of nullptr
►CDune::DuneBoundaryProjection< dimworld >	Interface class for vertex projection at the boundary
CDune::BoundarySegmentWrapper< dim, dimworld >
CDune::GenericGeometry::DuneGeometryType< Topology, linetype >	Statically convert a generic topology type into a GeometryType
CDune::GenericGeometry::DuneGeometryTypeProvider< dim, linetype >	Dynamically convert a generic topology type into a GeometryType
CDune::DuneGridFormatParser	The DuneGridFormatParser class: reads a DGF file and stores build information in vector structures used by the MacroGrid class
CDune::DynamicMatrixSubdomainSolver< M, X, Y >	Exact subdomain solver using Dune::DynamicMatrix<T>::solve
CDune::Amg::SubGraph< G, T >::EdgeIndexMap	An index map for mapping the edges to indices
CDune::Amg::MatrixGraph< M >::EdgeIteratorT< C >	Iterator over all edges starting from a vertex
CDune::Amg::EdgeProperties	Class representing the properties of an ede in the matrix graph
CDune::Element< N >	Get the N-th element of a tuple
CDune::Element< 0 >	Get the first element of a tuple
CDune::ElementTopologyMapping< type >
CDune::Empty	Just an empty class
CDune::EmptySet< TA >	An empty set
CDune::enable_if< b, T >	Enable typedef if condition is met
►CDune::enable_if< IsInteroperable< T1, T2 >::value, Type >
CDune::EnableIfInterOperable< T1, T2, Type >	Enable typedef if two types are interoperable
►CDune::Entity< cd, dim, GridImp, EntityImp >	Wrapper class for entities
CDune::MakeableInterfaceObject< Entity >
CDune::Entity< 0, dim, GridImp, EntityImp >	Template specialization of Dune::Entity for Elements (codim==0)
►CDune::GeoGrid::EntityBase< codim, Grid, fake >	Actual implementation of the entity
CDune::GeoGrid::Entity< codim, dim, Grid >	DUNE-conform implementation of the entity
CDune::GeoGrid::EntityBase< 0, Grid >
CDune::GeoGrid::EntityBase< codim, Grid, false >	construct an uninitialized entity
CDune::GeoGrid::EntityBase< codim, Grid, true >	construct an uninitialized entity
►CDune::EntityDefaultImplementation< cd, dim, GridImp, EntityImp >	Default Implementations for EntityImp
CDune::EntityDefaultImplementation< 0, dim, GridImp, EntityImp >	Default Implementations for EntityImp (Elements [cd=0])
►CDune::EntityDefaultImplementation< 0, dim, Grid, AlbertaGridEntity >
CDune::AlbertaGridEntity< 0, dim, Grid >
►CDune::EntityDefaultImplementation< 0, dim, GridImp, ALU2dGridEntity >
CDune::ALU2dGridEntity< 0, dim, GridImp >
►CDune::EntityDefaultImplementation< 0, dim, GridImp, ALU3dGridEntity >
CDune::ALU3dGridEntity< 0, dim, GridImp >
►CDune::EntityDefaultImplementation< cd, dim, GridImp, ALU2dGridEntity >
CDune::ALU2dGridEntity< cd, dim, GridImp >
►CDune::EntityDefaultImplementation< cd, dim, GridImp, ALU3dGridEntity >
CDune::ALU3dGridEntity< cd, dim, GridImp >
►CDune::EntityDefaultImplementation< codim, dim, Grid, AlbertaGridEntity >
CDune::AlbertaGridEntity< codim, dim, Grid >
►CDune::EntityDefaultImplementation< codim, dim, GridImp, EntityImp >
CDune::SEntityBase< codim, dim, GridImp, EntityImp >
►CDune::EntityDefaultImplementation< codim, dim, GridImp, SEntity >
►CDune::SEntityBase< codim, dim, GridImp, SEntity >
CDune::SEntity< codim, dim, GridImp >
►CDune::SEntityBase< 0, dim, GridImp, SEntity >
CDune::SEntity< 0, dim, GridImp >
CDune::EntityInfo< ctype >	Structure to hold statistical information about one type of entity
CDune::EntityPointer< GridImp, IteratorImp >	Wrapper class for pointers to entities
►CDune::EntityPointer< Grid, IteratorImp >
CDune::EntityIterator< codim, Grid, IteratorImp >	Interface class for an iterator over grid entities
►CDune::EntityPointer< GridImp, HierarchicIteratorImp< GridImp > >
►CDune::EntityIterator< 0, GridImp, HierarchicIteratorImp< GridImp > >
CDune::HierarchicIterator< GridImp, HierarchicIteratorImp >	Enables iteration over all codim zero entities in a subtree See also the documentation of Dune::EntityPointer
►CDune::EntityPointer< GridImp, LeafIteratorImp< codim, pitype, GridImp > >
►CDune::EntityIterator< codim, GridImp, LeafIteratorImp< codim, pitype, GridImp > >
CDune::LeafIterator< codim, pitype, GridImp, LeafIteratorImp >	Enables iteration over all leaf entities of a codimension zero of a grid. See also the documentation of Dune::EntityPointer
►CDune::EntityPointer< GridImp, LevelIteratorImp< codim, pitype, GridImp > >
►CDune::EntityIterator< codim, GridImp, LevelIteratorImp< codim, pitype, GridImp > >
CDune::LevelIterator< codim, pitype, GridImp, LevelIteratorImp >	Enables iteration over all entities of a given codimension and level of a grid. See also the documentation of Dune::EntityPointer
CDune::EntitySeed< GridImp, EntitySeedImp >	Store a reference to an entity with a minimal memory footprint
CDune::EnumItem< TA, item >	A set consisting only of one item
CDune::EnumRange< TA, from, end >	A set representing a range including the borders
CDune::FloatCmp::EpsilonType< T >	Mapping of value type to epsilon type
CDune::FloatCmp::EpsilonType< FieldVector< T, n > >	Specialization of EpsilonType for Dune::FieldVector
CDune::FloatCmp::EpsilonType< std::vector< T, A > >	Specialization of EpsilonType for std::vector
►CDune::Exception	Base class for Dune-Exceptions
CDune::FMatrixError	Error thrown if operations of a FieldMatrix fail
CDune::GridError	Base class for exceptions in Dune grid modules
►CDune::IOError	Default exception class for I/O errors
CDune::CommPolicy< V >::CommunicationError	Error thrown if there was a problem with the communication
CDune::DGFException	Exception class for IO errors in the DGF parser
CDune::DebugStreamError	Standard exception for the debugstream
CDune::InvalidIndexSetState	Exception indicating that the index set is not in the expected state
CDune::InvalidStateException	Default exception if a function was called while the object is not in a valid state for that function
►CDune::MathError	Default exception class for mathematical errors
►CDune::ISTLError	Derive error class from the base class in common
►CDune::BCRSMatrixError	Error specific to BCRSMatrix
CDune::ImplicitModeOverflowExhausted	The overflow error used during implicit BCRSMatrix construction was exhausted
►CDune::NotImplemented	Default exception for dummy implementations
CDune::QuadratureOrderOutOfRange	Exception thrown if a desired QuadratureRule is not available, because the requested order is to high
►CDune::ParallelError	Default exception if an error in the parallel communication of the programm occured
CDune::MPIGuardError	This exception is thrown if the MPIGuard detects an error on a remote process
CDune::RangeError	Default exception class for range errors
►CDune::SystemError	Default exception class for OS errors
CDune::OutOfMemoryError	Default exception if memory allocation fails
CDune::TimerError	Exception thrown by the Timer class
CDune::ExceptionHook	Base class to add a hook to the Dune::Exception
CDune::FaceTopologyMapping< type >
CDune::Factorial< m >	Calculates the factorial of m at compile time
CDune::Factorial< 0 >	End of recursion of factorial via specialization
CDune::FakeMPIHelper	A fake mpi helper
CDune::FlattenTuple< TupleTuple >	Flatten a tuple of tuples
CDune::FloatCmpOps< T, cstyle_, rstyle_ >	Class encapsulating a default epsilon
CDune::fmatrix_assigner< T, n, m >	Fmatrix assignment operator
CDune::FMatrixPrecision< ctype >	Precisions for calculations with FieldMatrix and FieldVector
CDune::ForEachType< TypeEvaluator, TupleType >	Helper template to clone the type definition of a tuple with the storage types replaced by a user-defined rule
CDune::ForEachValue< TupleType >	Helper template which implements iteration over all storage elements in a tuple
CDune::ForEachValuePair< TupleType1, TupleType2 >	Extension of ForEachValue to two tuples..
CDune::ForLoop< Operation, first, last >	A static loop using TMP
CDune::ForwardIteratorFacade< T, V, R, D >	Base class for stl conformant forward iterators
►CDune::ForwardIteratorFacade< BoundaryIterator< GV >, const GV::Intersection, const GV::Intersection &, std::iterator_traits< GV::template Codim< 0 >::Iterator >::difference_type >
CDune::VTK::BoundaryIterator< GV >	Iterate over the GridViews boundary intersections
►CDune::ForwardIteratorFacade< const_iterator, const Matrix::row_type >
CDune::MatrixRowSubset< M, S >::const_iterator	The matrix row iterator type
►CDune::ForwardIteratorFacade< CornerIterator, const Entity, const Entity &, int >
CDune::VTKWriter< GridView >::CornerIterator	Iterate over the elements' corners
►CDune::ForwardIteratorFacade< CornerIterator< CellIterator >, const Corner< remove_const< std::iterator_traits< CellIterator >::value_type >::type >, const Corner< remove_const< std::iterator_traits< CellIterator >::value_type >::type > &, std::iterator_traits< CellIterator >::difference_type >
CDune::VTK::CornerIterator< CellIterator >	Iterate over the corners of some cell range
►CDune::ForwardIteratorFacade< PointIterator< CellIterator, IS >, const Corner< remove_const< std::iterator_traits< CellIterator >::value_type >::type >, const Corner< remove_const< std::iterator_traits< CellIterator >::value_type >::type > &, std::iterator_traits< CellIterator >::difference_type >
CDune::VTK::PointIterator< CellIterator, IS >	Iterate over the points of some corner range
►CDune::ForwardIteratorFacade< SLListConstIterator< T, A >, const T, const T &, std::size_t >
CDune::SLListConstIterator< T, A >	A constant iterator for the SLList
►CDune::ForwardIteratorFacade< SLListIterator< RemoteIndex, Allocator >, RemoteIndex, RemoteIndex &, std::size_t >
CDune::SLListIterator< RemoteIndex, Allocator >
►CDune::ForwardIteratorFacade< SLListIterator< T, A >, T, T &, std::size_t >
CDune::SLListIterator< T, A >	A mutable iterator for the SLList
►CDune::ForwardIteratorFacade< SLListModifyIterator< RemoteIndex, Allocator >, RemoteIndex, RemoteIndex &, std::size_t >
CDune::SLListModifyIterator< RemoteIndex, Allocator >
►CDune::ForwardIteratorFacade< SLListModifyIterator< T, A >, T, T &, std::size_t >
CDune::SLListModifyIterator< T, A >	A mutable iterator for the SLList
►CDune::ForwardIteratorFacade< VertexIterator, const Entity, const Entity &, int >
CDune::VTKWriter< GridView >::VertexIterator	Iterate over the grid's vertices
►CDune::ForwardIteratorFacade< VertexIterator, const VertexDescriptor >
CDune::Amg::SubGraph< G, T >::VertexIterator	The vertex iterator of the graph
CDune::Function< Domain, Range >	Base class template for function classes
►CDune::Function< const DomainType &, RangeType & >
CDune::VirtualFunction< DomainType, RangeType >	Virtual base class template for function classes
CDune::VTK::FunctionWriterBase< Cell_ >	Base class for function writers
►CDune::VTK::FunctionWriterBase< Cell >
CDune::VTK::CoordinatesWriter< Cell >	Writer for the Coordinates array
CDune::VTK::NonConformingConnectivityWriter< Cell >	Writer for the connectivity array in nonconforming mode
CDune::VTK::OffsetsWriter< Cell >	Writer for the offsets array
CDune::VTK::TypesWriter< Cell >	Writer for the types array
►CDune::VTK::FunctionWriterBase< Func::Entity >
CDune::VTK::VTKFunctionWriter< Func >	Base class for function writers
►CDune::VTK::FunctionWriterBase< Func::Traits::Cell >
CDune::VTK::SkeletonFunctionWriter< Func >	Function writer for skeleton functions
►CDune::VTK::FunctionWriterBase< IteratorFactory::Cell >
CDune::VTK::ConformingConnectivityWriter< IteratorFactory >	Writer for the connectivity array in conforming mode
CDune::fvector_assigner< T, s >	Fvector assignment operator
CALUGridSpace::GatherScatterBaseImpl< GridType, DataCollectorType, codim >	Corresponding interface class is defined in bsinclude.hh
CALUGridSpace::GatherScatterBaseImpl< GridType, DataCollectorType, 0 >	Corresponding interface class is defined in bsinclude.hh
CALUGridSpace::GatherScatterLoadBalance< GridType, DataCollectorType, IndexOperatorType >	Corresponding interface class is defined in bsinclude.hh
CDune::GaussLobattoQuadratureInitHelper< ct, fundamental >
CDune::GaussQuadratureInitHelper< ct, fundamental >
CDune::Gcd< a, b >	Calculator of the greatest common divisor
CDune::GeneralVertexOrder< dim, Index_ >	Class providing information on the ordering of vertices
CDune::GenericReferenceElement< ctype, dim >	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
CDune::GenericReferenceElementContainer< ctype, dim >
CDune::GenericReferenceElements< ctype, dim >	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
CDune::Geometry< mydim, cdim, GridImp, GeometryImp >	Wrapper class for geometries
CDune::GeometryDefaultImplementation< mydim, cdim, GridImp, GeometryImp >	Default implementation for class Geometry
►CDune::GeometryDefaultImplementation< mydim, cdim, GridImp, ALU2dGridGeometry >
CDune::ALU2dGridGeometry< mydim, cdim, GridImp >
CDune::GeometryDefaultImplementation< mydim, cdim, GridImp, ALU3dGridGeometry >
CDune::GeometryGrid< HostGrid, CoordFunction, Allocator >	Grid wrapper replacing the geometries
CDune::MyALUGridGeometryImplementation< cdim >::GeometryImpl< dummy, dim, eltype >	General type of geometry implementation
CDune::GeometryType	Unique label for each type of entities that can occur in DUNE grids
CDune::GenericGeometry::GlobalGeometryTraits< Grid >	Grid specific information required by GenericGeometry::Geometry
CDune::GlobalGeometryTypeIndex	Compute indices for geometry types, taking the dimension into account
CDune::GlobalLookupIndexSet< I >	Decorates an index set with the possibility to find a global index that is mapped to a specific local
CDune::GlobalLookupIndexSet< ParallelIndexSet >
CDune::GmshReader< GridType >	Read Gmsh mesh file
CDune::GmshReaderOptions	Options for read operation
CDune::GmshReaderParser< GridType >	Dimension independent parts for GmshReaderParser
CDune::GmshWriter< GridView >	Write Gmsh mesh file
CDune::GnuplotWriter< GridView >	Writer for 1D grids in gnuplot format
►CDune::GnuplotWriter< G::LeafGridView >
CDune::LeafGnuplotWriter< G >	GnuplotWriter on the leaf grid
►CDune::GnuplotWriter< G::LevelGridView >
CDune::LevelGnuplotWriter< G >	GnuplotWriter on a given level grid
►CDune::GrapeGridDisplay< GridType >
CDune::GrapeDataDisplay< GridType >
CDune::Amg::GraphEdgePropertiesSelector< G >	Wrapper to access the internal vertex properties of a graph via operator[]()
CDune::Amg::GraphVertexPropertiesSelector< G >	Wrapper to access the internal edge properties of a graph via operator[]()
CDune::greater_or_equal< current, threshold >	Greater or equal template test
►CDune::Grid< dim, dimworld, ct, GridFamily >	Grid abstract base class
CDune::GridDefaultImplementation< dim, dimworld, ct, GridFamily >
►CDune::Grid< dim, dimworld, Alberta::Real, AlbertaGridFamily< dim, Alberta::dimWorld > >
►CDune::GridDefaultImplementation< dim, Alberta::dimWorld, Alberta::Real, AlbertaGridFamily< dim, Alberta::dimWorld > >
CDune::AlbertaGrid< dim, dimworld >	[ provides Dune::Grid ]
►CDune::Grid< dim, dimworld, Alberta::Real, AlbertaGridFamily< dim, dimworld > >
►CDune::GridDefaultImplementation< dim, dimworld, Alberta::Real, AlbertaGridFamily< dim, dimworld > >
CDune::AlbertaGrid< dim, dimworld >
►CDune::Grid< dim, dimworld, alu2d_ctype, ALU2dGridFamily< dim, dimworld, eltype > >
►CDune::GridDefaultImplementation< dim, dimworld, alu2d_ctype, ALU2dGridFamily< dim, dimworld, eltype > >
►CDune::ALU2dGrid< 2, dimw, ALU2DSPACE triangle >
CDune::ALUConformGrid< 2, dimw >	[ provides Dune::Grid ]
CDune::ALUSimplexGrid< 2, dimw >	constructor for creating ALUSimplexGrid from given macro grid file
►CDune::ALU2dGrid< 2, dimw, ALU2DSPACE quadrilateral >
CDune::ALUCubeGrid< 2, dimw >	constructor for creating ALUSimplexGrid from given macro grid file
CDune::ALU2dGrid< dim, dimworld, eltype >	[ provides Dune::Grid ]
►CDune::Grid< dim, dimworld, alu3d_ctype, ALU3dGridFamily< elType, Comm > >
►CDune::GridDefaultImplementation< 3, 3, alu3d_ctype, ALU3dGridFamily< elType, Comm > >
►CDune::ALU3dGrid< hexa >
CDune::ALUCubeGrid< 3, 3 >	constructor for creating ALUCubeGrid from given macro grid file
►CDune::ALU3dGrid< tetra >
CDune::ALUSimplexGrid< 3, 3 >	constructor for creating ALUSimplexGrid from given macro grid file
CDune::ALU3dGrid< elType, Comm >	[ provides Dune::Grid ]
►CDune::Grid< dim, dimworld, double, OneDGridFamily< 1, 1 > >
►CDune::GridDefaultImplementation< 1, 1, double, OneDGridFamily< 1, 1 > >
CDune::OneDGrid	One-dimensional adaptive grid
►CDune::Grid< dim, dimworld, double, UGGridFamily< dim > >
►CDune::GridDefaultImplementation< dim, dim, double, UGGridFamily< dim > >
CDune::UGGrid< dimworld >
CDune::UGGrid< dim >	Front-end for the grid manager of the finite element toolbox UG
►CDune::Grid< dim, dimworld, sgrid_ctype, SGridFamily< dim, dimworld, sgrid_ctype > >
►CDune::GridDefaultImplementation< dim, dimworld, sgrid_ctype, SGridFamily< dim, dimworld, sgrid_ctype > >
CDune::SGrid< dim, dimworld, _ctype >	[ provides Dune::Grid ]
►CDune::Grid< dim, dimworld, yaspgrid_ctype, YaspGridFamily< dim > >
►CDune::GridDefaultImplementation< dim, dim, yaspgrid_ctype, YaspGridFamily< dim > >
CDune::YaspGrid< dim >	[ provides Dune::Grid ]
►CDune::GridFactoryInterface< GridType >	Provide a generic factory class for unstructured grids
CDune::GridFactory< GridType >	Provide a generic factory class for unstructured grids
►CDune::GridFactoryInterface< AlbertaGrid< dim, dimworld > >
CDune::GridFactory< AlbertaGrid< dim, dimworld > >	Specialization of the generic GridFactory for AlbertaGrid
►CDune::GridFactoryInterface< Grid >
CDune::GridFactory< Grid >
►CDune::GridFactoryInterface< UGGrid< dimworld > >
CDune::GridFactory< UGGrid< dimworld > >	Specialization of the generic GridFactory for UGGrid
CDune::GridObjectStreamOrDefault< GridImp, DefaultImp >	Template to choose right Object stream type for a given class
CDune::GridObjectStreamOrDefaultHelper< hasStream, GridImp, DefaultImp >
CDune::GridObjectStreamOrDefaultHelper< false, GridImp, DefaultImp >
►CDune::dgf::GridParameterBlock	Common Grid parameters
CDune::dgf::YaspGridParameterBlock	Grid parameters for YaspGrid
CDune::GridPtr< GridType >	Class for constructing grids from DGF files
CDune::GridTraits< dim, dimw, GridImp, GeometryImp, EntityImp, EntityPointerImp, LevelIteratorImp, LeafIntersectionImp, LevelIntersectionImp, LeafIntersectionIteratorImp, LevelIntersectionIteratorImp, HierarchicIteratorImp, LeafIteratorImp, LevelIndexSetImp, LeafIndexSetImp, GlobalIdSetImp, GIDType, LocalIdSetImp, LIDType, CCType, LevelGridViewTraits, LeafGridViewTraits, EntitySeedImp, LocalGeometryImp >	A traits struct that collects all associated types of one grid model
CDune::GridView< ViewTraits >	Grid view abstract base class
CDune::GridViewInfoGTCompare	Comparison object to sort GeometryType by majorly dimension
CDune::Capabilities::hasBackupRestoreFacilities< Grid >	Specialize with 'true' if implementation provides backup and restore facilities. (default=false)
CDune::Capabilities::hasBackupRestoreFacilities< AlbertaGrid< dim, dimworld > >	AlbertaGrid has backup and restore facilities
CDune::Capabilities::hasBackupRestoreFacilities< ALUConformGrid< dim, dimw > >	ALUConformGrid has backup and restore facilities
CDune::Capabilities::hasEntity< Grid, codim >	Specialize with 'true' for all codims that a grid implements entities for. (default=false)
CDune::Capabilities::hasEntity< AlbertaGrid< dim, dimworld >, codim >	AlbertaGrid has entities for all codimensions
CDune::Capabilities::hasEntity< Dune::ALUConformGrid< dim, dimw >, cdim >	ALUConformGrid has entities for all codimension
CDune::Capabilities::hasEntity< OneDGrid, cdim >	OneDGrid has entities for all codimension
CDune::Capabilities::hasEntity< SGrid< dim, dimw >, cdim >	SGrid has entities for all codimension
CDune::Capabilities::hasEntity< UGGrid< dim >, 0 >	UGGrid has codim=0 entities (elements)
CDune::Capabilities::hasEntity< UGGrid< dim >, dim >	UGGrid has codim=dim entities (vertices)
CDune::Capabilities::hasEntity< YaspGrid< dim >, 0 >	YaspGrid has codim=0 entities (elements)
CDune::Capabilities::hasEntity< YaspGrid< dim >, dim >	YaspGrid has codim=dim entities (vertices)
CDune::hash< T >	Functor for hashing objects of type T
►CDune::HasHierarchicIndexSet	Tagging interface to indicate that Grid has HierarchicIndexSet
CDune::ALU2dGrid< 2, dimw, ALU2DSPACE triangle >
CDune::ALU2dGrid< 2, dimw, ALU2DSPACE quadrilateral >
CDune::ALU3dGrid< hexa >
CDune::ALU3dGrid< tetra >
CDune::ALU2dGrid< dim, dimworld, eltype >	[ provides Dune::Grid ]
CDune::ALU3dGrid< elType, Comm >	[ provides Dune::Grid ]
►CDune::HasObjectStream	Tagging interface to indicate that Grid provides typedef ObjectStreamType
CDune::ALU2dGrid< 2, dimw, ALU2DSPACE triangle >
CDune::ALU2dGrid< 2, dimw, ALU2DSPACE quadrilateral >
CDune::ALU3dGrid< hexa >
CDune::ALU3dGrid< tetra >
CDune::ALU2dGrid< dim, dimworld, eltype >	[ provides Dune::Grid ]
CDune::ALU3dGrid< elType, Comm >	[ provides Dune::Grid ]
CDune::Capabilities::hasSingleGeometryType< Grid >	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)
CDune::GenericGeometry::DefaultGeometryTraits< ctype, dimG, dimW, alwaysAffine >::hasSingleGeometryType< dim >	Will there be only one geometry type for a dimension?
CDune::MultiLinearGeometryTraits< ct >::hasSingleGeometryType< dim >	Will there be only one geometry type for a dimension?
CDune::Capabilities::hasSingleGeometryType< AlbertaGrid< dim, dimworld > >	AlbertaGrid has only one geometry type for codim 0 entities
CDune::Capabilities::hasSingleGeometryType< OneDGrid >	OneDGrid has only one geometry type for codim 0 entities
CDune::Capabilities::hasSingleGeometryType< SGrid< dim, dimw > >	SGrid has only one geometry type for codim 0 entities
CDune::Capabilities::hasSingleGeometryType< YaspGrid< dim > >	YaspGrid has only one geometry type for codim 0 entities
CDune::HierarchicSearch< Grid, IS >	Search an IndexSet for an Entity containing a given point
CDune::Amg::Hierarchy< T, A >	A hierarchy of coantainers (e.g. matrices or vectors)
CDune::Amg::Hierarchy< Domain, A >
CDune::Amg::Hierarchy< Domain, std::allocator< X > >
CDune::Amg::Hierarchy< MatrixOperator, Allocator >
CDune::Amg::Hierarchy< ParallelInformation, Allocator >
CDune::Amg::Hierarchy< Range, A >
CDune::Amg::Hierarchy< Range, std::allocator< X > >
CDune::Amg::Hierarchy< Smoother, A >
CDune::Amg::Hierarchy< Smoother, std::allocator< X > >
CDune::HostGridAccess< Grid >	Access to host grid objects
CDune::GenericGeometry::HybridMapping< dim, GeometryTraits >	Abstract base class for generic mapping
CDune::GenericGeometry::HybridMapping< Topology::dimension, GeometryTraits >
CDune::IdentityMap	A property map that applies the identity function to integers
CDune::IdentityMatrix< K, N >	Read-only identity matrix
CDune::IdSet< GridImp, IdSetImp, IdTypeImp >	Id Set Interface
►CDune::IdSet< AlbertaGrid< dim, dimworld >, AlbertaGridIdSet< dim, dimworld >, unsigned int >
CDune::AlbertaGridIdSet< dim, Alberta::dimWorld >
CDune::AlbertaGridIdSet< dim, dimworld >	Hierarchic index set of AlbertaGrid
►CDune::IdSet< ALU2dGrid< dim, dimworld, eltype >, ALU2dGridLocalIdSet< dim, dimworld, eltype >, int >
CDune::ALU2dGridLocalIdSet< dim, dimworld, elementType >
CDune::ALU2dGridLocalIdSet< dim, dimworld, eltype >	Hierarchic index set of ALU3dGrid
►CDune::IdSet< const Dune::SGrid< dim, dimworld >, SGridGlobalIdSet< const Dune::SGrid< dim, dimworld > >, remove_const< const Dune::SGrid< dim, dimworld > >::type::PersistentIndexType >
CDune::SGridGlobalIdSet< const Dune::SGrid< dim, dimworld > >
CDune::IdSet< Grid, IdSet< Grid, HostIdSet >, HostIdSet::IdType >
►CDune::IdSet< GridImp, SGridGlobalIdSet< GridImp >, remove_const< GridImp >::type::PersistentIndexType >
CDune::SGridGlobalIdSet< GridImp >	Persistent, globally unique Ids
►CDune::ILUSubdomainSolver< M, X, Y >	Base class encapsulating common algorithms of ILU0SubdomainSolver and ILUNSubdomainSolver
CDune::ILU0SubdomainSolver< M, X, Y >	Exact subdomain solver using ILU(p) with appropriate p
CDune::ImplementationDefined	Dummy struct used for documentation purposes
CDune::ImplicitMatrixBuilder< M_ >	A wrapper for uniform access to the BCRSMatrix during and after the build stage in implicit build mode
CDune::Indent	Utility class for handling nested indentation in output
CDune::IndexInfoFromGrid< G, L >	Information about the index distribution
CDune::IndexPair< TG, TL >	A pair consisting of a global and local index
CDune::IndexSet< GridImp, IndexSetImp, IndexTypeImp >	Index Set Interface base class
CDune::IndexSet< AlbertaGrid< dim, dimworld >, AlbertaGridIndexSet< dim, dimworld >, int >
CDune::IndexSet< AlbertaGridFamily< dim, dimworld >, AlbertaGridHierarchicIndexSet< dim, dimworld >, int >
►CDune::IndexSet< ALU2dGrid< dim, dimworld, eltype >, ALU2dGridHierarchicIndexSet< dim, dimworld, eltype >, int >
CDune::ALU2dGridHierarchicIndexSet< dim, dimworld, elementType >
CDune::ALU2dGridHierarchicIndexSet< dim, dimworld, eltype >	Hierarchic index set of ALU2dGrid
►CDune::IndexSet< ALU3dGrid< elType, Comm >, ALU3dGridHierarchicIndexSet< elType, Comm > >
CDune::ALU3dGridHierarchicIndexSet< elType, Comm >	Hierarchic index set of ALU3dGrid
►CDune::IndexSet< const Dune::SGrid< dim, dimworld >, SGridLevelIndexSet< const Dune::SGrid< dim, dimworld > > >
CDune::SGridLevelIndexSet< const Dune::SGrid< dim, dimworld > >
CDune::IndexSet< Grid, IndexSet< Grid, HostIndexSet >, HostIndexSet::IndexType >
►CDune::IndexSet< GridImp, DefaultIndexSet< GridImp, IteratorImp >, unsigned int >
CDune::DefaultIndexSet< GridImp, IteratorImp >	DefaultIndexSet creates an index set by using the grids persistent container an a given pair of iterators
►CDune::IndexSet< GridImp, IndexSetImp >
CDune::IndexSetDefaultImplementation< GridImp, IndexSetImp >	Provide default implementation of method if IndexSet
►CDune::IndexSet< GridImp, SGridLevelIndexSet< GridImp > >
CDune::SGridLevelIndexSet< GridImp >	Implementation of index set
CDune::IndexStack< T, length >
CDune::Amg::IndicesCoarsener< OwnerOverlapCopyCommunication< G, L >, E >	Coarsen Indices in the parallel case
CDune::Amg::IndicesCoarsener< SequentialInformation, E >	Coarsen Indices in the sequential case
CDune::IndicesSyncer< T >	Class for recomputing missing indices of a distributed index set
►CDune::integral_constant< T, v >	Generate a type for a given integral constant
►CDune::FirstPredicateIndex< Tuple, IsType< T >::template Predicate, 0 >
CDune::FirstTypeIndex< Tuple, T, start >	Find the first occurance of a type in a tuple
CDune::FirstPredicateIndex< Tuple, Predicate, start, size >	Finding the index of a certain type in a tuple
►CDune::integral_constant< bool,(__is_lvalue_reference_helper< T >::value)>
CDune::is_lvalue_reference< T >	Determine whether a type is a lvalue reference type
►CDune::integral_constant< bool,(__is_pointer_helper< T >::value)>
CDune::is_pointer< T >	Is_pointer
►CDune::InterfaceBuilder	Base class of all classes representing a communication interface
CDune::Interface	Communication interface between remote and local indices
CDune::InterfaceInformation	Information describing an interface
CDune::Intersection< GridImp, IntersectionImp >	Intersection of a mesh entities of codimension 0 ("elements") with a "neighboring" element or with the domain boundary
CDune::Intersection< const GridImp, Dune::SIntersection< const GridImp > >
CDune::Intersection< Grid, IntersectionImpl >
CDune::Intersection< GridImp, AlbertaGridLeafIntersection< GridImp > >
CDune::IntersectionDefaultNormalVectors< GridImp, IntersectionImp >	Default Implementations of integrationOuterNormal and unitOuterNormal for IntersectionImp
CDune::IntersectionIterator< GridImp, IntersectionIteratorImp, IntersectionImp >	Mesh entities of codimension 0 ("elements") allow to visit all intersections with "neighboring" elements and with the domain boundary
CDune::IntersectionIteratorWrapper< GridImp, IntersectionIteratorImpl >	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid
CDune::IntersectionIteratorWrapper< GridImp, GridImp::LeafIntersectionIteratorImp >
►CDune::IntersectionIteratorWrapper< GridImp, GridImp::LevelIntersectionIteratorImp >
CDune::LevelIntersectionWrapper< GridImp >	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid
CDune::InverseOperator< X, Y >	Abstract base class for all solvers
►CDune::InverseOperator< BlockVector< FieldVector< T, m >, A::template rebind< FieldVector< T, m > >::other >, BlockVector< FieldVector< T, n >, A::template rebind< FieldVector< T, n > >::other > >
CDune::SuperLU< BCRSMatrix< FieldMatrix< T, n, m >, A > >	SuperLu Solver
CDune::UMFPack< BCRSMatrix< FieldMatrix< T, n, m >, A > >	The UMFPack direct sparse solver for matrices of type BCRSMatrix
CDune::InverseOperator< Domain, Range >
►CDune::InverseOperator< X, X >
CDune::BiCGSTABSolver< X >	Bi-conjugate Gradient Stabilized (BiCG-STAB)
CDune::CGSolver< X >	Conjugate gradient method
CDune::GeneralizedPCGSolver< X >	Generalized preconditioned conjugate gradient solver
CDune::GradientSolver< X >	Gradient method
CDune::LoopSolver< X >	Preconditioned loop solver
CDune::MINRESSolver< X >	Minimal Residual Method (MINRES)
CDune::RestartedGMResSolver< X, Y, F >	Implements the Generalized Minimal Residual (GMRes) method
CDune::InverseOperatorResult	Statistics about the application of an inverse operator
CDune::ios_base_all_saver	Utility class for storing and resetting stream attributes
CDune::is_same< T1, T2 >	Compile time test for testing whether two types are the same
►CDune::is_same< T, U >
CDune::IsType< T >::Predicate< U >	The actual predicate
CDune::IsBaseOf< Base, Derived >	Checks wether a type is derived from another
CDune::Capabilities::isCartesian< Grid >	Specialize with 'true' if the grid is a Cartesian grid. Cartesian grids satisfy the following properties:
CDune::Capabilities::isCartesian< SGrid< dim, dimw > >	SGrid is a Cartesian grid
CDune::Capabilities::isCartesian< YaspGrid< dim > >	YaspGrid is a Cartesian grid
CDune::IsConst< T >	Tests wether a type is constant
CDune::IsDofManager	Tagging interface to indicate that class is of Type DofManager
CDune::IsFieldVectorSizeCorrect< C, SIZE >	TMP to check the size of a DenseVectors statically, if possible
CDune::IsInteroperable< T1, T2 >	Checks wether two types are interoperable
CDune::Capabilities::isLeafwiseConforming< Grid >	Specialize with 'true' if implementation guarantees a conforming leaf grid. (default=false)
CDune::Capabilities::isLeafwiseConforming< AlbertaGrid< dim, dimworld > >	AlbertaGrid is leafwise conforming
CDune::Capabilities::isLeafwiseConforming< ALUConformGrid< dim, dimw > >	ALUConformGrid has a conforming leaf grid
CDune::Capabilities::isLeafwiseConforming< OneDGrid >	OneDGrid is leafwise conforming
CDune::Capabilities::isLeafwiseConforming< SGrid< dim, dimw > >	SGrid is leafwise conforming
CDune::Capabilities::isLeafwiseConforming< UGGrid< dim > >	UGGrid may not be leafwise conforming
CDune::Capabilities::isLeafwiseConforming< YaspGrid< dim > >	YaspGrid is leafwise conforming
CDune::Capabilities::isLevelwiseConforming< Grid >	Specialize with 'true' if implementation guarantees conforming level grids. (default=false)
CDune::Capabilities::isLevelwiseConforming< AlbertaGrid< dim, dimworld > >	AlbertaGrid is not levelwise conforming (since it uses bisection)
CDune::Capabilities::isLevelwiseConforming< ALUConformGrid< dim, dimw > >	ALUConformGrid has non-conforming level grids
CDune::Capabilities::isLevelwiseConforming< OneDGrid >	OneDGrid is levelwise conforming
CDune::Capabilities::isLevelwiseConforming< SGrid< dim, dimw > >	SGrid is levelwise conforming
CDune::Capabilities::isLevelwiseConforming< UGGrid< dim > >	UGGrid is levelwise conforming
CDune::Capabilities::isLevelwiseConforming< YaspGrid< dim > >	YaspGrid is levelwise conforming
CDune::IsMatrix< T >	Test whether a type is an ISTL Matrix
CDune::Capabilities::isParallel< Grid >	Specialize with 'true' if implementation supports parallelism. (default=false)
CDune::Capabilities::isParallel< const ALUConformGrid< dim, dimw > >	ALUConformGrid is parallel
CDune::Capabilities::isParallel< OneDGrid >	OneDGrid is not parallel
CDune::Capabilities::isParallel< UGGrid< dim > >	UGGrid is parallel
CDune::Capabilities::isParallel< YaspGrid< dim > >	YaspGrid is parallel
CDune::IsType< T >	Generator for predicates accepting one particular type
CDune::IsVolatile< T >	Tests wether a type is volatile
CDune::CollectiveIterator< T, A >::iterator	Iterator over the valid underlying iterators
CDune::VariableBlockVector< B, A >::Iterator	Iterator class for sequential access
CDune::IteratorDirectionSelector< T1, T2, forward >	Helper template meta program for application of overlapping schwarz
CDune::IteratorPropertyMap< RAI, IM, T, R >	Adapter to turn a random access iterator into a property map
CDune::Jacobi1QuadratureInitHelper< ct, fundamental >
CDune::Jacobi2QuadratureInitHelper< ct, fundamental >
CDune::JoinTuples< Head, Tail >	Join two tuples
CDune::Lcm< m, n >	Calculate the least common multiple of two numbers
CDune::LeafIntersectionIteratorWrapper< GridImp >	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid
CDune::LevelIntersectionIteratorWrapper< GridImp >	Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid
CDune::Amg::LevelTransferPolicy< FO, CO >	Abstract base class for transfer between levels and creation of the coarse level system
CDune::Amg::LevelTransferPolicy< FO, typename CSP::Operator >
►CDune::Amg::LevelTransferPolicy< O, O >
CDune::Amg::AggregationLevelTransferPolicy< O, C >	A LeveTransferPolicy that used aggregation to construct the coarse level system
CDune::LinearMapping< cdim, mydim >	A linear mapping
CDune::LinearMapping< cdim, 0 >
CDune::LinearMapping< cdim, 1 >
CDune::LinearMapping< cdim, 2 >
CDune::LinearMapping< cdim, cdim >
CDune::LinearMapping< cdim, dim >
►CDune::LinearOperator< X, Y >	A linear operator
►CDune::AssembledLinearOperator< M, X, Y >	A linear operator exporting itself in matrix form
CDune::MatrixAdapter< M, X, Y >	Adapter to turn a matrix into a linear operator
CDune::NonoverlappingSchwarzOperator< M, X, Y, C >	A nonoverlapping operator with communication object
CDune::OverlappingSchwarzOperator< M, X, Y, C >	An overlapping schwarz operator
CDune::LinearOperator< X, X >
CDune::GenericGeometry::LocalGeometryTraits< Grid >	Grid specific information required by GenericGeometry::LocalGeometry
CDune::LocalGeometryTypeIndex	Compute per-dimension indices for geometry types
CDune::LocalIndex	An index present on the local process
CDune::lru< _Key, _Tp, _Traits >	LRU Cache Container
CDune::MakeableInterfaceObject< InterfaceType >
CDune::MallocAllocator< T >	Allocators implementation which simply calls malloc/free
►Cstd::map< K, T >	STL class
CDune::GridViewInfo< ctype >	Structure to hold information about a certain GridView
CDune::Mapper< G, MapperImp >	Mapper interface
►CDune::Mapper< G, UniversalMapper< G, G::Traits::GlobalIdSet > >
►CDune::UniversalMapper< G, G::Traits::GlobalIdSet >
CDune::GlobalUniversalMapper< G >	Universal mapper based on global ids
►CDune::Mapper< G, UniversalMapper< G, G::Traits::LocalIdSet > >
►CDune::UniversalMapper< G, G::Traits::LocalIdSet >
CDune::LocalUniversalMapper< G >	Universal mapper based on local ids
►CDune::Mapper< G, UniversalMapper< G, IDS > >
CDune::UniversalMapper< G, IDS >	Implements a mapper for an arbitrary subset of entities
►CDune::Mapper< GV::Grid, MultipleCodimMultipleGeomTypeMapper< G::LeafGridView, Layout > >
►CDune::MultipleCodimMultipleGeomTypeMapper< G::LeafGridView, Layout >
CDune::LeafMultipleCodimMultipleGeomTypeMapper< G, Layout >	Multiple codim and multiple geometry type mapper for leaf entities
►CDune::Mapper< GV::Grid, MultipleCodimMultipleGeomTypeMapper< G::LevelGridView, Layout > >
►CDune::MultipleCodimMultipleGeomTypeMapper< G::LevelGridView, Layout >
CDune::LevelMultipleCodimMultipleGeomTypeMapper< G, Layout >	Multiple codim and multiple geometry type mapper for entities of one level
►CDune::Mapper< GV::Grid, MultipleCodimMultipleGeomTypeMapper< GV, Layout > >
CDune::MultipleCodimMultipleGeomTypeMapper< GV, Layout >	Implementation class for a multiple codim and multiple geometry type mapper
►CDune::Mapper< GV::Grid, MultipleCodimMultipleGeomTypeMapper< GV, MCMGElementLayout > >
CDune::MultipleCodimMultipleGeomTypeMapper< GV, MCMGElementLayout >
►CDune::Mapper< GV::Grid, MultipleCodimMultipleGeomTypeMapper< GV, MCMGVertexLayout > >
CDune::MultipleCodimMultipleGeomTypeMapper< GV, MCMGVertexLayout >
►CDune::Mapper< GV::Grid, SingleCodimSingleGeomTypeMapper< G::LeafGridView, c > >
►CDune::SingleCodimSingleGeomTypeMapper< G::LeafGridView, c >
CDune::LeafSingleCodimSingleGeomTypeMapper< G, c >	Single codim and single geometry type mapper for leaf entities
►CDune::Mapper< GV::Grid, SingleCodimSingleGeomTypeMapper< G::LevelGridView, c > >
►CDune::SingleCodimSingleGeomTypeMapper< G::LevelGridView, c >
CDune::LevelSingleCodimSingleGeomTypeMapper< G, c >	Single codim and single geometry type mapper for entities of one level
►CDune::Mapper< GV::Grid, SingleCodimSingleGeomTypeMapper< GV, c > >
CDune::SingleCodimSingleGeomTypeMapper< GV, c >	Implementation class for a single codim and single geometry type mapper
CDune::GenericGeometry::DefaultGeometryTraits< ctype, dimG, dimW, alwaysAffine >::Mapping< Topology >	Reference mapping to be used
CDune::GenericGeometry::Mapping< CoordTraits, Topo, dimW, Impl >	Interface for a mapping
CDune::GenericGeometry::Mapping< typename GeometryTraits::CoordTraits, Topology, GeometryTraits::dimWorld, MappingImpl >
CDune::GenericGeometry::MappingTraits< CT, dim, dimW >	Default mapping traits using Dune::FieldVector and Dune::FieldMatrix
CDune::MathematicalConstants< Field >	Provides commonly used mathematical constants
CDune::MatMultMatResult< M1, M2 >	Helper TMP to get the result type of a sparse matrix matrix multiplication ( $C=A*B$)
CDune::Matrix< T, A >	A generic dynamic dense matrix
CDune::Matrix< double >
CDune::Amg::MatrixGraph< M >	The (undirected) graph of a matrix
CDune::Amg::MatrixGraph< const M >
CDune::Amg::MatrixHierarchy< M, PI, A >	The hierarchies build by the coarsening process
CDune::MatrixIndexSet	Stores the nonzero entries in a sparse matrix
CDune::MatrixRowSet< M >	Provides access to an iterator over all matrix rows
CDune::MatrixRowSubset< M, S >	Provides access to an iterator over an arbitrary subset of matrix rows
CMCMGElementEdgeLayout< dimgrid >	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)
CDune::MCMGElementLayout< dimgrid >	Layout template for elements
CDune::MCMGElementLayout< GV::dimension >
CDune::MCMGVertexLayout< dim >	Layout template for vertices
CDune::MCMGVertexLayout< GV::dimension >
CDune::MessageBufferIF< MessageBufferImp >	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
CMPIError	MPI Error. Thrown when an mpi error occurs
CDune::MPIGuard	Detects a thrown exception and communicates to all other processes
CDune::MPIHelper	A real mpi helper
CDune::MPITraits< T >	A traits class describing the mapping of types onto MPI_Datatypes
CDune::MPITraits< IndexPair< TG, ParallelLocalIndex< TA > > >
CDune::MPITraits< ParallelLocalIndex< T > >
CDune::MultiLinearGeometry< ct, mydim, cdim, Traits >	Generic geometry implementation based on corner coordinates
►CDune::MultiLinearGeometry< ct, mydim, cdim, MultiLinearGeometryTraits< ct > >
CDune::CachedMultiLinearGeometry< ct, mydim, cdim, Traits >	Implement a MultiLinearGeometry with additional caching
CDune::MultiLinearGeometry< typename Base::CoordinateType::value_type, dim-1, dimworld >
CDune::MultiLinearGeometryTraits< ct >	Default traits class for MultiLinearGeometry
CDune::MultiplicativeSchwarzMode	Tag that tells the Schwarz method to be multiplicative
CDune::mutable_reference< R >	Get the 'mutable' version of a reference to a const object
CDune::NegateSet< S >	The negation of a set. An item is contained in the set if and only if it is not contained in the negated set
CDune::Nil	An empty class
CDune::NonConformingFaceMapping< type, Comm >
CDune::NonConformingFaceMapping< hexa, Comm >	Non-conforming face mappings for hexahedra
CDune::NonConformingFaceMapping< tetra, Comm >	Non-conforming face mappings for tetrahedra
CDune::GenericGeometry::NonHybridMapping< Topology, GeometryTraits >	Non-virtual geometric mapping
CDune::null_deleter< T >	Implements the Deleter concept of shared_ptr without deleting anything
CDune::NullPointerInitialiser< Tuple >	A helper template that initializes a tuple consisting of pointers to NULL
CDune::Amg::OneStepAMGCoarseSolverPolicy< O, S, C >	A policy class for solving the coarse level system using one step of AMG
CDune::OverlappingSchwarzInitializer< I, S, D >	Initializer for SuperLU Matrices representing the subdomains
CDune::OwnerOverlapCopyAttributeSet	Attribute set for overlapping schwarz
CDune::OwnerOverlapCopyCommunication< GlobalIdType, LocalIdType >	A class setting up standard communication for a two-valued attribute set with owner/overlap/copy semantics
►CDune::Pair< T1, TT >	A tuple consisting of two objects
CDune::tuple< RemoteIndexModifier, GlobalIndexModifier, BoolListModifier, const ConstRemoteIndexIterator >
CDune::tuple< OneDGridList< OneDEntityImp< 0 > >, OneDGridList< OneDEntityImp< 1 > > >
CDune::tuple< T1, T2, T3, T4, T5, T6, T7, T8, T9 >	A Tuple of objects
CDune::Pair< T1, Nil >	A tuple consisting of one object. Specialization of Pair that really is a single value
CDune::ParallelIndexSet< TG, TL, N >	Manager class for the mapping between local indices and globally unique indices
CDune::ParallelIndexSet< GlobalIdType, LI, 512 >
CDune::ParallelIndexSet< TG, TL, N >
CDune::ParallelLocalIndex< T >	An index present on the local process with an additional attribute flag
CDune::ParameterTree	Hierarchical structure of string parameters
CDune::ParameterTreeParser	Parsers to set up a ParameterTree from various input sources
CDune::AlbertaLeafGridViewTraits< GridImp, pitype >::Codim< cd >::Partition< pit >	Define types needed to iterate over entities of a given partition type
CDune::AlbertaLevelGridViewTraits< GridImp, pitype >::Codim< cd >::Partition< pit >	Define types needed to iterate over entities of a given partition type
CDune::DefaultLeafGridViewTraits< GridImp, pitype >::Codim< cd >::Partition< pit >	Define types needed to iterate over entities of a given partition type
CDune::DefaultLevelGridViewTraits< GridImp, pitype >::Codim< cd >::Partition< pit >	Define types needed to iterate over entities of a given partition type
CDune::GeometryGrid< HostGrid, CoordFunction, Allocator >::Partition< pitype >	Types for GridView
CDune::Grid< dim, dimworld, ct, GridFamily >::Codim< cd >::Partition< pitype >	A struct collecting all types depending on the partition iterator type
CDune::Grid< dim, dimworld, ct, GridFamily >::Partition< pitype >	Types for GridView
CDune::GridTraits< dim, dimw, GridImp, GeometryImp, EntityImp, EntityPointerImp, LevelIteratorImp, LeafIntersectionImp, LevelIntersectionImp, LeafIntersectionIteratorImp, LevelIntersectionIteratorImp, HierarchicIteratorImp, LeafIteratorImp, LevelIndexSetImp, LeafIndexSetImp, GlobalIdSetImp, GIDType, LocalIdSetImp, LIDType, CCType, LevelGridViewTraits, LeafGridViewTraits, EntitySeedImp, LocalGeometryImp >::Codim< cd >::Partition< pitype >	Traits associated with a specific grid partition type
CDune::GridTraits< dim, dimw, GridImp, GeometryImp, EntityImp, EntityPointerImp, LevelIteratorImp, LeafIntersectionImp, LevelIntersectionImp, LeafIntersectionIteratorImp, LevelIntersectionIteratorImp, HierarchicIteratorImp, LeafIteratorImp, LevelIndexSetImp, LeafIndexSetImp, GlobalIdSetImp, GIDType, LocalIdSetImp, LIDType, CCType, LevelGridViewTraits, LeafGridViewTraits, EntitySeedImp, LocalGeometryImp >::Partition< pitype >	Traits associated with a specific grid partition type
CDune::GridView< ViewTraits >::Codim< cd >::Partition< pit >	Define types needed to iterate over entities of a given partition type
CDune::PersistentContainerInterface< G, T >	Persistent storage of data on all entities of a grid
CDune::PersistentContainerMap< G, IdSet, Map >	Map-based implementation of the PersistentContainer
►CDune::PersistentContainerMap< G, G::LocalIdSet, std::map< G::LocalIdSet::IdType, T > >
CDune::PersistentContainer< G, T >	A class for storing data during an adaptation cycle
►CDune::PersistentContainerMap< HostGrid, G::LocalIdSet, std::map< G::LocalIdSet::IdType, Coordinate > >
CDune::PersistentContainer< HostGrid, Coordinate >
►CDune::PersistentContainerMap< HostGrid, G::LocalIdSet, std::map< G::LocalIdSet::IdType, RangeVector > >
CDune::PersistentContainer< HostGrid, RangeVector >
►CDune::PersistentContainerMap< HostGrid, G::LocalIdSet, std::map< G::LocalIdSet::IdType, T > >
CDune::PersistentContainer< HostGrid, T >
CDune::PersistentContainerVector< G, IndexSet, Vector >	Vector-based implementation of the PersistentContainer
CDune::PersistentContainerVector< AlbertaGrid< dim, dimworld >, AlbertaGrid< dim, dimworld >::HierarchicIndexSet, std::vector< T > >
CDune::PointerPairDeletor< Tuple >	Deletes all objects pointed to in a tuple of pointers
CDune::Pool< T, s >	A memory pool of objects
CDune::Pool< T, size >
CDune::PoolAllocator< T, s >	An allocator managing a pool of objects for reuse
CDune::Power< p >	Compute power for a run-time mantissa and a compile-time integer exponent
►CDune::Preconditioner< X, Y >	Base class for matrix free definition of preconditioners
CDune::BlockPreconditioner< X, Y, C, T >	Block parallel preconditioner
CDune::ParSSOR< M, X, Y, C >	A parallel SSOR preconditioner
CDune::Richardson< X, Y >	Richardson preconditioner
CDune::SeqGS< M, X, Y, l >	Sequential Gauss Seidel preconditioner
CDune::SeqILU0< M, X, Y, l >	Sequential ILU0 preconditioner
CDune::SeqILUn< M, X, Y, l >	Sequential ILU(n) preconditioner
CDune::SeqJac< M, X, Y, l >	The sequential jacobian preconditioner
CDune::SeqPardiso< M, X, Y >	The sequential Pardiso preconditioner
CDune::SeqSOR< M, X, Y, l >	Sequential SOR preconditioner
CDune::SeqSSOR< M, X, Y, l >	Sequential SSOR preconditioner
►CDune::Preconditioner< AMG::Domain, AMG::Range >
CDune::Amg::KAmgTwoGrid< Dune::Amg::AMG >
CDune::Amg::KAmgTwoGrid< AMG >	Two grid operator for AMG with Krylov cycle
►CDune::Preconditioner< FO::domain_type, FO::range_type >
CDune::Amg::TwoLevelMethod< FO, CSP, S >
►CDune::Preconditioner< O::domain_type, O::range_type >
CDune::InverseOperator2Preconditioner< O, c >	Turns an InverseOperator into a Preconditioner
►CDune::Preconditioner< P::domain_type, P::range_type >
CDune::NonoverlappingBlockPreconditioner< C, P >	Nonoverlapping parallel preconditioner
►CDune::Preconditioner< X, X >
CDune::Amg::AMG< M, X, S, SequentialInformation, std::allocator< X > >
CDune::Amg::AMG< Operator, X, Smoother >
CDune::SeqOverlappingSchwarz< M, X, TM, TS, TA >
CDune::Amg::AMG< M, X, S, PI, A >	Parallel algebraic multigrid based on agglomeration
CDune::Amg::FastAMG< M, X, PI, A >	A fast (sequential) algebraic multigrid based on agglomeration that saves memory bandwidth
CDune::Amg::KAMG< M, X, S, PI, K, A >	Algebraic multigrid method using a Krylov-cycle
CDune::SeqOverlappingSchwarz< M, X, TM, TD, TA >	Sequential overlapping Schwarz preconditioner
CDune::VTK::PrintType< T >	Determine a type to safely put another type into a stream
CDune::PrismQuadraturePoints< dim >
CDune::PrismQuadraturePoints< 3 >
CDune::PrismQuadraturePointsSingleton< dim >	Singleton holding the Prism Quadrature points
CDune::PrismQuadraturePointsSingleton< 3 >	Singleton holding the Prism Quadrature points
CDune::PrismQuadratureRule< ct, dim >	Quadrature rules for prisms
CDune::Amg::PropertiesGraph< G, VP, EP, VM, EM >	Attaches properties to the edges and vertices of a graph
CDune::PropertyMapTypeSelector< T, C >	Selector for the property map type
CDune::PushBackTuple< Tuple, T >	Helper template to append a type to a tuple
CDune::PushBackTuple< typenameCodimTable< Element, dim-1 >::ElementTuple, Element< dim > >
CDune::PushBackTuple< typenameCodimTable< GeometryArray, dim-1 >::ElementTuple, GeometryArray< dim > >
CDune::PushBackTuple< typenameCodimTable< MappingArray, dim-1 >::ElementTuple, MappingArray< dim > >
CDune::PushFrontTuple< Tuple, T >	Helper template to prepend a type to a tuple
CDune::VTK::PVTUWriter	Dump a .vtu/.vtp files contents to a stream
CDune::QuadraturePoint< ct, dim >	Single evaluation point in a quadrature rule
CDune::QuadratureRuleFactory< ctype, dim >	Factory class for creation of quadrature rules, depending on GeometryType, order and QuadratureType
CDune::QuadratureRules< ctype, dim >	A container for all quadrature rules of dimension dim
CDune::Amg::RandomAccessBundledPropertyMap< C, K, i, T, R >	A property map that extracts one property out of a bundle using operator[]()
CDune::RandomAccessIteratorFacade< T, V, R, D >	Base class for stl conformant forward iterators
►CDune::RandomAccessIteratorFacade< ArrayListIterator< T, N, A >, A::value_type, A::reference, A::difference_type >
►CDune::ArrayListIterator< T, N, A >	A random access iterator for the Dune::ArrayList class
CDune::ParallelIndexSet< TG, TL, N >::iterator	The iterator over the pairs
►CDune::RandomAccessIteratorFacade< ConstArrayListIterator< IndexPair< TG, TL >, N, std::allocator< Dune::IndexPair< TG, TL > > >, const A::value_type, A::const_reference, A::difference_type >
CDune::ConstArrayListIterator< IndexPair< TG, TL >, N, std::allocator< Dune::IndexPair< TG, TL > > >
►CDune::RandomAccessIteratorFacade< ConstArrayListIterator< T, N, A >, const A::value_type, A::const_reference, A::difference_type >
CDune::ConstArrayListIterator< T, N, A >	A constant random access iterator for the Dune::ArrayList class
►CDune::RandomAccessIteratorFacade< DenseIterator< C, T >, T, T &, std::ptrdiff_t >
CDune::DenseIterator< C, T >	Generic iterator class for dense vector and matrix implementations
►CDune::RandomAccessIteratorFacade< EdgeIterator, const EdgeDescriptor >
CDune::Amg::SubGraph< G, T >::EdgeIterator	The edge iterator of the graph
►CDune::RandomAccessIteratorFacade< GenericIterator< C, T, T &, std::ptrdiff_t, RandomAccessIteratorFacade >, T, T &, std::ptrdiff_t >
CDune::GenericIterator< C, T, R, D, IteratorFacade >	Generic class for stl-conforming iterators for container classes with operator[]
►CDune::RandomAccessIteratorFacade< iterator, const Index_ >
CDune::GeneralVertexOrder< dim, Index_ >::iterator	Iterate over the vertex indices of some sub-entity
►CDune::RandomAccessIteratorFacade< RealIterator< T >, T >
CDune::base_array_unmanaged< B, A >::RealIterator< T >	Iterator implementation class
►CDune::RandomAccessIteratorFacade< RealRowIterator< T >, T >
CDune::BCRSMatrix< B, A >::RealRowIterator< T >	Iterator access to matrix rows
CDune::RawStream	Write out data in binary
►CDune::ReadablePropertyMapTag	Tag for the category of readable property maps
►CDune::ReadWritePropertyMapTag	Tag for the category of readable and writable property maps
CDune::LvaluePropertyMapTag	Tag for the category of lvalue property maps
CDune::PoolAllocator< T, s >::rebind< U >	Rebind the allocator to another type
CDune::ReduceTuple< F, Tuple, Seed, N >	Apply reduce with meta binary function to template
CDune::ReduceTuple< F, Tuple, Seed, 0 >	Apply reduce with meta binary function to template
CDune::ReferenceElement< ctype, dim >	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
CDune::ReferenceElements< ctype, dim >	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
CDune::RefinementImp::HCube::RefinementImp< dimension_, CoordType >	Refinement implementation for hypercubes
CDune::RefinementImp::PrismTriangulation::RefinementImp< dimension_, CoordType >	Implementation of the refinement of a prism into simplices
CDune::RefinementImp::PyramidTriangulation::RefinementImp< dimension_, CoordType >	Implementation of the refinement of a pyramid into simplices
CDune::RefinementImp::HCube::RefinementSubEntityIteratorSpecial< dimension, CoordType, codimension >	SubEntityIterator base class for hypercube refinement
CDune::RemoteIndex< T1, T2 >	Information about an index residing on another processor
CDune::RemoteIndexListModifier< T, A, mode >	Modifier for adding and/or deleting remote indices from the remote index list
CDune::RemoteIndices< T, A >	The indices present on remote processes
CDune::RemoteIndices< PIS >
CDune::remove_const< T >	Removes a const qualifier while preserving others
CDune::remove_const< CW >
CDune::remove_const< Grid >
CDune::remove_const< M >
CDune::remove_const< typename std::iterator_traits< CellIterator >::value_type >
CDune::remove_pointer< _Tp >	Return the type a pointer type points to
CDune::remove_reference< T >	Remove a reference from a type
CDune::ReservedVector< T, n >	A Vector class with statically reserved memory
CDune::ReservedVector< Dune::SGridLevelIndexSet< const Dune::SGrid< dim, dimworld > > *, MAXL >
CDune::ReservedVector< Dune::YaspGrid::YGridLevel, 32 >
CDune::ReservedVector< T, length >
CDune::GridDefaultImplementation< dim, dimworld, ct, GridFamily >::ReturnImplementationType< T >	Helper class to choose correct implementation return type for getRealImplementation
CDune::ImplicitMatrixBuilder< M_ >::row_object	Proxy row object for entry access
CDune::Amg::RowSum	Functor using the row sum (infinity) norm to determine strong couplings
►CDune::ScalarProduct< X >	Base class for scalar product and norm computation
CDune::NonoverlappingSchwarzScalarProduct< X, C >	Nonoverlapping Scalar Product with communication object
CDune::OverlappingSchwarzScalarProduct< X, C >	Scalar product for overlapping schwarz methods
CDune::SeqScalarProduct< X >	Default implementation for the scalar case
CDune::ScalarProductChooser< X, C, c >	Choose the approriate scalar product for a solver category
CDune::ScaledIdentityMatrix< K, n >	A multiple of the identity matrix of static size
CDune::Selection< TS, TG, TL, N >	A cached selection of indices
CDune::SelectionIterator< TS, TG, TL, N >	A const iterator over an uncached selection
CDune::SelectType< first, T1, T2 >	Select a type based on a condition
►CDune::SEntityPointer< codim, GridImp >
CDune::SLevelIterator< codim, pitype, GridImp >
CDune::SEntityPointer< 0, GridImp >
CDune::SEntitySeed< codim, GridImp >
CDune::SeqOverlappingSchwarzApplier< T >	Helper template meta program for application of overlapping schwarz
CDune::SeqOverlappingSchwarzDomainSize< M >
CDune::shared_ptr< T >	A reference counting smart pointer
CDune::shared_ptr< CoarseOperatorType >
CDune::shared_ptr< const DuneProjection >
CDune::shared_ptr< const Func >
CDune::shared_ptr< const Projection >
CDune::shared_ptr< Dune::Amg::AggregatesMap >
CDune::shared_ptr< Dune::Amg::Hierarchy< Smoother, std::allocator< X > > >
CDune::shared_ptr< Dune::Amg::KAmgTwoGrid< Dune::Amg::AMG > >
CDune::shared_ptr< Dune::Amg::MatrixHierarchy >
CDune::shared_ptr< Dune::array< MemberType, chunkSize_ > >
CDune::shared_ptr< Dune::BoundarySegment >
CDune::shared_ptr< Dune::BoundarySegment< dim > >
CDune::shared_ptr< Dune::InverseOperator< Domain, Range > >
CDune::shared_ptr< Dune::VTK::DataArrayWriter< float > >
CDune::shared_ptr< Dune::VTK::DataArrayWriter< RF > >
CDune::shared_ptr< Dune::VTK::DataArrayWriter< unsigned > >
CDune::shared_ptr< Dune::VTK::DataArrayWriter< unsigned char > >
CDune::shared_ptr< GridType >
CDune::shared_ptr< IntersectionIterator >
CDune::shared_ptr< InverseOperator< X, X > >
CDune::shared_ptr< MPI_Op >
CDune::shared_ptr< Operator >
CDune::shared_ptr< S >
CDune::shared_ptr< ScalarProduct >
CDune::shared_ptr< size_type >
CDune::shared_ptr< Smoother >
CDune::shared_ptr< SmootherType >
CDune::shared_ptr< typename AMG::LevelContext >
CDune::shared_ptr< typename Amg::ScalarProduct >
CDune::shared_ptr< typename O::matrix_type >
CDune::shared_ptr< UGGridLevelIndexSet< const Dune::UGGrid< dim > > >
CDune::shared_ptr< YaspIndexSet< const Dune::YaspGrid< dim >, false > >
CDune::SharedCount	The object we reference
CDune::SHierarchicStackElem
CDune::Singleton< T >	An adapter to turn a class into a singleton
CDune::SIntersectionIterator< GridImp >
CDune::GenericGeometry::Size< Topology, codim >	Statically compute the number of subentities of a given codimension
►CDune::SizeCache< GridImp >	Organizes the caching of sizes for one grid and one GeometryType
CDune::SingleTypeSizeCache< GridImp >	Organizes the caching of sizes for one grid and one GeometryType
CDune::SizeCache< AlbertaGrid< dim, Alberta::dimWorld > >
CDune::SizeCache< AlbertaGrid< dim, dimworld > >
CDune::SizeOne	Flag for marking indexed data structures where data at each index is of the same size
CDune::VTK::SkeletonFunctionInterface< GV, RF >	A prototype for VTKFunctions on the skeleton
CDune::SLList< T, A >	A single linked list
CDune::SLList< GlobalIndex, Allocator >
CDune::SLList< RemoteIndex, Allocator >
CDune::SLList< T, A >
CDune::Amg::SmootherApplier< T >	Helper class for applying the smoothers
CDune::Amg::SmootherTraits< T >	Traits class for getting the attribute class of a smoother
CDune::Amg::SmootherTraits< S >
CDune::Amg::SmootherTraits< Smoother >
CDune::SolverCategory	Categories for the solvers
CDune::Amg::SparsityBuilder< M >	Functor for building the sparsity pattern of the matrix using examineConnectivity
►Cstd::stack< T >	STL class
CDune::AutoPtrStack< T >	Stack of pointers with auto destruction if the stack is destructed
CDune::StandardMathematicalConstants< T >	Standard implementation of MathematicalConstants
CDune::StarCDReader< GridType >	File reader for the Star-CD format
CDune::StaticPower< m, p >	Calculates m^p at compile time
CDune::StaticPower< m, 0 >	End of recursion via specialization
CDune::StaticRefinement< topologyId, CoordType, coerceToId, dimension_ >	Wrap each Refinement implementation to get a consistent interface
CDune::FacadeOptions::StoreGeometryReference< mydim, cdim, GridImp, GeometryImp >	Traits class determining whether the Dune::Geometry facade class stores the implementation object by reference or by value
CDune::FacadeOptions::StoreGeometryReference< mydim, cdim, GridImp, ALU2dGridGeometry >	Geometry can be stored as an object
CDune::FacadeOptions::StoreGeometryReference< mydim, cdim, GridImp, ALU3dGridGeometry >	Geometry can be stored as an object
CDune::StructuredGridFactory< GridType >	Construct structured cube and simplex grids in unstructured grid managers
CDune::StructuredGridFactory< SGrid< dim, dim > >	Specialization of the StructuredGridFactory for SGrid
CDune::StructuredGridFactory< YaspGrid< dim > >	Specialization of the StructuredGridFactory for YaspGrid
CDune::GenericReferenceElement< ctype, dim >::SubEntityInfo	Topological and geometric information about the subentities of a reference element
CDune::ReferenceElement< ctype, dim >::SubEntityInfo	Topological information about the subentities of a reference element
CDune::Amg::SubGraph< G, T >	A subgraph of a graph
CDune::Amg::SubGraph< Graph, T >
CDune::SuperLUMatrix< M >	Utility class for converting an ISTL Matrix into a SuperLU Matrix
CDune::SuperLUMatrix< Matrix >
►CDune::SurfaceNormalCalculator	A bilinear surface mapping
CDune::BilinearSurfaceMapping	A bilinear surface mapping
CDune::SymmetricMultiplicativeSchwarzMode	Tag that tells the Schwarz method to be multiplicative and symmetric
CDune::Capabilities::threadSafe< Grid >	Specialize with 'true' if the grid implementation is thread safe. (default=false)
CDune::Timer	A simple stop watch
CDune::TopologyFactory< Traits >	Provide a factory over the generic topologies
CDune::TopologySingletonFactory< Factory >	A wrapper for a TopologyFactory providing singleton storage. Same usage as TopologyFactory but with empty release method an internal storage
CDune::Function< Domain, Range >::Traits	Traits class containing raw types
CDune::RefinementImp::Traits< topologyId, CoordType, coerceToId, dimension, Dummy >	Mapping from geometryType, CoordType and coerceTo to a particular Refinement implementation
CDune::TransformTupleFunctor< TE, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9 >	Helper class to implement transformTuple()
CDune::TransposedMatMultMatResult< M1, M2 >	Helper TMP to get the result type of a sparse matrix matrix multiplication ( $C=A*B$)
CDune::TrilinearMapping
CDune::tuple_element< N, Tuple >	Get the type of the N-th element of the tuple
CDune::tuple_element< 0, Pair< T1, T2 > >	Get the type of the first element of the tuple
CDune::tuple_size< T >	Template meta_programm to query the size of a tuple
CDune::TupleToPairs< T1, T2, T3, T4, T5, T6, T7, T8, T9 >	Converts the Tuple to a list of pairs
CDune::TupleToPairs< T1, Nil, Nil, Nil, Nil, Nil, Nil, Nil, Nil >	Specialization for a tuple consisting only of one type
CDune::TransformTupleFunctor< TE, A0, A1, A2, A3, A4, A5, A6, A7, A8, A9 >::TypeEvaluator< T >	Export the TypeEvaluator template class for genericTransformTuple()
CDune::VTK::TypeName< T >	Map type to its VTK name in data array
CDune::TypeTraits< T >	General type traits class to check whether type is reference or pointer type
CDune::UMFPack< Matrix >	Use the UMFPack package to directly solve linear systems – empty default class
CDune::UncachedSelection< TS, TG, TL, N >	An uncached selection of indices
CDune::GenericGeometry::DefaultGeometryTraits< ctype, dimG, dimW, alwaysAffine >::UserData	Type of additional user data to be stored in each mapping
CDune::VariableSize	Flag for marking indexed data structures where the data at each index may be a variable multiple of another type
CDune::VariableSizeCommunicator< Allocator >	A buffered communicator where the amount of data sent does not have to be known a priori
►Cstd::vector< T >	STL class
►CDune::QuadratureRule< ct, 1 >
CDune::GaussLobattoQuadratureRule1D< ct >	Jacobi-Gauss quadrature for alpha=2, beta=0
CDune::GaussQuadratureRule1D< ct >	Gauss quadrature rule in 1D
CDune::Jacobi1QuadratureRule1D< ct >	Jacobi-Gauss quadrature for alpha=1, beta=0
CDune::Jacobi2QuadratureRule1D< ct >	Jacobi-Gauss quadrature for alpha=2, beta=0
►CDune::QuadratureRule< ct, 3 >
CDune::PrismQuadratureRule< ct, 3 >	Quadrature rules for prisms
CDune::BitSetVector< block_size, Allocator >	A dynamic array of blocks of booleans
CDune::QuadratureRule< ct, dim >	Abstract base class for quadrature rules
CDune::Amg::MatrixGraph< M >::VertexIteratorT< C >	The vertex iterator type of the graph
CDune::VertexOrderByIdFactory< IdSet, Index >::VertexOrder< dim >	Type of vertex order object may depend on the dimension of the element
CDune::VertexOrderByIdFactory< IdSet, Index >	Factory for GeneralVertexOrder objects using an IdSet
CDune::Amg::VertexProperties	Class representing a node in the matrix graph
CDune::Amg::VertexPropertiesGraph< G, VP, VM >	Attaches properties to the vertices of a graph
CDune::Amg::VertexVisitedTag	Tag idnetifying the visited property of a vertex
CDune::Capabilities::viewThreadSafe< Grid >	Specialize with 'true' if the grid implementation is thread safe, while it is not modified. (default=false)
CDune::VirtualRefinement< dimension, CoordType >	VirtualRefinement base class
CDune::VTKFunction< GridView >	A base class for grid functions with any return type and dimension
►CDune::VTKFunction< GV >
CDune::P0VTKFunction< GV, V >	Take a vector and interpret it as cell data for the VTKWriter
CDune::P1VTKFunction< GV, V >	Take a vector and interpret it as point data for the VTKWriter
►CDune::VTKWriter< GridView >	Writer for the ouput of grid functions in the vtk format
CDune::SubsamplingVTKWriter< GridView >	Writer for the output of subsampled grid functions in the vtk format
CDune::VTKSequenceWriter< GridView >	Writer for the ouput of grid functions in the vtk format
CDune::VTK::VTUWriter	Dump a .vtu/.vtp files contents to a stream
►CDune::WritablePropertyMapTag	Tag for the category of writable property maps
CDune::ReadWritePropertyMapTag	Tag for the category of readable and writable property maps
CDune::YaspGrid< dim >::YGridLevel	A single grid level within a YaspGrid