Class Hierarchy

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

[detail level 1234567]

CDune::AdaptDataHandleInterface< Grid, Impl >	Interface class for the Grid's adapt method where the parameter is a AdaptDataHandleInterface
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::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::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, 0, cdim >
CDune::YaspGeometry< 0, cdim, GridImp >	Specialization for dim=0, this is a vertex
►CDune::AxisAlignedCubeGeometry< GridImp::ctype, mydim, cdim >
CDune::YaspGeometry< mydim, cdim, GridImp >	The general version that handles all codimensions but 0 and dim
►CDune::AxisAlignedCubeGeometry< GridImp::ctype, mydim, mydim >
CDune::YaspGeometry< mydim, mydim, GridImp >	Specialize for dim=dimworld, i.e. a volume element
CDune::b64chunk	Union representing the three byte text as well 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< Dune::YaspGrid< dim, Coordinates > >	facility for writing and reading grids
CDune::BackupRestoreFacility< YaspGrid< dim, TensorProductCoordinates< ctype, dim > > >	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, A >
►CDune::block_vector_unmanaged< B, A >
CDune::BlockVectorWindow< B, A >
►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::MatrixImp::DenseMatrixBase< B, A >	A Vector of blocks with different blocksizes
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::MatrixImp::DenseMatrixBase< 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::MatrixImp::DenseMatrixBase< T, std::allocator< T > >
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::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::Capabilities::canCommunicate< Grid, codim >	Specialize with 'true' for all codims that a grid can communicate data on (default=false)
CDune::Capabilities::canCommunicate< YaspGrid< dim, Coordinates >, codim >	YaspGrid can communicate on all codimensions
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 >::Codim< cd >	Codim Structure
CDune::AlbertaLevelGridView< GridImp >::Codim< cd >	Codim Structure
CDune::Codim< codim >	Static tag representing a codimension
CDune::DefaultLeafGridView< GridImp >::Codim< cd >	Codim Structure
CDune::DefaultLevelGridView< GridImp >::Codim< cd >	Codim Structure
CDune::Entity< 0, dim, GridImp, EntityImp >::Codim< cd >	Entity types of the different codimensions
CDune::EntityPointer< GridImp, IteratorImp >::Codim< cd >	EntityPointer types of the different codimensions
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, 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::HostGridAccess< IdentityGrid< HG > >::Codim< codim >	A Traits struct that collects return types of class member methods
CDune::IndexSet< GridImp, IndexSetImp, IndexTypeImp, TypesImp >::Codim< cc >	Export the type of the entity used as parameter in the index(...) method
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::Codim< 0 >
CDune::Codim< 1 >
CDune::Codim< codimension >
CDune::Codim< CodimInHostGrid >
CDune::Codim< dimension >
CDune::Codim< std::remove_const< Grid >::type::dimension - mydim >
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< Communicator >	Collective communication interface and sequential default implementation
CDune::CollectiveCommunication< Dune::IdentityGrid >
CDune::CollectiveCommunication< Dune::UGGrid >
CDune::CollectiveCommunication< MPI_Comm >	Specialization of CollectiveCommunication for MPI
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::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::CommDataHandleIF< IndexExchange, Index >
CDune::CommDataHandleIF< MinimumExchange< IS, V >, V::value_type >
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::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::ConstAssociativePropertyMap< T >	An adaptor to turn an unique associative container into a property map
CDune::MatrixImp::DenseMatrixBase< 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::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 std::remove_const< typename std::iterator_traits< CellIterator >::value_type >::type >
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::BCRSMatrix< B, A >::Deallocator	Class used by shared_ptr to deallocate memory using the proper allocator
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::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< ctype, ROWS, COLS > >
CDune::FieldMatrix< ctype, coorddimension, mydimension >
CDune::FieldMatrix< ctype, mydimension, coorddimension >
CDune::FieldMatrix< ctype, numCorners, coorddimension >
►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::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, std::allocator< field_type > > >
CDune::DynamicVector< field_type >
►CDune::DenseVector< DynamicVector< K, std::allocator< K > > >
CDune::DynamicVector< K, Allocator >	Construct a vector with a dynamic size
►CDune::DenseVector< FieldVector< ct, SIZE > >
CDune::FieldVector< ct, dim >
►CDune::DenseVector< FieldVector< ctype, SIZE > >
CDune::FieldVector< ctype, COLS >
CDune::FieldVector< ctype, dim >
CDune::FieldVector< ctype, coorddim >
CDune::FieldVector< ctype, coorddimension >
CDune::FieldVector< ctype, dimworld >
►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::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::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::DGFGridFactory< YaspGrid< dim > >	Grid factory for YaspGrid with equidistant coordinates
CDune::DGFGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< double, dim > > >	Grid factory for YaspGrid with equidistant coordinates
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::Dim< dim >	Static tag representing a dimension
►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::DuneBoundaryProjection< dimworld >	Interface class for vertex projection at the boundary
CDune::BoundarySegmentWrapper< dim, dimworld >
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::Empty	Just an empty class
CDune::EmptySet< TA >	An empty set
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::Entity< codim, dim, Grid, EntityImp >
►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 >	actual implementation of the entity
CDune::GeoGrid::EntityBase< codim, Grid, true >	actual implementation of the 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, IdentityGridEntity >
CDune::IdentityGridEntity< 0, dim, GridImp >	Specialization for codim-0-entities
CDune::EntityDefaultImplementation< 0, dim, GridImp, YaspEntity >
►CDune::EntityDefaultImplementation< codim, dim, Grid, AlbertaGridEntity >
CDune::AlbertaGridEntity< codim, dim, Grid >
►CDune::EntityDefaultImplementation< codim, dim, GridImp, IdentityGridEntity >
CDune::IdentityGridEntity< codim, dim, GridImp >	The implementation of entities in a IdentityGrid
CDune::EntityDefaultImplementation< codim, dim, GridImp, YaspEntity >
CDune::EntityDefaultImplementation< dim, dim, GridImp, YaspEntity >
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::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::EquidistantCoordinates< ct, dim >	Container for equidistant coordinates in a YaspGrid
CDune::EquidistantOffsetCoordinates< ct, dim >	Container for equidistant coordinates in a YaspGrid with non-trivial origin
►Cstd::exception	STL class
►CDune::Exception	Base class for Dune-Exceptions
CDune::GridError	Base class for exceptions in Dune grid modules
CDune::HelpRequest	Exception thrown if the user wants to see help string
►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::InvalidStateException	Default exception if a function was called while the object is not in a valid state for that function
CDune::InvalidIndexSetState	Exception indicating that the index set is not in the expected state
►CDune::MathError	Default exception class for mathematical errors
CDune::FMatrixError	Error thrown if operations of a FieldMatrix fail
►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::SolverAbort	Thrown when a solver aborts due to some problem
►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 occurred
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::ParameterTreeParserError	Report parser error while reading ParameterTree
►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::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::VTK::FieldInfo	Descriptor struct for VTK fields
CDune::FirstPredicateIndex< Tuple, Predicate, start, size >	Finding the index of a certain type in a std::tuple
►CDune::FirstPredicateIndex< Tuple, IsType< T >::template Predicate, 0 >
CDune::FirstTypeIndex< Tuple, T, start >	Find the first occurrence of a type in a std::tuple
CDune::FlattenTuple< Tuple >	Flatten a std::tuple of std::tuple's
CDune::FloatCmpOps< T, cstyle_, rstyle_ >	Class encapsulating a default epsilon
CDune::FMatrixPrecision< ctype >	Precisions for calculations with FieldMatrix and FieldVector
CDune::ForEachType< TE, T >	Helper template to clone the type definition of a std::tuple with the storage types replaced by a user-defined rule
CDune::ForEachValue< Tuple >	Helper template which implements iteration over all storage elements in a std::tuple
CDune::ForEachValuePair< Tuple1, Tuple2 >	Extension of ForEachValue to two std::tuple's
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, EntityReference, int >
CDune::VTKWriter< GridView >::CornerIterator	Iterate over the elements' corners
►CDune::ForwardIteratorFacade< CornerIterator< CellIterator >, const Corner< std::remove_const< std::iterator_traits< CellIterator >::value_type >::type >, const Corner< std::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< std::remove_const< std::iterator_traits< CellIterator >::value_type >::type >, const Corner< std::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, EntityReference, 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::VTKWriter< GridView >::VTKLocalFunction::FunctionWrapperBase	Base class for polymorphic container of underlying data set
CDune::VTKWriter< GridView >::VTKLocalFunction::FunctionWrapper< F >	Type erasure implementation for functions conforming to the dune-functions LocalFunction interface
CDune::VTKWriter< GridView >::VTKLocalFunction::VTKFunctionWrapper	Type erasure implementation for legacy VTKFunctions
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::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::Geometry< mydim, cdim, GridImp, GeometryImp >	Wrapper class for geometries
CDune::GeometryDefaultImplementation< mydim, cdim, GridImp, GeometryImp >	Default implementation for class Geometry
CDune::GeometryDefaultImplementation< mydim, coorddim, GridImp, IdentityGridGeometry >
CDune::GeometryGrid< HostGrid, CoordFunction, Allocator >	Grid wrapper replacing the geometries
CDune::GeometryType	Unique label for each type of entities that can occur in DUNE grids
CDune::GlobalGeometryTypeIndex	Compute indices for geometry types, taking the dimension into account
CDune::GlobalIndexSet< GridView >	Calculate globally unique index over all processes in a Dune grid
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::GMPField< precision >	Number class for high precision floating point number using the GMP library mpf_class implementation
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::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, Coordinates::ctype, YaspGridFamily< dim, CoordCont > >
►CDune::GridDefaultImplementation< dim, dim, Coordinates::ctype, YaspGridFamily< dim, CoordCont > >
CDune::YaspGrid< dim, CoordCont >
►CDune::Grid< dim, dimworld, Coordinates::ctype, YaspGridFamily< dim, EquidistantCoordinates< double, dim > > >
►CDune::GridDefaultImplementation< dim, dim, Coordinates::ctype, YaspGridFamily< dim, EquidistantCoordinates< double, dim > > >
CDune::YaspGrid< dim, EquidistantCoordinates< double, dim > >
CDune::YaspGrid< dim, Coordinates >	[ provides Dune::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, HostGrid::ctype, IdentityGridFamily< HostGrid::dimension, HostGrid > >
►CDune::GridDefaultImplementation< HostGrid::dimension, HostGrid::dimensionworld, HostGrid::ctype, IdentityGridFamily< HostGrid::dimension, HostGrid > >
CDune::IdentityGrid< HostGrid >	Provides a meta grid that is identical to its host
►CDune::Grid< dim, dimworld, OneDGridGeometry< 0, 1, OneDGrid >::ctype, OneDGridFamily >
►CDune::GridDefaultImplementation< 1, 1, OneDGridGeometry< 0, 1, OneDGrid >::ctype, OneDGridFamily >
CDune::OneDGrid	One-dimensional adaptive 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::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, 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::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< IdentityGrid< HostGrid >, codim >	Has entities for some codimensions as host grid
CDune::Capabilities::hasEntity< OneDGrid, cdim >	OneDGrid 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, Coordinates >, codim >	YaspGrid has entities for all codimensions
CDune::hash< T >	Functor for hashing objects of type T
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::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< YaspGrid< dim, Coordinates > >	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 from GeometryGrid
CDune::IdentityGridEntitySeed< codim, GridImp >	The EntitySeed class provides the minimal information needed to restore an Entity using the grid
CDune::IdentityGridHierarchicIterator< GridImp >	Iterator over the descendants of an entity.Mesh entities of codimension 0 ("elements") allow to visit all entities of codimension 0 obtained through nested, hierarchic refinement of the entity. Iteration over this set of entities is provided by the HierarchicIterator, starting from a given entity
CDune::IdentityGridLeafIntersection< GridImp >	An intersection with a leaf neighbor elementMesh entities of codimension 0 ("elements") allow to visit all neighbors, where a neighbor is an entity of codimension 0 which has a common entity of codimension 1 These neighbors are accessed via a IntersectionIterator. This allows the implement non-matching meshes. The number of neighbors may be different from the number of an element!
CDune::IdentityGridLeafIntersectionIterator< GridImp >	Iterator over all element neighborsMesh entities of codimension 0 ("elements") allow to visit all neighbors, where a neighbor is an entity of codimension 0 which has a common entity of codimension 1 These neighbors are accessed via a IntersectionIterator. This allows the implement non-matching meshes. The number of neighbors may be different from the number of an element!
CDune::IdentityGridLeafIterator< codim, pitype, GridImp >	Iterator over all entities of a given codimension and level of a grid
CDune::IdentityGridLevelIntersection< GridImp >
CDune::IdentityGridLevelIntersectionIterator< GridImp >
CDune::IdentityGridLevelIterator< codim, pitype, GridImp >	Iterator over all entities of a given codimension and level of a grid
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< const Dune::IdentityGrid< HostGrid >, IdentityGridGlobalIdSet< const Dune::IdentityGrid< HostGrid > >, std::remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::Traits::GlobalIdSet::IdType >
CDune::IdSet< const Dune::IdentityGrid< HostGrid >, IdentityGridLocalIdSet< const Dune::IdentityGrid< HostGrid > >, std::remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::Traits::LocalIdSet::IdType >
►CDune::IdSet< const Dune::YaspGrid< dim, CoordCont >, YaspGlobalIdSet< const Dune::YaspGrid< dim, CoordCont > >, std::remove_const< const Dune::YaspGrid< dim, CoordCont > >::type::PersistentIndexType >
CDune::YaspGlobalIdSet< const Dune::YaspGrid< dim, CoordCont > >
►CDune::IdSet< const Dune::YaspGrid< dim, EquidistantCoordinates< double, dim > >, YaspGlobalIdSet< const Dune::YaspGrid< dim, EquidistantCoordinates< double, dim > > >, std::remove_const< const Dune::YaspGrid< dim, EquidistantCoordinates< double, dim > > >::type::PersistentIndexType >
CDune::YaspGlobalIdSet< const Dune::YaspGrid< dim, EquidistantCoordinates< double, dim > > >
CDune::IdSet< Grid, IdSet< Grid, HostIdSet >, HostIdSet::IdType >
CDune::IdSet< GridImp, IdentityGridGlobalIdSet< GridImp >, std::remove_const< GridImp >::type::HostGridType::Traits::GlobalIdSet::IdType >
CDune::IdSet< GridImp, IdentityGridLocalIdSet< GridImp >, std::remove_const< GridImp >::type::HostGridType::Traits::LocalIdSet::IdType >
►CDune::IdSet< GridImp, YaspGlobalIdSet< GridImp >, std::remove_const< GridImp >::type::PersistentIndexType >
CDune::YaspGlobalIdSet< 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::SolverHelper< ISTLLinearSolver, BCRSMatrix >::Implementation< is_direct_solver, Dummy >	Implementation that works together with iterative ISTL solvers, e.g. Dune::CGSolver or Dune::BiCGSTABSolver
CDune::SolverHelper< ISTLLinearSolver, BCRSMatrix >::Implementation< true, Dummy >	Implementation that works together with direct ISTL solvers, e.g. Dune::SuperLU or Dune::UMFPack
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, TypesImp >	Index Set Interface base class
CDune::IndexSet< AlbertaGrid< dim, dimworld >, AlbertaGridIndexSet< dim, dimworld >, int, std::array< GeometryType, 1 > >
CDune::IndexSet< AlbertaGridFamily< dim, dimworld >, AlbertaGridHierarchicIndexSet< dim, dimworld >, int, std::array< GeometryType, 1 > >
CDune::IndexSet< const Dune::IdentityGrid< HostGrid >, IdentityGridLeafIndexSet< const Dune::IdentityGrid< HostGrid > >, std::remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::LeafGridView::IndexSet::IndexType, std::remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::LeafGridView::IndexSet::Types >
►CDune::IndexSet< const Dune::IdentityGrid< HostGrid >, IdentityGridLevelIndexSet< const Dune::IdentityGrid< HostGrid > >, std::remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::LevelGridView::IndexSet::IndexType, std::remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::LevelGridView::IndexSet::Types >
CDune::IdentityGridLevelIndexSet< const Dune::IdentityGrid< HostGrid > >
►CDune::IndexSet< const Dune::YaspGrid< dim, CoordCont >, YaspIndexSet< const Dune::YaspGrid< dim, CoordCont >, isLeafIndexSet >, unsigned int >
CDune::YaspIndexSet< const Dune::YaspGrid< dim, CoordCont >, false >
CDune::YaspIndexSet< const Dune::YaspGrid< dim, CoordCont >, true >
►CDune::IndexSet< const Dune::YaspGrid< dim, EquidistantCoordinates< double, dim > >, YaspIndexSet< const Dune::YaspGrid< dim, EquidistantCoordinates< double, dim > >, isLeafIndexSet >, unsigned int >
CDune::YaspIndexSet< const Dune::YaspGrid< dim, EquidistantCoordinates< double, dim > >, false >
CDune::YaspIndexSet< const Dune::YaspGrid< dim, EquidistantCoordinates< double, dim > >, true >
CDune::IndexSet< Grid, IndexSet< Grid, HostIndexSet >, HostIndexSet::IndexType, HostIndexSet::Types >
CDune::IndexSet< GridImp, IdentityGridLeafIndexSet< GridImp >, std::remove_const< GridImp >::type::HostGridType::LeafGridView::IndexSet::IndexType, std::remove_const< GridImp >::type::HostGridType::LeafGridView::IndexSet::Types >
►CDune::IndexSet< GridImp, IdentityGridLevelIndexSet< GridImp >, std::remove_const< GridImp >::type::HostGridType::LevelGridView::IndexSet::IndexType, std::remove_const< GridImp >::type::HostGridType::LevelGridView::IndexSet::Types >
CDune::IdentityGridLevelIndexSet< GridImp >
►CDune::IndexSet< GridImp, IndexSetImp >
CDune::IndexSetDefaultImplementation< GridImp, IndexSetImp >	Provide default implementation of method if IndexSet
►CDune::IndexSet< GridImp, YaspIndexSet< GridImp, isLeafIndexSet >, unsigned int >
CDune::YaspIndexSet< GridImp, isLeafIndexSet >	Implementation of Level- and LeafIndexSets for YaspGrid
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::Std::integer_sequence< T, Ints >	Implementation of std::integer_sequence as introduced in C++14
►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 entity of codimension 0 ("element") with a "neighboring" element or with the domain boundary
CDune::YGridList< Coordinates >::Intersection	Type describing an intersection with a neighboring processor
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::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::LDL< BCRSMatrix< FieldMatrix< T, n, m >, A > >	The LDL direct sparse solver for matrices of type BCRSMatrix
CDune::SPQR< BCRSMatrix< FieldMatrix< T, n, m >, A > >	The SPQR direct sparse solver for matrices of type BCRSMatrix
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::Std::is_callable< D, R >	Traits class to check if function is callable
CDune::Std::is_callable< F(Args...), R >	Traits class to check if function is callable
CDune::is_indexable< T, I >
CDune::is_range< T, typename >
CDune::Capabilities::isCartesian< Grid >	Specialize with 'true' if the grid is a Cartesian grid. Cartesian grids satisfy the following properties:
CDune::Capabilities::isCartesian< YaspGrid< dim, Coordinates > >	YaspGrid is a Cartesian grid
CDune::IsEmptyTypeList< T >	Check if given type is an empty TypeList
CDune::IsFieldVectorSizeCorrect< C, SIZE >	TMP to check the size of a DenseVectors statically, if possible
CDune::IsIntegralConstant< T >	Check if T is an std::integral_constant<I, i>
CDune::IsInteroperable< T1, T2 >	Checks whether 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< IdentityGrid< HostGrid > >	Has conforming leaf grids when host grid has
CDune::Capabilities::isLeafwiseConforming< OneDGrid >	OneDGrid is leafwise conforming
CDune::Capabilities::isLeafwiseConforming< UGGrid< dim > >	UGGrid may not be leafwise conforming
CDune::Capabilities::isLeafwiseConforming< YaspGrid< dim, Coordinates > >	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< IdentityGrid< HostGrid > >	Has conforming level grids when host grid has
CDune::Capabilities::isLevelwiseConforming< OneDGrid >	OneDGrid is levelwise conforming
CDune::Capabilities::isLevelwiseConforming< UGGrid< dim > >	UGGrid is levelwise conforming
CDune::Capabilities::isLevelwiseConforming< YaspGrid< dim, Coordinates > >	YaspGrid is levelwise conforming
CDune::IsMatrix< T >	Test whether a type is an ISTL Matrix
CDune::IsTuple< T >	Check if T is a std::tuple<...>
CDune::IsTupleOrDerived< T >	Check if T derived from a std::tuple<...>
CDune::IsType< T >	Generator for predicates accepting one particular type
CDune::IsTypeList< T >	Check if given type is a TypeList
CDune::IsTypeList< TypeList< T... > >	Check if given type is a TypeList.
CDune::CollectiveIterator< T, A >::iterator	Iterator over the valid underlying iterators
CDune::MatrixImp::DenseMatrixBase< B, A >::Iterator	Iterator class for sequential access
CDune::YGrid< Coordinates >::Iterator	Iterator over a collection o YGrids A YGrid::Iterator is the heart of an entity in YaspGrid
CDune::YGridComponent< Coordinates >::Iterator
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::IteratorRange< Iterator >	Simple range between a begin and an end iterator
CDune::Jacobi1QuadratureInitHelper< ct, fundamental >
CDune::Jacobi2QuadratureInitHelper< ct, fundamental >
CDune::JoinTuples< Head, Tail >	Join two std::tuple's
CDune::Lcm< m, n >	Calculate the least common multiple of two numbers
CDune::LDL< Matrix >	Use the LDL package to directly solve linear systems – empty default class
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::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< OP1::domain_type, OP1::range_type >
CDune::LinearOperatorSum< MatrixOperator, ScalingOperator >
CDune::LinearOperatorSum< OP1, OP2 >	A linear operator representing the sum of two linear operators
►CDune::LinearOperator< X, X >
CDune::ScalingLinearOperator< X, Y >	A linear operator scaling vectors by a scalar value. The scalar value can be changed as it is given in a form decomposed into an immutable and a mutable part
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, IndexType >	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, IndexType >	Implements a mapper for an arbitrary subset of entities
►CDune::Mapper< GV::Grid, MultipleCodimMultipleGeomTypeMapper< G::LeafGridView, Layout >, GV::IndexSet::IndexType >
►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 >, GV::IndexSet::IndexType >
►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 >, GV::IndexSet::IndexType >
CDune::MultipleCodimMultipleGeomTypeMapper< GV, Layout >	Implementation class for a multiple codim and multiple geometry type mapper
►CDune::Mapper< GV::Grid, MultipleCodimMultipleGeomTypeMapper< GV, MCMGElementLayout >, GV::IndexSet::IndexType >
CDune::MultipleCodimMultipleGeomTypeMapper< GV, MCMGElementLayout >
►CDune::Mapper< GV::Grid, MultipleCodimMultipleGeomTypeMapper< GV, MCMGVertexLayout >, GV::IndexSet::IndexType >
CDune::MultipleCodimMultipleGeomTypeMapper< GV, MCMGVertexLayout >
►CDune::Mapper< GV::Grid, SingleCodimSingleGeomTypeMapper< G::LeafGridView, c >, GV::IndexSet::IndexType >
►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 >, GV::IndexSet::IndexType >
►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 >, GV::IndexSet::IndexType >
CDune::SingleCodimSingleGeomTypeMapper< GV, c >	Implementation class for a single codim and single geometry type mapper
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
CMatrixInfo< BCRSMatrix >	Class template which yields information related to a square matrix like its spectral (i.e. 2-norm) condition number
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
CDune::MatrixMarketImpl::MatrixValuesSetter< D, brows, bcols >	Functor to the data values of the matrix
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
CDune::MatrixMarketImpl::mm_block_structure_header< M >	Metaprogram for writing the ISTL block structure header
CDune::MatrixMarketImpl::mm_header_printer< M >	Meta program to write the correct Matrix Market header
CDune::MatrixMarketImpl::mm_numeric_type< T >	Helper metaprogram to get the matrix market string representation of the numeric type
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::MultiTypeBlockMatrix< FirstRow, Args >	A Matrix class to support different block types
CDune::MultiTypeBlockMatrix_Solver< I, crow, remain_row >	Solver for MultiTypeBlockVector & MultiTypeBlockMatrix types
CDune::MultiTypeBlockMatrix_Solver_Col< I, crow, ccol, remain_col >	Part of solvers for MultiTypeBlockVector & MultiTypeBlockMatrix types
CDune::MultiTypeBlockVector< Args >	A Vector class to support different block types
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::null_deleter< T >	Implements the Deleter concept of shared_ptr without deleting anything
CDune::NullPointerInitialiser< T >	A helper template that initializes a std::tuple consisting of pointers to nullptr
CDune::MatrixMarketImpl::NumericWrapper< T >	Wrapper class of numeric values
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::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 >::Codim< cd >::Partition< pit >	Define types needed to iterate over entities of a given partition type
CDune::AlbertaLevelGridViewTraits< GridImp >::Codim< cd >::Partition< pit >	Define types needed to iterate over entities of a given partition type
CDune::DefaultLeafGridViewTraits< GridImp >::Codim< cd >::Partition< pit >	Define types needed to iterate over entities of a given partition type
CDune::DefaultLevelGridViewTraits< GridImp >::Codim< cd >::Partition< pit >	Define types needed to iterate over entities of a given partition type
CDune::Grid< dim, dimworld, ct, GridFamily >::Codim< cd >::Partition< pitype >	A struct collecting all types depending on the partition iterator type
CDune::GridTraits< dim, dimw, GridImp, GeometryImp, EntityImp, 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::GridView< ViewTraits >::Codim< cd >::Partition< pit >	Define types needed to iterate over entities of a given partition type
CDune::PartitionSet< partitions >	A set of PartitionType values
CDune::MatrixMarketImpl::PatternDummy	Utility class for marking the pattern type of the MatrixMarket matrices
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< Grid, G::LocalIdSet, std::map< G::LocalIdSet::IdType, T > >
►CDune::PersistentContainer< Grid, T >
CDune::PersistentContainer< const Grid, T >	Refer PersistentContainer<const Grid> to the implementation of the mutable grid
►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::PersistentContainerVector< YaspGrid< dim, CoordCont >, YaspPersistentContainerIndex< const YaspGrid< dim, CoordCont > >, std::vector< T > >
CDune::PersistentContainer< YaspGrid< dim, CoordCont >, T >	Specialization of the PersistentContainer for YaspGrid
CDune::PointerPairDeletor< Tuple >	Deletes all objects pointed to in a std::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::PowerIteration_Algorithms< BCRSMatrix, BlockVector >	A class template for performing some iterative eigenvalue algorithms based on power iteration
►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::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::IsType< T >::Predicate< U >	The actual predicate
CDune::VTK::PrintType< T >	Determine a type to safely put another type into a stream
CDune::PriorityTag< priority >	Helper class for tagging priorities
CDune::PriorityTag< 0 >	Helper class for tagging priorities
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::Torus< CollectiveCommunication, d >::ProcListIterator
CDune::PromotionTraits< T1, T2 >	Compute type of the result of an arithmetic operation involving two different number types
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 std::tuple
CDune::PushFrontTuple< Tuple, T >	Helper template to prepend a type to a std::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, T &, std::ptrdiff_t >
CDune::DenseIterator< C, T, R >	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< RealIterator< T, R >, T, R >
CDune::VariableBlockVector< B, A >::RealIterator< T, R >	Iterator class for sequential access
►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
CDune::ReferenceElements< ctype, dim >	Class providing access to the singletons of the reference elements
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::Concept::Refines< BaseConcepts >	Base class for refined concepts
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::ReservedVector< T, n >	A Vector class with statically reserved memory
CDune::ReservedVector< T, length >
CDune::ReservedVector< YGridLevel, 32 >
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::SeqOverlappingSchwarzApplier< T >	Helper template meta program for application of overlapping schwarz
CDune::SeqOverlappingSchwarzDomainSize< M >
CDune::Singleton< T >	An adapter to turn a class into a singleton
CDune::SizeCache< GridImp >	Organizes the caching of sizes for one grid and one GeometryType
CDune::SizeCache< AlbertaGrid< dim, Alberta::dimWorld > >
CDune::SizeCache< AlbertaGrid< dim, dimworld > >
CDune::SizeOf< T >	Compute size of variadic type list
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::SolverHelper< ISTLLinearSolver, BCRSMatrix >	Helper class for notifying a DUNE-ISTL linear solver about a change of the iteration matrix object in a unified way, i.e. independent from the solver's type (direct/iterative)
CDune::Amg::SparsityBuilder< M >	Functor for building the sparsity pattern of the matrix using examineConnectivity
CDune::SPQR< Matrix >	Use the SPQR package to directly solve linear systems – empty default class
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::StructuredGridFactory< GridType >	Construct structured cube and simplex grids in unstructured grid managers
CDune::StructuredGridFactory< YaspGrid< dim, EquidistantCoordinates< ctype, dim > > >	Specialization of the StructuredGridFactory for YaspGrid
CDune::StructuredGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > > >	Specialization of the StructuredGridFactory for YaspGrid<EquidistantOffsetCoordinates>
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::GlobalIndexSet< GridView >::SubPartitionTypeProvider< Entity, Codim >	Helper class to provide access to subentity PartitionTypes with a run-time codimension
CDune::SuperLUMatrix< M >	Utility class for converting an ISTL Matrix into a SuperLU Matrix
CDune::SuperLUMatrix< Matrix >
CDune::SymmetricMultiplicativeSchwarzMode	Tag that tells the Schwarz method to be multiplicative and symmetric
CDune::TensorGridFactory< Grid >	A factory class for conveniently creating tensorproduct grids
CDune::TensorGridFactory< Dune::Grid >
CDune::TensorGridFactory< Dune::YaspGrid >
CDune::TensorProductCoordinates< ct, dim >	Coordinate container for a tensor product YaspGrid
CDune::Capabilities::threadSafe< Grid >	Specialize with 'true' if the grid implementation is thread safe. (default=false)
CDune::Timer	A simple stop watch
CDune::Std::to_false_type< T >	Template mapping a type to std::false_type
CDune::Std::to_true_type< T >	Template mapping a type to std::true_type
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::Torus< CollectiveCommunication, d >
CDune::Torus< Dune::CollectiveCommunication< MPI_Comm >, dim >
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, Args >
CDune::TransposedMatMultMatResult< M1, M2 >	Helper TMP to get the result type of a sparse matrix matrix multiplication ( $C=A*B$)
CDune::TupleVector< T >	A class augmenting std::tuple by element access via operator[]
CDune::TypeList< T >	A simple type list
CDune::TypeListElement< i, TypeList< T... > >	Get element of TypeList
CDune::TypeListSize< TypeList< T... > >	Get size of TypeList
CDune::VTK::TypeName< T >	Map type to its VTK name in data array
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::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::detail::voider<... >	Helper to make void_t work with gcc versions prior to gcc 5.0
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 >::VTKLocalFunction	Type erasure wrapper for VTK data sets
►CDune::VTKSequenceWriterBase< GridView >	Base class to write pvd-files which contains a list of all collected vtk-files
CDune::SubsamplingVTKSequenceWriter< GridView >	Writer for the ouput of grid functions in the vtk format
CDune::VTKSequenceWriter< GridView >	Writer for the ouput of grid functions in the vtk format
►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::VTKWriter< Dune::GridView >
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::YaspEntityPointer< codim, GridImp >	A pointer to a YaspGrid::Entity
CDune::YaspLevelIterator< codim, pitype, GridImp >	Iterates over entities of one grid level
►CDune::YaspEntityPointer< 0, GridImp >
CDune::YaspHierarchicIterator< GridImp >	YaspHierarchicIterator enables iteration over son entities of codim 0
CDune::YaspEntitySeed< codim, GridImp >	Describes the minimal information necessary to create a fully functional YaspEntity
CDune::YaspIntersection< GridImp >	YaspIntersection provides data about intersection with neighboring codim 0 entities
CDune::YaspIntersectionIterator< GridImp >	YaspIntersectionIterator enables iteration over intersections with neighboring codim 0 entities
CDune::YaspPersistentContainerIndex< Grid >	Implement a consecutive index for all entities of given codim of a YaspGrid
►CDune::YaspPersistentContainerIndex< const YaspGrid< dim, CoordCont > >
CDune::PersistentContainer< YaspGrid< dim, CoordCont >, T >	Specialization of the PersistentContainer for YaspGrid
CDune::YGrid< Coordinates >	Implements a collection of YGridComponents which form a codimension Entities of given codimension c need to be represented by d choose c YgridComponents. All entities in one such component share the same set of spanning unit vectors. A YGrid is used to iterate over the entire set of components the codimension consists of. It doesn't hold any data, but instead holds an iterator range into an array of components (which is owned by YGridLevel)
CDune::YGridComponent< Coordinates >
CDune::YGridList< Coordinates >	Implements a collection of multiple std::deque<Intersection> Intersections with neighboring processors are stored as std::deque<Intersection>. Eachsuch intersection only holds one YGridComponent. To do all communication associated with one codimension, multiple such deques have to be concatenated. YGridList manges this concatenation. As for YGrids, YGridList doesn't hold any data, but an iterator range into a data array owned by YGridLevel
►CDune::YLoadBalance< d >	Base class for the yaspgrid partitioning strategy The name might be irritating. It will probably change to YaspPartitionerBase in a 3.0 release
CDune::YLoadBalanceDefault< d >	Implement the default load balance strategy of yaspgrid
CDune::YLoadBalancePowerD< d >	Implement yaspgrid load balance strategy for P=x^{dim} processors
CDune::YaspFixedSizePartitioner< d >	Implement partitioner that gets a fixed partitioning from an array If the given partitioning doesn't match the number of processors, the grid should be distributed to, an exception is thrown