Classes | Public Types | Public Member Functions | Static Public Attributes | Private Member Functions | Private Attributes | List of all members
walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T > Class Template Reference

#include <TimeStep.h>

Classes

class  BlockFunctionWrappper
 
class  SharedBlockFunctor
 
class  SharedVoidFunctor
 
class  VoidFunctionWrappper
 

Public Types

using CommunicationStencil_T = typename NeighborsStencil< LatticeModel_T >::type
 
using VoidFunction = std::function< void(const uint_t, const uint_t)>
 
using BlockFunction = std::function< void(IBlock *, const uint_t, const uint_t)>
 
using Stencil = typename LatticeModel_T::Stencil
 

Public Member Functions

 TimeStep (weak_ptr< StructuredBlockForest > blocks, shared_ptr< Sweep_T > &sweep, const BlockDataID &pdfFieldId, const BlockDataID &boundaryHandlingId, const Set< SUID > &requiredBlockSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleBlockSelectors=Set< SUID >::emptySet())
 
 TimeStep (weak_ptr< StructuredBlockForest > blocks, shared_ptr< Sweep_T > &sweep, const BlockDataID &pdfFieldId, const BlockDataID &boundaryHandlingId, const shared_ptr< TimeStepPdfPackInfo > &pdfPackInfo, const Set< SUID > &requiredBlockSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleBlockSelectors=Set< SUID >::emptySet())
 
bool asynchronousCommunicationIsUsed () const
 
void asynchronousCommunication (const bool value=true)
 
bool optimizedCommunicationIsUsed () const
 
void optimizeCommunication (const bool value=true)
 
bool equalLevelBorderStreamCorrectionIsPerformed () const
 
void performEqualLevelBorderStreamCorrection (const bool value=true)
 
bool linearExplosionIsPerformed () const
 
void performLinearExplosion (const bool value=true)
 
void deactivateTiming ()
 
void enableTiming (const shared_ptr< WcTimingPool > &timingPool, const shared_ptr< WcTimingPool > &levelwiseTimingPool)
 
void enableTiming ()
 
const shared_ptr< WcTimingPool > & getTimingPool () const
 
const shared_ptr< WcTimingPool > & getLevelWiseTimingPool () const
 
void operator() ()
 
void addPackInfo (const typename blockforest::communication::NonUniformBufferedScheme< CommunicationStencil_T >::PackInfo &packInfo)
 
void addPostCollideVoidFunction (const VoidFunction &function, const std::string &identifier)
 
void addPostCollideBlockFunction (const BlockFunction &function, const std::string &identifier)
 
void addPostCollideVoidFunction (const VoidFunction &function, const std::string &identifier, const uint_t level)
 
void addPostCollideBlockFunction (const BlockFunction &function, const std::string &identifier, const uint_t level)
 
void addPostBoundaryHandlingVoidFunction (const VoidFunction &function, const std::string &identifier)
 
void addPostBoundaryHandlingBlockFunction (const BlockFunction &function, const std::string &identifier)
 
void addPostBoundaryHandlingVoidFunction (const VoidFunction &function, const std::string &identifier, const uint_t level)
 
void addPostBoundaryHandlingBlockFunction (const BlockFunction &function, const std::string &identifier, const uint_t level)
 
void addPostStreamVoidFunction (const VoidFunction &function, const std::string &identifier)
 
void addPostStreamBlockFunction (const BlockFunction &function, const std::string &identifier)
 
void addPostStreamVoidFunction (const VoidFunction &function, const std::string &identifier, const uint_t level)
 
void addPostStreamBlockFunction (const BlockFunction &function, const std::string &identifier, const uint_t level)
 
template<typename F >
void addPostCollideVoidFunction (const shared_ptr< F > &functorPtr, const std::string &identifier)
 
template<typename F >
void addPostCollideBlockFunction (const shared_ptr< F > &functorPtr, const std::string &identifier)
 
template<typename F >
void addPostCollideVoidFunction (const shared_ptr< F > &functorPtr, const std::string &identifier, const uint_t level)
 
template<typename F >
void addPostCollideBlockFunction (const shared_ptr< F > &functorPtr, const std::string &identifier, const uint_t level)
 
template<typename F >
void addPostBoundaryHandlingVoidFunction (const shared_ptr< F > &functorPtr, const std::string &identifier)
 
template<typename F >
void addPostBoundaryHandlingBlockFunction (const shared_ptr< F > &functorPtr, const std::string &identifier)
 
template<typename F >
void addPostBoundaryHandlingVoidFunction (const shared_ptr< F > &functorPtr, const std::string &identifier, const uint_t level)
 
template<typename F >
void addPostBoundaryHandlingBlockFunction (const shared_ptr< F > &functorPtr, const std::string &identifier, const uint_t level)
 
template<typename F >
void addPostStreamVoidFunction (const shared_ptr< F > &functorPtr, const std::string &identifier)
 
template<typename F >
void addPostStreamBlockFunction (const shared_ptr< F > &functorPtr, const std::string &identifier)
 
template<typename F >
void addPostStreamVoidFunction (const shared_ptr< F > &functorPtr, const std::string &identifier, const uint_t level)
 
template<typename F >
void addPostStreamBlockFunction (const shared_ptr< F > &functorPtr, const std::string &identifier, const uint_t level)
 

Static Public Attributes

static const uint_t StreamIncludedGhostLayers = 2
 

Private Member Functions

void init (const BlockDataID &pdfFieldId, const BlockDataID &boundaryHandlingId)
 
void consistencyChecks (const BlockDataID &pdfFieldId, const BlockDataID &boundaryHandlingId) const
 
void refresh (const uint_t levels)
 
std::string getTimingPoolString (const std::string &name, const std::string &suffix=std::string("")) const
 
std::string getLevelwiseTimingPoolString (const std::string &name, const uint_t level, const std::string &suffix=std::string("")) const
 
void createTimers (const uint_t levels)
 
template<typename Function >
void addFunction (std::vector< std::vector< std::pair< Function, std::string > > > &functions, const Function &function, const std::string &identifier)
 
template<typename Function >
void addFunction (std::vector< std::vector< std::pair< Function, std::string > > > &functions, const Function &function, const std::string &identifier, const uint_t level)
 
std::vector< Block * > selectedBlocks (const uint_t level) const
 
void startTiming (const std::string &name, const uint_t level, const std::string &suffix=std::string(""))
 
void stopTiming (const std::string &name, const uint_t level, const std::string &suffix=std::string(""))
 
void collide (std::vector< Block * > &blocks, const uint_t level, const uint_t executionCount)
 
void stream (std::vector< Block * > &blocks, const uint_t level, const uint_t executionCount)
 
void finishStream (std::vector< Block * > &blocks, const uint_t level, const uint_t executionCount)
 
void streamCollide (std::vector< Block * > &blocks, const uint_t level, const uint_t executionCount)
 
void startCommunicationEqualLevel (const uint_t level)
 
void endCommunicationEqualLevel (const uint_t level)
 
void startCommunicationCoarseToFine (const uint_t level)
 
void endCommunicationCoarseToFine (const uint_t level)
 
void startCommunicationFineToCoarse (const uint_t level)
 
void endCommunicationFineToCoarse (const uint_t level)
 
void performLinearExplosion (std::vector< Block * > &blocks, const uint_t level)
 
void recursiveStep (const uint_t level, const uint_t executionCount)
 

Private Attributes

weak_ptr< StructuredBlockForest > blocks_
 
shared_ptr< Sweep_T > sweep_
 
BoundaryHandling_T::BlockSweep boundarySweep_
 
BoundaryHandling_T::BlockSweep boundarySweepWithLayers_
 
bool asynchronousCommunication_
 
bool optimizedCommunication_
 
shared_ptr< TimeStepPdfPackInfo > pdfPackInfo_
 
blockforest::communication::NonUniformBufferedScheme< CommunicationStencil_T > communication_
 
bool performEqualLevelBorderStreamCorrection_
 
EqualLevelBorderStreamCorrection< LatticeModel_T > equalLevelBorderStreamCorrection_
 
bool performLinearExplosion_
 
LinearExplosion< LatticeModel_T, BoundaryHandling_T > linearExplosion_
 
bool timing_
 
shared_ptr< WcTimingPool > timingPool_
 
shared_ptr< WcTimingPool > levelwiseTimingPool_
 
Set< SUID > requiredBlockSelectors_
 
Set< SUID > incompatibleBlockSelectors_
 
std::vector< std::pair< VoidFunction, std::string > > globalPostCollideVoidFunctions_
 
std::vector< std::pair< BlockFunction, std::string > > globalPostCollideBlockFunctions_
 
std::vector< std::pair< VoidFunction, std::string > > globalPostBoundaryHandlingVoidFunctions_
 
std::vector< std::pair< BlockFunction, std::string > > globalPostBoundaryHandlingBlockFunctions_
 
std::vector< std::pair< VoidFunction, std::string > > globalPostStreamVoidFunctions_
 
std::vector< std::pair< BlockFunction, std::string > > globalPostStreamBlockFunctions_
 
std::vector< std::vector< std::pair< VoidFunction, std::string > > > postCollideVoidFunctions_
 
std::vector< std::vector< std::pair< BlockFunction, std::string > > > postCollideBlockFunctions_
 
std::vector< std::vector< std::pair< VoidFunction, std::string > > > postBoundaryHandlingVoidFunctions_
 
std::vector< std::vector< std::pair< BlockFunction, std::string > > > postBoundaryHandlingBlockFunctions_
 
std::vector< std::vector< std::pair< VoidFunction, std::string > > > postStreamVoidFunctions_
 
std::vector< std::vector< std::pair< BlockFunction, std::string > > > postStreamBlockFunctions_
 

Member Typedef Documentation

◆ BlockFunction

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
using walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::BlockFunction = std::function<void (IBlock *, const uint_t, const uint_t)>

◆ CommunicationStencil_T

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
using walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::CommunicationStencil_T = typename NeighborsStencil<LatticeModel_T>::type

◆ Stencil

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
using walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::Stencil = typename LatticeModel_T::Stencil

◆ VoidFunction

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
using walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::VoidFunction = std::function<void (const uint_t, const uint_t)>

Constructor & Destructor Documentation

◆ TimeStep() [1/2]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::TimeStep ( weak_ptr< StructuredBlockForest >  blocks,
shared_ptr< Sweep_T > &  sweep,
const BlockDataID &  pdfFieldId,
const BlockDataID &  boundaryHandlingId,
const Set< SUID > &  requiredBlockSelectors = Set<SUID>::emptySet(),
const Set< SUID > &  incompatibleBlockSelectors = Set<SUID>::emptySet() 
)

◆ TimeStep() [2/2]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::TimeStep ( weak_ptr< StructuredBlockForest >  blocks,
shared_ptr< Sweep_T > &  sweep,
const BlockDataID &  pdfFieldId,
const BlockDataID &  boundaryHandlingId,
const shared_ptr< TimeStepPdfPackInfo > &  pdfPackInfo,
const Set< SUID > &  requiredBlockSelectors = Set<SUID>::emptySet(),
const Set< SUID > &  incompatibleBlockSelectors = Set<SUID>::emptySet() 
)

Member Function Documentation

◆ addFunction() [1/2]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename Function >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addFunction ( std::vector< std::vector< std::pair< Function, std::string > > > &  functions,
const Function &  function,
const std::string &  identifier 
)
private

◆ addFunction() [2/2]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename Function >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addFunction ( std::vector< std::vector< std::pair< Function, std::string > > > &  functions,
const Function &  function,
const std::string &  identifier,
const uint_t  level 
)
private

◆ addPackInfo()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPackInfo ( const typename blockforest::communication::NonUniformBufferedScheme< CommunicationStencil_T >::PackInfo &  packInfo)
inline

◆ addPostBoundaryHandlingBlockFunction() [1/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostBoundaryHandlingBlockFunction ( const BlockFunction &  function,
const std::string &  identifier 
)
inline

◆ addPostBoundaryHandlingBlockFunction() [2/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostBoundaryHandlingBlockFunction ( const BlockFunction &  function,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostBoundaryHandlingBlockFunction() [3/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostBoundaryHandlingBlockFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier 
)
inline

◆ addPostBoundaryHandlingBlockFunction() [4/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostBoundaryHandlingBlockFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostBoundaryHandlingVoidFunction() [1/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostBoundaryHandlingVoidFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier 
)
inline

◆ addPostBoundaryHandlingVoidFunction() [2/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostBoundaryHandlingVoidFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostBoundaryHandlingVoidFunction() [3/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostBoundaryHandlingVoidFunction ( const VoidFunction &  function,
const std::string &  identifier 
)
inline

◆ addPostBoundaryHandlingVoidFunction() [4/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostBoundaryHandlingVoidFunction ( const VoidFunction &  function,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostCollideBlockFunction() [1/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostCollideBlockFunction ( const BlockFunction &  function,
const std::string &  identifier 
)
inline

◆ addPostCollideBlockFunction() [2/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostCollideBlockFunction ( const BlockFunction &  function,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostCollideBlockFunction() [3/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostCollideBlockFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier 
)
inline

◆ addPostCollideBlockFunction() [4/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostCollideBlockFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostCollideVoidFunction() [1/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostCollideVoidFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier 
)
inline

◆ addPostCollideVoidFunction() [2/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostCollideVoidFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostCollideVoidFunction() [3/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostCollideVoidFunction ( const VoidFunction &  function,
const std::string &  identifier 
)
inline

◆ addPostCollideVoidFunction() [4/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostCollideVoidFunction ( const VoidFunction &  function,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostStreamBlockFunction() [1/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostStreamBlockFunction ( const BlockFunction &  function,
const std::string &  identifier 
)
inline

◆ addPostStreamBlockFunction() [2/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostStreamBlockFunction ( const BlockFunction &  function,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostStreamBlockFunction() [3/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostStreamBlockFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier 
)
inline

◆ addPostStreamBlockFunction() [4/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostStreamBlockFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostStreamVoidFunction() [1/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostStreamVoidFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier 
)
inline

◆ addPostStreamVoidFunction() [2/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
template<typename F >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostStreamVoidFunction ( const shared_ptr< F > &  functorPtr,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ addPostStreamVoidFunction() [3/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostStreamVoidFunction ( const VoidFunction &  function,
const std::string &  identifier 
)
inline

◆ addPostStreamVoidFunction() [4/4]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::addPostStreamVoidFunction ( const VoidFunction &  function,
const std::string &  identifier,
const uint_t  level 
)
inline

◆ asynchronousCommunication()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::asynchronousCommunication ( const bool  value = true)
inline

◆ asynchronousCommunicationIsUsed()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
bool walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::asynchronousCommunicationIsUsed ( ) const
inline

◆ collide()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::collide ( std::vector< Block * > &  blocks,
const uint_t  level,
const uint_t  executionCount 
)
private

◆ consistencyChecks()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::consistencyChecks ( const BlockDataID &  pdfFieldId,
const BlockDataID &  boundaryHandlingId 
) const
private

◆ createTimers()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::createTimers ( const uint_t  levels)
private

◆ deactivateTiming()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::deactivateTiming ( )
inline

◆ enableTiming() [1/2]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::enableTiming ( )
inline

◆ enableTiming() [2/2]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::enableTiming ( const shared_ptr< WcTimingPool > &  timingPool,
const shared_ptr< WcTimingPool > &  levelwiseTimingPool 
)
inline

◆ endCommunicationCoarseToFine()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::endCommunicationCoarseToFine ( const uint_t  level)
private

◆ endCommunicationEqualLevel()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::endCommunicationEqualLevel ( const uint_t  level)
private

◆ endCommunicationFineToCoarse()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::endCommunicationFineToCoarse ( const uint_t  level)
private

◆ equalLevelBorderStreamCorrectionIsPerformed()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
bool walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::equalLevelBorderStreamCorrectionIsPerformed ( ) const
inline

◆ finishStream()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::finishStream ( std::vector< Block * > &  blocks,
const uint_t  level,
const uint_t  executionCount 
)
private

◆ getLevelWiseTimingPool()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
const shared_ptr<WcTimingPool>& walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::getLevelWiseTimingPool ( ) const
inline

◆ getLevelwiseTimingPoolString()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::string walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::getLevelwiseTimingPoolString ( const std::string &  name,
const uint_t  level,
const std::string &  suffix = std::string("") 
) const
private

◆ getTimingPool()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
const shared_ptr<WcTimingPool>& walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::getTimingPool ( ) const
inline

◆ getTimingPoolString()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::string walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::getTimingPoolString ( const std::string &  name,
const std::string &  suffix = std::string("") 
) const
private

◆ init()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::init ( const BlockDataID &  pdfFieldId,
const BlockDataID &  boundaryHandlingId 
)
private

◆ linearExplosionIsPerformed()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
bool walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::linearExplosionIsPerformed ( ) const
inline

◆ operator()()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::operator() ( )
inline

◆ optimizeCommunication()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::optimizeCommunication ( const bool  value = true)
inline

◆ optimizedCommunicationIsUsed()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
bool walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::optimizedCommunicationIsUsed ( ) const
inline

◆ performEqualLevelBorderStreamCorrection()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::performEqualLevelBorderStreamCorrection ( const bool  value = true)
inline

◆ performLinearExplosion() [1/2]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::performLinearExplosion ( const bool  value = true)
inline

◆ performLinearExplosion() [2/2]

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::performLinearExplosion ( std::vector< Block * > &  blocks,
const uint_t  level 
)
private

◆ recursiveStep()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::recursiveStep ( const uint_t  level,
const uint_t  executionCount 
)
private

◆ refresh()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::refresh ( const uint_t  levels)
private

◆ selectedBlocks()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< Block * > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::selectedBlocks ( const uint_t  level) const
private

◆ startCommunicationCoarseToFine()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::startCommunicationCoarseToFine ( const uint_t  level)
private

◆ startCommunicationEqualLevel()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::startCommunicationEqualLevel ( const uint_t  level)
private

◆ startCommunicationFineToCoarse()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::startCommunicationFineToCoarse ( const uint_t  level)
private

◆ startTiming()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::startTiming ( const std::string &  name,
const uint_t  level,
const std::string &  suffix = std::string("") 
)
inlineprivate

◆ stopTiming()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::stopTiming ( const std::string &  name,
const uint_t  level,
const std::string &  suffix = std::string("") 
)
inlineprivate

◆ stream()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::stream ( std::vector< Block * > &  blocks,
const uint_t  level,
const uint_t  executionCount 
)
private

◆ streamCollide()

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
void walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::streamCollide ( std::vector< Block * > &  blocks,
const uint_t  level,
const uint_t  executionCount 
)
private

Member Data Documentation

◆ asynchronousCommunication_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
bool walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::asynchronousCommunication_
private

◆ blocks_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
weak_ptr< StructuredBlockForest > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::blocks_
private

◆ boundarySweep_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
BoundaryHandling_T::BlockSweep walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::boundarySweep_
private

◆ boundarySweepWithLayers_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
BoundaryHandling_T::BlockSweep walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::boundarySweepWithLayers_
private

◆ communication_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
blockforest::communication::NonUniformBufferedScheme< CommunicationStencil_T > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::communication_
private

◆ equalLevelBorderStreamCorrection_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
EqualLevelBorderStreamCorrection< LatticeModel_T > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::equalLevelBorderStreamCorrection_
private

◆ globalPostBoundaryHandlingBlockFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::pair< BlockFunction, std::string > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::globalPostBoundaryHandlingBlockFunctions_
private

◆ globalPostBoundaryHandlingVoidFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::pair< VoidFunction, std::string > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::globalPostBoundaryHandlingVoidFunctions_
private

◆ globalPostCollideBlockFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::pair< BlockFunction, std::string > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::globalPostCollideBlockFunctions_
private

◆ globalPostCollideVoidFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::pair< VoidFunction, std::string > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::globalPostCollideVoidFunctions_
private

◆ globalPostStreamBlockFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::pair< BlockFunction, std::string > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::globalPostStreamBlockFunctions_
private

◆ globalPostStreamVoidFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::pair< VoidFunction, std::string > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::globalPostStreamVoidFunctions_
private

◆ incompatibleBlockSelectors_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
Set<SUID> walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::incompatibleBlockSelectors_
private

◆ levelwiseTimingPool_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
shared_ptr<WcTimingPool> walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::levelwiseTimingPool_
private

◆ linearExplosion_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
LinearExplosion< LatticeModel_T, BoundaryHandling_T > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::linearExplosion_
private

◆ optimizedCommunication_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
bool walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::optimizedCommunication_
private

◆ pdfPackInfo_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
shared_ptr< TimeStepPdfPackInfo > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::pdfPackInfo_
private

◆ performEqualLevelBorderStreamCorrection_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
bool walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::performEqualLevelBorderStreamCorrection_
private

◆ performLinearExplosion_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
bool walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::performLinearExplosion_
private

◆ postBoundaryHandlingBlockFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::vector< std::pair< BlockFunction, std::string > > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::postBoundaryHandlingBlockFunctions_
private

◆ postBoundaryHandlingVoidFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::vector< std::pair< VoidFunction, std::string > > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::postBoundaryHandlingVoidFunctions_
private

◆ postCollideBlockFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::vector< std::pair< BlockFunction, std::string > > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::postCollideBlockFunctions_
private

◆ postCollideVoidFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::vector< std::pair< VoidFunction, std::string > > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::postCollideVoidFunctions_
private

◆ postStreamBlockFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::vector< std::pair< BlockFunction, std::string > > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::postStreamBlockFunctions_
private

◆ postStreamVoidFunctions_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
std::vector< std::vector< std::pair< VoidFunction, std::string > > > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::postStreamVoidFunctions_
private

◆ requiredBlockSelectors_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
Set<SUID> walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::requiredBlockSelectors_
private

◆ StreamIncludedGhostLayers

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
const uint_t walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::StreamIncludedGhostLayers = 2
static

◆ sweep_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
shared_ptr< Sweep_T > walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::sweep_
private

◆ timing_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
bool walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::timing_
private

◆ timingPool_

template<typename LatticeModel_T , typename Sweep_T , typename BoundaryHandling_T >
shared_ptr<WcTimingPool> walberla::lbm::refinement::TimeStep< LatticeModel_T, Sweep_T, BoundaryHandling_T >::timingPool_
private
The documentation for this class was generated from the following file: