Namespaces
namespace	internal

Classes
class	Iterator
	Iterator over all directions contained in a stencil. More...

Typedefs
using	$name = internal::$name<>

Enumerations
enum	Direction { C = 0 , N = 1 , S = 2 , W = 3 , E = 4 , T = 5 , B = 6 , NW = 7 , NE = 8 , SW = 9 , SE = 10 , TN = 11 , TS = 12 , TW = 13 , TE = 14 , BN = 15 , BS = 16 , BW = 17 , BE = 18 , TNE = 19 , TNW = 20 , TSE = 21 , TSW = 22 , BNE = 23 , BNW = 24 , BSE = 25 , BSW = 26 , INVALID_DIR = 27 }

enum	BinaryDirection { Bin_C = 1<<0 , Bin_N = 1<<1 , Bin_S = 1<<2 , Bin_W = 1<<3 , Bin_E = 1<<4 , Bin_T = 1<<5 , Bin_B = 1<<6 , Bin_NW = 1<<7 , Bin_NE = 1<<8 , Bin_SW = 1<<9 , Bin_SE = 1<<10 , Bin_TN = 1<<11 , Bin_TS = 1<<12 , Bin_TW = 1<<13 , Bin_TE = 1<<14 , Bin_BN = 1<<15 , Bin_BS = 1<<16 , Bin_BW = 1<<17 , Bin_BE = 1<<18 , Bin_TNE = 1<<19 , Bin_TNW = 1<<20 , Bin_TSE = 1<<21 , Bin_TSW = 1<<22 , Bin_BNE = 1<<23 , Bin_BNW = 1<<24 , Bin_BSE = 1<<25 , Bin_BSW = 1<<26 }

Functions
template<typename U >
Direction	getQuadrant (const math::GenericAABB< U > &aabb, const typename math::GenericAABB< U >::vector_type &p)
	Determine sin which neighboring section of an AABB a point lies.

Direction	vectorToDirection (cell_idx_t x, cell_idx_t y, cell_idx_t z)
	Maps a (x,y,z) direction vector to its direction.

Direction	vectorToDirection (Vector3< cell_idx_t > vec)

bool	isFaceDirection (Direction dir)

bool	isEdgeDirection (Direction dir)

bool	isCornerDirection (Direction dir)

Direction	directionFromAxis (int axis, bool minOrMax)
	Maps (direction,axis) pair to direction.

Direction	directionFromAxis (uint_t axis, bool minOrMax)
	Maps (direction,axis) pair to direction.

Cell	operator+ (const Cell &cell, const Direction d)
	Computes neighbor from cell in direction d.

Cell	operator- (const Cell &cell, const Direction d)
	Computes neighbor from cell in direction inverseDir[d].

Cell &	operator+= (Cell &cell, const Direction d)
	Shifts cell to its neighbor in direction d.

Cell &	operator-= (Cell &cell, const Direction d)
	Shifts cell to its neighbor in direction inverseDir[d].

Variables
const uint_t	NR_OF_DIRECTIONS = 27

const std::array< int, NR_OF_DIRECTIONS >	cx
	The x component for each direction.

const std::array< int, NR_OF_DIRECTIONS >	cy
	The y component for each direction.

const std::array< int, NR_OF_DIRECTIONS >	cz
	The z component for each direction.

const std::array< std::array< int, NR_OF_DIRECTIONS >, 3 >	c
	The x,y,z component for each direction.

const std::array< std::array< real_t, NR_OF_DIRECTIONS >, 3 >	cNorm
	The x,y,z component for each normalized direction.

const std::array< std::string, NR_OF_DIRECTIONS >	dirToString
	String representation for each direction.

const std::array< BinaryDirection, NR_OF_DIRECTIONS >	dirToBinary
	Binary encoded direction for each direction.

const std::array< Direction, NR_OF_DIRECTIONS >	inverseDir
	Inverse directions.

const std::array< real_t, NR_OF_DIRECTIONS >	dirLength
	Length for each direction.

const std::array< real_t, NR_OF_DIRECTIONS >	gaussianWeights

const std::array< uint_t, NR_OF_DIRECTIONS >	gaussianMultipliers

const std::array< Direction, NR_OF_DIRECTIONS >	mirrorX
	The mirrored directions (flip W-E)

const std::array< Direction, NR_OF_DIRECTIONS >	mirrorY
	The mirrored directions (flip N-S)

const std::array< Direction, NR_OF_DIRECTIONS >	mirrorZ
	The mirrored directions (flip T-B)

const std::array< std::array< Direction, NR_OF_DIRECTIONS >, 3 >	map2Dto3D
	Maps from 2D directions (C, N, S, W, E, NW, NE, SW, SE) to 3D directions, by slicing through x,y or z coordinate The first array index represents the slice dimension ( 0 for x, 1 for y, 2 for z) Example: printing a slice through x coordinate (keeping x fixed) of a D3Q19 field:

Typedef Documentation

◆ $name

using walberla::stencil::$name = internal::$name<>

Enumeration Type Documentation

◆ BinaryDirection

enum walberla::stencil::BinaryDirection

Enumerator
Bin_C	Center.
Bin_N	North.
Bin_S	South.
Bin_W	West.
Bin_E	East.
Bin_T	Top.
Bin_B	Bottom.
Bin_NW	North-West.
Bin_NE	North-East.
Bin_SW	South-West.
Bin_SE	South-East.
Bin_TN	Top-North.
Bin_TS	Top-South.
Bin_TW	Top-West.
Bin_TE	Top-East.
Bin_BN	Bottom-North.
Bin_BS	Bottom-South.
Bin_BW	Bottom-West.
Bin_BE	Bottom-East.
Bin_TNE	Top-North-East.
Bin_TNW	Top-North-West.
Bin_TSE	Top-South-East.
Bin_TSW	Top-South-West.
Bin_BNE	Bottom-North-East.
Bin_BNW	Bottom-North-West.
Bin_BSE	Bottom-South-East.
Bin_BSW	Bottom-South-West.

◆ Direction

enum walberla::stencil::Direction

Enumerator
C	Center.
N	North.
S	South.
W	West.
E	East.
T	Top.
B	Bottom.
NW	North-West.
NE	North-East.
SW	South-West.
SE	South-East.
TN	Top-North.
TS	Top-South.
TW	Top-West.
TE	Top-East.
BN	Bottom-North.
BS	Bottom-South.
BW	Bottom-West.
BE	Bottom-East.
TNE	Top-North-East.
TNW	Top-North-West.
TSE	Top-South-East.
TSW	Top-South-West.
BNE	Bottom-North-East.
BNW	Bottom-North-West.
BSE	Bottom-South-East.
BSW	Bottom-South-West.
INVALID_DIR	Invalid direction.

Function Documentation

◆ directionFromAxis() [1/2]

Direction walberla::stencil::directionFromAxis	(	int	axis,
		bool	minOrMax )

inline

Maps (direction,axis) pair to direction.

Parameters

axis	0,1 or 2 standing for x,y,z
minOrMax	if true, the direction pointing in the negative axis direction is returned, if false, the positive axis direction

◆ directionFromAxis() [2/2]

Direction walberla::stencil::directionFromAxis	(	uint_t	axis,
		bool	minOrMax )

inline

Maps (direction,axis) pair to direction.

Parameters

axis	0,1 or 2 standing for x,y,z
minOrMax	if true, the direction pointing in the negative axis direction is returned, if false, the positive axis direction

◆ getQuadrant()

template<typename U >

Direction walberla::stencil::getQuadrant	(	const math::GenericAABB< U > &	aabb,
		const typename math::GenericAABB< U >::vector_type &	p )

Determine sin which neighboring section of an AABB a point lies.

If p lies within aabb returns C. Other it is determined in which of the 26 imaginary neighboring AABBs p is located. The direction of the from aabb to the determined neighboring aabb is returned

2D Example:

----------------------— Let aabb be the AABB marked with asterisks. The boxes surrounding aabb are the eight (in 2D) imaginary | | | | neighboring boxes. Let p be marked with x. The result of the function would be NE. | | | x |
| | | | -----—*********-----— | * * | | * * | | * * | -----—*********-----—

Template Parameters

T	The scalar data type used for the AABB and the tested point

Parameters

aabb	The AABB
p	The tested point

◆ isCornerDirection()

bool walberla::stencil::isCornerDirection ( Direction dir )

inline

◆ isEdgeDirection()

bool walberla::stencil::isEdgeDirection ( Direction dir )

inline

◆ isFaceDirection()

bool walberla::stencil::isFaceDirection ( Direction dir )

inline

◆ operator+()

Cell walberla::stencil::operator+	(	const Cell &	cell,
		const Direction	d )

inline

Computes neighbor from cell in direction d.

Parameters

cell	origin cell
d	direction pointing towards the computed neighbor

◆ operator+=()

Cell & walberla::stencil::operator+=	(	Cell &	cell,
		const Direction	d )

inline

Shifts cell to its neighbor in direction d.

Parameters

cell	shifted cell
d	direction in which to shift the cell

◆ operator-()

Cell walberla::stencil::operator-	(	const Cell &	cell,
		const Direction	d )

inline

Computes neighbor from cell in direction inverseDir[d].

Parameters

cell	origin cell
d	direction pointing away from the computed neighbor

◆ operator-=()

Cell & walberla::stencil::operator-=	(	Cell &	cell,
		const Direction	d )

inline

Shifts cell to its neighbor in direction inverseDir[d].

Parameters

cell	shifted cell
d	direction opposite to which the cell gets shifted

◆ vectorToDirection() [1/2]

Direction walberla::stencil::vectorToDirection	(	cell_idx_t	x,
		cell_idx_t	y,
		cell_idx_t	z )

inline

Maps a (x,y,z) direction vector to its direction.

◆ vectorToDirection() [2/2]

Direction walberla::stencil::vectorToDirection ( Vector3< cell_idx_t > vec )

inline

Variable Documentation

◆ c

const std::array< std::array< int, NR_OF_DIRECTIONS >, 3 > walberla::stencil::c

Initial value:

{ {
      {
   
      0,  0,  0, -1,  1,  0,  0, -1,  1, -1,  1,  0,  0, -1,  1,  0,  0, -1,  1,  1, -1,  1, -1,  1, -1,  1, -1
      }, {
   
      0,  1, -1,  0,  0,  0,  0,  1,  1, -1, -1,  1, -1,  0,  0,  1, -1,  0,  0,  1,  1, -1, -1,  1,  1, -1, -1
      }, {
   
      0,  0,  0,  0,  0,  1, -1,  0,  0,  0,  0,  1,  1,  1,  1, -1, -1, -1, -1,  1,  1,  1,  1, -1, -1, -1, -1
      }
   } }

The x,y,z component for each direction.

◆ cNorm

const std::array< std::array< real_t, NR_OF_DIRECTIONS >, 3 > walberla::stencil::cNorm

Initial value:

{ {
      {
         real_t(0), real_t(0), real_t(0), real_t(-1), real_t(1), real_t(0), real_t(0), real_t(-1) / std::sqrt( real_t(2) ),
         real_t(1) / std::sqrt( real_t(2) ), real_t(-1) / std::sqrt( real_t(2) ), real_t(1) / std::sqrt( real_t(2) ), real_t(0), real_t(0),
         real_t(-1) / std::sqrt( real_t(2) ), real_t(1) / std::sqrt( real_t(2) ), real_t(0), real_t(0), real_t(-1) / std::sqrt( real_t(2) ),
         real_t(1) / std::sqrt( real_t(2) ), real_t(1) / std::sqrt( real_t(3) ), real_t(-1) / std::sqrt( real_t(3) ),
         real_t(1) / std::sqrt( real_t(3) ), real_t(-1) / std::sqrt( real_t(3) ), real_t(1) / std::sqrt( real_t(3) ),
         real_t(-1) / std::sqrt( real_t(3) ), real_t(1) / std::sqrt( real_t(3) ), real_t(-1) / std::sqrt( real_t(3) )
      }, {
         real_t(0), real_t(1), real_t(-1), real_t(0), real_t(0), real_t(0), real_t(0), real_t(1) / std::sqrt( real_t(2) ),
         real_t(1) / std::sqrt( real_t(2) ), real_t(-1) / std::sqrt( real_t(2) ), real_t(-1) / std::sqrt( real_t(2) ),
         real_t(1) / std::sqrt( real_t(2) ), real_t(-1) / std::sqrt( real_t(2) ), real_t(0), real_t(0), real_t(1) / std::sqrt( real_t(2) ),
         real_t(-1) / std::sqrt( real_t(2) ), real_t(0), real_t(0), real_t(1) / std::sqrt( real_t(3) ), real_t(1) / std::sqrt( real_t(3) ),
         real_t(-1) / std::sqrt( real_t(3) ), real_t(-1) / std::sqrt( real_t(3) ), real_t(1) / std::sqrt( real_t(3) ),
         real_t(1) / std::sqrt( real_t(3) ), real_t(-1) / std::sqrt( real_t(3) ), real_t(-1) / std::sqrt( real_t(3) )
      }, {
         real_t(0), real_t(0), real_t(0), real_t(0), real_t(0), real_t(1), real_t(-1), real_t(0), real_t(0), real_t(0), real_t(0),
         real_t(1) / std::sqrt( real_t(2) ), real_t(1) / std::sqrt( real_t(2) ), real_t(1) / std::sqrt( real_t(2) ),
         real_t(1) / std::sqrt( real_t(2) ), real_t(-1) / std::sqrt( real_t(2) ), real_t(-1) / std::sqrt( real_t(2) ),
         real_t(-1) / std::sqrt( real_t(2) ), real_t(-1) / std::sqrt( real_t(2) ), real_t(1) / std::sqrt( real_t(3) ),
         real_t(1) / std::sqrt( real_t(3) ), real_t(1) / std::sqrt( real_t(3) ), real_t(1) / std::sqrt( real_t(3) ),
         real_t(-1) / std::sqrt( real_t(3) ), real_t(-1) / std::sqrt( real_t(3) ), real_t(-1) / std::sqrt( real_t(3) ),
         real_t(-1) / std::sqrt( real_t(3) )
      }
   } }

The x,y,z component for each normalized direction.

◆ cx

const std::array< int, NR_OF_DIRECTIONS > walberla::stencil::cx

Initial value:

{
   
      0,  0,  0, -1,  1,  0,  0, -1,  1, -1,  1,  0,  0, -1,  1,  0,  0, -1,  1,  1, -1,  1, -1,  1, -1,  1, -1
   }

The x component for each direction.

◆ cy

const std::array< int, NR_OF_DIRECTIONS > walberla::stencil::cy

Initial value:

{
   
      0,  1, -1,  0,  0,  0,  0,  1,  1, -1, -1,  1, -1,  0,  0,  1, -1,  0,  0,  1,  1, -1, -1,  1,  1, -1, -1
   }

The y component for each direction.

◆ cz

const std::array< int, NR_OF_DIRECTIONS > walberla::stencil::cz

Initial value:

{
   
      0,  0,  0,  0,  0,  1, -1,  0,  0,  0,  0,  1,  1,  1,  1, -1, -1, -1, -1,  1,  1,  1,  1, -1, -1, -1, -1
   }

The z component for each direction.

◆ dirLength

const std::array< real_t, NR_OF_DIRECTIONS > walberla::stencil::dirLength

Initial value:

{
        real_t(0), real_t(1), real_t(1), real_t(1), real_t(1), real_t(1), real_t(1),
        std::sqrt( real_t(2) ), std::sqrt( real_t(2) ), std::sqrt( real_t(2) ), std::sqrt( real_t(2) ), 
        std::sqrt( real_t(2) ), std::sqrt( real_t(2) ), std::sqrt( real_t(2) ), std::sqrt( real_t(2) ),
        std::sqrt( real_t(2) ), std::sqrt( real_t(2) ), std::sqrt( real_t(2) ), std::sqrt( real_t(2) ),
        std::sqrt( real_t(3) ), std::sqrt( real_t(3) ), std::sqrt( real_t(3) ), std::sqrt( real_t(3) ),
        std::sqrt( real_t(3) ), std::sqrt( real_t(3) ), std::sqrt( real_t(3) ), std::sqrt( real_t(3) )
   }

Length for each direction.

◆ dirToBinary

const std::array< BinaryDirection, NR_OF_DIRECTIONS > walberla::stencil::dirToBinary

Initial value:

{
      Bin_C, Bin_N, Bin_S, Bin_W, Bin_E, Bin_T, Bin_B,
      Bin_NW, Bin_NE, Bin_SW, Bin_SE, Bin_TN, Bin_TS, Bin_TW, Bin_TE, Bin_BN, Bin_BS, Bin_BW, Bin_BE,
      Bin_TNE, Bin_TNW, Bin_TSE, Bin_TSW, Bin_BNE, Bin_BNW, Bin_BSE, Bin_BSW,
   }

Binary encoded direction for each direction.

◆ dirToString

const std::array< std::string, NR_OF_DIRECTIONS > walberla::stencil::dirToString

Initial value:

{
      "C", "N", "S", "W", "E", "T", "B",
      "NW", "NE", "SW", "SE", "TN", "TS", "TW", "TE", "BN", "BS", "BW","BE",
      "TNE", "TNW", "TSE", "TSW", "BNE", "BNW", "BSE", "BSW",
   }

String representation for each direction.

◆ gaussianMultipliers

const std::array< uint_t, NR_OF_DIRECTIONS > walberla::stencil::gaussianMultipliers

Initial value:

{
      uint_t(8u),
      uint_t(4u), uint_t(4u), uint_t(4u), uint_t(4u) ,
      uint_t(4u), uint_t(4u),
      uint_t(2u), uint_t(2u), uint_t(2u), uint_t(2u) ,
      uint_t(2u), uint_t(2u), uint_t(2u), uint_t(2u) ,
      uint_t(2u), uint_t(2u), uint_t(2u), uint_t(2u) ,
      uint_t(1u), uint_t(1u), uint_t(1u), uint_t(1u) ,
      uint_t(1u), uint_t(1u), uint_t(1u), uint_t(1u)
   }

◆ gaussianWeights

const std::array< real_t, NR_OF_DIRECTIONS > walberla::stencil::gaussianWeights

Initial value:

{
      real_t(8) / real_t(64),
      real_t(4) / real_t(64), real_t(4) / real_t(64), real_t(4) / real_t(64), real_t(4) / real_t(64),
      real_t(4) / real_t(64), real_t(4) / real_t(64),
      real_t(2) / real_t(64), real_t(2) / real_t(64), real_t(2) / real_t(64), real_t(2) / real_t(64),
      real_t(2) / real_t(64), real_t(2) / real_t(64), real_t(2) / real_t(64), real_t(2) / real_t(64), 
      real_t(2) / real_t(64), real_t(2) / real_t(64), real_t(2) / real_t(64), real_t(2) / real_t(64),
      real_t(1) / real_t(64), real_t(1) / real_t(64), real_t(1) / real_t(64), real_t(1) / real_t(64), 
      real_t(1) / real_t(64), real_t(1) / real_t(64), real_t(1) / real_t(64), real_t(1) / real_t(64)
   }

◆ inverseDir

const std::array< Direction, NR_OF_DIRECTIONS > walberla::stencil::inverseDir

Initial value:

{
      C, S, N, E, W, B, T,
      SE, SW, NE, NW, BS, BN, BE, BW, TS, TN, TE, TW,
      BSW, BSE, BNW, BNE, TSW, TSE, TNW, TNE
   }

Inverse directions.

◆ map2Dto3D

const std::array< std::array< Direction, NR_OF_DIRECTIONS >, 3 > walberla::stencil::map2Dto3D

Initial value:

{
   {
            { C, T, B, S, N, INVALID_DIR, INVALID_DIR, TS, TN, BS, BN,
              INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR,
              INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR },
 
            { C, T, B, W, E, INVALID_DIR, INVALID_DIR, TW, TE, BW, BE,
              INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR,
              INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR },
 
            { C, N, S, W, E, INVALID_DIR, INVALID_DIR, NW, NE, SW, SE,
              INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR,
              INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR, INVALID_DIR }
   } }

Maps from 2D directions (C, N, S, W, E, NW, NE, SW, SE) to 3D directions, by slicing through x,y or z coordinate The first array index represents the slice dimension ( 0 for x, 1 for y, 2 for z) Example: printing a slice through x coordinate (keeping x fixed) of a D3Q19 field:

GhostLayerField<real_t,19,1> pdfField;
for(auto i = D2Q9::begin(); i != D2Q9::end(); ++i)
    cout << pdfField.get(x,y,z, D3Q19::idx[ map2Dto3D[0][*i] ] ) << endl;

◆ mirrorX

const std::array< Direction, NR_OF_DIRECTIONS > walberla::stencil::mirrorX

Initial value:

{
      C, N, S, E, W, T, B,
      NE, NW, SE, SW, TN, TS, TE, TW, BN, BS, BE, BW,
      TNW, TNE, TSW, TSE, BNW, BNE, BSW, BSE
   }

The mirrored directions (flip W-E)

◆ mirrorY

const std::array< Direction, NR_OF_DIRECTIONS > walberla::stencil::mirrorY

Initial value:

{
      C, S, N, W, E, T, B,
      SW, SE, NW, NE, TS, TN, TW, TE, BS, BN, BW, BE,
      TSE, TSW, TNE, TNW, BSE, BSW, BNE, BNW
   }

The mirrored directions (flip N-S)

◆ mirrorZ

const std::array< Direction, NR_OF_DIRECTIONS > walberla::stencil::mirrorZ

Initial value:

{
      C, N, S, W, E, B, T,
      NW, NE, SW, SE, BN, BS, BW, BE, TN, TS, TW, TE,
      BNE, BNW, BSE, BSW, TNE, TNW, TSE, TSW
   }

The mirrored directions (flip T-B)

◆ NR_OF_DIRECTIONS

const uint_t walberla::stencil::NR_OF_DIRECTIONS = 27

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Typedef Documentation

◆ $name

Enumeration Type Documentation

◆ BinaryDirection

◆ Direction

Function Documentation

◆ directionFromAxis() [1/2]

◆ directionFromAxis() [2/2]

◆ getQuadrant()

◆ isCornerDirection()

◆ isEdgeDirection()

◆ isFaceDirection()

◆ operator+()

◆ operator+=()

◆ operator-()

◆ operator-=()

◆ vectorToDirection() [1/2]

◆ vectorToDirection() [2/2]

Variable Documentation

◆ c

◆ cNorm

◆ cx

◆ cy

◆ cz

◆ dirLength

◆ dirToBinary

◆ dirToString

◆ gaussianMultipliers

◆ gaussianWeights

◆ inverseDir

◆ map2Dto3D

◆ mirrorX

◆ mirrorY

◆ mirrorZ

◆ NR_OF_DIRECTIONS