#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<HandlersTuple>::value - 1> requires ( N!=0 && std::is_same_v< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type > )
const BoundaryHandling_T &	getBoundaryHandling (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const

template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==0 && std::is_same_v< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type > )
const BoundaryHandling_T &	getBoundaryHandling (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const

template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=0 && std::is_same_v< typename std::is_same< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type >::type, std::false_type > )
const BoundaryHandling_T &	getBoundaryHandling (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const

template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==0 && std::is_same_v< typename std::is_same< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type >::type, std::false_type > )
const BoundaryHandling_T &	getBoundaryHandling (const BoundaryHandlingUID &, const HandlersTuple &) const

template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=0 && std::is_same_v< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type > )
const BoundaryHandling_T &	getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const

template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==0 && std::is_same_v< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type > )
const BoundaryHandling_T &	getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const

template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=0 && std::is_same_v< typename std::is_same< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type >::type, std::false_type > )
const BoundaryHandling_T &	getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &boundaryHandlers) const

template<typename BoundaryHandling_T , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==0 && std::is_same_v< typename std::is_same< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type >::type, std::false_type > )
const BoundaryHandling_T &	getBoundaryHandling_TypeExists (const BoundaryHandlingUID &uid, const HandlersTuple &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
void	checkForUniqueBoundaryHandlingUIDs (const HandlersTuple &boundaryHandlers) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
void	checkForUniqueBoundaryHandlingUIDs (const HandlersTuple &) const

std::vector< BoundaryUID >	getBoundaryUIDs () const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
void	getBoundaryUIDs (const HandlersTuple &boundaryHandlers, std::vector< BoundaryUID > &uids) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
void	getBoundaryUIDs (const HandlersTuple &, std::vector< BoundaryUID > &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
bool	checkForIdenticalFlagFields (const HandlersTuple &boundaryHandlers) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
bool	checkForIdenticalFlagFields (const HandlersTuple &) const

uint_t	numberOfMatchingBoundaryHandlers (const BoundaryHandlingUID &uid) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
uint_t	numberOfMatchingBoundaryHandlers (const HandlersTuple &boundaryHandlers, const BoundaryHandlingUID &uid) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
uint_t	numberOfMatchingBoundaryHandlers (const HandlersTuple &, const BoundaryHandlingUID &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
uint_t	numberOfMatchingHandlers (const HandlersTuple &boundaryHandlers, const flag_t flag) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
uint_t	numberOfMatchingHandlers (const HandlersTuple &, const flag_t) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
uint_t	numberOfMatchingHandlersForDomain (const HandlersTuple &boundaryHandlers, const flag_t flag) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
uint_t	numberOfMatchingHandlersForDomain (const HandlersTuple &, const flag_t) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
uint_t	numberOfMatchingHandlersForBoundary (const HandlersTuple &boundaryHandlers, const flag_t flag) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
uint_t	numberOfMatchingHandlersForBoundary (const HandlersTuple &, const flag_t) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
bool	containsBoundaryCondition (const HandlersTuple &boundaryHandlers, const BoundaryUID &uid) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
bool	containsBoundaryCondition (const HandlersTuple &, const BoundaryUID &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
bool	containsBoundaryCondition (const HandlersTuple &boundaryHandlers, const flag_t flag) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
bool	containsBoundaryCondition (const HandlersTuple &, const flag_t) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
flag_t	getBoundaryMask (const HandlersTuple &boundaryHandlers, const BoundaryUID &uid) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
flag_t	getBoundaryMask (const HandlersTuple &, const BoundaryUID &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
BoundaryUID	getBoundaryUID (const HandlersTuple &boundaryHandlers, const flag_t flag) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
BoundaryUID	getBoundaryUID (const HandlersTuple &, const flag_t) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
shared_ptr< BoundaryConfiguration >	createBoundaryConfiguration (const HandlersTuple &boundaryHandlers, const BoundaryUID &uid, const Config::BlockHandle &config) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
shared_ptr< BoundaryConfiguration >	createBoundaryConfiguration (const HandlersTuple &, const BoundaryUID &, const Config::BlockHandle &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
bool	checkConsistency (const HandlersTuple &boundaryHandlers, const CellInterval &cells) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
bool	checkConsistency (const HandlersTuple &, const CellInterval &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
void	refresh (HandlersTuple &boundaryHandlers, const CellInterval &cells)

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
void	refresh (const HandlersTuple &, const CellInterval &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
void	refreshOutermostLayer (HandlersTuple &boundaryHandlers, cell_idx_t thickness)

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
void	refreshOutermostLayer (const HandlersTuple &, cell_idx_t) const

General Flag Handling (private helper functions)
template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-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<HandlersTuple>::value - 1> requires ( N==-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<HandlersTuple>::value - 1> requires ( N!=-1 )
void	setFlag (HandlersTuple &boundaryHandlers, const flag_t flag, const CellInterval &cells, const BoundaryConfiguration &parameter)

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
void	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> requires ( N!=-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<HandlersTuple>::value - 1> requires ( N==-1 )
flag_t	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> requires ( N!=-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<HandlersTuple>::value - 1> requires ( N!=-1 )
void	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> requires ( N!=-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<HandlersTuple>::value - 1> requires ( N==-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<HandlersTuple>::value - 1> requires ( N!=-1 )
void	execute (HandlersTuple &boundaryHandlers, const uint_t numberOfGhostLayersToInclude)

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
void	execute (const HandlersTuple &, const uint_t) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-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<HandlersTuple>::value - 1> requires ( N==-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<HandlersTuple>::value - 1> requires ( N!=-1 )
void	execute (HandlersTuple &boundaryHandlers, const CellInterval &cells)

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
void	execute (const HandlersTuple &, const CellInterval &) const

template<typename CellIterator , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
void	execute (HandlersTuple &boundaryHandlers, const CellIterator &begin, const CellIterator &end)

template<typename CellIterator , typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
void	execute (const HandlersTuple &, const CellIterator &, const CellIterator &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
void	beforeBoundaryTreatment (HandlersTuple &boundaryHandlers)

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
void	beforeBoundaryTreatment (const HandlersTuple &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-1 )
void	afterBoundaryTreatment (HandlersTuple &boundaryHandlers)

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
void	afterBoundaryTreatment (const HandlersTuple &) 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> requires ( N!=-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<HandlersTuple>::value - 1> requires ( N==-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<HandlersTuple>::value - 1> requires ( N!=-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<HandlersTuple>::value - 1> requires ( N==-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<HandlersTuple>::value - 1> requires ( N!=-1 )
void	toStream (const HandlersTuple &boundaryHandlers, std::ostream &os) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
void	toStream (const HandlersTuple &, std::ostream &) 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> requires ( N!=-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<HandlersTuple>::value - 1> requires ( N==-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<HandlersTuple>::value - 1> requires ( N!=-1 )
bool	isEmpty (const HandlersTuple &boundaryHandlers, const ConstFlagFieldBaseIterator &it) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
bool	isEmpty (const HandlersTuple &, const ConstFlagFieldBaseIterator &) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N!=-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<HandlersTuple>::value - 1> requires ( N==-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<HandlersTuple>::value - 1> requires ( N!=-1 )
bool	consideredByAllHandlers (const HandlersTuple &boundaryHandlers, const ConstFlagFieldBaseIterator &it) const

template<typename HandlersTuple , int N = std::tuple_size<HandlersTuple>::value - 1> requires ( N==-1 )
bool	consideredByAllHandlers (const HandlersTuple &, const ConstFlagFieldBaseIterator &) 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>
requires ( N==-1 )

void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::afterBoundaryTreatment ( const HandlersTuple & ) const

inlineprivate

◆ afterBoundaryTreatment() [3/3]

template<typename FlagField_T , typename... Handlers>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-1 )

void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::beforeBoundaryTreatment ( const HandlersTuple & ) const

inlineprivate

◆ beforeBoundaryTreatment() [3/3]

template<typename FlagField_T , typename... Handlers>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-1 )

bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkConsistency	(	const HandlersTuple &	,
		const CellInterval &	) const

inlineprivate

◆ checkConsistency() [3/4]

template<typename FlagField_T , typename... Handlers>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-1 )

bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkForIdenticalFlagFields ( const HandlersTuple & ) const

inlineprivate

◆ checkForIdenticalFlagFields() [2/2]

template<typename FlagField_T , typename... Handlers>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-1 )

void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::checkForUniqueBoundaryHandlingUIDs ( const HandlersTuple & ) const

inlineprivate

◆ checkForUniqueBoundaryHandlingUIDs() [2/2]

template<typename FlagField_T , typename... Handlers>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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<HandlersTuple>::value - 1>
requires ( N==-1 )

bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::consideredByAllHandlers	(	const HandlersTuple &	,
		const ConstFlagFieldBaseIterator &	) const

inlineprivate

◆ consideredByAllHandlers() [7/9]

template<typename FlagField_T , typename... Handlers>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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<HandlersTuple>::value - 1>
requires ( N==-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<HandlersTuple>::value - 1>
requires ( N==-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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::execute	(	HandlersTuple &	boundaryHandlers,
		const CellInterval &	cells )

inlineprivate

◆ execute() [7/8]

template<typename FlagField_T , typename... Handlers>
requires ( N!=-1 )

template<typename CellIterator , typename HandlersTuple , int N>
requires ( N!=-1 )

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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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>

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>
requires ( N==0 && std::is_same_v< typename std::is_same< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type >::type, std::false_type > )

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<HandlersTuple>::value - 1>
requires ( N!=0 && std::is_same_v< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type > )

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<HandlersTuple>::value - 1>
requires ( N==0 && std::is_same_v< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type > )

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<HandlersTuple>::value - 1>
requires ( N!=0 && std::is_same_v< typename std::is_same< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type >::type, std::false_type > )

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<HandlersTuple>::value - 1>
requires ( N==0 && std::is_same_v< typename std::is_same< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type >::type, std::false_type > )

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<HandlersTuple>::value - 1>
requires ( N!=0 && std::is_same_v< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type > )

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<HandlersTuple>::value - 1>
requires ( N==0 && std::is_same_v< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type > )

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<HandlersTuple>::value - 1>
requires ( N!=0 && std::is_same_v< typename std::is_same< BoundaryHandling_T, typename std::tuple_element<N, HandlersTuple>::type >::type, std::false_type > )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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<HandlersTuple>::value - 1>
requires ( N==-1 )

bool walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::isEmpty	(	const HandlersTuple &	,
		const ConstFlagFieldBaseIterator &	) const

inlineprivate

◆ isEmpty() [5/6]

template<typename FlagField_T , typename... Handlers>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename Buffer_T , typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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>
requires ( N==-1 )

template<typename HandlersTuple , int N>
requires ( N==-1 )

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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-1 )

void walberla::boundary::BoundaryHandlingCollection< FlagField_T, Handlers >::toStream	(	const HandlersTuple &	,
		std::ostream &	) const

inlineprivate

◆ toStream() [2/3]

template<typename FlagField_T , typename... Handlers>
requires ( N!=-1 )

template<typename HandlersTuple , int N>
requires ( N!=-1 )

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<HandlersTuple>::value - 1>
requires ( N==-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>
requires ( N!=-1 )

template<typename Buffer_T , typename HandlersTuple , int N>
requires ( N!=-1 )

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:

/builds/administration/walberla-website/walberla/src/boundary/BoundaryHandlingCollection.h

Classes

Public Types

Public Member Functions

Private Member Functions

Pack / Unpack boundary handling (private helper functions)

Boundary Treatment

Pack / Unpack boundary handling collection

Member Typedef Documentation

◆ ConstFlagFieldBaseIterator

◆ flag_t

◆ FlagField

◆ Tuple

Constructor & Destructor Documentation

◆ BoundaryHandlingCollection()

Member Function Documentation

◆ afterBoundaryTreatment() [1/3]

◆ afterBoundaryTreatment() [2/3]

◆ afterBoundaryTreatment() [3/3]

◆ beforeBoundaryTreatment() [1/3]

◆ beforeBoundaryTreatment() [2/3]

◆ beforeBoundaryTreatment() [3/3]

◆ checkConsistency() [1/4]

◆ checkConsistency() [2/4]

◆ checkConsistency() [3/4]

◆ checkConsistency() [4/4]

◆ checkForIdenticalFlagFields() [1/2]

◆ checkForIdenticalFlagFields() [2/2]

◆ checkForUniqueBoundaryHandlingUIDs() [1/2]

◆ checkForUniqueBoundaryHandlingUIDs() [2/2]

◆ clear() [1/6]

◆ clear() [2/6]

◆ clear() [3/6]

◆ clear() [4/6]

◆ clear() [5/6]

◆ clear() [6/6]

◆ consideredByAllHandlers() [1/9]

◆ consideredByAllHandlers() [2/9]

◆ consideredByAllHandlers() [3/9]

◆ consideredByAllHandlers() [4/9]

◆ consideredByAllHandlers() [5/9]

◆ consideredByAllHandlers() [6/9]

◆ consideredByAllHandlers() [7/9]

◆ consideredByAllHandlers() [8/9]

◆ consideredByAllHandlers() [9/9]

◆ containsBoundaryCondition() [1/7]

◆ containsBoundaryCondition() [2/7]

◆ containsBoundaryCondition() [3/7]

◆ containsBoundaryCondition() [4/7]

◆ containsBoundaryCondition() [5/7]

◆ containsBoundaryCondition() [6/7]

◆ containsBoundaryCondition() [7/7]

◆ createBoundaryConfiguration() [1/3]

◆ createBoundaryConfiguration() [2/3]

◆ createBoundaryConfiguration() [3/3]

◆ execute() [1/8]

◆ execute() [2/8]

◆ execute() [3/8]

◆ execute() [4/8]

◆ execute() [5/8]

◆ execute() [6/8]

◆ execute() [7/8]

◆ execute() [8/8]

◆ flagsToRemove() [1/2]

◆ flagsToRemove() [2/2]

◆ forceFlag() [1/6]

◆ forceFlag() [2/6]

◆ forceFlag() [3/6]

◆ forceFlag() [4/6]

◆ forceFlag() [5/6]

◆ forceFlag() [6/6]

◆ forceFlagHelper()

◆ getBlockSweep()

◆ getBoundaryHandling() [1/6]

◆ getBoundaryHandling() [2/6]

◆ getBoundaryHandling() [3/6]

◆ getBoundaryHandling() [4/6]

◆ getBoundaryHandling() [5/6]

◆ getBoundaryHandling() [6/6]

◆ getBoundaryHandling_TypeExists() [1/4]

◆ getBoundaryHandling_TypeExists() [2/4]