Namespaces | Classes | Functions
walberla::domain_decomposition Namespace Reference

Namespaces

 internal
 

Classes

class  AlwaysInitializeBlockDataHandling
 
class  BlockCounter
 Class/functor for counting the blocks stored in parallel on all processes in a structured block storage. More...
 
struct  BlockDataCreator
 
class  BlockDataHandling
 
class  BlockDataID
 
class  BlockStorage
 Base class for block storage data structures (the entire simulation space is partitioned into blocks [see class 'IBlock'], and block storage data structures manage these blocks) More...
 
class  BlockSweepWrapper
 Takes an existing block 'sweep' functor and wrapps it into a void-void functor. More...
 
class  ConstBlockDataID
 
class  IBlock
 Base class for blocks (blocks are used to partition the simulation space: blocks are rectangular parts of the simulation space that manage all the data that is assigned to their part of the simulation space) More...
 
class  IBlockID
 Interface/base class for block IDs (unique identifiers for blocks) More...
 
struct  StructuredBlockDataCreator
 
class  StructuredBlockStorage
 Base class for structured block storages (the entire simulation space is partitioned into blocks [see class 'IBlock'], the blocks are partitioned into cells, and structured block storages manage those blocks) More...
 

Functions

std::ostream & operator<< (std::ostream &os, const IBlockID &id)
 
template<class T , typename... Args>
std::function< T *(const IBlock *const block) > makeBlockDataInitFunction (Args &&... args)
 
void mapPointToPeriodicDomain (const std::array< bool, 3 > &periodic, const AABB &domain, real_t &x, real_t &y, real_t &z)
 This function can be used to transform any point in 3D space into the periodic simulation space. More...
 
void mapPointToPeriodicDomain (const std::array< bool, 3 > &periodic, const AABB &domain, Vector3< real_t > &p)
 see documentation of 'void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AABB & domain, real_t & x, real_t & y, real_t & z )' More...
 
Vector3< real_t > mapPointToPeriodicDomain (const std::array< bool, 3 > &periodic, const AABB &domain, const Vector3< real_t > &p)
 see documentation of 'void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AABB & domain, real_t & x, real_t & y, real_t & z )' More...
 
bool periodicIntersect (const std::array< bool, 3 > &periodic, const math::AABB &domain, const math::AABB &box1, const math::AABB &box2)
 
bool periodicIntersect (const std::array< bool, 3 > &periodic, const math::AABB &domain, const math::AABB &box1, const math::AABB &box2, const real_t dx)
 
real_t periodicIntersectionVolume (const std::array< bool, 3 > &periodic, const math::AABB &domain, const math::AABB &box1, const math::AABB &box2)
 
real_t periodicIntersectionVolume (const std::array< bool, 3 > &periodic, const math::AABB &domain, const math::AABB &box1, const math::AABB &box2, const real_t dx)
 
template<typename T >
internal::SharedSweep< T > makeSharedSweep (const shared_ptr< T > &sweepPtr)
 
void transformGlobalToBlockLocal (CellVector &local, const StructuredBlockStorage &blockStorage, const IBlock &block, const CellVector &global)
 global cells are transformed to the block local cell space and added to vector 'local' via calling push_back ! More...
 
void transformGlobalToBlockLocal (CellVector &cells, const StructuredBlockStorage &blockStorage, const IBlock &block)
 cells in vector 'cells' are transformed in place (from the global to the block local cell space) More...
 
void transformBlockLocalToGlobal (CellVector &global, const StructuredBlockStorage &blockStorage, const IBlock &block, const CellVector &local)
 block local cells are transformed to the global cell space and added to vector 'global' via calling push_back ! More...
 
void transformBlockLocalToGlobal (CellVector &cells, const StructuredBlockStorage &blockStorage, const IBlock &block)
 cells in vector 'cells' are transformed in place (from the block local to the global cell space) More...
 
void transformGlobalToBlockLocal (CellSet &local, const StructuredBlockStorage &blockStorage, const IBlock &block, const CellSet &global)
 global cells are transformed to the block local cell space and added to set 'local' via calling insert ! [-> O(N*logN)] More...
 
void transformGlobalToBlockLocal (CellSet &cells, const StructuredBlockStorage &blockStorage, const IBlock &block)
 cells in set 'cells' are transformed in place (from the global to the block local cell space) [cells are possibly reordered -> O(N*logN)] More...
 
void transformBlockLocalToGlobal (CellSet &global, const StructuredBlockStorage &blockStorage, const IBlock &block, const CellSet &local)
 block local cells are transformed to the global cell space and added to set 'global' via calling insert ! [-> O(N*logN)] More...
 
void transformBlockLocalToGlobal (CellSet &cells, const StructuredBlockStorage &blockStorage, const IBlock &block)
 cells in set 'cells' are transformed in place (from the block local to the global cell space) [cells are possibly reordered -> O(N*logN)] More...
 

Function Documentation

◆ makeBlockDataInitFunction()

template<class T , typename... Args>
std::function< T* ( const IBlock* const block ) > walberla::domain_decomposition::makeBlockDataInitFunction ( Args &&...  args)

◆ makeSharedSweep()

template<typename T >
internal::SharedSweep<T> walberla::domain_decomposition::makeSharedSweep ( const shared_ptr< T > &  sweepPtr)

◆ mapPointToPeriodicDomain() [1/3]

Vector3< real_t > walberla::domain_decomposition::mapPointToPeriodicDomain ( const std::array< bool, 3 > &  periodic,
const AABB &  domain,
const Vector3< real_t > &  p 
)
inline

see documentation of 'void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AABB & domain, real_t & x, real_t & y, real_t & z )'

◆ mapPointToPeriodicDomain() [2/3]

void walberla::domain_decomposition::mapPointToPeriodicDomain ( const std::array< bool, 3 > &  periodic,
const AABB &  domain,
real_t &  x,
real_t &  y,
real_t &  z 
)

This function can be used to transform any point in 3D space into the periodic simulation space.

For example, if the simulation is periodic in x direction and the simulation domain spans from x = 0 to x = 10, then a point located at x = 38 is mapped to x = 8, and a point located at x = -13 is mapped to x = 7. The min points of the domain are included in the simulation space, the max points are excluded!

◆ mapPointToPeriodicDomain() [3/3]

void walberla::domain_decomposition::mapPointToPeriodicDomain ( const std::array< bool, 3 > &  periodic,
const AABB &  domain,
Vector3< real_t > &  p 
)
inline

see documentation of 'void mapPointToPeriodicDomain( const std::array< bool, 3 > & periodic, const AABB & domain, real_t & x, real_t & y, real_t & z )'

◆ operator<<()

std::ostream& walberla::domain_decomposition::operator<< ( std::ostream &  os,
const IBlockID &  id 
)
inline

◆ periodicIntersect() [1/2]

bool walberla::domain_decomposition::periodicIntersect ( const std::array< bool, 3 > &  periodic,
const math::AABB &  domain,
const math::AABB &  box1,
const math::AABB &  box2 
)

◆ periodicIntersect() [2/2]

bool walberla::domain_decomposition::periodicIntersect ( const std::array< bool, 3 > &  periodic,
const math::AABB &  domain,
const math::AABB &  box1,
const math::AABB &  box2,
const real_t  dx 
)

◆ periodicIntersectionVolume() [1/2]

real_t walberla::domain_decomposition::periodicIntersectionVolume ( const std::array< bool, 3 > &  periodic,
const math::AABB &  domain,
const math::AABB &  box1,
const math::AABB &  box2 
)

◆ periodicIntersectionVolume() [2/2]

real_t walberla::domain_decomposition::periodicIntersectionVolume ( const std::array< bool, 3 > &  periodic,
const math::AABB &  domain,
const math::AABB &  box1,
const math::AABB &  box2,
const real_t  dx 
)

◆ transformBlockLocalToGlobal() [1/4]

void walberla::domain_decomposition::transformBlockLocalToGlobal ( CellSet &  cells,
const StructuredBlockStorage &  blockStorage,
const IBlock &  block 
)
inline

cells in set 'cells' are transformed in place (from the block local to the global cell space) [cells are possibly reordered -> O(N*logN)]

◆ transformBlockLocalToGlobal() [2/4]

void walberla::domain_decomposition::transformBlockLocalToGlobal ( CellSet &  global,
const StructuredBlockStorage &  blockStorage,
const IBlock &  block,
const CellSet &  local 
)
inline

block local cells are transformed to the global cell space and added to set 'global' via calling insert ! [-> O(N*logN)]

◆ transformBlockLocalToGlobal() [3/4]

void walberla::domain_decomposition::transformBlockLocalToGlobal ( CellVector &  cells,
const StructuredBlockStorage &  blockStorage,
const IBlock &  block 
)
inline

cells in vector 'cells' are transformed in place (from the block local to the global cell space)

◆ transformBlockLocalToGlobal() [4/4]

void walberla::domain_decomposition::transformBlockLocalToGlobal ( CellVector &  global,
const StructuredBlockStorage &  blockStorage,
const IBlock &  block,
const CellVector &  local 
)
inline

block local cells are transformed to the global cell space and added to vector 'global' via calling push_back !

◆ transformGlobalToBlockLocal() [1/4]

void walberla::domain_decomposition::transformGlobalToBlockLocal ( CellSet &  cells,
const StructuredBlockStorage &  blockStorage,
const IBlock &  block 
)
inline

cells in set 'cells' are transformed in place (from the global to the block local cell space) [cells are possibly reordered -> O(N*logN)]

◆ transformGlobalToBlockLocal() [2/4]

void walberla::domain_decomposition::transformGlobalToBlockLocal ( CellSet &  local,
const StructuredBlockStorage &  blockStorage,
const IBlock &  block,
const CellSet &  global 
)
inline

global cells are transformed to the block local cell space and added to set 'local' via calling insert ! [-> O(N*logN)]

◆ transformGlobalToBlockLocal() [3/4]

void walberla::domain_decomposition::transformGlobalToBlockLocal ( CellVector &  cells,
const StructuredBlockStorage &  blockStorage,
const IBlock &  block 
)
inline

cells in vector 'cells' are transformed in place (from the global to the block local cell space)

◆ transformGlobalToBlockLocal() [4/4]

void walberla::domain_decomposition::transformGlobalToBlockLocal ( CellVector &  local,
const StructuredBlockStorage &  blockStorage,
const IBlock &  block,
const CellVector &  global 
)
inline

global cells are transformed to the block local cell space and added to vector 'local' via calling push_back !