| 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::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::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::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::SGeometry< mydim, cdim, GridImp > | |
| 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 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::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, 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::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::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, pitype >::Codim< cd > | Codim Structure |
| CDune::AlbertaLevelGridView< GridImp, pitype >::Codim< cd > | Codim Structure |
| CDune::Codim< codim > | Static tag representing a codimension |
| 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::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, 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::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< cd > | |
| CDune::Codim< codimension > | |
| CDune::Codim< CodimInHostGrid > | |
| CDune::Codim< dimension > | |
| 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::IdentityGrid > | |
| 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::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::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::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::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, coorddimension, mydimension > | |
| CDune::FieldMatrix< ctype, mydim, cdim > | |
| CDune::FieldMatrix< ctype, cdim, mydim > | |
| CDune::FieldMatrix< ctype, mydimension, coorddimension > | |
| 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, 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< 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, dim > | |
| CDune::FieldVector< ctype, coorddim > | |
| CDune::FieldVector< ctype, coorddimension > | |
| CDune::FieldVector< ctype, dimension > | |
| 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::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::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_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::ElementTopologyMapping< type > | |
| 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, ALU2dGridEntity > | |
| CDune::ALU2dGridEntity< 0, dim, GridImp > | |
| ►CDune::EntityDefaultImplementation< 0, dim, GridImp, ALU3dGridEntity > | |
| CDune::ALU3dGridEntity< 0, dim, GridImp > | |
| ►CDune::EntityDefaultImplementation< 0, dim, GridImp, IdentityGridEntity > | |
| CDune::IdentityGridEntity< 0, dim, GridImp > | Specialization for codim-0-entities |
| CDune::EntityDefaultImplementation< 0, dim, GridImp, YaspEntity > | |
| ►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, IdentityGridEntity > | |
| CDune::IdentityGridEntity< codim, dim, GridImp > | The implementation of entities in a IdentityGrid |
| ►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::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 |
| ►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::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::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::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::VTK::FieldInfo | Descriptor struct for VTK fields |
| CDune::FirstPredicateIndex< Tuple, Predicate, start, size > | Finding the index of a certain type in a tuple |
| ►CDune::FirstPredicateIndex< Tuple, IsType< T >::template Predicate, 0 > | |
| CDune::FirstTypeIndex< Tuple, T, start > | Find the first occurance of a type in a tuple |
| 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, EntityReference, 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, 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::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::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::GeometryDefaultImplementation< mydim, coorddim, GridImp, IdentityGridGeometry > | |
| 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::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::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< 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< elType, Comm > | [ provides Dune::Grid ] |
| ►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, 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, 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, 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::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::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< 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, Coordinates >, codim > | YaspGrid has entities for all codimensions |
| CDune::hash< T > | Functor for hashing objects of type T |
| ►CDune::HasHierarchicIndexSet | Tagging interface to indicate that Grid has HierarchicIndexSet |
| 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< 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::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, 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::IdentityGridEntityPointer< codim, GridImp, HostGridEntityPointer_ > | |
| ►CDune::IdentityGridEntityPointer< 0, GridImp, GridImp::HostGridType::template Codim< 0 >::Entity::HierarchicIterator > | |
| 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::IdentityGridEntityPointer< codim, GridImp, GridImp::HostGridType::template Codim< codim >::template Partition< pitype >::LeafIterator > | |
| CDune::IdentityGridLeafIterator< codim, pitype, GridImp > | Iterator over all entities of a given codimension and level of a grid |
| ►CDune::IdentityGridEntityPointer< codim, GridImp, GridImp::HostGridType::Traits::template Codim< codim >::template Partition< pitype >::LevelIterator > | |
| CDune::IdentityGridLevelIterator< codim, pitype, GridImp > | Iterator over all entities of a given codimension and level of a grid |
| CDune::IdentityGridEntitySeed< codim, GridImp > | The EntitySeed class provides the minimal information needed to restore an Entity using the grid |
| 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::IdentityGridLevelIntersection< GridImp > | |
| CDune::IdentityGridLevelIntersectionIterator< GridImp > | |
| 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::IdentityGrid< HostGrid >, IdentityGridGlobalIdSet< const Dune::IdentityGrid< HostGrid > >, remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::Traits::GlobalIdSet::IdType > | |
| CDune::IdSet< const Dune::IdentityGrid< HostGrid >, IdentityGridLocalIdSet< const Dune::IdentityGrid< HostGrid > >, remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::Traits::LocalIdSet::IdType > | |
| ►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< const Dune::YaspGrid< dim, CoordCont >, YaspGlobalIdSet< const Dune::YaspGrid< dim, CoordCont > >, 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 > > >, 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 >, remove_const< GridImp >::type::HostGridType::Traits::GlobalIdSet::IdType > | |
| CDune::IdSet< GridImp, IdentityGridLocalIdSet< GridImp >, remove_const< GridImp >::type::HostGridType::Traits::LocalIdSet::IdType > | |
| ►CDune::IdSet< GridImp, SGridGlobalIdSet< GridImp >, remove_const< GridImp >::type::PersistentIndexType > | |
| CDune::SGridGlobalIdSet< GridImp > | Persistent, globally unique Ids |
| ►CDune::IdSet< GridImp, YaspGlobalIdSet< GridImp >, 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::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< 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::IdentityGrid< HostGrid >, IdentityGridLeafIndexSet< const Dune::IdentityGrid< HostGrid > >, remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::LeafGridView::IndexSet::IndexType, remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::LeafGridView::IndexSet::Types > | |
| ►CDune::IndexSet< const Dune::IdentityGrid< HostGrid >, IdentityGridLevelIndexSet< const Dune::IdentityGrid< HostGrid > >, remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::LevelGridView::IndexSet::IndexType, remove_const< const Dune::IdentityGrid< HostGrid > >::type::HostGridType::LevelGridView::IndexSet::Types > | |
| CDune::IdentityGridLevelIndexSet< const Dune::IdentityGrid< HostGrid > > | |
| ►CDune::IndexSet< const Dune::SGrid< dim, dimworld >, SGridLevelIndexSet< const Dune::SGrid< dim, dimworld > > > | |
| CDune::SGridLevelIndexSet< const Dune::SGrid< dim, dimworld > > | |
| ►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, 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, IdentityGridLeafIndexSet< GridImp >, remove_const< GridImp >::type::HostGridType::LeafGridView::IndexSet::IndexType, remove_const< GridImp >::type::HostGridType::LeafGridView::IndexSet::Types > | |
| ►CDune::IndexSet< GridImp, IdentityGridLevelIndexSet< GridImp >, remove_const< GridImp >::type::HostGridType::LevelGridView::IndexSet::IndexType, 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, SGridLevelIndexSet< GridImp > > | |
| CDune::SGridLevelIndexSet< GridImp > | Implementation of index set |
| ►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 to be introduced in C++14 |
| ►CDune::Std::integer_sequence< std::size_t, Ints... > | |
| CDune::Std::index_sequence< Ints > | Function similar to std::index_sequence to be 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 entities of codimension 0 ("elements") with a "neighboring" element or with the domain boundary |
| CDune::YGridList< Coordinates >::Intersection | Type describing an intersection with a neighboring processor |
| CDune::Intersection< const GridImp, Dune::SIntersection< const GridImp > > | |
| 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_indexable< T, I > | |
| CDune::is_lvalue_reference< T > | Determine whether a type is a lvalue reference type |
| CDune::is_pointer< T > | Is_pointer |
| 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, Coordinates > > | 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< IdentityGrid< HostGrid > > | Has conforming leaf grids when host grid has |
| 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, 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< SGrid< dim, dimw > > | SGrid 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::Capabilities::isParallel< Grid > | Specialize with 'true' if implementation supports parallelism. (default=false) |
| CDune::Capabilities::isParallel< OneDGrid > | OneDGrid is not 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::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 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::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 |
| 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::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::NonConformingFaceMapping< type, Comm > | |
| CDune::NonConformingFaceMapping< hexa, Comm > | Non-conforming face mappings for hexahedra |
| CDune::NonConformingFaceMapping< tetra, Comm > | Non-conforming face mappings for tetrahedra |
| 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::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, 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::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 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::IsType< T >::Predicate< U > | The actual predicate |
| 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::Torus< CollectiveCommunication, d >::ProcListIterator | |
| 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::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, 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< 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::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_pointer< _Tp > | Return the type a pointer type points to |
| CDune::ReservedVector< T, n > | A Vector class with statically reserved memory |
| CDune::ReservedVector< Dune::SGridLevelIndexSet< const Dune::SGrid< dim, dimworld > > *, MAXL > | |
| 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::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::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::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, EquidistantCoordinates< ctype, dim > > > | Specialization of the StructuredGridFactory for YaspGrid |
| CDune::StructuredGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > > > | Specialization of the StructuredGridFactory for YaspGrid |
| 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::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::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, 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::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::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 >::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 doesnt 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 doesnt 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 |
|
Legal Statements / Impressum |
Hosted by TU Dresden |
generated with Hugo v0.111.3
(Jan 6, 23:30, 2025)