All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Groups Pages
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...
 
struct  OrderByFirst
 
class  SimpleMessageBuffer
 
class  Point2PointCommunicator
 Point-2-Point communicator for exchange messages between processes. More...
 
class  CartesianIndexMapper< CpGrid >
 
struct  DGFGridFactory< CpGrid >
 
struct  DGFGridInfo< CpGrid >
 
class  PersistentContainer< CpGrid, Data >
 
struct  CpGridTraits
 
struct  CpGridFamily
 
class  CpGrid
 [ provides Dune::Grid ] More...
 
class  CartesianIndexMapper< PolyhedralGrid< dim, dimworld > >
 
class  PolyhedralGrid
 identical grid wrapper More...
 
struct  DGFGridFactory< PolyhedralGrid< dim, dimworld > >
 
struct  DGFGridInfo< PolyhedralGrid< dim, dimworld > >
 
class  PolyhedralGridEntityBasic
 
class  PolyhedralGridEntity
 
class  PolyhedralGridEntity< 0, dim, Grid >
 construct a null entity More...
 
class  PolyhedralGridEntityPointer
 
class  PolyhedralGridEntitySeed
 
class  PolyhedralGridGeometry
 
class  PolyhedralGridLocalGeometry
 
struct  PolyhedralGridBasicGeometry
 
struct  PolyhedralGridFamily
 
class  PolyhedralGridView
 
struct  PolyhedralGridViewTraits
 
class  PolyhedralGridIdSet
 
class  PolyhedralGridIndexSet
 
class  PolyhedralGridIntersection
 
class  PolyhedralGridIntersectionIterator
 
class  PolyhedralGridIterator
 
class  PersistentContainer< PolyhedralGrid< dim, dimworld >, Data >
 

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

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.
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.

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.

template<typename T >
FieldVector<T, 3> Dune::cross ( const FieldVector< T, 3 > &  a,
const FieldVector< T, 3 > &  b 
)
Todo:
Doc me!
Template Parameters
@param
Returns
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.

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.

template<class Vector >
Vector::field_type Dune::inner ( const Vector &  a,
const Vector &  b 
)
Todo:
Doc me!
Template Parameters
@param
Returns
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
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.