 ALU2DSPACENAME | |
  AdaptRestrictProlong2dImpl | |
 ALUGridSpace | |
  BSMacroIterator | |
  ALUHElementType | |
  ALUHElementType< 0, Comm > | |
  ALUHElementType< 1, Comm > | |
  ALUHElementType< 2, Comm > | |
  ALUHElementType< 3, Comm > | |
  IteratorWrapperInterface | |
  IteratorElType | |
  ALU3dGridLevelIteratorWrapper | |
  ALU3dGridLevelIteratorWrapper< 0, pitype, Comm > | |
  ALU3dGridLevelIteratorWrapper< 1, pitype, Comm > | |
  ALU3dGridLevelIteratorWrapper< 3, pitype, Comm > | |
  ALU3dGridLeafIteratorWrapper | |
  ALU3dGridLeafIteratorWrapper< 0, pitype, Comm > | |
  LeafStopRule | |
  ALU3dGridLeafIteratorWrapper< 1, pitype, Comm > | |
  ALU3dGridLeafIteratorWrapper< 2, pitype, Comm > | |
  ALU3dGridLeafIteratorWrapper< 3, pitype, Comm > | |
  ALU3dGridLevelIteratorWrapper< 2, pitype, Comm > | |
  GatherScatterBaseImpl | Corresponding interface class is defined in bsinclude.hh |
  GatherScatterBaseImpl< GridType, DataCollectorType, 0 > | Corresponding interface class is defined in bsinclude.hh |
  GatherScatterLoadBalance | Corresponding interface class is defined in bsinclude.hh |
  AdaptRestrictProlongImpl | |
  AdaptRestrictProlongGlSet | |
  LoadBalanceElementCount | |
  ALUGridFiniteStack | |
 Dune | Include standard header files |
  Alberta | |
   CoordCache | |
    Interpolation | |
    LocalCaching | |
   AdaptRestrictProlongHandler | |
   MeshPointer | |
    MacroIterator | |
   DofAccess | |
   HierarchyDofNumbering | |
   DofVectorProvider | |
   DofVectorProvider< int > | |
   DofVectorProvider< signed char > | |
   DofVectorProvider< unsigned char > | |
   DofVectorProvider< Real > | |
   DofVectorProvider< GlobalVector > | |
   DofVectorPointer | |
   ElementInfo | |
    Instance | |
    Seed | |
    Stack | |
   GeometryCache | |
   GeometryCacheProxy | |
   MacroData | |
    Library | |
   MacroElement | |
   GlobalSpace | |
   NumSubEntities | |
   NumSubEntities< dim, 0 > | |
   NumSubEntities< dim, dim > | |
   NumSubEntities< 0, 0 > | |
   NumSubEntities< 2, 1 > | |
   NumSubEntities< 3, 1 > | |
   NumSubEntities< 3, 2 > | |
   CodimType | |
   CodimType< dim, 0 > | |
   CodimType< dim, dim > | |
   CodimType< 2, 1 > | |
   CodimType< 3, 1 > | |
   CodimType< 3, 2 > | |
   FillFlags | |
   RefinementEdge | |
   RefinementEdge< 2 > | |
   Dune2AlbertaNumbering | |
   Dune2AlbertaNumbering< 3, 2 > | |
   Generic2AlbertaNumbering | |
   Generic2AlbertaNumbering< dim, 1 > | |
   Generic2AlbertaNumbering< 1, 1 > | |
   Generic2AlbertaNumbering< 3, 2 > | |
   NumberingMap | |
   MapVertices | |
   MapVertices< dim, 0 > | |
   MapVertices< 2, 1 > | |
   MapVertices< 3, 1 > | |
   MapVertices< 3, 2 > | |
   MapVertices< dim, dim > | |
   Twist | |
   Twist< dim, 1 > | |
   Twist< 1, 1 > | |
   Twist< dim, 2 > | |
   Twist< 2, 2 > | |
   ProjectionFactory | |
   DuneBoundaryProjection | |
   ProjectionFactoryInterface | |
   DuneGlobalBoundaryProjectionFactory | |
   BasicNodeProjection | |
   NodeProjection | |
   ForEachInteriorSubChild | |
   Patch | |
   ForEachInteriorSubChild< dim, 0 > | |
   ForEachInteriorSubChild< dim, dim > | |
   ForEachInteriorSubChild< 2, 1 > | |
   ForEachInteriorSubChild< 3, 1 > | |
   ForEachInteriorSubChild< 3, 2 > | |
   GeometryInFather | |
   GeometryInFather< 1 > | |
   GeometryInFather< 2 > | |
   GeometryInFather< 3 > | |
  Capabilities | Contains all capabilities classes |
   hasSingleGeometryType< AlbertaGrid< dim, dimworld > > | AlbertaGrid has only one geometry type for codim 0 entities |
   hasEntity< AlbertaGrid< dim, dimworld >, codim > | AlbertaGrid has entities for all codimensions |
   isLevelwiseConforming< AlbertaGrid< dim, dimworld > > | AlbertaGrid is not levelwise conforming (since it uses bisection) |
   isLeafwiseConforming< AlbertaGrid< dim, dimworld > > | AlbertaGrid is leafwise conforming |
   hasBackupRestoreFacilities< AlbertaGrid< dim, dimworld > > | AlbertaGrid has backup and restore facilities |
   hasHierarchicIndexSet | |
   hasHierarchicIndexSet< AlbertaGrid< dim, dimworld > > | |
   hasEntity< ALU2dGrid< dim, dimw, eltype >, cdim > | |
   isLevelwiseConforming< ALU2dGrid< dim, dimw, eltype > > | |
   hasEntity< Dune::ALU3dGrid< elType, Comm >, cdim > | |
   isParallel< ALU3dGrid< elType, Comm > > | |
   isLevelwiseConforming< ALU3dGrid< elType, Comm > > | |
   hasBackupRestoreFacilities< ALU3dGrid< elType, Comm > > | |
   hasSingleGeometryType | 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) |
   isCartesian | Specialize with 'true' if the grid is a Cartesian grid. Cartesian grids satisfy the following properties: |
   hasEntity | Specialize with 'true' for all codims that a grid implements entities for. (default=false) |
   isParallel | Specialize with 'true' if implementation supports parallelism. (default=false) |
   canCommunicate | Specialize with 'true' for all codims that a grid can communicate data on (default=false) |
   isLevelwiseConforming | Specialize with 'true' if implementation guarantees conforming level grids. (default=false) |
   isLeafwiseConforming | Specialize with 'true' if implementation guarantees a conforming leaf grid. (default=false) |
   hasBackupRestoreFacilities | Specialize with 'true' if implementation provides backup and restore facilities. (default=false) |
   threadSafe | Specialize with 'true' if the grid implementation is thread safe. (default=false) |
   viewThreadSafe | Specialize with 'true' if the grid implementation is thread safe, while it is not modified. (default=false) |
   hasSingleGeometryType< const Grid > | |
   isCartesian< const Grid > | |
   hasEntity< const Grid, codim > | |
   isParallel< const Grid > | |
   canCommunicate< const Grid, codim > | |
   isLevelwiseConforming< const Grid > | |
   isLeafwiseConforming< const Grid > | |
   hasBackupRestoreFacilities< const Grid > | |
   threadSafe< const Grid > | |
   viewThreadSafe< const Grid > | |
   hasEntity< Grid< dim, dimworld, ct, GridFamily >, codim > | |
   hasEntity< GridDefaultImplementation< dim, dimworld, ct, GridFamily >, cdim > | |
   hasSingleGeometryType< GeometryGrid< HostGrid, CoordFunction, Allocator > > | |
   hasEntity< GeometryGrid< HostGrid, CoordFunction, Allocator >, codim > | |
   isParallel< GeometryGrid< HostGrid, CoordFunction, Allocator > > | |
   canCommunicate< GeometryGrid< HostGrid, CoordFunction, Allocator >, codim > | |
   hasBackupRestoreFacilities< GeometryGrid< HostGrid, CoordFunction, Allocator > > | |
   isLevelwiseConforming< GeometryGrid< HostGrid, CoordFunction, Allocator > > | |
   isLeafwiseConforming< GeometryGrid< HostGrid, CoordFunction, Allocator > > | |
   threadSafe< GeometryGrid< HostGrid, CoordFunction, Allocator > > | |
   viewThreadSafe< GeometryGrid< HostGrid, CoordFunction, Allocator > > | |
   hasHostEntity | |
   hasHostEntity< const Grid, codim > | |
   hasHostEntity< GeometryGrid< HostGrid, CoordFunction, Allocator >, codim > | |
   CodimCache | |
   hasEntity< IdentityGrid< HostGrid >, codim > | Has entities for some codimensions as host grid |
   isParallel< IdentityGrid< HostGrid > > | Parallel when host grid is |
   isLevelwiseConforming< IdentityGrid< HostGrid > > | Has conforming level grids when host grid has |
   isLeafwiseConforming< IdentityGrid< HostGrid > > | Has conforming leaf grids when host grid has |
   hasSingleGeometryType< OneDGrid > | OneDGrid has only one geometry type for codim 0 entities |
   hasEntity< OneDGrid, cdim > | OneDGrid has entities for all codimension |
   isParallel< OneDGrid > | OneDGrid is not parallel |
   isLevelwiseConforming< OneDGrid > | OneDGrid is levelwise conforming |
   isLeafwiseConforming< OneDGrid > | OneDGrid is leafwise conforming |
   hasSingleGeometryType< SGrid< dim, dimw > > | SGrid has only one geometry type for codim 0 entities |
   isCartesian< SGrid< dim, dimw > > | SGrid is a Cartesian grid |
   hasEntity< SGrid< dim, dimw >, cdim > | SGrid has entities for all codimension |
   isLevelwiseConforming< SGrid< dim, dimw > > | SGrid is levelwise conforming |
   isLeafwiseConforming< SGrid< dim, dimw > > | SGrid is leafwise conforming |
   hasEntity< UGGrid< dim >, 0 > | UGGrid has codim=0 entities (elements) |
   hasEntity< UGGrid< dim >, dim > | UGGrid has codim=dim entities (vertices) |
   isParallel< UGGrid< dim > > | UGGrid is parallel |
   isLevelwiseConforming< UGGrid< dim > > | UGGrid is levelwise conforming |
   isLeafwiseConforming< UGGrid< dim > > | UGGrid may not be leafwise conforming |
   hasBackupRestoreFacilities< YaspGrid< dim, Coordinates > > | |
   hasSingleGeometryType< YaspGrid< dim, Coordinates > > | YaspGrid has only one geometry type for codim 0 entities |
   isCartesian< YaspGrid< dim, Coordinates > > | YaspGrid is a Cartesian grid |
   hasEntity< YaspGrid< dim, Coordinates >, codim > | YaspGrid has entities for all codimensions |
   canCommunicate< YaspGrid< dim, Coordinates >, codim > | YaspGrid can communicate on all codimensions |
   isParallel< YaspGrid< dim, Coordinates > > | YaspGrid is parallel |
   isLevelwiseConforming< YaspGrid< dim, Coordinates > > | YaspGrid is levelwise conforming |
   isLeafwiseConforming< YaspGrid< dim, Coordinates > > | YaspGrid is leafwise conforming |
  detail | |
   _has_local_context | |
  dgf | |
   Expr | |
    ConstantExpression | |
    VariableExpression | |
    FunctionCallExpression | |
    VectorExpression | |
    BracketExpression | |
    MinusExpression | |
    NormExpression | |
    SqrtExpression | |
    SinExpression | |
    CosExpression | |
    PowerExpression | |
    SumExpression | |
    DifferenceExpression | |
    ProductExpression | |
    QuotientExpression | |
   BasicBlock | |
   DomainData | |
   Domain | |
   BoundaryDomBlock | |
   BoundarySegBlock | |
   CubeBlock | |
   DimBlock | |
   GridParameterBlock | Common Grid parametersFor each grid implementation there is a set of parameters that can be passed via the GridParameter block to the momment of grid construction. Currently implemented common parameters are:
|
   IntervalBlock | |
    Interval | |
   PeriodicFaceTransformationBlock | |
    AffineTransformation | |
    Matrix | |
   ProjectionBlock | |
    Expression | |
   SimplexBlock | |
   SimplexGenerationBlock | |
   VertexBlock | |
   UGGridParameterBlock | |
   YaspGridParameterBlock | Grid parameters for YaspGridThe YaspGridParameter class is in charge of passing parameters specific to YaspGrid to the grid construction. Current parameters are:
- overlap defining the overlap of the grid (default value is zero)
See the examplegrid5.dgf file for an example |
  FactoryUtilities | |
   MultiIndex | |
  GeoGrid | Namespace containing the implementations of GeometryGrid |
   BackupRestoreFacilities | |
   BackupRestoreFacilities< Grid, true > | |
   CoordCache | |
   isCoordFunctionInterface | |
   isCoordFunctionInterface< AnalyticalCoordFunctionInterface< ct, dimD, dimR, Impl > > | |
   isCoordFunctionInterface< DiscreteCoordFunctionInterface< ct, dimR, Impl > > | |
   isDiscreteCoordFunctionInterface | |
   isDiscreteCoordFunctionInterface< DiscreteCoordFunctionInterface< ct, dimR, Impl > > | |
   AdaptCoordFunction | |
   AdaptCoordFunction< DiscreteCoordFunctionInterface< ct, dimR, Impl > > | |
   CoordFunctionCaller | |
   CoordFunctionCaller< HostEntity, AnalyticalCoordFunctionInterface< ct, dimD, dimR, Impl > > | |
   CoordFunctionCaller< HostEntity, DiscreteCoordFunctionInterface< ct, dimR, Impl > > | |
   CoordVector | |
   CoordVector< mydim, Grid, false > | |
   CoordVector< mydim, Grid, true > | |
   IntersectionCoordVector | |
   CornerStorage | |
   CommDataHandle | |
   EntityBase | Actual implementation of the entity |
   Entity | DUNE-conform implementation of the entityThis class merely changes the template parameters of the entity to make DUNE happy. The actual implementation of the entity can be found in EntityBase |
   HierarchicIterator | |
   IntersectionIterator | |
   EntityBase< codim, Grid, false > | |
   EntityBase< codim, Grid, true > | |
   Entity< 0, dim, Grid > | |
   EntitySeed | |
   EntitySeed< codim, Grd, false > | |
   EntitySeed< codim, Grd, true > | |
   InferHasSingleGeometryType | |
   InferHasSingleGeometryType< hasSingleGeometryType, dim, 1 > | |
   InferHasSingleGeometryType< hasSingleGeometryType, dim, 0 > | |
   GeometryTraits | |
    CornerStorage | |
    hasSingleGeometryType | |
   Geometry | |
    Mapping | |
   ExportParams | |
   GridFamily | |
    Traits | |
     Codim | |
      Partition | |
     Partition | |
   GridView | |
    Codim | |
   GridViewTraits | |
    Codim | |
     Partition | |
   HostCorners | |
   IdSet | |
   IndexSet | |
   Intersection | |
   Iterator | |
   PartitionIteratorFilter | |
   PartitionIteratorFilter< codim, Interior_Partition, Grid > | |
   PartitionIteratorFilter< codim, InteriorBorder_Partition, Grid > | |
   PartitionIteratorFilter< codim, Overlap_Partition, Grid > | |
   PartitionIteratorFilter< codim, OverlapFront_Partition, Grid > | |
   PartitionIteratorFilter< codim, All_Partition, Grid > | |
   PartitionIteratorFilter< codim, Ghost_Partition, Grid > | |
   Iterator< HostGridView, codim, pitype, G, false > | |
   Iterator< HostGridView, codim, pitype, G, true > | |
  Partitions | Predefined PartitionSets for commonly used combinations of parallel grid PartitionTypes |
  VTK | |
   BasicWriter | |
   BoundaryIterator | Iterate over the GridViews boundary intersections |
   IntersectionIndexSet | |
   NonConformingBoundaryIteratorFactory | |
   NonConformingBoundaryWriter | |
   PrintType | Determine a type to safely put another type into a stream |
   PrintType< unsigned char > | |
   PrintType< signed char > | |
   PrintType< char > | |
   TypeName | Map type to its VTK name in data array |
   FieldInfo | Descriptor struct for VTK fields |
   Corner | Simple class representing a corner of a cell |
   CornerIterator | Iterate over the corners of some cell range |
   DataArrayWriter | Base class for data array writers |
   AsciiDataArrayWriter | Streaming writer for data array tags, uses ASCII inline format |
   BinaryDataArrayWriter | Streaming writer for data array tags, uses binary inline format |
   AppendedRawDataArrayWriter | Streaming writer for data array tags, uses appended raw format |
   AppendedBase64DataArrayWriter | Streaming writer for data array tags, uses appended base64 format |
   NakedBase64DataArrayWriter | Streaming writer for appended data array tags, uses base64 format |
   NakedRawDataArrayWriter | Streaming writer for appended data arrays, uses raw format |
   DataArrayWriterFactory | Factory for DataArrayWriters |
   FunctionWriterBase | Base class for function writers |
   VTKFunctionWriter | Base class for function writers |
   CoordinatesWriter | Writer for the Coordinates array |
   ConformingConnectivityWriter | Writer for the connectivity array in conforming mode |
   NonConformingConnectivityWriter | Writer for the connectivity array in nonconforming mode |
   OffsetsWriter | Writer for the offsets array |
   TypesWriter | Writer for the types array |
   PointIterator | Iterate over the points of some corner range |
   PVTUWriter | Dump a .vtu/.vtp files contents to a stream |
   SkeletonFunctionTraits | |
   SkeletonFunctionInterface | A prototype for VTKFunctions on the skeleton |
   SkeletonFunctionWriter | Function writer for skeleton functions |
   ConformingVolumeIteratorFactory | |
   NonConformingVolumeIteratorFactory | |
   ConformingVolumeWriter | |
   VTUWriter | Dump a .vtu/.vtp files contents to a stream |
  VTKWriteTypeTraits | |
   IsLocalFunction | |
  Yasp | |
  DGFGridFactory | |
  AlbertaGrid | [ provides Dune::Grid ] |
  AlbertaReader | |
  BackupRestoreFacility< AlbertaGrid< dim, dimworld > > | |
  Intersection | Intersection of a mesh entities of codimension 0 ("elements") with a "neighboring" element or with the domain boundary |
  DGFGridFactory< AlbertaGrid< dim, dimworld > > | |
  DGFGridInfo< AlbertaGrid< dim, dimworld > > | |
  AlbertaGridEntityPointer | EntityPointer implementation for AlbertaGrid |
  AlbertaGridTreeIterator | |
  AlbertaGridHierarchicIterator | |
  AlbertaGridLeafIntersection | |
  AlbertaGridLeafIntersectionIterator | |
   Begin | |
   End | |
  AlbertaGridEntity | |
   Codim | |
  AlbertaGridEntity< 0, dim, Grid > | |
   Codim | |
  AlbertaGridEntitySeed | |
  AlbertaGridEntitySeed< codim, const AlbertaGrid< dim, dimworld > > | |
  AlbertaGridEntitySeed< 0, const AlbertaGrid< dim, dimworld > > | |
  AlbertaGridCoordinateReader | |
  AlbertaGridGeometry | Geometry implementation for AlbertaGrid |
  AlbertaGridGlobalGeometry | |
  AlbertaGridGlobalGeometry< dim, cdim, const AlbertaGrid< dim, cdim > > | |
  AlbertaGridLocalGeometryProvider | |
   Codim | |
   FaceCoordReader | |
   GeoInFatherCoordReader | |
  GeometryReference | |
  LocalGeometryReference | |
  GridFactory< AlbertaGrid< dim, dimworld > > | Specialization of the generic GridFactory for AlbertaGrid |
   Codim | |
   ProjectionFactory | |
  AlbertaGridHierarchicIndexSet | |
   InitEntityNumber | |
  AlbertaGridIdSet | Hierarchic index set of AlbertaGrid |
  AlbertaGridIndexSet | |
  AlbertaGridLeafIterator | |
  AlbertaGridLevelIterator | |
  AlbertaGridFamily | |
   Traits | |
    Codim | |
     Partition | |
    Partition | |
  AlbertaLevelGridView | |
   Codim | Codim Structure |
  AlbertaLeafGridView | |
   Codim | Codim Structure |
  AlbertaLevelGridViewTraits | |
   Codim | |
    Partition | Define types needed to iterate over entities of a given partition type |
  AlbertaLeafGridViewTraits | |
   Codim | |
    Partition | Define types needed to iterate over entities of a given partition type |
  IndexStack | |
  AlbertaGridIntersectionBase | |
   GlobalCoordReader | |
   LocalCoordReader | |
  AlbertaGridLeafIterator< codim, Ghost_Partition, GridImp > | |
  AlbertaGridLevelProvider | |
   CalcMaxLevel | |
   Interpolation | |
   SetLocal | |
  AlbertaGridLevelIterator< codim, Ghost_Partition, GridImp > | |
  AlbertaError | |
  AlbertaIOError | |
  PersistentContainer< AlbertaGrid< dim, dimworld >, T > | |
  AlbertaTransformation | |
  AlbertaMarkerVector | Marker assigning subentities to one element containing them |
  ALU2dImplTraits | |
   Codim | |
  ALU2dGridMarkerVector | |
  ALU2dGridLeafMarkerVector | |
  ALU2dGridObjectStream | |
   EOFException | |
  ALUGrid< 2, dimw, elType, refinementType, Comm > | |
   Partition | |
  ALU2dGridBoundaryProjection | |
  ALU2dGridEntity | |
  ALU2dGridLevelIterator | |
  ALU2dGridEntityPointer | |
  ALU2dGridGeometry | |
  ALU2dGridHierarchicIterator | Hierarchic Iterator of ALU2dGrid |
  ALU2dGridLevelIntersectionIterator | |
  ALU2dGridLeafIntersectionIterator | |
  ALU2dGridIntersectionIterator | |
  ALU2dGridLeafIterator | |
  ALU2dGrid | [ provides Dune::Grid ] |
  ALU2dGridEntity< 0, dim, GridImp > | |
   Codim | |
  ALU2dGridEntitySeed | |
  ALU2dGridEntitySeedBase | |
  ALU2dGridEntitySeed< 0, GridImp > | |
  MyALU2dGridGeometryImpl | |
  MyALU2dGridGeometryImplBase | |
  MyALU2dGridGeometryImpl< 0, cdim, eltype > | |
  MyALU2dGridGeometryImpl< 1, cdim, eltype > | |
  MyALU2dGridGeometryImpl< 2, cdim, ALU2DSPACE triangle > | |
  MyALU2dGridGeometryImpl< 2, cdim, ALU2DSPACE quadrilateral > | |
  MyALU2dGridGeometryImpl< 2, cdim, ALU2DSPACE mixed > | |
  ALU2dGridMakeableGeometry | |
  ALU2dGridIntersectionBase | |
   impl | |
  ALU2dGridMakeableEntity | |
  ALU2dGridFaceGeometryInfo | |
  ALU2dGridLocalIdSet | Hierarchic index set of ALU3dGrid |
  ALU2dGridHierarchicIndexSet | Hierarchic index set of ALU2dGrid |
  ALUMemoryProvider | Organize the memory management for entitys used by the NeighborIterator |
  ALULocalGeometryStorage | |
  ALUGridBaseGrid< 2, dimw, cube, Comm > | |
  ALUGridBaseGrid< 2, dimw, simplex, Comm > | |
  ALU2dGridFamily | |
   Traits | |
    Codim | |
     Partition | |
    Partition | |
  ALU2DIntersectionGeometryStorage | |
  ALU2dGridLeafIterator< 1, pitype, GridImp > | |
  ALU2dGridLevelIterator< 0, pitype, GridImp > | |
  ALU2dGridLevelIterator< 1, pitype, GridImp > | |
  ALU2dGridLevelIterator< 2, pitype, GridImp > | |
  ALU3dBasicImplTraits | |
  ALU3dBasicImplTraits< No_Comm > | |
  ALU3dCodimImplTraits | |
  ALU3dCodimImplTraits< tetra, Comm, 0 > | |
  ALU3dCodimImplTraits< hexa, Comm, 0 > | |
  ALU3dCodimImplTraits< tetra, Comm, 1 > | |
  ALU3dCodimImplTraits< hexa, Comm, 1 > | |
  ALU3dCodimImplTraits< elType, Comm, 2 > | |
  ALU3dCodimImplTraits< elType, Comm, 3 > | |
  ALU3dImplTraits | |
  ALU3dImplTraits< tetra, Comm > | |
   Codim | |
  ALU3dImplTraits< hexa, Comm > | |
   Codim | |
  ALU3dGridVertexList | |
  ALU3dGridLeafVertexList | |
  ALU3dGridItemList | |
  ALU3dGridFaceGetter | |
  ALUGrid< 3, 3, elType, refineType, Comm > | |
   Partition | |
  ALU3dGridEntity | |
  ALU3dGridLevelIterator | |
  ALU3dGridEntityPointer | |
  ALU3dGridGeometry | |
  ALU3dGridHierarchicIterator | |
  ALU3dGridIntersectionIterator | |
  ALU3dGridLeafIterator | Leaf iterator |
  ALU3dGrid | [ provides Dune::Grid ] |
  ALU3dGridEntity< 0, dim, GridImp > | |
   Codim | |
  ALU3dGridEntityPointerBase | |
  ALU3dGridEntityPointer< 0, GridImp > | |
  ALU3dGridEntitySeed | |
  ALU3dGridEntitySeedBase | |
   Bnd | |
   Bnd< 0, Key > | |
  ALU3dGridEntitySeed< 0, GridImp > | |
  ALU3dGridFaceInfo | |
  ALU3dGridSurfaceMappingFactory | |
  ALU3dGridSurfaceMappingFactory< tetra, Comm > | |
  ALU3dGridSurfaceMappingFactory< hexa, Comm > | |
  ALU3dGridGeometricFaceInfoBase | |
  ALU3dGridGeometricFaceInfoTetra | |
  ALU3dGridGeometricFaceInfoHexa | |
  MyALUGridGeometryImplementation | |
   GeometryImpl | General type of geometry implementation |
   GeometryImpl< dummy, 1, eltype > | |
   GeometryImpl< dummy, 2, hexa > | |
   GeometryImpl< dummy, 2, tetra > | |
   GeometryImpl< dummy, 3, hexa > | |
   GeometryImpl< dummy, 3, tetra > | |
   GeometryImplBase | |
    CoordTypeExtractorType | |
    CoordTypeExtractorType< dummy, 3 > | |
  ALU3dGridLevelIntersectionIterator | |
  ALU3dGridMakeableEntity | |
  ALU3dGridFaceGeometryInfo | |
  ALU3dGridGlobalIdSet | |
  ALU3dGridLocalIdSet | |
  ALU3dGridHierarchicIndexSet | Hierarchic index set of ALU3dGrid |
  ALU3dGridFactory | |
  ALU3dGridCommHelper | |
  ALUGridBaseGrid< 3, 3, cube, Comm > | |
  ALUGridBaseGrid< 3, 3, simplex, Comm > | |
  ALU3dGridCommunicationsBase | |
  ALU3dGridCommunications | |
  ALU3dGridCommunications< elType, No_Comm > | |
  ALU3dGridFamily | |
   Traits | |
    Codim | |
     Partition | |
    Partition | |
  ALU3dGridCommHelper< elType, No_Comm > | |
  ALUMacroKey | |
  ALUGridId | |
  ALU3dGridGeometricFaceInfo | |
  ALU3dGridTreeIterator | |
   GetLevel | |
   GetLevel< GridImp, 0 > | |
   GetLevel< GridImp, 3 > | |
  ALUGridLoadBalanceDataHandle | |
   Codim | |
  TrilinearMapping | |
  SurfaceNormalCalculator | A bilinear surface mapping |
  BilinearSurfaceMapping | A bilinear surface mapping |
  BilinearMapping | A bilinear mapping |
  LinearMapping | A linear mapping |
  NonConformingFaceMapping | |
  NonConformingFaceMapping< tetra, Comm > | Non-conforming face mappings for tetrahedra |
  NonConformingFaceMapping< hexa, Comm > | Non-conforming face mappings for hexahedra |
  EntityCount | |
  EntityCount< tetra > | |
  EntityCount< hexa > | |
  ElementTopologyMapping | |
  FaceTopologyMapping | |
  BackupRestoreFacility< ALUGrid< dim, dimworld, elType, refineType, Comm > > | facility for writing and reading grids |
  ALUGridBoundaryProjection | ALUGrid boundary projection implementation DuneBndProjection has to fulfil the DuneBoundaryProjection interface |
  ALUGrid | [ provides Dune::Grid ] |
  ALUGridBaseGrid | |
  DefaultLevelIteratorTypes | LevelIterator tpyes for all codims and partition types |
   Codim | The types |
    Partition | |
  DefaultLeafIteratorTypes | LeafIterator tpyes for all codims and partition types |
   Codim | The types of the iterator |
    Partition | |
  DefaultIndexSet | DefaultIndexSet creates an index set by using the grids persistent container an a given pair of iterators |
   Index | |
  HasObjectStream | Tagging interface to indicate that Grid provides typedef ObjectStreamType |
  GridObjectStreamOrDefaultHelper | |
  GridObjectStreamOrDefaultHelper< false, GridImp, DefaultImp > | |
  GridObjectStreamOrDefault | Template to choose right Object stream type for a given class |
  IsDofManager | Tagging interface to indicate that class is of Type DofManager |
  HasHierarchicIndexSet | Tagging interface to indicate that Grid has HierarchicIndexSet |
  IntersectionIteratorWrapper | Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid |
  LeafIntersectionWrapper | |
  LeafIntersectionIteratorWrapper | Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid |
  LevelIntersectionWrapper | Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid |
  LevelIntersectionIteratorWrapper | Class that wraps IntersectionIteratorImp of a grid and gets it's internal object from a object stack hold by the grid |
  MakeableInterfaceObject | |
  ALUGridObjectFactory | |
  AdaptDataHandle | |
  AdaptDataHandleInterface | Interface class for the Grid's adapt method where the parameter is a AdaptDataHandleInterface |
  CombinedAdaptProlongRestrict | Class for combining 2 index sets together for adaptation process |
  BackupRestoreFacility | Facility for writing and reading grids |
  BackupRestoreFacility< const Grid > | BackupRestoreFacility taking const Grid as type and deriving from the version with the const |
  DuneBoundaryProjection | Interface class for vertex projection at the boundary |
  BoundaryProjectionWrapper | |
  BoundarySegmentWrapper | |
  CircleBoundaryProjection | |
  BoundarySegment | Base class for classes implementing geometries of boundary segments |
  MessageBufferIF | 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 |
  CommDataHandleIF | 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 |
  DefaultLevelGridView | |
   Codim | Codim Structure |
  DefaultLeafGridView | |
   Codim | Codim Structure |
  DefaultLevelGridViewTraits | |
   Codim | |
    Partition | Define types needed to iterate over entities of a given partition type |
  DefaultLeafGridViewTraits | |
   Codim | |
    Partition | Define types needed to iterate over entities of a given partition type |
  Entity | Wrapper class for entities |
  Entity< 0, dim, GridImp, EntityImp > | Template specialization of Dune::Entity for Elements (codim==0) |
   Codim | EntityPointer types of the different codimensions |
  EntityDefaultImplementation | Default Implementations for EntityImp |
  EntityDefaultImplementation< 0, dim, GridImp, EntityImp > | Default Implementations for EntityImp (Elements [cd=0]) |
  EntityIterator | Interface class for an iterator over grid entitiesAn entity iterator is an iterator over a subset of entities within a hierarchical grid. It is an extension of the Dune::EntityPointer interface |
  EntityPointer | Wrapper class for pointers to entities |
   Codim | EntityPointer types of the different codimensions |
  DefaultEntityPointer | |
  DefaultEntityPointer< Dune::Entity< codim, dim, Grid, EntityImp > > | |
  EntitySeed | Store a reference to an entity with a minimal memory footprint |
  GridError | Base class for exceptions in Dune grid modules |
  GridDefaultImplementation | |
   ReturnImplementationType | Helper class to choose correct implementation return type for getRealImplementation |
   ReturnImplementationType< const T > | |
  Geometry | Wrapper class for geometries |
  GeometryDefaultImplementation | Default implementation for class Geometry |
  GeometryDefaultImplementation< 0, cdim, GridImp, GeometryImp > | |
  GlobalGeometryReference | |
  IntersectionIterator | Mesh entities of codimension 0 ("elements") allow to visit all intersections with "neighboring" elements and with the domain boundary |
  IndexSet | Index Set Interface base class |
   Codim | Export the type of the entity used as parameter in the index(...) method |
  IdSet | Id Set Interface |
  Grid | Grid abstract base classThis class is the base class for all grid implementations. Although no virtual functions are used we call it abstract since its methods do not contain an implementation but forward to the methods of the derived class via the Barton-Nackman trick |
   Codim | A Traits struct that collects all associated types of one implementation |
    Partition | A struct collecting all types depending on the partition iterator type |
   Partition | Types for GridView |
  GridTraits | A traits struct that collects all associated types of one grid model |
   Codim | Traits associated with a specific codim |
    Partition | Traits associated with a specific grid partition type |
   Partition | Traits associated with a specific grid partition type |
  GridFactoryInterface | Provide a generic factory class for unstructured grids |
   Codim | |
  GridFactory | Provide a generic factory class for unstructured grids |
  GridView | Grid view abstract base class |
   Codim | A struct that collects all associated types of one implementation from the Traits class |
    Partition | Define types needed to iterate over entities of a given partition type |
  IndexSetDefaultImplementation | Provide default implementation of method if IndexSet |
  IntersectionDefaultNormalVectors | Default Implementations of integrationOuterNormal and unitOuterNormal for IntersectionImp |
  Mapper | Mapper interface |
  MCMGElementLayout | Layout template for elements |
  MCMGVertexLayout | Layout template for vertices |
  MultipleCodimMultipleGeomTypeMapper | Implementation class for a multiple codim and multiple geometry type mapper |
  LeafMultipleCodimMultipleGeomTypeMapper | Multiple codim and multiple geometry type mapper for leaf entities |
  LevelMultipleCodimMultipleGeomTypeMapper | Multiple codim and multiple geometry type mapper for entities of one level |
  PartitionSet | A set of PartitionType values |
  SingleCodimSingleGeomTypeMapper | Implementation class for a single codim and single geometry type mapper |
  LeafSingleCodimSingleGeomTypeMapper | Single codim and single geometry type mapper for leaf entities |
  LevelSingleCodimSingleGeomTypeMapper | Single codim and single geometry type mapper for entities of one level |
  SizeCache | Organizes the caching of sizes for one grid and one GeometryType |
  SingleTypeSizeCache | Organizes the caching of sizes for one grid and one GeometryType |
  UniversalMapper | Implements a mapper for an arbitrary subset of entities |
  GlobalUniversalMapper | Universal mapper based on global ids |
  LocalUniversalMapper | Universal mapper based on local ids |
  BackupRestoreFacility< GeometryGrid< HostGrid, CoordFunction, Allocator > > | |
  CachedCoordFunction | |
  AnalyticalCoordFunction | Derive an implementation of an analytical coordinate function from this class |
  DiscreteCoordFunction | Derive an implementation of a discrete coordinate function from this class |
  AnalyticalCoordFunctionInterface | 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 has to be supplied |
  DiscreteCoordFunctionInterface | 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 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 |
  GeometryGrid | Grid wrapper replacing the geometriesGeometryGrid wraps another DUNE grid and replaces its geometry by the generic geometries from dune-grid. These are linear (respectively n-linear) DUNE geometries interpolating some given corners. These corners are obtained by mapping the corners of the host grid's geometry (also called host geometry) by a coordinate function |
   Codim | Traits structure containing types for a codimension |
    Partition | |
   Partition | Types for GridView |
  DefaultCoordFunction | |
  IdenticalCoordFunction | |
  PersistentContainer< GeometryGrid< HostGrid, CoordFunction, Allocator >, T > | |
  IdentityGrid | Provides a meta grid that is identical to its host |
  HostGridAccess | Access to host grid objects from GeometryGrid |
  IdentityGridFamily | |
   Traits | |
    Codim | |
  IdentityGridEntity | The implementation of entities in a IdentityGridA Grid is a container of grid entities. An entity is parametrized by the codimension. An entity of codimension c in dimension d is a d-c dimensional object |
  IdentityGridEntityPointer | |
  IdentityGridLevelIterator | Iterator over all entities of a given codimension and level of a grid |
  IdentityGridLevelIntersectionIterator | |
  IdentityGridLeafIntersectionIterator | 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! |
  IdentityGridHierarchicIterator | 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 |
  IdentityGridEntity< 0, dim, GridImp > | Specialization for codim-0-entities.This class embodies the topological parts of elements of the grid. It has an extended interface compared to the general entity class. For example, Entities of codimension 0 allow to visit all neighbors |
  IdentityGridEntitySeed | The EntitySeed class provides the minimal information needed to restore an Entity using the grid |
  IdentityGridGeometry | |
  IdentityGridLevelIndexSet | |
  IdentityGridLeafIndexSet | |
  IdentityGridGlobalIdSet | |
  IdentityGridLocalIdSet | |
  IdentityGridLeafIntersection | 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! |
  IdentityGridLevelIntersection | |
  IdentityGridLeafIterator | Iterator over all entities of a given codimension and level of a grid |
  AmiraMeshWriter | Provides file writing facilities in the AmiraMesh format |
  LevelAmiraMeshWriter | Provides file writing facilities in the AmiraMesh format for level grids |
  LeafAmiraMeshWriter | Provides file writing facilities in the AmiraMesh format for leaf grids |
  DGFException | Exception class for IO errors in the DGF parser |
  DGFCoordFunction | |
  DGFCoordFunctionFactory | |
  DGFCoordFunctionFactory< HostGrid, CoordFunction, false > | |
  DGFCoordFunctionFactory< HostGrid, CoordFunction, true > | |
  DGFCoordFunctionFactory< HostGrid, DGFCoordFunction< dimD, dimR >, false > | |
  DGFGridFactory< GeometryGrid< HostGrid, CoordFunction, Allocator > > | |
  DGFGridInfo< GeometryGrid< HostGrid, CoordFunction, Allocator > > | |
  DGFGridFactory< IdentityGrid< HostGrid > > | |
  DGFGridInfo< IdentityGrid< HostGrid > > | |
  DGFGridInfo< OneDGrid > | |
  DGFGridFactory< OneDGrid > | |
  DGFPrintInfo | |
  DGFGridInfo | Some simple static information for a given GridType |
  DGFGridFactory< SGrid< dim, dimworld, ctype > > | |
  DGFGridInfo< SGrid< dim, dimworld, ctype > > | |
  DGFWriter | Write a GridView to a DGF file |
  DGFGridFactory< YaspGrid< dim > > | Grid factory for YaspGrid with equidistant coordinates |
  DGFGridInfo< YaspGrid< dim > > | |
  DGFGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< double, dim > > > | Grid factory for YaspGrid with equidistant coordinates |
  DGFGridInfo< YaspGrid< dim, EquidistantOffsetCoordinates< double, dim > > > | |
  DGFEntityKey | |
  ElementFaceUtil | |
  GridPtr | Class for constructing grids from DGF files |
   DataHandle | |
   mygrid_ptr | |
  MacroGrid | |
  DGFBoundaryParameter | Contains types for additional features |
  DuneGridFormatParser | The DuneGridFormatParser class: reads a DGF file and stores build information in vector structures used by the MacroGrid class |
  GmshReaderOptions | Options for read operation |
  GmshReaderParser | Dimension independent parts for GmshReaderParser |
  GmshReader | Read Gmsh mesh file |
  GmshWriter | Write Gmsh mesh file |
  GnuplotWriter | Writer for 1D grids in gnuplot format |
  LeafGnuplotWriter | GnuplotWriter on the leaf grid |
  LevelGnuplotWriter | GnuplotWriter on a given level grid |
  StarCDReader | File reader for the Star-CD format |
  b64txt | Struct with three bytes of text |
  b64data | |
  b64chunk | Union representing the three byte text aswell as the four 6 bit chunks |
  VTKFunction | A base class for grid functions with any return type and dimension |
  P0VTKFunction | Take a vector and interpret it as cell data for the VTKWriter |
  P1VTKFunction | Take a vector and interpret it as point data for the VTKWriter |
  Base64Stream | Class to base64 encode a stream of data |
  RawStream | Write out data in binary |
  SubsamplingVTKWriter | Writer for the output of subsampled grid functions in the vtk format.Writes arbitrary grid functions (living on cells or vertices of a grid) to a file suitable for easy visualization with The Visualization Toolkit (VTK). In contrast to the regular VTKWriter, this Writer allows subsampling of the elements via VirtualRefinement. The SubSamplingVTKWriter always writes nonconforming data |
  VTKSequenceWriter | Writer for the ouput of grid functions in the vtk format.Writes arbitrary grid functions (living on cells or vertices of a grid) to a file suitable for easy visualization with The Visualization Toolkit (VTK) |
  SubsamplingVTKSequenceWriter | Writer for the ouput of grid functions in the vtk format.Writes arbitrary grid functions (living on cells or vertices of a grid) to a file suitable for easy visualization with The Visualization Toolkit (VTK) |
  VTKSequenceWriterBase | Base class to write pvd-files which contains a list of all collected vtk-files |
  VTKWriter | Writer for the ouput of grid functions in the vtk format.Writes arbitrary grid functions (living on cells or vertices of a grid) to a file suitable for easy visualization with The Visualization Toolkit (VTK) |
   CellIterator | Iterator over the grids elements |
   CornerIterator | Iterate over the elements' corners |
   VertexIterator | Iterate over the grid's vertices |
   VTKLocalFunction | Type erasure wrapper for VTK data sets |
    FunctionWrapper | Type erasure implementation for functions conforming to the dune-functions LocalFunction interface |
    FunctionWrapperBase | Base class for polymorphic container of underlying data set |
    VTKFunctionWrapper | Type erasure implementation for legacy VTKFunctions |
  CombinedGrapeDisplay | Combines GrapeDataDisplays to one so that visualisation for parallel grid is more easy to handle |
  HasLevelIntersections | |
  HasLevelIntersections< AlbertaGrid< d, w > > | |
  GrapeLagrangePoints | |
  GrapeFunction | |
  GrapeDataDisplay | |
  GrapeGridDisplay | |
  OneDGridFamily | |
  OneDGrid | One-dimensional adaptive grid |
  SGeometry | |
  SEntity | |
  SEntityPointer | |
  SEntitySeed | |
  SLevelIterator | |
  SGrid | [ provides Dune::Grid ] |
  SIntersection | |
  SIntersectionIterator | |
  SHierarchicIterator | |
  SEntityBase | |
  SEntity< 0, dim, GridImp > | |
   Codim | |
  SHierarchicStackElem | |
  AutoPtrStack | Stack of pointers with auto destruction if the stack is destructed |
  SGridLevelIndexSet | Implementation of index set |
  SGridGlobalIdSet | Persistent, globally unique Ids |
  SGridFamily | |
  StructuredGridFactory< SGrid< dim, dim > > | Specialization of the StructuredGridFactory for SGrid |
  UGGridFamily | |
  UGGrid | Front-end for the grid manager of the finite element toolbox UG |
  GridFactory< UGGrid< dimworld > > | Specialization of the generic GridFactory for UGGrid |
   Codim | |
  EntityCommHelper | |
  EntityCommHelper< InteriorBorder_InteriorBorder_Interface > | |
  EntityCommHelper< InteriorBorder_All_Interface > | |
  EntityCommHelper< Overlap_OverlapFront_Interface > | |
  EntityCommHelper< Overlap_All_Interface > | |
  EntityCommHelper< All_All_Interface > | |
  GlobalIndexSet | Calculate globally unique index over all processes in a Dune grid |
   SubPartitionTypeProvider | Helper class to provide access to subentity PartitionTypes with a run-time codimension |
   SubPartitionTypeProvider< Entity, 0 > | |
  EntityInfo | Structure to hold statistical information about one type of entity |
  GridViewInfoGTCompare | Comparison object to sort GeometryType by majorly dimension |
  GridViewInfo | Structure to hold information about a certain GridView |
  HierarchicSearch | Search an IndexSet for an Entity containing a given point |
  HostGridAccess< GeometryGrid< HG, CoordFunction, Allocator > > | |
   Codim | A Traits struct that collects return types of class member methods |
  HostGridAccess< IdentityGrid< HG > > | |
   Codim | A Traits struct that collects return types of class member methods |
  PersistentContainer | A class for storing data during an adaptation cycle |
  PersistentContainer< const Grid, T > | Refer PersistentContainer<const Grid> to the implementation of the mutable grid |
  PersistentContainerInterface | Persistent storage of data on all entities of a grid |
  PersistentContainerMap | Map-based implementation of the PersistentContainer |
   IteratorWrapper | |
   Resize | |
  PersistentContainerVector | Vector-based implementation of the PersistentContainer |
  PersistentContainerWrapper | |
  StructuredGridFactory | Construct structured cube and simplex grids in unstructured grid managers |
  StructuredGridFactory< YaspGrid< dim, EquidistantCoordinates< ctype, dim > > > | Specialization of the StructuredGridFactory for YaspGrid |
  StructuredGridFactory< YaspGrid< dim, EquidistantOffsetCoordinates< ctype, dim > > > | Specialization of the StructuredGridFactory for YaspGrid |
  TensorGridFactoryCreator | |
  TensorGridFactory | A factory class for conveniently creating tensorproduct grids |
  TensorGridFactoryCreator< YaspGrid< dim, TensorProductCoordinates< ctype, dim > > > | |
  VertexOrderByIdFactory | Factory for GeneralVertexOrder objects using an IdSet |
   VertexOrder | Type of vertex order object may depend on the dimension of the element |
  YaspGrid | [ provides Dune::Grid ] |
  YaspGeometry | The general version that handles all codimensions but 0 and dim |
  YaspEntity | |
  YaspEntityPointer | A pointer to a YaspGrid::Entity |
  YaspEntitySeed | Describes the minimal information necessary to create a fully functional YaspEntity |
  YaspLevelIterator | Iterates over entities of one grid level |
  YaspIntersectionIterator | YaspIntersectionIterator enables iteration over intersections with neighboring codim 0 entities |
  YaspIntersection | YaspIntersection provides data about intersection with neighboring codim 0 entities |
  YaspHierarchicIterator | YaspHierarchicIterator enables iteration over son entities of codim 0 |
  YaspIndexSet | Implementation of Level- and LeafIndexSets for YaspGrid |
  YaspGlobalIdSet | Persistent, globally unique Ids |
  YaspPersistentContainerIndex | |
  YaspGridFamily | |
  MaybeHaveOrigin | |
  MaybeHaveOrigin< Dune::EquidistantOffsetCoordinates< ctype, dim > > | |
  BackupRestoreFacility< Dune::YaspGrid< dim, Coordinates > > | facility for writing and reading grids |
  BackupRestoreFacility< YaspGrid< dim, TensorProductCoordinates< ctype, dim > > > | facility for writing and reading grids |
  EquidistantCoordinates | Container for equidistant coordinates in a YaspGrid |
  EquidistantOffsetCoordinates | Container for equidistant coordinates in a YaspGrid with non-trivial origin |
  TensorProductCoordinates | Coordinate container for a tensor product YaspGrid |
  YLoadBalance | Base class for the yaspgrid partitioning strategy The name might be irritating. It will probably change to YaspPartitionerBase in a 3.0 release |
  YLoadBalanceDefault | Implement the default load balance strategy of yaspgrid |
  YLoadBalancePowerD | Implement yaspgrid load balance strategy for P=x^{dim} processors |
  YaspFixedSizePartitioner | 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 |
  Torus | |
   ProcListIterator | |
  YaspEntity< 0, dim, GridImp > | |
   Codim | |
  YaspEntity< dim, dim, GridImp > | |
   Codim | |
  YaspGeometry< mydim, mydim, GridImp > | Specialize for dim=dimworld, i.e. a volume element |
  YaspGeometry< 0, cdim, GridImp > | Specialization for dim=0, this is a vertex |
  PersistentContainer< YaspGrid< dim, CoordCont >, T > | Specialization of the PersistentContainer for YaspGrid |
  YGridComponent | |
   Iterator | |
  YGrid | 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) |
   Iterator | Iterator over a collection o YGrids A YGrid::Iterator is the heart of an entity in YaspGrid |
  YGridList | 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 |
   Intersection | Type describing an intersection with a neighboring processor |
   Iterator | |
 FctSelector | |
  function_modifier | |
  chosen_function | |
 std | STL namespace |
  iterator_traits< Dune::EntityIterator< codim, Grid, IteratorImp > > | |
  iterator_traits< Dune::IntersectionIterator< GridImp, IntersectionIteratorImp, IntersectionImp > > | |
 datainfo | |
 info | |
 IsUnstructured | |
 IsUnstructured | |
 stackentry | |