waLBerla 7.3
Loading...
Searching...
No Matches
walberla::domain_decomposition Namespace Reference

Namespaces

namespace  internal

Classes

class  BlockCounter
 Class/functor for counting the blocks stored in parallel on all processes in a structured block storage. More...
class  BlockDataHandling
class  AlwaysInitializeBlockDataHandling
struct  BlockDataCreator
class  BlockDataID
class  ConstBlockDataID
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  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.
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 )'
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 )'
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 !
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)
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 !
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)
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)]
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)]
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)]
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)]

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 !