waLBerla 7.3
Loading...
Searching...
No Matches
walberla::BoundaryHandlingCollection< FlagField_T, Handlers > Class Template Reference

#include <BoundaryHandlingCollection.h>

Classes

class  BlockSweep

Public Types

using FlagField = FlagField_T
using flag_t = typename FlagField_T::flag_t
using ConstFlagFieldBaseIterator = typename FlagField_T::const_base_iterator

Public Member Functions

 BoundaryHandlingCollection (const std::string &identifier, FlagField_T *const flagField, const Handlers &... boundaryHandlers)
bool operator== (const BoundaryHandlingCollection &) const
bool operator!= (const BoundaryHandlingCollection &rhs) const
const BoundaryHandlingCollectionUID & getUID () const
const FlagField_T * getFlagField () const
FlagField_T * getFlagField ()
bool isEmpty (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z) const
bool isEmpty (const ConstFlagFieldBaseIterator &it) const
bool consideredByAllHandlers (const uint_t numberOfGhostLayersToInclude=0) const
bool consideredByAllHandlers (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z) const
bool consideredByAllHandlers (const ConstFlagFieldBaseIterator &it) const
bool consideredByAllHandlers (const CellInterval &cells) const
template<typename CellIterator>
bool consideredByAllHandlers (const CellIterator &begin, const CellIterator &end) const
template<typename BoundaryHandling_T>
const BoundaryHandling_T & getBoundaryHandling (const BoundaryHandlingUID &uid) const
 You most likely have to call this function via "collection.template getBoundaryHandling< BoundaryHandling_T >(uid)".
template<typename BoundaryHandling_T>
BoundaryHandling_T & getBoundaryHandling (const BoundaryHandlingUID &uid)
 You most likely have to call this function via "collection.template getBoundaryHandling< BoundaryHandling_T >(uid)".
uint_t numberOfMatchingHandlers (const flag_t flag) const
uint_t numberOfMatchingHandlersForDomain (const flag_t flag) const
uint_t numberOfMatchingHandlersForBoundary (const flag_t flag) const
bool containsBoundaryCondition (const BoundaryUID &uid) const
bool containsBoundaryCondition (const FlagUID &flag) const
bool containsBoundaryCondition (const flag_t flag) const
flag_t getBoundaryMask (const BoundaryUID &uid) const
BoundaryUID getBoundaryUID (const FlagUID &flag) const
BoundaryUID getBoundaryUID (const flag_t flag) const
shared_ptr< BoundaryConfiguration > createBoundaryConfiguration (const BoundaryUID &uid, const Config::BlockHandle &config) const
bool checkConsistency (const uint_t numberOfGhostLayersToInclude=0) const
bool checkConsistency (const CellInterval &cells) const
void refresh (const uint_t numberOfGhostLayersToInclude=0)
void refresh (const CellInterval &cells)
void refreshOutermostLayer (cell_idx_t thickness=1)
General Flag Handling
void setFlag (const FlagUID &flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
void setFlag (const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
void setFlag (const FlagUID &flag, const CellInterval &cells, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
void setFlag (const flag_t flag, const CellInterval &cells, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
template<typename CellIterator>
void setFlag (const FlagUID &flag, const CellIterator &begin, const CellIterator &end, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
template<typename CellIterator>
void setFlag (const flag_t flag, const CellIterator &begin, const CellIterator &end, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
void forceFlag (const FlagUID &flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
void forceFlag (const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
void forceFlag (const FlagUID &flag, const CellInterval &cells, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
void forceFlag (const flag_t flag, const CellInterval &cells, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
template<typename CellIterator>
void forceFlag (const FlagUID &flag, const CellIterator &begin, const CellIterator &end, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
template<typename CellIterator>
void forceFlag (const flag_t flag, const CellIterator &begin, const CellIterator &end, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
void removeFlag (const FlagUID &flag, const uint_t numberOfGhostLayersToInclude=0)
void removeFlag (const flag_t flag, const uint_t numberOfGhostLayersToInclude=0)
void removeFlag (const FlagUID &flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
void removeFlag (const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
void removeFlag (const FlagUID &flag, const CellInterval &cells)
void removeFlag (const flag_t flag, const CellInterval &cells)
template<typename CellIterator>
void removeFlag (const FlagUID &flag, const CellIterator &begin, const CellIterator &end)
template<typename CellIterator>
void removeFlag (const flag_t flag, const CellIterator &begin, const CellIterator &end)
Clear Cells
void clear (const uint_t numberOfGhostLayersToInclude=0)
void clear (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
void clear (const CellInterval &cells)
template<typename CellIterator>
void clear (const CellIterator &begin, const CellIterator &end)

Private Member Functions

Get Boundary Handling (private helper functions)
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & getBoundaryHandling (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & getBoundaryHandling (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & getBoundaryHandling (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & getBoundaryHandling (const BoundaryHandlingUID &, const HandlersTuple &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t numberOfMatchingHandlers (const HandlersTuple &boundaryHandlers, const flag_t flag) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t numberOfMatchingHandlers (const HandlersTuple &, const flag_t) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t numberOfMatchingHandlersForDomain (const HandlersTuple &boundaryHandlers, const flag_t flag) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t numberOfMatchingHandlersForDomain (const HandlersTuple &, const flag_t) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t numberOfMatchingHandlersForBoundary (const HandlersTuple &boundaryHandlers, const flag_t flag) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t numberOfMatchingHandlersForBoundary (const HandlersTuple &, const flag_t) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool containsBoundaryCondition (const HandlersTuple &boundaryHandlers, const BoundaryUID &uid) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool containsBoundaryCondition (const HandlersTuple &, const BoundaryUID &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool containsBoundaryCondition (const HandlersTuple &boundaryHandlers, const flag_t flag) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool containsBoundaryCondition (const HandlersTuple &, const flag_t) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
flag_t getBoundaryMask (const HandlersTuple &boundaryHandlers, const BoundaryUID &uid) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
flag_t getBoundaryMask (const HandlersTuple &, const BoundaryUID &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
BoundaryUID getBoundaryUID (const HandlersTuple &boundaryHandlers, const flag_t flag) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
BoundaryUID getBoundaryUID (const HandlersTuple &, const flag_t) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
shared_ptr< BoundaryConfiguration > createBoundaryConfiguration (const HandlersTuple &boundaryHandlers, const BoundaryUID &uid, const Config::BlockHandle &config) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
shared_ptr< BoundaryConfiguration > createBoundaryConfiguration (const HandlersTuple &, const BoundaryUID &, const Config::BlockHandle &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool checkConsistency (const HandlersTuple &boundaryHandlers, const CellInterval &cells) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool checkConsistency (const HandlersTuple &, const CellInterval &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void refresh (HandlersTuple &boundaryHandlers, const CellInterval &cells)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void refresh (const HandlersTuple &, const CellInterval &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void refreshOutermostLayer (HandlersTuple &boundaryHandlers, cell_idx_t thickness)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void refreshOutermostLayer (const HandlersTuple &, cell_idx_t) const
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void checkForUniqueBoundaryHandlingUIDs (const HandlersTuple &boundaryHandlers) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void checkForUniqueBoundaryHandlingUIDs (const HandlersTuple &) const
std::vector< BoundaryUID > getBoundaryUIDs () const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void getBoundaryUIDs (const HandlersTuple &boundaryHandlers, std::vector< BoundaryUID > &uids) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void getBoundaryUIDs (const HandlersTuple &, std::vector< BoundaryUID > &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool checkForIdenticalFlagFields (const HandlersTuple &boundaryHandlers) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool checkForIdenticalFlagFields (const HandlersTuple &) const
uint_t numberOfMatchingBoundaryHandlers (const BoundaryHandlingUID &uid) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t numberOfMatchingBoundaryHandlers (const HandlersTuple &boundaryHandlers, const BoundaryHandlingUID &uid) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t numberOfMatchingBoundaryHandlers (const HandlersTuple &, const BoundaryHandlingUID &) const
General Flag Handling (private helper functions)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void setFlag (HandlersTuple &boundaryHandlers, const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const BoundaryConfiguration &parameter)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void setFlag (const HandlersTuple &, const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const BoundaryConfiguration &)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void setFlag (HandlersTuple &boundaryHandlers, const flag_t flag, const CellInterval &cells, const BoundaryConfiguration &parameter)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void setFlag (const HandlersTuple &, const flag_t flag, const CellInterval &cells, const BoundaryConfiguration &)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void removeFlag (HandlersTuple &boundaryHandlers, const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void removeFlag (const HandlersTuple &, const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
void forceFlagHelper (const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const BoundaryConfiguration &parameter)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
flag_t flagsToRemove (HandlersTuple &boundaryHandlers, const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
flag_t flagsToRemove (const HandlersTuple &, const flag_t, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
Clear Cells (private helper functions)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
flag_t clear (HandlersTuple &boundaryHandlers, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
flag_t clear (const HandlersTuple &, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
Boundary Treatment (private helper functions)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void beforeBoundaryTreatment (HandlersTuple &boundaryHandlers)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void beforeBoundaryTreatment (const HandlersTuple &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void afterBoundaryTreatment (HandlersTuple &boundaryHandlers)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void afterBoundaryTreatment (const HandlersTuple &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void execute (HandlersTuple &boundaryHandlers, const uint_t numberOfGhostLayersToInclude)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void execute (const HandlersTuple &, const uint_t) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void execute (HandlersTuple &boundaryHandlers, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void execute (const HandlersTuple &, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void execute (HandlersTuple &boundaryHandlers, const CellInterval &cells)
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void execute (const HandlersTuple &, const CellInterval &) const
template<typename CellIterator, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void execute (HandlersTuple &boundaryHandlers, const CellIterator &begin, const CellIterator &end)
template<typename CellIterator, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void execute (const HandlersTuple &, const CellIterator &, const CellIterator &) const

Pack / Unpack boundary handling (private helper functions)

using Tuple = std::tuple<Handlers...>
const BoundaryHandlingCollectionUID uid_
FlagField_T *const flagField_
const CellInterval outerBB_
Tuple boundaryHandlers_
template<typename Buffer_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void pack (const HandlersTuple &boundaryHandlers, Buffer_T &buffer, const flag_t mask, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z) const
template<typename Buffer_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void pack (const HandlersTuple &, Buffer_T &, const flag_t, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
template<typename Buffer_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void unpack (HandlersTuple &boundaryHandlers, Buffer_T &buffer, const flag_t mask, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
template<typename Buffer_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void unpack (const HandlersTuple &, Buffer_T &, const flag_t, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void toStream (const HandlersTuple &boundaryHandlers, std::ostream &os) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void toStream (const HandlersTuple &, std::ostream &) const
std::map< std::string, flag_t > getFlagMapping () const
template<typename Buffer_T>
std::vector< flag_t > getNeighborFlagMapping (Buffer_T &buffer, const bool assumeIdenticalFlagMapping, bool &identicalFlagMapping) const
void translateMask (flag_t &mask, const std::vector< flag_t > &flagMapping) const
CellInterval getPackingInterval (stencil::Direction direction, const uint_t numberOfLayers) const
CellInterval getUnpackingInterval (stencil::Direction direction, const uint_t numberOfLayers) const

Boundary Treatment

void operator() (const uint_t numberOfGhostLayersToInclude=0)
void operator() (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
void operator() (const CellInterval &cells)
template<typename CellIterator>
void operator() (const CellIterator &begin, const CellIterator &end)
void beforeBoundaryTreatment ()
void afterBoundaryTreatment ()
static BlockSweep getBlockSweep (const BlockDataID handling, const uint_t numberOfGhostLayersToInclude=0)

Pack / Unpack boundary handling collection

template<typename Buffer_T>
void pack (Buffer_T &buffer, stencil::Direction direction, const uint_t numberOfLayers=1, const bool assumeIdenticalFlagMapping=true) const
template<typename Buffer_T>
void unpack (Buffer_T &buffer, stencil::Direction direction, const uint_t numberOfLayers=1, const bool assumeIdenticalFlagMapping=true)
void toStream (std::ostream &os) const
std::string toString () const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool isEmpty (const HandlersTuple &boundaryHandlers, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool isEmpty (const HandlersTuple &, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool isEmpty (const HandlersTuple &boundaryHandlers, const ConstFlagFieldBaseIterator &it) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool isEmpty (const HandlersTuple &, const ConstFlagFieldBaseIterator &) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool consideredByAllHandlers (const HandlersTuple &boundaryHandlers, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool consideredByAllHandlers (const HandlersTuple &, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool consideredByAllHandlers (const HandlersTuple &boundaryHandlers, const ConstFlagFieldBaseIterator &it) const
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool consideredByAllHandlers (const HandlersTuple &, const ConstFlagFieldBaseIterator &) const
CellInterval getGhostLayerCellInterval (const uint_t numberOfGhostLayersToInclude) const

Member Typedef Documentation

◆ ConstFlagFieldBaseIterator

template<typename FlagField_T, typename... Handlers>
using walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::ConstFlagFieldBaseIterator = typename FlagField_T::const_base_iterator

◆ flag_t

template<typename FlagField_T, typename... Handlers>
using walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::flag_t = typename FlagField_T::flag_t

◆ FlagField

template<typename FlagField_T, typename... Handlers>
using walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::FlagField = FlagField_T

◆ Tuple

template<typename FlagField_T, typename... Handlers>
using walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::Tuple = std::tuple<Handlers...>
private

Constructor & Destructor Documentation

◆ BoundaryHandlingCollection()

template<typename FlagField_T, typename... Handlers>
walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::BoundaryHandlingCollection ( const std::string & identifier,
FlagField_T *const flagField,
const Handlers &... boundaryHandlers )

Member Function Documentation

◆ afterBoundaryTreatment() [1/3]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::afterBoundaryTreatment ( )
inline

◆ afterBoundaryTreatment() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::afterBoundaryTreatment ( const HandlersTuple & ) const
inlineprivate

◆ afterBoundaryTreatment() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::afterBoundaryTreatment ( HandlersTuple & boundaryHandlers)
inlineprivate

◆ beforeBoundaryTreatment() [1/3]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::beforeBoundaryTreatment ( )
inline

◆ beforeBoundaryTreatment() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::beforeBoundaryTreatment ( const HandlersTuple & ) const
inlineprivate

◆ beforeBoundaryTreatment() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::beforeBoundaryTreatment ( HandlersTuple & boundaryHandlers)
inlineprivate

◆ checkConsistency() [1/4]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkConsistency ( const CellInterval & cells) const
inline

◆ checkConsistency() [2/4]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkConsistency ( const HandlersTuple & ,
const CellInterval &  ) const
inlineprivate

◆ checkConsistency() [3/4]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkConsistency ( const HandlersTuple & boundaryHandlers,
const CellInterval & cells ) const
inlineprivate

◆ checkConsistency() [4/4]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkConsistency ( const uint_t numberOfGhostLayersToInclude = 0) const
inline

◆ checkForIdenticalFlagFields() [1/2]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkForIdenticalFlagFields ( const HandlersTuple & ) const
inlineprivate

◆ checkForIdenticalFlagFields() [2/2]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkForIdenticalFlagFields ( const HandlersTuple & boundaryHandlers) const
inlineprivate

◆ checkForUniqueBoundaryHandlingUIDs() [1/2]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkForUniqueBoundaryHandlingUIDs ( const HandlersTuple & ) const
inlineprivate

◆ checkForUniqueBoundaryHandlingUIDs() [2/2]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkForUniqueBoundaryHandlingUIDs ( const HandlersTuple & boundaryHandlers) const
inlineprivate

◆ clear() [1/6]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::clear ( const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z )
inline

◆ clear() [2/6]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::clear ( const CellInterval & cells)
inline

◆ clear() [3/6]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::clear ( const CellIterator & begin,
const CellIterator & end )
inline

◆ clear() [4/6]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
flag_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::clear ( const HandlersTuple & ,
const cell_idx_t ,
const cell_idx_t ,
const cell_idx_t  ) const
inlineprivate

◆ clear() [5/6]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::clear ( const uint_t numberOfGhostLayersToInclude = 0)
inline

◆ clear() [6/6]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
BoundaryHandlingCollection< FlagField_T, Handlers... >::flag_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::clear ( HandlersTuple & boundaryHandlers,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z )
inlineprivate

◆ consideredByAllHandlers() [1/9]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::consideredByAllHandlers ( const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z ) const
inline

◆ consideredByAllHandlers() [2/9]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::consideredByAllHandlers ( const CellInterval & cells) const
inline

◆ consideredByAllHandlers() [3/9]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::consideredByAllHandlers ( const CellIterator & begin,
const CellIterator & end ) const
inline

◆ consideredByAllHandlers() [4/9]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::consideredByAllHandlers ( const ConstFlagFieldBaseIterator & it) const
inline

◆ consideredByAllHandlers() [5/9]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::consideredByAllHandlers ( const HandlersTuple & ,
const cell_idx_t ,
const cell_idx_t ,
const cell_idx_t  ) const
inlineprivate

◆ consideredByAllHandlers() [6/9]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::consideredByAllHandlers ( const HandlersTuple & ,
const ConstFlagFieldBaseIterator &  ) const
inlineprivate

◆ consideredByAllHandlers() [7/9]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::consideredByAllHandlers ( const HandlersTuple & boundaryHandlers,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z ) const
inlineprivate

◆ consideredByAllHandlers() [8/9]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::consideredByAllHandlers ( const HandlersTuple & boundaryHandlers,
const ConstFlagFieldBaseIterator & it ) const
inlineprivate

◆ consideredByAllHandlers() [9/9]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::consideredByAllHandlers ( const uint_t numberOfGhostLayersToInclude = 0) const
inline

◆ containsBoundaryCondition() [1/7]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::containsBoundaryCondition ( const BoundaryUID & uid) const
inline

◆ containsBoundaryCondition() [2/7]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::containsBoundaryCondition ( const flag_t flag) const
inline

◆ containsBoundaryCondition() [3/7]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::containsBoundaryCondition ( const FlagUID & flag) const
inline

◆ containsBoundaryCondition() [4/7]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::containsBoundaryCondition ( const HandlersTuple & ,
const BoundaryUID &  ) const
inlineprivate

◆ containsBoundaryCondition() [5/7]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::containsBoundaryCondition ( const HandlersTuple & ,
const flag_t  ) const
inlineprivate

◆ containsBoundaryCondition() [6/7]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::containsBoundaryCondition ( const HandlersTuple & boundaryHandlers,
const BoundaryUID & uid ) const
inlineprivate

◆ containsBoundaryCondition() [7/7]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::containsBoundaryCondition ( const HandlersTuple & boundaryHandlers,
const flag_t flag ) const
inlineprivate

◆ createBoundaryConfiguration() [1/3]

template<typename FlagField_T, typename... Handlers>
shared_ptr< BoundaryConfiguration > walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::createBoundaryConfiguration ( const BoundaryUID & uid,
const Config::BlockHandle & config ) const
inline

◆ createBoundaryConfiguration() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
shared_ptr< BoundaryConfiguration > walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::createBoundaryConfiguration ( const HandlersTuple & ,
const BoundaryUID & ,
const Config::BlockHandle &  ) const
inlineprivate

◆ createBoundaryConfiguration() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
shared_ptr< BoundaryConfiguration > walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::createBoundaryConfiguration ( const HandlersTuple & boundaryHandlers,
const BoundaryUID & uid,
const Config::BlockHandle & config ) const
inlineprivate

◆ execute() [1/8]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::execute ( const HandlersTuple & ,
const cell_idx_t ,
const cell_idx_t ,
const cell_idx_t  ) const
inlineprivate

◆ execute() [2/8]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::execute ( const HandlersTuple & ,
const CellInterval &  ) const
inlineprivate

◆ execute() [3/8]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::execute ( const HandlersTuple & ,
const CellIterator & ,
const CellIterator &  ) const
inlineprivate

◆ execute() [4/8]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::execute ( const HandlersTuple & ,
const uint_t  ) const
inlineprivate

◆ execute() [5/8]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::execute ( HandlersTuple & boundaryHandlers,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z )
inlineprivate

◆ execute() [6/8]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::execute ( HandlersTuple & boundaryHandlers,
const CellInterval & cells )
inlineprivate

◆ execute() [7/8]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator, typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::execute ( HandlersTuple & boundaryHandlers,
const CellIterator & begin,
const CellIterator & end )
inlineprivate

◆ execute() [8/8]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::execute ( HandlersTuple & boundaryHandlers,
const uint_t numberOfGhostLayersToInclude )
inlineprivate

◆ flagsToRemove() [1/2]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
flag_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::flagsToRemove ( const HandlersTuple & ,
const flag_t ,
const cell_idx_t ,
const cell_idx_t ,
const cell_idx_t  ) const
inlineprivate

◆ flagsToRemove() [2/2]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
BoundaryHandlingCollection< FlagField_T, Handlers... >::flag_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::flagsToRemove ( HandlersTuple & boundaryHandlers,
const flag_t flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z )
inlineprivate

◆ forceFlag() [1/6]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::forceFlag ( const flag_t flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ forceFlag() [2/6]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::forceFlag ( const flag_t flag,
const CellInterval & cells,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ forceFlag() [3/6]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::forceFlag ( const flag_t flag,
const CellIterator & begin,
const CellIterator & end,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ forceFlag() [4/6]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::forceFlag ( const FlagUID & flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ forceFlag() [5/6]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::forceFlag ( const FlagUID & flag,
const CellInterval & cells,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ forceFlag() [6/6]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::forceFlag ( const FlagUID & flag,
const CellIterator & begin,
const CellIterator & end,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ forceFlagHelper()

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::forceFlagHelper ( const flag_t flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z,
const BoundaryConfiguration & parameter )
private

◆ getBlockSweep()

template<typename FlagField_T, typename... Handlers>
BlockSweep walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBlockSweep ( const BlockDataID handling,
const uint_t numberOfGhostLayersToInclude = 0 )
inlinestatic

◆ getBoundaryHandling() [1/6]

template<typename FlagField_T, typename... Handlers>
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling ( const BoundaryHandlingUID & ,
const HandlersTuple &  ) const
inlineprivate

◆ getBoundaryHandling() [2/6]

template<typename FlagField_T, typename... Handlers>
template<typename BoundaryHandling_T>
BoundaryHandling_T & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling ( const BoundaryHandlingUID & uid)
inline

You most likely have to call this function via "collection.template getBoundaryHandling< BoundaryHandling_T >(uid)".

◆ getBoundaryHandling() [3/6]

template<typename FlagField_T, typename... Handlers>
template<typename BoundaryHandling_T>
const BoundaryHandling_T & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling ( const BoundaryHandlingUID & uid) const
inline

You most likely have to call this function via "collection.template getBoundaryHandling< BoundaryHandling_T >(uid)".

◆ getBoundaryHandling() [4/6]

template<typename FlagField_T, typename... Handlers>
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling ( const BoundaryHandlingUID & uid,
const HandlersTuple & boundaryHandlers ) const
inlineprivate

◆ getBoundaryHandling() [5/6]

template<typename FlagField_T, typename... Handlers>
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling ( const BoundaryHandlingUID & uid,
const HandlersTuple & boundaryHandlers ) const
inlineprivate

◆ getBoundaryHandling() [6/6]

template<typename FlagField_T, typename... Handlers>
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling ( const BoundaryHandlingUID & uid,
const HandlersTuple & boundaryHandlers ) const
inlineprivate

◆ getBoundaryHandling_TypeExists() [1/4]

template<typename FlagField_T, typename... Handlers>
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling_TypeExists ( const BoundaryHandlingUID & uid,
const HandlersTuple &  ) const
inlineprivate

◆ getBoundaryHandling_TypeExists() [2/4]

template<typename FlagField_T, typename... Handlers>
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling_TypeExists ( const BoundaryHandlingUID & uid,
const HandlersTuple & boundaryHandlers ) const
inlineprivate

◆ getBoundaryHandling_TypeExists() [3/4]

template<typename FlagField_T, typename... Handlers>
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling_TypeExists ( const BoundaryHandlingUID & uid,
const HandlersTuple & boundaryHandlers ) const
inlineprivate

◆ getBoundaryHandling_TypeExists() [4/4]

template<typename FlagField_T, typename... Handlers>
template<typename BoundaryHandling_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
const BoundaryHandling_T & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling_TypeExists ( const BoundaryHandlingUID & uid,
const HandlersTuple & boundaryHandlers ) const
inlineprivate

◆ getBoundaryMask() [1/3]

template<typename FlagField_T, typename... Handlers>
flag_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryMask ( const BoundaryUID & uid) const
inline

◆ getBoundaryMask() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
flag_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryMask ( const HandlersTuple & ,
const BoundaryUID &  ) const
inlineprivate

◆ getBoundaryMask() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
BoundaryHandlingCollection< FlagField_T, Handlers... >::flag_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryMask ( const HandlersTuple & boundaryHandlers,
const BoundaryUID & uid ) const
inlineprivate

◆ getBoundaryUID() [1/4]

template<typename FlagField_T, typename... Handlers>
BoundaryUID walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryUID ( const flag_t flag) const
inline

◆ getBoundaryUID() [2/4]

template<typename FlagField_T, typename... Handlers>
BoundaryUID walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryUID ( const FlagUID & flag) const
inline

◆ getBoundaryUID() [3/4]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
BoundaryUID walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryUID ( const HandlersTuple & ,
const flag_t  ) const
inlineprivate

◆ getBoundaryUID() [4/4]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
BoundaryUID walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryUID ( const HandlersTuple & boundaryHandlers,
const flag_t flag ) const
inlineprivate

◆ getBoundaryUIDs() [1/3]

template<typename FlagField_T, typename... Handlers>
std::vector< BoundaryUID > walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryUIDs ( ) const
inlineprivate

◆ getBoundaryUIDs() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryUIDs ( const HandlersTuple & ,
std::vector< BoundaryUID > &  ) const
inlineprivate

◆ getBoundaryUIDs() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryUIDs ( const HandlersTuple & boundaryHandlers,
std::vector< BoundaryUID > & uids ) const
inlineprivate

◆ getFlagField() [1/2]

template<typename FlagField_T, typename... Handlers>
FlagField_T * walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getFlagField ( )
inline

◆ getFlagField() [2/2]

template<typename FlagField_T, typename... Handlers>
const FlagField_T * walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getFlagField ( ) const
inline

◆ getFlagMapping()

template<typename FlagField_T, typename... Handlers>
std::map< std::string, flag_t > walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getFlagMapping ( ) const
inlineprivate

◆ getGhostLayerCellInterval()

template<typename FlagField_T, typename... Handlers>
CellInterval walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getGhostLayerCellInterval ( const uint_t numberOfGhostLayersToInclude) const
private

◆ getNeighborFlagMapping()

template<typename FlagField_T, typename... Handlers>
template<typename Buffer_T>
std::vector< flag_t > walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getNeighborFlagMapping ( Buffer_T & buffer,
const bool assumeIdenticalFlagMapping,
bool & identicalFlagMapping ) const
inlineprivate

◆ getPackingInterval()

template<typename FlagField_T, typename... Handlers>
CellInterval walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getPackingInterval ( stencil::Direction direction,
const uint_t numberOfLayers ) const
inlineprivate

◆ getUID()

template<typename FlagField_T, typename... Handlers>
const BoundaryHandlingCollectionUID & walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getUID ( ) const
inline

◆ getUnpackingInterval()

template<typename FlagField_T, typename... Handlers>
CellInterval walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getUnpackingInterval ( stencil::Direction direction,
const uint_t numberOfLayers ) const
inlineprivate

◆ isEmpty() [1/6]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::isEmpty ( const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z ) const
inline

◆ isEmpty() [2/6]

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::isEmpty ( const ConstFlagFieldBaseIterator & it) const
inline

◆ isEmpty() [3/6]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::isEmpty ( const HandlersTuple & ,
const cell_idx_t ,
const cell_idx_t ,
const cell_idx_t  ) const
inlineprivate

◆ isEmpty() [4/6]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::isEmpty ( const HandlersTuple & ,
const ConstFlagFieldBaseIterator &  ) const
inlineprivate

◆ isEmpty() [5/6]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::isEmpty ( const HandlersTuple & boundaryHandlers,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z ) const
inlineprivate

◆ isEmpty() [6/6]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::isEmpty ( const HandlersTuple & boundaryHandlers,
const ConstFlagFieldBaseIterator & it ) const
inlineprivate

◆ numberOfMatchingBoundaryHandlers() [1/3]

template<typename FlagField_T, typename... Handlers>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingBoundaryHandlers ( const BoundaryHandlingUID & uid) const
inlineprivate

◆ numberOfMatchingBoundaryHandlers() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingBoundaryHandlers ( const HandlersTuple & ,
const BoundaryHandlingUID &  ) const
inlineprivate

◆ numberOfMatchingBoundaryHandlers() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingBoundaryHandlers ( const HandlersTuple & boundaryHandlers,
const BoundaryHandlingUID & uid ) const
inlineprivate

◆ numberOfMatchingHandlers() [1/3]

template<typename FlagField_T, typename... Handlers>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingHandlers ( const flag_t flag) const
inline

◆ numberOfMatchingHandlers() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingHandlers ( const HandlersTuple & ,
const flag_t  ) const
inlineprivate

◆ numberOfMatchingHandlers() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingHandlers ( const HandlersTuple & boundaryHandlers,
const flag_t flag ) const
inlineprivate

◆ numberOfMatchingHandlersForBoundary() [1/3]

template<typename FlagField_T, typename... Handlers>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingHandlersForBoundary ( const flag_t flag) const
inline

◆ numberOfMatchingHandlersForBoundary() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingHandlersForBoundary ( const HandlersTuple & ,
const flag_t  ) const
inlineprivate

◆ numberOfMatchingHandlersForBoundary() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingHandlersForBoundary ( const HandlersTuple & boundaryHandlers,
const flag_t flag ) const
inlineprivate

◆ numberOfMatchingHandlersForDomain() [1/3]

template<typename FlagField_T, typename... Handlers>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingHandlersForDomain ( const flag_t flag) const
inline

◆ numberOfMatchingHandlersForDomain() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingHandlersForDomain ( const HandlersTuple & ,
const flag_t  ) const
inlineprivate

◆ numberOfMatchingHandlersForDomain() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
uint_t walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::numberOfMatchingHandlersForDomain ( const HandlersTuple & boundaryHandlers,
const flag_t flag ) const
inlineprivate

◆ operator!=()

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::operator!= ( const BoundaryHandlingCollection< FlagField_T, Handlers > & rhs) const
inline

◆ operator()() [1/4]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::operator() ( const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z )
inline

◆ operator()() [2/4]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::operator() ( const CellInterval & cells)
inline

◆ operator()() [3/4]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::operator() ( const CellIterator & begin,
const CellIterator & end )
inline

◆ operator()() [4/4]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::operator() ( const uint_t numberOfGhostLayersToInclude = 0)
inline

◆ operator==()

template<typename FlagField_T, typename... Handlers>
bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::operator== ( const BoundaryHandlingCollection< FlagField_T, Handlers > & ) const
inline

◆ pack() [1/3]

template<typename FlagField_T, typename... Handlers>
template<typename Buffer_T>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::pack ( Buffer_T & buffer,
stencil::Direction direction,
const uint_t numberOfLayers = 1,
const bool assumeIdenticalFlagMapping = true ) const

◆ pack() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename Buffer_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::pack ( const HandlersTuple & ,
Buffer_T & ,
const flag_t ,
const cell_idx_t ,
const cell_idx_t ,
const cell_idx_t  ) const
inlineprivate

◆ pack() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename Buffer_T, typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::pack ( const HandlersTuple & boundaryHandlers,
Buffer_T & buffer,
const flag_t mask,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z ) const
inlineprivate

◆ refresh() [1/4]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::refresh ( const CellInterval & cells)
inline

◆ refresh() [2/4]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::refresh ( const HandlersTuple & ,
const CellInterval &  ) const
inlineprivate

◆ refresh() [3/4]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::refresh ( const uint_t numberOfGhostLayersToInclude = 0)
inline

◆ refresh() [4/4]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::refresh ( HandlersTuple & boundaryHandlers,
const CellInterval & cells )
inlineprivate

◆ refreshOutermostLayer() [1/3]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::refreshOutermostLayer ( cell_idx_t thickness = 1)
inline

◆ refreshOutermostLayer() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::refreshOutermostLayer ( const HandlersTuple & ,
cell_idx_t  ) const
inlineprivate

◆ refreshOutermostLayer() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::refreshOutermostLayer ( HandlersTuple & boundaryHandlers,
cell_idx_t thickness )
inlineprivate

◆ removeFlag() [1/10]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::removeFlag ( const flag_t flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z )
inline

◆ removeFlag() [2/10]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::removeFlag ( const flag_t flag,
const CellInterval & cells )
inline

◆ removeFlag() [3/10]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::removeFlag ( const flag_t flag,
const CellIterator & begin,
const CellIterator & end )
inline

◆ removeFlag() [4/10]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::removeFlag ( const flag_t flag,
const uint_t numberOfGhostLayersToInclude = 0 )
inline

◆ removeFlag() [5/10]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::removeFlag ( const FlagUID & flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z )
inline

◆ removeFlag() [6/10]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::removeFlag ( const FlagUID & flag,
const CellInterval & cells )
inline

◆ removeFlag() [7/10]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::removeFlag ( const FlagUID & flag,
const CellIterator & begin,
const CellIterator & end )
inline

◆ removeFlag() [8/10]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::removeFlag ( const FlagUID & flag,
const uint_t numberOfGhostLayersToInclude = 0 )
inline

◆ removeFlag() [9/10]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::removeFlag ( const HandlersTuple & ,
const flag_t flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z )
inlineprivate

◆ removeFlag() [10/10]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::removeFlag ( HandlersTuple & boundaryHandlers,
const flag_t flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z )
private

◆ setFlag() [1/10]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::setFlag ( const flag_t flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ setFlag() [2/10]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::setFlag ( const flag_t flag,
const CellInterval & cells,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ setFlag() [3/10]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::setFlag ( const flag_t flag,
const CellIterator & begin,
const CellIterator & end,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ setFlag() [4/10]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::setFlag ( const FlagUID & flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ setFlag() [5/10]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::setFlag ( const FlagUID & flag,
const CellInterval & cells,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ setFlag() [6/10]

template<typename FlagField_T, typename... Handlers>
template<typename CellIterator>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::setFlag ( const FlagUID & flag,
const CellIterator & begin,
const CellIterator & end,
const BoundaryConfiguration & parameter = BoundaryConfiguration::null() )
inline

◆ setFlag() [7/10]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::setFlag ( const HandlersTuple & ,
const flag_t flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z,
const BoundaryConfiguration &  )
inlineprivate

◆ setFlag() [8/10]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::setFlag ( const HandlersTuple & ,
const flag_t flag,
const CellInterval & cells,
const BoundaryConfiguration &  )
inlineprivate

◆ setFlag() [9/10]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::setFlag ( HandlersTuple & boundaryHandlers,
const flag_t flag,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z,
const BoundaryConfiguration & parameter )
private

◆ setFlag() [10/10]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::setFlag ( HandlersTuple & boundaryHandlers,
const flag_t flag,
const CellInterval & cells,
const BoundaryConfiguration & parameter )
private

◆ toStream() [1/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::toStream ( const HandlersTuple & ,
std::ostream &  ) const
inlineprivate

◆ toStream() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::toStream ( const HandlersTuple & boundaryHandlers,
std::ostream & os ) const
inlineprivate

◆ toStream() [3/3]

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::toStream ( std::ostream & os) const
inline

◆ toString()

template<typename FlagField_T, typename... Handlers>
std::string walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::toString ( ) const
inline

◆ translateMask()

template<typename FlagField_T, typename... Handlers>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::translateMask ( flag_t & mask,
const std::vector< flag_t > & flagMapping ) const
inlineprivate

◆ unpack() [1/3]

template<typename FlagField_T, typename... Handlers>
template<typename Buffer_T>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::unpack ( Buffer_T & buffer,
stencil::Direction direction,
const uint_t numberOfLayers = 1,
const bool assumeIdenticalFlagMapping = true )

◆ unpack() [2/3]

template<typename FlagField_T, typename... Handlers>
template<typename Buffer_T, typename HandlersTuple, int N = std::tuple_size_v<HandlersTuple> - 1>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::unpack ( const HandlersTuple & ,
Buffer_T & ,
const flag_t ,
const cell_idx_t ,
const cell_idx_t ,
const cell_idx_t  ) const
inlineprivate

◆ unpack() [3/3]

template<typename FlagField_T, typename... Handlers>
template<typename Buffer_T, typename HandlersTuple, int N>
void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::unpack ( HandlersTuple & boundaryHandlers,
Buffer_T & buffer,
const flag_t mask,
const cell_idx_t x,
const cell_idx_t y,
const cell_idx_t z )
inlineprivate

Member Data Documentation

◆ boundaryHandlers_

template<typename FlagField_T, typename... Handlers>
Tuple walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::boundaryHandlers_
private

◆ flagField_

template<typename FlagField_T, typename... Handlers>
FlagField_T* const walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::flagField_
private

◆ outerBB_

template<typename FlagField_T, typename... Handlers>
const CellInterval walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::outerBB_
private

◆ uid_

template<typename FlagField_T, typename... Handlers>
const BoundaryHandlingCollectionUID walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::uid_
private
The documentation for this class was generated from the following file: