Classes | Public Types | Public Member Functions | List of all members
walberla::boundary::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)". More...
 
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)". More...
 
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<HandlersTuple>::value - 1>
const std::enable_if<(N!=0), BoundaryHandling_T >::type & getBoundaryHandling (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers, typename std::enable_if< std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::value >::type *=0) const
 
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N==0), BoundaryHandling_T >::type & getBoundaryHandling (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers, typename std::enable_if< std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::value >::type *=0) const
 
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N!=0), BoundaryHandling_T >::type & getBoundaryHandling (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers, typename std::enable_if< std::is_same< typename std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::type, std::false_type >::value >::type *=0) const
 
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N==0), BoundaryHandling_T >::type & getBoundaryHandling (const BoundaryHandlingUID &, const HandlersTuple &, typename std::enable_if< std::is_same< typename std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::type, std::false_type >::value >::type *=0) const
 
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N!=0), BoundaryHandling_T >::type & getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers, typename std::enable_if< std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::value >::type *=0) const
 
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N==0), BoundaryHandling_T >::type & getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers, typename std::enable_if< std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::value >::type *=0) const
 
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N!=0), BoundaryHandling_T >::type & getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers, typename std::enable_if< std::is_same< typename std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::type, std::false_type >::value >::type *=0) const
 
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N==0), BoundaryHandling_T >::type & getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &, typename std::enable_if< std::is_same< typename std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::type, std::false_type >::value >::type *=0) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type checkForUniqueBoundaryHandlingUIDs (const HandlersTuple &boundaryHandlers) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type checkForUniqueBoundaryHandlingUIDs (const HandlersTuple &) const
 
std::vector< BoundaryUID > getBoundaryUIDs () const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type getBoundaryUIDs (const HandlersTuple &boundaryHandlers, std::vector< BoundaryUID > &uids) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type getBoundaryUIDs (const HandlersTuple &, std::vector< BoundaryUID > &) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), bool >::type checkForIdenticalFlagFields (const HandlersTuple &boundaryHandlers) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool >::type checkForIdenticalFlagFields (const HandlersTuple &) const
 
uint_t numberOfMatchingBoundaryHandlers (const BoundaryHandlingUID &uid) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), uint_t >::type numberOfMatchingBoundaryHandlers (const HandlersTuple &boundaryHandlers, const BoundaryHandlingUID &uid) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), uint_t >::type numberOfMatchingBoundaryHandlers (const HandlersTuple &, const BoundaryHandlingUID &) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), uint_t >::type numberOfMatchingHandlers (const HandlersTuple &boundaryHandlers, const flag_t flag) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), uint_t >::type numberOfMatchingHandlers (const HandlersTuple &, const flag_t) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), uint_t >::type numberOfMatchingHandlersForDomain (const HandlersTuple &boundaryHandlers, const flag_t flag) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), uint_t >::type numberOfMatchingHandlersForDomain (const HandlersTuple &, const flag_t) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), uint_t >::type numberOfMatchingHandlersForBoundary (const HandlersTuple &boundaryHandlers, const flag_t flag) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), uint_t >::type numberOfMatchingHandlersForBoundary (const HandlersTuple &, const flag_t) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), bool >::type containsBoundaryCondition (const HandlersTuple &boundaryHandlers, const BoundaryUID &uid) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool >::type containsBoundaryCondition (const HandlersTuple &, const BoundaryUID &) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), bool >::type containsBoundaryCondition (const HandlersTuple &boundaryHandlers, const flag_t flag) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool >::type containsBoundaryCondition (const HandlersTuple &, const flag_t) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), flag_t >::type getBoundaryMask (const HandlersTuple &boundaryHandlers, const BoundaryUID &uid) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), flag_t >::type getBoundaryMask (const HandlersTuple &, const BoundaryUID &) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), BoundaryUID >::type getBoundaryUID (const HandlersTuple &boundaryHandlers, const flag_t flag) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), BoundaryUID >::type getBoundaryUID (const HandlersTuple &, const flag_t) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), shared_ptr< BoundaryConfiguration > >::type createBoundaryConfiguration (const HandlersTuple &boundaryHandlers, const BoundaryUID &uid, const Config::BlockHandle &config) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), shared_ptr< BoundaryConfiguration > >::type createBoundaryConfiguration (const HandlersTuple &, const BoundaryUID &, const Config::BlockHandle &) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), bool >::type checkConsistency (const HandlersTuple &boundaryHandlers, const CellInterval &cells) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool >::type checkConsistency (const HandlersTuple &, const CellInterval &) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type refresh (HandlersTuple &boundaryHandlers, const CellInterval &cells)
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type refresh (const HandlersTuple &, const CellInterval &) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type refreshOutermostLayer (HandlersTuple &boundaryHandlers, cell_idx_t thickness)
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type refreshOutermostLayer (const HandlersTuple &, cell_idx_t) const
 
General Flag Handling (private helper functions)
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type setFlag (HandlersTuple &boundaryHandlers, const flag_t flag, const CellInterval &cells, const BoundaryConfiguration &parameter)
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type setFlag (const HandlersTuple &, const flag_t flag, const CellInterval &cells, const BoundaryConfiguration &)
 
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<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), flag_t >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), flag_t >::type flagsToRemove (const HandlersTuple &, const flag_t, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type removeFlag (const HandlersTuple &, const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
Clear Cells (private helper functions)
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), flag_t >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), flag_t >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type execute (HandlersTuple &boundaryHandlers, const uint_t numberOfGhostLayersToInclude)
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type execute (const HandlersTuple &, const uint_t) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type execute (const HandlersTuple &, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type execute (HandlersTuple &boundaryHandlers, const CellInterval &cells)
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type execute (const HandlersTuple &, const CellInterval &) const
 
template<typename CellIterator , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type execute (HandlersTuple &boundaryHandlers, const CellIterator &begin, const CellIterator &end)
 
template<typename CellIterator , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type execute (const HandlersTuple &, const CellIterator &, const CellIterator &) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type beforeBoundaryTreatment (HandlersTuple &boundaryHandlers)
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type beforeBoundaryTreatment (const HandlersTuple &) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type afterBoundaryTreatment (HandlersTuple &boundaryHandlers)
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type afterBoundaryTreatment (const HandlersTuple &) 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
 
CellInterval getGhostLayerCellInterval (const uint_t numberOfGhostLayersToInclude) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), bool >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool >::type isEmpty (const HandlersTuple &, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), bool >::type isEmpty (const HandlersTuple &boundaryHandlers, const ConstFlagFieldBaseIterator &it) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool >::type isEmpty (const HandlersTuple &, const ConstFlagFieldBaseIterator &) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), bool >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool >::type consideredByAllHandlers (const HandlersTuple &, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), bool >::type consideredByAllHandlers (const HandlersTuple &boundaryHandlers, const ConstFlagFieldBaseIterator &it) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool >::type consideredByAllHandlers (const HandlersTuple &, const ConstFlagFieldBaseIterator &) 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_
 
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
 
template<typename Buffer_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N!=-1), void >::type toStream (const HandlersTuple &boundaryHandlers, std::ostream &os) const
 
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void >::type toStream (const HandlersTuple &, std::ostream &) 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool>::type 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>
std::enable_if<(N!=-1), bool >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool>::type 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>
std::enable_if<(N!=-1), bool >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), flag_t>::type 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>
std::enable_if<(N!=-1), typename BoundaryHandlingCollection< FlagField_T, Handlers... >::flag_t >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool>::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool>::type 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>
std::enable_if<(N!=-1), bool >::type 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>
std::enable_if<(N!=-1), bool >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool>::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool>::type 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>
std::enable_if<(N!=-1), bool >::type 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>
std::enable_if<(N!=-1), bool >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), shared_ptr<BoundaryConfiguration> >::type 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>
std::enable_if<(N!=-1), shared_ptr< BoundaryConfiguration > >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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>
std::enable_if<(N!=-1), void >::type 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>
std::enable_if<(N!=-1), void >::type 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>
std::enable_if<(N!=-1), void >::type 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>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), flag_t>::type 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>
std::enable_if<(N!=-1), typename BoundaryHandlingCollection< FlagField_T, Handlers... >::flag_t >::type 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>
static 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<HandlersTuple>::value - 1>
const std::enable_if<(N==0), BoundaryHandling_T>::type& walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling ( const BoundaryHandlingUID &  ,
const HandlersTuple &  ,
typename std::enable_if< std::is_same< typename std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::type, std::false_type >::value >::type *  = 0 
) 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<HandlersTuple>::value - 1>
const std::enable_if<(N!=0), BoundaryHandling_T>::type& walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling ( const BoundaryHandlingUID &  uid,
const HandlersTuple &  boundaryHandlers,
typename std::enable_if< std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryHandling() [5/6]

template<typename FlagField_T , typename... Handlers>
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N==0), BoundaryHandling_T>::type& walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling ( const BoundaryHandlingUID &  uid,
const HandlersTuple &  boundaryHandlers,
typename std::enable_if< std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryHandling() [6/6]

template<typename FlagField_T , typename... Handlers>
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N!=0), BoundaryHandling_T>::type& walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling ( const BoundaryHandlingUID &  uid,
const HandlersTuple &  boundaryHandlers,
typename std::enable_if< std::is_same< typename std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::type, std::false_type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryHandling_TypeExists() [1/4]

template<typename FlagField_T , typename... Handlers>
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N==0), BoundaryHandling_T>::type& walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling_TypeExists ( const BoundaryHandlingUID &  uid,
const HandlersTuple &  ,
typename std::enable_if< std::is_same< typename std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::type, std::false_type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryHandling_TypeExists() [2/4]

template<typename FlagField_T , typename... Handlers>
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N!=0), BoundaryHandling_T>::type& walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling_TypeExists ( const BoundaryHandlingUID &  uid,
const HandlersTuple &  boundaryHandlers,
typename std::enable_if< std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryHandling_TypeExists() [3/4]

template<typename FlagField_T , typename... Handlers>
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N==0), BoundaryHandling_T>::type& walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling_TypeExists ( const BoundaryHandlingUID &  uid,
const HandlersTuple &  boundaryHandlers,
typename std::enable_if< std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryHandling_TypeExists() [4/4]

template<typename FlagField_T , typename... Handlers>
template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
const std::enable_if<(N!=0), BoundaryHandling_T>::type& walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::getBoundaryHandling_TypeExists ( const BoundaryHandlingUID &  uid,
const HandlersTuple &  boundaryHandlers,
typename std::enable_if< std::is_same< typename std::is_same< BoundaryHandling_T, typename std::tuple_element< N, HandlersTuple >::type >::type, std::false_type >::value >::type *  = 0 
) 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), flag_t>::type 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>
std::enable_if<(N!=-1), typename BoundaryHandlingCollection< FlagField_T, Handlers... >::flag_t >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), BoundaryUID>::type 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>
std::enable_if<(N==-1), BoundaryUID >::type 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
inlineprivate

◆ getBoundaryUIDs() [2/3]

template<typename FlagField_T , typename... Handlers>
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool>::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), bool>::type 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>
std::enable_if<(N!=-1), bool >::type 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>
std::enable_if<(N!=-1), bool >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), uint_t>::type 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>
std::enable_if<(N!=-1), uint_t >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), uint_t>::type 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>
std::enable_if<(N!=-1), uint_t >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), uint_t>::type 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>
std::enable_if<(N!=-1), uint_t >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), uint_t>::type 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>
std::enable_if<(N!=-1), uint_t >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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>
std::enable_if<(N!=-1), void >::type 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>
std::enable_if<(N==-1), void >::type 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>
std::enable_if<(N!=-1), void >::type 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>
std::enable_if<(N==-1), void >::type 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>
std::enable_if<(N==-1), void >::type 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>
std::enable_if<(N!=-1), void >::type 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>
std::enable_if<(N!=-1), void >::type 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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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>
std::enable_if<(N!=-1), void >::type 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
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<HandlersTuple>::value - 1>
std::enable_if<(N==-1), void>::type 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>
std::enable_if<(N!=-1), void >::type 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: