walberla::pe_coupling Namespace Reference

Namespaces

 amr
 
 discrete_particle_methods
 

Classes

struct  BlockInfo
 
class  BodiesForceTorqueContainer
 
class  BodyAndVolumeFractionMapping
 Mapping class that can be used inside the timeloop to update the volume fractions and body mappings. More...
 
class  BodyContainerSwapper
 
class  BodyMapping
 Maps the moving bodies into the simulation domain and updates the mapping. More...
 
class  CurvedLinear
 Linear boundary handling for moving obstacles. More...
 
class  CurvedQuadratic
 Quadratic boundary handling for moving obstacles. More...
 
class  EquilibriumAndNonEquilibriumReconstructor
 
class  EquilibriumReconstructor
 Classes to be used together with the PDFReconstruction class to reconstruct PDFs. More...
 
class  ExtrapolationReconstructor
 
class  FlagFieldNormalExtrapolationDirectionFinder
 
class  ForceOnBodiesAdder
 
class  ForceTorqueOnBodiesResetter
 
class  ForceTorqueOnBodiesScaler
 
class  LubricationCorrection
 
class  NaNDestroyer
 
class  PDFReconstruction
 Class to manage the reconstruction of PDFs that is needed when cells are becoming uncovered by moving obstacles. More...
 
class  PSMSweep
 LBM sweep for the partially saturated cells method. More...
 
class  SimpleBB
 Bounce back boundary handling for moving obstacles. More...
 
class  SphereNormalExtrapolationDirectionFinder
 
class  TimeStep
 Carries out the the PE time steps, including sub iteration functionality. More...
 

Typedefs

typedef std::map< blockforest::BlockID, BlockInfoInfoCollection
 
typedef std::pair< blockforest::BlockID, BlockInfoInfoCollectionPair
 

Functions

std::ostream & operator<< (std::ostream &os, const BlockInfo &bi)
 
template<typename T , typename G >
mpi::GenericSendBuffer< T, G > & operator<< (mpi::GenericSendBuffer< T, G > &buf, const BlockInfo &info)
 
template<typename T >
mpi::GenericRecvBuffer< T > & operator>> (mpi::GenericRecvBuffer< T > &buf, BlockInfo &info)
 
void getBlockInfoFromInfoCollection (const PhantomBlock *block, const shared_ptr< InfoCollection > &ic, BlockInfo &blockInfo)
 
template<typename BoundaryHandling_T >
void createWithNeighborhood (BlockForest &bf, const BlockDataID boundaryHandlingID, const BlockDataID bodyStorageID, const BlockDataID ccdID, const BlockDataID fcdID, const uint_t numberOfPeSubCycles, InfoCollection &ic)
 
real_t overlapFractionPe (const pe::RigidBody &peRigidBody, const Vector3< real_t > &cellMidpoint, const Vector3< real_t > &dx, uint_t maxDepth=4)
 
real_t getSphereEquivalentDiameter (pe::RigidBody &body)
 
CellInterval getCellBB (const pe::ConstBodyID body, const IBlock &block, StructuredBlockStorage &blockStorage, const uint_t numberOfGhostLayersToInclude)
 
template<typename BoundaryHandling_T >
void mapBody (pe::BodyID body, IBlock &block, StructuredBlockStorage &blockStorage, const BlockDataID &boundaryHandlingID, const FlagUID &obstacle)
 
template<typename BoundaryHandling_T >
void mapBodies (StructuredBlockStorage &blockStorage, const BlockDataID &boundaryHandlingID, const BlockDataID &bodyStorageID, pe::BodyStorage &globalBodyStorage, const FlagUID &obstacle, const std::function< bool(pe::BodyID)> &mappingBodySelectorFct=selectAllBodies)
 Mapping function to map all bodies - with certain properties - onto all blocks with the 'obstacle' flag. More...
 
template<typename BoundaryHandling_T >
void mapMovingBody (pe::BodyID body, IBlock &block, StructuredBlockStorage &blockStorage, const BlockDataID &boundaryHandlingID, const BlockDataID &bodyFieldID, const FlagUID &obstacle)
 
template<typename BoundaryHandling_T >
void mapMovingBodies (StructuredBlockStorage &blockStorage, const BlockDataID &boundaryHandlingID, const BlockDataID &bodyStorageID, pe::BodyStorage &globalBodyStorage, const BlockDataID &bodyFieldID, const FlagUID &obstacle, const std::function< bool(pe::BodyID)> &mappingBodySelectorFct=selectAllBodies)
 Mapping function to map all bodies - with certain properties - onto all blocks to the "moving obstacle" boundary condition, that requires the additional bodyField. More...
 
template<typename Stencil_T >
void findCorrespondingLatticeDirection (const Vector3< real_t > &direction, Vector3< cell_idx_t > &correspondingLatticeDirection)
 Classes to be used with some Reconstructor variants to find an extrapolation direction. More...
 
void mapPSMBodyAndVolumeFraction (const pe::BodyID body, IBlock &block, StructuredBlockStorage &blockStorage, const BlockDataID bodyAndVolumeFractionFieldID)
 Computes the solid volume fraction for each cell intersecting with the specific pe body. More...
 
template<int Weighting_T>
real_t calculateWeighting (const real_t &epsilon, const real_t &tau)
 
template<>
real_t calculateWeighting< 1 > (const real_t &epsilon, const real_t &)
 
template<>
real_t calculateWeighting< 2 > (const real_t &epsilon, const real_t &tau)
 
template<typename LatticeModel_T , typename Filter_T , typename DensityVelocityIn_T , typename DensityVelocityOut_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, Filter_T, DensityVelocityIn_T, DensityVelocityOut_T, SolidCollision_T, Weighting_T > > makePSMSweep (const BlockDataID &pdfFieldID, const BlockDataID &bodyAndVolumeFractionFieldID, const shared_ptr< StructuredBlockStorage > &blockStorage, const Filter_T &filter, const DensityVelocityIn_T &densityVelocityIn, const DensityVelocityOut_T &densityVelocityOut)
 
template<typename LatticeModel_T , typename Filter_T , typename DensityVelocityIn_T , typename DensityVelocityOut_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, Filter_T, DensityVelocityIn_T, DensityVelocityOut_T, SolidCollision_T, Weighting_T > > makePSMSweep (const BlockDataID &srcID, const BlockDataID &dstID, const BlockDataID &bodyAndVolumeFractionFieldID, const shared_ptr< StructuredBlockStorage > &blockStorage, const Filter_T &filter, const DensityVelocityIn_T &densityVelocityIn, const DensityVelocityOut_T &densityVelocityOut)
 
template<typename LatticeModel_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DefaultDensityVelocityCallback, SolidCollision_T, Weighting_T > > makePSMSweep (const BlockDataID &pdfFieldID, const BlockDataID &bodyAndVolumeFractionFieldID, const shared_ptr< StructuredBlockStorage > &blockStorage)
 
template<typename LatticeModel_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DefaultDensityVelocityCallback, SolidCollision_T, Weighting_T > > makePSMSweep (const BlockDataID &srcID, const BlockDataID &dstID, const BlockDataID &bodyAndVolumeFractionFieldID, const shared_ptr< StructuredBlockStorage > &blockStorage)
 
template<typename LatticeModel_T , typename FlagField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DefaultDensityVelocityCallback, SolidCollision_T, Weighting_T > > makePSMSweep (const BlockDataID &pdfFieldID, const BlockDataID &bodyAndVolumeFractionFieldID, const shared_ptr< StructuredBlockStorage > &blockStorage, const ConstBlockDataID &flagFieldID, const Set< FlagUID > &cellsToEvaluate)
 
template<typename LatticeModel_T , typename FlagField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DefaultDensityVelocityCallback, SolidCollision_T, Weighting_T > > makePSMSweep (const BlockDataID &srcID, const BlockDataID &dstID, const BlockDataID &bodyAndVolumeFractionFieldID, const shared_ptr< StructuredBlockStorage > &blockStorage, const ConstBlockDataID &flagFieldID, const Set< FlagUID > &cellsToEvaluate)
 
template<typename LatticeModel_T , typename FlagField_T , typename VelocityField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::VelocityCallback< VelocityField_T >, SolidCollision_T, Weighting_T > > makePSMSweep (const BlockDataID &pdfFieldID, const BlockDataID &bodyAndVolumeFractionFieldID, const shared_ptr< StructuredBlockStorage > &blockStorage, const ConstBlockDataID &flagFieldID, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldID)
 
template<typename LatticeModel_T , typename FlagField_T , typename VelocityField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::VelocityCallback< VelocityField_T >, SolidCollision_T, Weighting_T > > makePSMSweep (const BlockDataID &srcID, const BlockDataID &dstID, const BlockDataID &bodyAndVolumeFractionFieldID, const shared_ptr< StructuredBlockStorage > &blockStorage, const ConstBlockDataID &flagFieldID, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldID)
 
template<typename LatticeModel_T , typename FlagField_T , typename VelocityField_T , typename DensityField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DensityVelocityCallback< VelocityField_T, DensityField_T >, SolidCollision_T, Weighting_T > > makePSMSweep (const BlockDataID &pdfFieldID, const BlockDataID &bodyAndVolumeFractionFieldID, const shared_ptr< StructuredBlockStorage > &blockStorage, const ConstBlockDataID &flagFieldID, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldID, const BlockDataID &densityFieldID)
 
template<typename LatticeModel_T , typename FlagField_T , typename VelocityField_T , typename DensityField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DensityVelocityCallback< VelocityField_T, DensityField_T >, SolidCollision_T, Weighting_T > > makePSMSweep (const BlockDataID &srcID, const BlockDataID &dstID, const BlockDataID &bodyAndVolumeFractionFieldID, const shared_ptr< StructuredBlockStorage > &blockStorage, const ConstBlockDataID &flagFieldID, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldID, const BlockDataID &densityFieldID)
 
template<typename LatticeModel_T , int Weighting_T>
Vector3< real_tgetPSMMacroscopicVelocity (const IBlock &block, lbm::PdfField< LatticeModel_T > *pdfField, GhostLayerField< std::vector< std::pair< pe::BodyID, real_t > >, 1 > *bodyAndVolumeFractionField, StructuredBlockStorage &blockStorage, const Cell &cell)
 Evaluates the macroscopic velocity for a given cell when using the PSM method. More...
 
template<typename LatticeModel_T , int Weighting_T>
void initializeDomainForPSM (StructuredBlockStorage &blockStorage, const BlockDataID &pdfFieldID, const BlockDataID &bodyAndVolumeFractionFieldID)
 Initializes the PDF field inside the bodies according to the velocities of the bodies. More...
 
bool selectAllBodies (pe::BodyID)
 
bool selectRegularBodies (pe::BodyID bodyID)
 
bool selectFixedBodies (pe::BodyID bodyID)
 
bool selectGlobalBodies (pe::BodyID bodyID)
 

Typedef Documentation

Function Documentation

template<int Weighting_T>
real_t walberla::pe_coupling::calculateWeighting ( const real_t epsilon,
const real_t tau 
)
template<>
real_t walberla::pe_coupling::calculateWeighting< 1 > ( const real_t epsilon,
const real_t  
)
inline
template<>
real_t walberla::pe_coupling::calculateWeighting< 2 > ( const real_t epsilon,
const real_t tau 
)
inline
template<typename BoundaryHandling_T >
void walberla::pe_coupling::createWithNeighborhood ( BlockForest &  bf,
const BlockDataID  boundaryHandlingID,
const BlockDataID  bodyStorageID,
const BlockDataID  ccdID,
const BlockDataID  fcdID,
const uint_t  numberOfPeSubCycles,
InfoCollection ic 
)
template<typename Stencil_T >
void walberla::pe_coupling::findCorrespondingLatticeDirection ( const Vector3< real_t > &  direction,
Vector3< cell_idx_t > &  correspondingLatticeDirection 
)

Classes to be used with some Reconstructor variants to find an extrapolation direction.

The goal is to find a suitable extrapolation direction which is a three dimensional vector with cell index offsets to the current cell. Each ExtrapolationDirectionFinder class must exactly implement the member function void getDirection( const cell_idx_t & x, const cell_idx_t & y, const cell_idx_t & z, IBlock * const block, Vector3<cell_idx_t> & extrapolationDirection ) const; the determines an appropriate extrapolationDirection.

Different variants are available:

  • FlagFieldNormalExtrapolationDirectionFinder: Uses information from the direct (N,S,E,W,T,B) neighbors' flags to find the extrapolation direction by checking for the domain (here: fluid) flag. This can lead to incorrect directions in close packing scenarios or in the vicinity of other boundaries.
  • SphereNormalExtrapolationDirectionFinder: Calculates the local normal of the body which is in its current form only correct for spherical bodies. The corresponding direction with cell offsets is then determined based on this normal.
void walberla::pe_coupling::getBlockInfoFromInfoCollection ( const PhantomBlock block,
const shared_ptr< InfoCollection > &  ic,
BlockInfo blockInfo 
)
CellInterval walberla::pe_coupling::getCellBB ( const pe::ConstBodyID  body,
const IBlock &  block,
StructuredBlockStorage &  blockStorage,
const uint_t  numberOfGhostLayersToInclude 
)
template<typename LatticeModel_T , int Weighting_T>
Vector3<real_t> walberla::pe_coupling::getPSMMacroscopicVelocity ( const IBlock &  block,
lbm::PdfField< LatticeModel_T > *  pdfField,
GhostLayerField< std::vector< std::pair< pe::BodyID, real_t > >, 1 > *  bodyAndVolumeFractionField,
StructuredBlockStorage &  blockStorage,
const Cell &  cell 
)

Evaluates the macroscopic velocity for a given cell when using the PSM method.

returns the cell local macroscopic velocity for the PSM method cell local velocity = (1- B_s) * u + B_s * v_s u = fluid velocity v_s = velocity of object s at cell center

lbm::PdfField< LatticeModel_T > is typically typedef'ed as PdfField_T; GhostLayerField< std::vector< std::pair< pe::BodyID, real_t > >, 1 > is typically typedef'ed as BodyAndVolumeFractionField_T;

Weighting_T is like in the PSMSweep.

real_t walberla::pe_coupling::getSphereEquivalentDiameter ( pe::RigidBody body)
template<typename LatticeModel_T , int Weighting_T>
void walberla::pe_coupling::initializeDomainForPSM ( StructuredBlockStorage &  blockStorage,
const BlockDataID &  pdfFieldID,
const BlockDataID &  bodyAndVolumeFractionFieldID 
)

Initializes the PDF field inside the bodies according to the velocities of the bodies.

As the Partially Saturated Cells method relies on executing the LBM sweep also inside the bodies, it is good practice (and for some PSM variants also required) to initialize the PDF field ( i.e. the velocity ) in agreement with possible initial velocities of the bodies. This is also the case in the presence of external forces acting on the fluid, as these will often shift the macroscopic velocities during the initialization of the PDF field.

Note, that the BodyAndVolumeFractionMapping for PSM has to be called first to have a valid field.

Only the velocity of cells intersecting with bodies is set, pure fluid cells remain unchanged.

template<typename LatticeModel_T , typename Filter_T , typename DensityVelocityIn_T , typename DensityVelocityOut_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, Filter_T, DensityVelocityIn_T, DensityVelocityOut_T, SolidCollision_T, Weighting_T > > walberla::pe_coupling::makePSMSweep ( const BlockDataID &  pdfFieldID,
const BlockDataID &  bodyAndVolumeFractionFieldID,
const shared_ptr< StructuredBlockStorage > &  blockStorage,
const Filter_T &  filter,
const DensityVelocityIn_T &  densityVelocityIn,
const DensityVelocityOut_T &  densityVelocityOut 
)
template<typename LatticeModel_T , typename Filter_T , typename DensityVelocityIn_T , typename DensityVelocityOut_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, Filter_T, DensityVelocityIn_T, DensityVelocityOut_T, SolidCollision_T, Weighting_T > > walberla::pe_coupling::makePSMSweep ( const BlockDataID &  srcID,
const BlockDataID &  dstID,
const BlockDataID &  bodyAndVolumeFractionFieldID,
const shared_ptr< StructuredBlockStorage > &  blockStorage,
const Filter_T &  filter,
const DensityVelocityIn_T &  densityVelocityIn,
const DensityVelocityOut_T &  densityVelocityOut 
)
template<typename LatticeModel_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DefaultDensityVelocityCallback, SolidCollision_T, Weighting_T > > walberla::pe_coupling::makePSMSweep ( const BlockDataID &  pdfFieldID,
const BlockDataID &  bodyAndVolumeFractionFieldID,
const shared_ptr< StructuredBlockStorage > &  blockStorage 
)
template<typename LatticeModel_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DefaultDensityVelocityCallback, SolidCollision_T, Weighting_T > > walberla::pe_coupling::makePSMSweep ( const BlockDataID &  srcID,
const BlockDataID &  dstID,
const BlockDataID &  bodyAndVolumeFractionFieldID,
const shared_ptr< StructuredBlockStorage > &  blockStorage 
)
template<typename LatticeModel_T , typename FlagField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter<FlagField_T>, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DefaultDensityVelocityCallback, SolidCollision_T, Weighting_T > > walberla::pe_coupling::makePSMSweep ( const BlockDataID &  pdfFieldID,
const BlockDataID &  bodyAndVolumeFractionFieldID,
const shared_ptr< StructuredBlockStorage > &  blockStorage,
const ConstBlockDataID &  flagFieldID,
const Set< FlagUID > &  cellsToEvaluate 
)
template<typename LatticeModel_T , typename FlagField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter<FlagField_T>, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DefaultDensityVelocityCallback, SolidCollision_T, Weighting_T > > walberla::pe_coupling::makePSMSweep ( const BlockDataID &  srcID,
const BlockDataID &  dstID,
const BlockDataID &  bodyAndVolumeFractionFieldID,
const shared_ptr< StructuredBlockStorage > &  blockStorage,
const ConstBlockDataID &  flagFieldID,
const Set< FlagUID > &  cellsToEvaluate 
)
template<typename LatticeModel_T , typename FlagField_T , typename VelocityField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter<FlagField_T>, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::VelocityCallback<VelocityField_T>, SolidCollision_T, Weighting_T > > walberla::pe_coupling::makePSMSweep ( const BlockDataID &  pdfFieldID,
const BlockDataID &  bodyAndVolumeFractionFieldID,
const shared_ptr< StructuredBlockStorage > &  blockStorage,
const ConstBlockDataID &  flagFieldID,
const Set< FlagUID > &  cellsToEvaluate,
const BlockDataID &  velocityFieldID 
)
template<typename LatticeModel_T , typename FlagField_T , typename VelocityField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter<FlagField_T>, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::VelocityCallback<VelocityField_T>, SolidCollision_T, Weighting_T > > walberla::pe_coupling::makePSMSweep ( const BlockDataID &  srcID,
const BlockDataID &  dstID,
const BlockDataID &  bodyAndVolumeFractionFieldID,
const shared_ptr< StructuredBlockStorage > &  blockStorage,
const ConstBlockDataID &  flagFieldID,
const Set< FlagUID > &  cellsToEvaluate,
const BlockDataID &  velocityFieldID 
)
template<typename LatticeModel_T , typename FlagField_T , typename VelocityField_T , typename DensityField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter<FlagField_T>, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DensityVelocityCallback<VelocityField_T,DensityField_T>, SolidCollision_T, Weighting_T > > walberla::pe_coupling::makePSMSweep ( const BlockDataID &  pdfFieldID,
const BlockDataID &  bodyAndVolumeFractionFieldID,
const shared_ptr< StructuredBlockStorage > &  blockStorage,
const ConstBlockDataID &  flagFieldID,
const Set< FlagUID > &  cellsToEvaluate,
const BlockDataID &  velocityFieldID,
const BlockDataID &  densityFieldID 
)
template<typename LatticeModel_T , typename FlagField_T , typename VelocityField_T , typename DensityField_T , int SolidCollision_T, int Weighting_T>
shared_ptr< PSMSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter<FlagField_T>, lbm::DefaultDensityEquilibriumVelocityCalculation, lbm::DensityVelocityCallback<VelocityField_T,DensityField_T>, SolidCollision_T, Weighting_T > > walberla::pe_coupling::makePSMSweep ( const BlockDataID &  srcID,
const BlockDataID &  dstID,
const BlockDataID &  bodyAndVolumeFractionFieldID,
const shared_ptr< StructuredBlockStorage > &  blockStorage,
const ConstBlockDataID &  flagFieldID,
const Set< FlagUID > &  cellsToEvaluate,
const BlockDataID &  velocityFieldID,
const BlockDataID &  densityFieldID 
)
template<typename BoundaryHandling_T >
void walberla::pe_coupling::mapBodies ( StructuredBlockStorage &  blockStorage,
const BlockDataID &  boundaryHandlingID,
const BlockDataID &  bodyStorageID,
pe::BodyStorage globalBodyStorage,
const FlagUID &  obstacle,
const std::function< bool(pe::BodyID)> &  mappingBodySelectorFct = selectAllBodies 
)

Mapping function to map all bodies - with certain properties - onto all blocks with the 'obstacle' flag.

All bodies (from bodyStorage and globalBodyStorage) are iterated and mapped to all blocks. Cells that are inside the bodies are set to 'obstacle'.

Whether or not a body is mapped depends on the return value of the 'mappingBodySelectorFct'.

template<typename BoundaryHandling_T >
void walberla::pe_coupling::mapBody ( pe::BodyID  body,
IBlock &  block,
StructuredBlockStorage &  blockStorage,
const BlockDataID &  boundaryHandlingID,
const FlagUID &  obstacle 
)
template<typename BoundaryHandling_T >
void walberla::pe_coupling::mapMovingBodies ( StructuredBlockStorage &  blockStorage,
const BlockDataID &  boundaryHandlingID,
const BlockDataID &  bodyStorageID,
pe::BodyStorage globalBodyStorage,
const BlockDataID &  bodyFieldID,
const FlagUID &  obstacle,
const std::function< bool(pe::BodyID)> &  mappingBodySelectorFct = selectAllBodies 
)

Mapping function to map all bodies - with certain properties - onto all blocks to the "moving obstacle" boundary condition, that requires the additional bodyField.

All bodies (from bodyStorage and globalBodyStorage) are iterated and mapped to all blocks. Cells that are inside the bodies are set to 'obstacle' and a pointer to the body is stored in the bodyField.

Whether or not a body is mapped depends on the return value of the 'mappingBodySelectorFct'.

template<typename BoundaryHandling_T >
void walberla::pe_coupling::mapMovingBody ( pe::BodyID  body,
IBlock &  block,
StructuredBlockStorage &  blockStorage,
const BlockDataID &  boundaryHandlingID,
const BlockDataID &  bodyFieldID,
const FlagUID &  obstacle 
)
void walberla::pe_coupling::mapPSMBodyAndVolumeFraction ( const pe::BodyID  body,
IBlock &  block,
StructuredBlockStorage &  blockStorage,
const BlockDataID  bodyAndVolumeFractionFieldID 
)

Computes the solid volume fraction for each cell intersecting with the specific pe body.

Depending on the implementation of the "overlapFraction" for the respective pe body type (sphere, ellipsoid, etc. ), super sampling or an analytical formula is used.

The information is stored as a pair of a pointer to a PE body and the corresponding solid volume fraction. As several bodies could intersect with one cell, the pairs are stored in a vector with the size of the amount of intersecting bodies.

template<typename T , typename G >
mpi::GenericSendBuffer<T,G>& walberla::pe_coupling::operator<< ( mpi::GenericSendBuffer< T, G > &  buf,
const BlockInfo info 
)
std::ostream& walberla::pe_coupling::operator<< ( std::ostream &  os,
const BlockInfo bi 
)
inline
template<typename T >
mpi::GenericRecvBuffer<T>& walberla::pe_coupling::operator>> ( mpi::GenericRecvBuffer< T > &  buf,
BlockInfo info 
)
real_t walberla::pe_coupling::overlapFractionPe ( const pe::RigidBody peRigidBody,
const Vector3< real_t > &  cellMidpoint,
const Vector3< real_t > &  dx,
uint_t  maxDepth = 4 
)
bool walberla::pe_coupling::selectAllBodies ( pe::BodyID  )
bool walberla::pe_coupling::selectFixedBodies ( pe::BodyID  bodyID)
bool walberla::pe_coupling::selectGlobalBodies ( pe::BodyID  bodyID)
bool walberla::pe_coupling::selectRegularBodies ( pe::BodyID  bodyID)