Dune Namespace Reference

Holds the implementation of the CpGrid as a pimple. More...

Classes

class  CartesianIndexMapper
 Interface class to access the logical Cartesian grid as used in industry standard simulator decks. More...
 
class  CartesianIndexMapper< CpGrid >
 
class  CartesianIndexMapper< PolyhedralGrid< dim, dimworld > >
 
class  CpGrid
 [ provides Dune::Grid ] More...
 
struct  CpGridFamily
 
struct  CpGridTraits
 
struct  DGFGridFactory< CpGrid >
 
struct  DGFGridFactory< PolyhedralGrid< dim, dimworld > >
 
struct  DGFGridInfo< CpGrid >
 
struct  DGFGridInfo< PolyhedralGrid< dim, dimworld > >
 
struct  OrderByFirst
 
class  PersistentContainer< CpGrid, Data >
 
class  PersistentContainer< PolyhedralGrid< dim, dimworld >, Data >
 
class  Point2PointCommunicator
 Point-2-Point communicator for exchange messages between processes. More...
 
class  PolyhedralGrid
 identical grid wrapper More...
 
struct  PolyhedralGridBasicGeometry
 
class  PolyhedralGridEntity
 
class  PolyhedralGridEntity< 0, dim, Grid >
 construct a null entity More...
 
class  PolyhedralGridEntityBasic
 
class  PolyhedralGridEntityPointer
 
class  PolyhedralGridEntitySeed
 
struct  PolyhedralGridFamily
 
class  PolyhedralGridGeometry
 
class  PolyhedralGridIdSet
 
class  PolyhedralGridIndexSet
 
class  PolyhedralGridIntersection
 
class  PolyhedralGridIntersectionIterator
 
class  PolyhedralGridIterator
 
class  PolyhedralGridLocalGeometry
 
class  PolyhedralGridView
 
struct  PolyhedralGridViewTraits
 
class  SimpleMessageBuffer
 

Typedefs

typedef std::array< int, 3 > coord_t
 

Functions

void partition (const CpGrid &grid, const std::array< int, 3 > &initial_split, int &num_part, std::vector< int > &cell_part, bool recursive=false, bool ensureConnectivity=true)
 Partition a CpGrid based on (ijk) coordinates, with splitting to ensure that each partition is connected. More...
 
void addOverlapCornerCell (const CpGrid &grid, int owner, const CpGrid::Codim< 0 >::Entity &from, const CpGrid::Codim< 0 >::Entity &neighbor, const std::vector< int > &cell_part, std::vector< std::set< int > > &cell_overlap)
 Adds cells to the overlap that just share a point with an owner cell.
 
void addOverlapLayer (const CpGrid &grid, int index, const CpGrid::Codim< 0 >::Entity &e, const int owner, const std::vector< int > &cell_part, std::vector< std::set< int > > &cell_overlap, int recursion_deps)
 
void addOverlapLayer (const CpGrid &grid, const std::vector< int > &cell_part, std::vector< std::set< int > > &cell_overlap, int mypart, int overlapLayers, bool all=false)
 Adds a layer of overlap cells to a partitioning. More...
 
template<typename T >
FieldVector< T, 3 > cross (const FieldVector< T, 3 > &a, const FieldVector< T, 3 > &b)
 
template<class Vector >
Vector::field_type inner (const Vector &a, const Vector &b)
 
template<typename T , template< typename, int > class Point>
determinantOf (const Point< T, 2 > *a)
 Calculates the determinant of a 2 x 2 matrix, represented in memory as an array of two-dimensional points. More...
 
template<typename T , template< typename, int > class Point>
determinantOf (const Point< T, 3 > *a)
 Calculates the determinant of a 3 x 3 matrix, represented in memory as an array of three-dimensional points. More...
 
template<typename T , template< typename, int > class Point, int Dim>
simplex_volume (const Point< T, Dim > *a)
 Computes the volume of a simplex consisting of (Dim+1) vertices embedded in Euclidean space of dimension (Dim)
 
template<typename T , template< typename, int > class Point>
area (const Point< T, 2 > *c)
 Computes the area of a 2-dimensional triangle. More...
 
template<typename T , template< typename, int > class Point>
area (const Point< T, 3 > *c)
 Computes the area of a 3-dimensional triangle. More...
 
template<typename T , template< typename, int > class Point>
volume (const Point< T, 3 > *c)
 Computes the volume of a 3D simplex (embedded i 3D space).
 
template<typename T , template< typename, int > class Point>
signed_area (const Point< T, 3 > *c, const Point< T, 3 > &normal)
 Computes the signed area of a triangle embedded in 3D space. More...
 
template<typename K , int n>
FieldVector< K, n > operator- (const FieldVector< K, n > &v)
 

Detailed Description

Holds the implementation of the CpGrid as a pimple.

The namespace Dune is the main namespace for all Dune code.

Author
Markus Blatt marku.nosp@m.s@dr.nosp@m.-blat.nosp@m.t.de Atgeirr F Rasmussen atgei.nosp@m.rr@s.nosp@m.intef.nosp@m..no Bård Skaflestad bard..nosp@m.skaf.nosp@m.lesta.nosp@m.d@si.nosp@m.ntef..nosp@m.no

Function Documentation

◆ addOverlapLayer()

void Dune::addOverlapLayer ( const CpGrid grid,
const std::vector< int > &  cell_part,
std::vector< std::set< int > > &  cell_overlap,
int  mypart,
int  overlapLayers,
bool  all = false 
)

Adds a layer of overlap cells to a partitioning.

Parameters
[in]gridThe grid that is partitioned.
[in]cell_parta vector containing each cells partition number.
[out]cell_overlapa vector of sets that contains for each cell all the partition numbers that it is an overlap cell of.
[in]mypartThe partition number of the processor.
[in]allWhether to compute the overlap for all partions or just the one associated by mypart.

◆ area() [1/2]

template<typename T , template< typename, int > class Point>
T Dune::area ( const Point< T, 2 > *  c)
inline

Computes the area of a 2-dimensional triangle.

Input is an array of corner points. Same function also exists for 3-dimensional triangles.

◆ area() [2/2]

template<typename T , template< typename, int > class Point>
T Dune::area ( const Point< T, 3 > *  c)
inline

Computes the area of a 3-dimensional triangle.

Input is an array of corner points. Same function also exists for 2-dimensional triangles.

◆ cross()

template<typename T >
FieldVector<T, 3> Dune::cross ( const FieldVector< T, 3 > &  a,
const FieldVector< T, 3 > &  b 
)
Todo:
Doc me!
Template Parameters

◆ determinantOf() [1/2]

template<typename T , template< typename, int > class Point>
T Dune::determinantOf ( const Point< T, 2 > *  a)
inline

Calculates the determinant of a 2 x 2 matrix, represented in memory as an array of two-dimensional points.

Same function also exists for 3 x 3 matrices.

◆ determinantOf() [2/2]

template<typename T , template< typename, int > class Point>
T Dune::determinantOf ( const Point< T, 3 > *  a)
inline

Calculates the determinant of a 3 x 3 matrix, represented in memory as an array of three-dimensional points.

Same function also exists for 2 x 2 matrices.

◆ inner()

template<class Vector >
Vector::field_type Dune::inner ( const Vector &  a,
const Vector &  b 
)
Todo:
Doc me!
Template Parameters

◆ partition()

void Dune::partition ( const CpGrid grid,
const std::array< int, 3 > &  initial_split,
int &  num_part,
std::vector< int > &  cell_part,
bool  recursive = false,
bool  ensureConnectivity = true 
)

Partition a CpGrid based on (ijk) coordinates, with splitting to ensure that each partition is connected.

Parameters
[in]gridthe grid to partition
[in]initial_splitthe number of parts in which to partition the grid, in each cardinal direction. Their product is the expected number of partitions produced.
[out]num_partthe resulting number of partitions. This may be lower than expected, because of inactive cells, or higher than expected, because of splits to ensure connectedness.
[out]cell_parta vector containing, for each cell, its partition number

◆ signed_area()

template<typename T , template< typename, int > class Point>
T Dune::signed_area ( const Point< T, 3 > *  c,
const Point< T, 3 > &  normal 
)

Computes the signed area of a triangle embedded in 3D space.

Input is an array of corner points and a normal to determine the sign.