walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries > Class Template Reference

#include <BoundaryHandling.h>

Classes

class  BlockSweep
 

Public Types

enum  Mode { OPTIMIZED_SPARSE_TRAVERSAL, ENTIRE_FIELD_TRAVERSAL }
 
typedef FlagField_T FlagField
 
typedef FlagField_T::flag_t flag_t
 
typedef FlagField_T::const_base_iterator ConstFlagFieldBaseIterator
 

Public Member Functions

 BoundaryHandling (const std::string &identifier, FlagField_T *const flagField, const flag_t domain, const Boundaries &... boundaryConditions, const Mode mode)
 
 BoundaryHandling (const std::string &identifier, FlagField_T *const flagField, const flag_t domain, const Boundaries &... boundaryConditions)
 
bool operator== (const BoundaryHandling &rhs) const
 
bool operator!= (const BoundaryHandling &rhs) const
 
const BoundaryHandlingUIDgetUID () const
 
const FlagField_TgetFlagField () const
 
FlagField_TgetFlagField ()
 
flag_t getBoundaryMask () const
 
flag_t getDomainMask () const
 
bool isEmpty (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z) const
 
bool isNearBoundary (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z) const
 
bool isBoundary (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z) const
 
bool isDomain (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z) const
 
bool isEmpty (const Cell &cell) const
 
bool isNearBoundary (const Cell &cell) const
 
bool isBoundary (const Cell &cell) const
 
bool isDomain (const Cell &cell) const
 
bool isEmpty (const ConstFlagFieldBaseIterator &it) const
 
bool isNearBoundary (const ConstFlagFieldBaseIterator &it) const
 
bool isBoundary (const ConstFlagFieldBaseIterator &it) const
 
bool isDomain (const ConstFlagFieldBaseIterator &it) 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
 
template<typename Boundary_T >
const Boundary_T & getBoundaryCondition (const BoundaryUID &uid) const
 You most likely have to call this function via "handling.template getBoundaryCondition< Boundary_T >( uid )". More...
 
template<typename Boundary_T >
Boundary_T & getBoundaryCondition (const BoundaryUID &uid)
 You most likely have to call this function via "handling.template getBoundaryCondition< Boundary_T >( uid )". More...
 
BoundaryUID getBoundaryUID (const FlagUID &flag) const
 
BoundaryUID getBoundaryUID (const flag_t flag) const
 
uint_t numberOfMatchingBoundaryConditions (const flag_t mask) 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)
 
template<typename Buffer_T >
std::vector< typename BoundaryHandling< FlagField_T, Stencil, Boundaries... >::flag_tgetNeighborFlagMapping (Buffer_T &buffer, const bool assumeIdenticalFlagMapping, bool &identicalFlagMapping) const
 
Set Domain Cells
void setDomain (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void setDomain (const flag_t domainSubFlag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void setDomain (const CellInterval &cells)
 
void setDomain (const flag_t domainSubFlag, const CellInterval &cells)
 
template<typename CellIterator >
void setDomain (const CellIterator &begin, const CellIterator &end)
 
template<typename CellIterator >
void setDomain (const flag_t domainSubFlag, const CellIterator &begin, const CellIterator &end)
 
void forceDomain (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void forceDomain (const flag_t domainSubFlag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void forceDomain (const CellInterval &cells)
 
void forceDomain (const flag_t domainSubFlag, const CellInterval &cells)
 
template<typename CellIterator >
void forceDomain (const CellIterator &begin, const CellIterator &end)
 
template<typename CellIterator >
void forceDomain (const flag_t domainSubFlag, const CellIterator &begin, const CellIterator &end)
 
void fillWithDomain (const uint_t numberOfGhostLayersToInclude=0)
 
void fillWithDomain (const flag_t domainSubFlag, const uint_t numberOfGhostLayersToInclude)
 
void fillWithDomain (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void fillWithDomain (const flag_t domainSubFlag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void fillWithDomain (const CellInterval &cells)
 
void fillWithDomain (const flag_t domainSubFlag, const CellInterval &cells)
 
template<typename CellIterator >
void fillWithDomain (const CellIterator &begin, const CellIterator &end)
 
template<typename CellIterator >
void fillWithDomain (const flag_t domainSubFlag, const CellIterator &begin, const CellIterator &end)
 
Set Boundary Cells
shared_ptr< BoundaryConfigurationcreateBoundaryConfiguration (const BoundaryUID &uid, const Config::BlockHandle &config) const
 
void setBoundary (const FlagUID &flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
 
void setBoundary (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 setBoundary (const FlagUID &flag, const CellInterval &cells, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
 
void setBoundary (const flag_t flag, const CellInterval &cells, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
 
template<typename CellIterator >
void setBoundary (const FlagUID &flag, const CellIterator &begin, const CellIterator &end, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
 
template<typename CellIterator >
void setBoundary (const flag_t flag, const CellIterator &begin, const CellIterator &end, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
 
void forceBoundary (const FlagUID &flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
 
void forceBoundary (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 forceBoundary (const FlagUID &flag, const CellInterval &cells, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
 
void forceBoundary (const flag_t flag, const CellInterval &cells, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
 
template<typename CellIterator >
void forceBoundary (const FlagUID &flag, const CellIterator &begin, const CellIterator &end, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
 
template<typename CellIterator >
void forceBoundary (const flag_t flag, const CellIterator &begin, const CellIterator &end, const BoundaryConfiguration &parameter=BoundaryConfiguration::null())
 
Remove Domain Cells
void removeDomain (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void removeDomain (const flag_t mask, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void removeDomain (const uint_t numberOfGhostLayersToInclude=0)
 
void removeDomain (const CellInterval &cells)
 
void removeDomain (const flag_t mask, const CellInterval &cells)
 
template<typename CellIterator >
void removeDomain (const CellIterator &begin, const CellIterator &end)
 
template<typename CellIterator >
void removeDomain (const flag_t mask, const CellIterator &begin, const CellIterator &end)
 
Remove Boundary Cells
void removeBoundary (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void removeBoundary (const FlagUID &flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void removeBoundary (const flag_t mask, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
void removeBoundary (const uint_t numberOfGhostLayersToInclude=0)
 
void removeBoundary (const CellInterval &cells)
 
void removeBoundary (const FlagUID &flag, const CellInterval &cells)
 
void removeBoundary (const flag_t mask, const CellInterval &cells)
 
template<typename CellIterator >
void removeBoundary (const CellIterator &begin, const CellIterator &end)
 
template<typename CellIterator >
void removeBoundary (const FlagUID &flag, const CellIterator &begin, const CellIterator &end)
 
template<typename CellIterator >
void removeBoundary (const flag_t mask, const CellIterator &begin, const CellIterator &end)
 
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 Class (private helper functions)
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N!=0), Boundary_T >::type & getBoundaryCondition (const BoundaryUID &uid, const BoundariesTuple &boundaryConditions, typename std::enable_if< std::is_same< Boundary_T, typename std::tuple_element< N, BoundariesTuple >::type >::value >::type *=0) const
 
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N==0), Boundary_T >::type & getBoundaryCondition (const BoundaryUID &uid, const BoundariesTuple &boundaryConditions, typename std::enable_if< std::is_same< Boundary_T, typename std::tuple_element< N, BoundariesTuple >::type >::value >::type *=0) const
 
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N!=0), Boundary_T >::type & getBoundaryCondition (const BoundaryUID &uid, const BoundariesTuple &boundaryConditions, typename std::enable_if< std::is_same< typename std::is_same< Boundary_T, typename std::tuple_element< N, BoundariesTuple >::type >::type, std::false_type >::value >::type *=0, typename std::enable_if<(N >0) >::type *=0) const
 
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N==0), Boundary_T >::type & getBoundaryCondition (const BoundaryUID &, const BoundariesTuple &, typename std::enable_if< std::is_same< typename std::is_same< Boundary_T, typename std::tuple_element< 0, BoundariesTuple >::type >::type, std::false_type >::value >::type *=0) const
 
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N!=0), Boundary_T >::type & getBoundaryCondition_TypeExists (const BoundaryUID &uid, const BoundariesTuple &boundaryConditions, typename std::enable_if< std::is_same< Boundary_T, typename std::tuple_element< N, BoundariesTuple >::type >::value >::type *=0) const
 
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N==0), Boundary_T >::type & getBoundaryCondition_TypeExists (const BoundaryUID &uid, const BoundariesTuple &boundaryConditions, typename std::enable_if< std::is_same< Boundary_T, typename std::tuple_element< 0, BoundariesTuple >::type >::value >::type *=0) const
 
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N!=0), Boundary_T >::type & getBoundaryCondition_TypeExists (const BoundaryUID &uid, const BoundariesTuple &boundaryConditions, typename std::enable_if< std::is_same< typename std::is_same< Boundary_T, typename std::tuple_element< N, BoundariesTuple >::type >::type, std::false_type >::value >::type *=0) const
 
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N==0), Boundary_T >::type & getBoundaryCondition_TypeExists (const BoundaryUID &uid, const BoundariesTuple &, typename std::enable_if< std::is_same< typename std::is_same< Boundary_T, typename std::tuple_element< 0, BoundariesTuple >::type >::type, std::false_type >::value >::type *=0) const
 
uint_t numberOfMatchingBoundaryConditions (const BoundaryUID &uid) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), uint_t >::type numberOfMatchingBoundaryConditions (const BoundariesTuple &boundaryConditions, const BoundaryUID &uid) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), uint_t >::type numberOfMatchingBoundaryConditions (const BoundariesTuple &, const BoundaryUID &) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), uint_t >::type numberOfMatchingBoundaryConditions (const BoundariesTuple &boundaryConditions, const flag_t mask) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), uint_t >::type numberOfMatchingBoundaryConditions (const BoundariesTuple &, const flag_t) const
 
bool checkFlagField (const uint_t numberOfGhostLayersToInclude=0) const
 
void addDomain (const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const flag_t domain)
 
Set Boundary Cells (private helper functions)
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), shared_ptr< BoundaryConfiguration > >::type createBoundaryConfiguration (const BoundariesTuple &boundaryConditions, const BoundaryUID &uid, const Config::BlockHandle &config) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), shared_ptr< BoundaryConfiguration > >::type createBoundaryConfiguration (const BoundariesTuple &, const BoundaryUID &uid, const Config::BlockHandle &) const
 
void addNearBoundary (const CellInterval &cells)
 
void addBoundary (const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
template<typename BoundariesTuple , int N = internal::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type setBoundary (BoundariesTuple &boundaryConditions, const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const BoundaryConfiguration &parameter)
 
template<typename BoundariesTuple , int N = internal::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type setBoundary (const BoundariesTuple &, const flag_t, const cell_idx_t, const cell_idx_t, const cell_idx_t, const BoundaryConfiguration &) const
 
template<typename BoundariesTuple , int N = internal::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type setBoundary (BoundariesTuple &boundaryConditions, const flag_t flag, const CellInterval &cells, const BoundaryConfiguration &parameter)
 
template<typename BoundariesTuple , int N = internal::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type setBoundary (const BoundariesTuple &, const flag_t, const CellInterval &, const BoundaryConfiguration &) const
 
template<typename BoundariesTuple , int N = internal::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type setBoundary (BoundariesTuple &boundaryConditions, const flag_t flag, const CellVector &cells, const BoundaryConfiguration &parameter)
 
template<typename BoundariesTuple , int N = internal::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type setBoundary (const BoundariesTuple &, const flag_t, const CellVector &, const BoundaryConfiguration &) const
 
Remove Boundary Cells (private helper functions)
template<typename BoundariesTuple , int N = internal::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type removeBoundary (BoundariesTuple &boundaryConditions, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const bool checkNearBoundaryFlags=true)
 
template<typename BoundariesTuple , int N = internal::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type removeBoundary (const BoundariesTuple &, const cell_idx_t, const cell_idx_t, const cell_idx_t, const bool) const
 
Boundary Treatment (private helper functions)
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type treatDirection (BoundariesTuple &boundaryConditions, const uint_t index, const std::vector< std::vector< std::pair< Cell, stencil::Direction > > > &cellDirectionPairs)
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type treatDirection (const BoundariesTuple &, const uint_t, const std::vector< std::vector< std::pair< Cell, stencil::Direction > > > &) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type treatDirection (BoundariesTuple &boundaryConditions, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, const stencil::Direction dir, const cell_idx_t nx, const cell_idx_t ny, const cell_idx_t nz)
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type treatDirection (const BoundariesTuple &, const cell_idx_t, const cell_idx_t, const cell_idx_t, const stencil::Direction, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type beforeBoundaryTreatment (BoundariesTuple &boundaryConditions)
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type beforeBoundaryTreatment (const BoundariesTuple &) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type afterBoundaryTreatment (BoundariesTuple &boundaryConditions)
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type afterBoundaryTreatment (const BoundariesTuple &) const
 

Friends

template<typename F , typename... T>
class BoundaryHandlingCollection
 

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

template<typename Buffer_T >
void pack (Buffer_T &buffer, const CellInterval &interval, const bool assumeIdenticalFlagMapping=true) const
 
template<typename Buffer_T >
void unpack (Buffer_T &buffer, const CellInterval &interval, const bool assumeIdenticalFlagMapping=true)
 
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 BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type setupBoundaryConditions (BoundariesTuple &boundaryConditions)
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type setupBoundaryConditions (const BoundariesTuple &) const
 
std::vector< BoundaryUIDgetBoundaryUIDs () const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type getBoundaryUIDs (const BoundariesTuple &boundaryConditions, std::vector< BoundaryUID > &uids) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type getBoundaryUIDs (const BoundariesTuple &, std::vector< BoundaryUID > &) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), BoundaryUID >::type getBoundaryUID (const BoundariesTuple &boundaryConditions, const flag_t flag) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), BoundaryUID >::type getBoundaryUID (const BoundariesTuple &, const flag_t flagUID) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), bool >::type containsBoundaryCondition (const BoundariesTuple &boundaryConditions, const BoundaryUID &uid) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), bool >::type containsBoundaryCondition (const BoundariesTuple &, const BoundaryUID &) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), flag_t >::type getBoundaryMask (const BoundariesTuple &boundaryConditions, const BoundaryUID &uid) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), flag_t >::type getBoundaryMask (const BoundariesTuple &, const BoundaryUID &) const
 

Pack / Unpack boundary handling (private helper functions)

typedef std::tuple< Boundaries... > Tuple
 
const BoundaryHandlingUID uid_
 
FlagField_T *const flagField_
 
const CellInterval innerBB_
 
const CellInterval outerBB_
 
const flag_t nearBoundary_
 
flag_t boundary_
 
const flag_t domain_
 
const Mode mode_
 
bool dirty_
 Every time "near boundary" flags are set or removed, dirty_ is set to true. More...
 
std::vector< flag_tbcMaskMapping_
 
std::vector< bool > rebuildCellDirectionPairs_
 
std::vector< std::vector< std::vector< std::pair< Cell, stencil::Direction > > > > cellDirectionPairs_
 
Tuple boundaryConditions_
 
bool threadSafeBCs_
 
std::map< std::string, flag_tgetFlagMapping () const
 
template<typename Buffer_T >
std::vector< flag_tgetNeighborFlagMapping (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 >
void pack (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 BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type pack (const BoundariesTuple &boundaryConditions, 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 BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type pack (const BoundariesTuple &, Buffer_T &, const flag_t, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
 
template<typename Buffer_T >
void unpack (Buffer_T &buffer, const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
template<typename Buffer_T >
void unpackBoundary (Buffer_T &buffer, const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
template<typename Buffer_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type unpackBoundary (BoundariesTuple &boundaryConditions, Buffer_T &buffer, const flag_t flag, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z)
 
template<typename Buffer_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type unpackBoundary (const BoundariesTuple &, Buffer_T &, const flag_t, const cell_idx_t, const cell_idx_t, const cell_idx_t) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N!=-1), void >::type getBoundaryConditions (const BoundariesTuple &boundaryConditions, std::vector< std::string > &bcs) const
 
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void >::type getBoundaryConditions (const BoundariesTuple &, std::vector< std::string > &) const
 
template<typename T >
static void valueToStream (std::ostream &os, const T value)
 
static void valueToStream (std::ostream &os, const int8_t value)
 
static void valueToStream (std::ostream &os, const uint8_t value)
 

Member Typedef Documentation

◆ ConstFlagFieldBaseIterator

template<typename FlagField_T , typename Stencil , typename... Boundaries>
typedef FlagField_T::const_base_iterator walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::ConstFlagFieldBaseIterator

◆ flag_t

template<typename FlagField_T , typename Stencil , typename... Boundaries>
typedef FlagField_T::flag_t walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::flag_t

◆ FlagField

template<typename FlagField_T , typename Stencil , typename... Boundaries>
typedef FlagField_T walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::FlagField

◆ Tuple

template<typename FlagField_T , typename Stencil , typename... Boundaries>
typedef std::tuple<Boundaries...> walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::Tuple
private

Member Enumeration Documentation

◆ Mode

template<typename FlagField_T , typename Stencil , typename... Boundaries>
enum walberla::boundary::BoundaryHandling::Mode
Enumerator
OPTIMIZED_SPARSE_TRAVERSAL 
ENTIRE_FIELD_TRAVERSAL 

Constructor & Destructor Documentation

◆ BoundaryHandling() [1/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::BoundaryHandling ( const std::string &  identifier,
FlagField_T *const  flagField,
const flag_t  domain,
const Boundaries &...  boundaryConditions,
const Mode  mode 
)

◆ BoundaryHandling() [2/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::BoundaryHandling ( const std::string &  identifier,
FlagField_T *const  flagField,
const flag_t  domain,
const Boundaries &...  boundaryConditions 
)
inline

Member Function Documentation

◆ addBoundary()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::addBoundary ( const flag_t  flag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inlineprivate

◆ addDomain()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::addDomain ( const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z,
const flag_t  domain 
)
inlineprivate

◆ addNearBoundary()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::addNearBoundary ( const CellInterval cells)
inlineprivate

◆ afterBoundaryTreatment() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::afterBoundaryTreatment ( )
inline

◆ afterBoundaryTreatment() [2/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::afterBoundaryTreatment ( BoundariesTuple &  boundaryConditions)
inlineprivate

◆ afterBoundaryTreatment() [3/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::afterBoundaryTreatment ( const BoundariesTuple &  ) const
inlineprivate

◆ beforeBoundaryTreatment() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::beforeBoundaryTreatment ( )
inline

◆ beforeBoundaryTreatment() [2/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::beforeBoundaryTreatment ( BoundariesTuple &  boundaryConditions)
inlineprivate

◆ beforeBoundaryTreatment() [3/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::beforeBoundaryTreatment ( const BoundariesTuple &  ) const
inlineprivate

◆ checkConsistency() [1/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::checkConsistency ( const CellInterval cells) const

◆ checkConsistency() [2/2]

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

◆ checkFlagField()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::checkFlagField ( const uint_t  numberOfGhostLayersToInclude = 0) const
inlineprivate

◆ clear() [1/4]

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

◆ clear() [2/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::clear ( const CellInterval cells)
inline

◆ clear() [3/4]

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

◆ clear() [4/4]

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

◆ containsBoundaryCondition() [1/5]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), bool>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::containsBoundaryCondition ( const BoundariesTuple &  ,
const BoundaryUID  
) const
inlineprivate

◆ containsBoundaryCondition() [2/5]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), bool >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::containsBoundaryCondition ( const BoundariesTuple &  boundaryConditions,
const BoundaryUID uid 
) const
inlineprivate

◆ containsBoundaryCondition() [3/5]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::containsBoundaryCondition ( const BoundaryUID uid) const
inline

◆ containsBoundaryCondition() [4/5]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::containsBoundaryCondition ( const flag_t  flag) const
inline

◆ containsBoundaryCondition() [5/5]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::containsBoundaryCondition ( const FlagUID &  flag) const
inline

◆ createBoundaryConfiguration() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), shared_ptr<BoundaryConfiguration> >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::createBoundaryConfiguration ( const BoundariesTuple &  ,
const BoundaryUID uid,
const Config::BlockHandle  
) const
inlineprivate

◆ createBoundaryConfiguration() [2/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N==-1), shared_ptr< BoundaryConfiguration > >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::createBoundaryConfiguration ( const BoundariesTuple &  boundaryConditions,
const BoundaryUID uid,
const Config::BlockHandle config 
) const
inlineprivate

◆ createBoundaryConfiguration() [3/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
shared_ptr< BoundaryConfiguration > walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::createBoundaryConfiguration ( const BoundaryUID uid,
const Config::BlockHandle config 
) const
inline

◆ fillWithDomain() [1/8]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::fillWithDomain ( const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ fillWithDomain() [2/8]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::fillWithDomain ( const CellInterval cells)
inline

◆ fillWithDomain() [3/8]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::fillWithDomain ( const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ fillWithDomain() [4/8]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::fillWithDomain ( const flag_t  domainSubFlag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ fillWithDomain() [5/8]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::fillWithDomain ( const flag_t  domainSubFlag,
const CellInterval cells 
)
inline

◆ fillWithDomain() [6/8]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::fillWithDomain ( const flag_t  domainSubFlag,
const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ fillWithDomain() [7/8]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::fillWithDomain ( const flag_t  domainSubFlag,
const uint_t  numberOfGhostLayersToInclude 
)
inline

◆ fillWithDomain() [8/8]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::fillWithDomain ( const uint_t  numberOfGhostLayersToInclude = 0)
inline

◆ forceBoundary() [1/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceBoundary ( 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

◆ forceBoundary() [2/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceBoundary ( const flag_t  flag,
const CellInterval cells,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ forceBoundary() [3/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceBoundary ( const flag_t  flag,
const CellIterator &  begin,
const CellIterator &  end,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ forceBoundary() [4/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceBoundary ( const FlagUID &  flag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ forceBoundary() [5/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceBoundary ( const FlagUID &  flag,
const CellInterval cells,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ forceBoundary() [6/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceBoundary ( const FlagUID &  flag,
const CellIterator &  begin,
const CellIterator &  end,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ forceDomain() [1/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceDomain ( const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ forceDomain() [2/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceDomain ( const CellInterval cells)
inline

◆ forceDomain() [3/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceDomain ( const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ forceDomain() [4/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceDomain ( const flag_t  domainSubFlag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ forceDomain() [5/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceDomain ( const flag_t  domainSubFlag,
const CellInterval cells 
)
inline

◆ forceDomain() [6/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceDomain ( const flag_t  domainSubFlag,
const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ forceFlag() [1/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::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 Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceFlag ( const flag_t  flag,
const CellInterval cells,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ forceFlag() [3/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::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 Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::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 Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::forceFlag ( const FlagUID &  flag,
const CellInterval cells,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ forceFlag() [6/6]

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

◆ getBlockSweep()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
static BlockSweep walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBlockSweep ( const BlockDataID  handling,
const uint_t  numberOfGhostLayersToInclude = 0 
)
inlinestatic

◆ getBoundaryCondition() [1/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N==0), Boundary_T>::type& walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryCondition ( const BoundaryUID ,
const BoundariesTuple &  ,
typename std::enable_if< std::is_same< typename std::is_same< Boundary_T, typename std::tuple_element< 0, BoundariesTuple >::type >::type, std::false_type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryCondition() [2/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Boundary_T >
Boundary_T & walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryCondition ( const BoundaryUID uid)
inline

You most likely have to call this function via "handling.template getBoundaryCondition< Boundary_T >( uid )".

◆ getBoundaryCondition() [3/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Boundary_T >
const Boundary_T & walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryCondition ( const BoundaryUID uid) const
inline

You most likely have to call this function via "handling.template getBoundaryCondition< Boundary_T >( uid )".

◆ getBoundaryCondition() [4/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N!=0), Boundary_T>::type& walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryCondition ( const BoundaryUID uid,
const BoundariesTuple &  boundaryConditions,
typename std::enable_if< std::is_same< Boundary_T, typename std::tuple_element< N, BoundariesTuple >::type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryCondition() [5/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N==0), Boundary_T>::type& walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryCondition ( const BoundaryUID uid,
const BoundariesTuple &  boundaryConditions,
typename std::enable_if< std::is_same< Boundary_T, typename std::tuple_element< N, BoundariesTuple >::type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryCondition() [6/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N!=0), Boundary_T>::type& walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryCondition ( const BoundaryUID uid,
const BoundariesTuple &  boundaryConditions,
typename std::enable_if< std::is_same< typename std::is_same< Boundary_T, typename std::tuple_element< N, BoundariesTuple >::type >::type, std::false_type >::value >::type *  = 0,
typename std::enable_if<(N >0) >::type *  = 0 
) const
inlineprivate

◆ getBoundaryCondition_TypeExists() [1/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N==0), Boundary_T>::type& walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryCondition_TypeExists ( const BoundaryUID uid,
const BoundariesTuple &  ,
typename std::enable_if< std::is_same< typename std::is_same< Boundary_T, typename std::tuple_element< 0, BoundariesTuple >::type >::type, std::false_type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryCondition_TypeExists() [2/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N==0), Boundary_T>::type& walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryCondition_TypeExists ( const BoundaryUID uid,
const BoundariesTuple &  boundaryConditions,
typename std::enable_if< std::is_same< Boundary_T, typename std::tuple_element< 0, BoundariesTuple >::type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryCondition_TypeExists() [3/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N!=0), Boundary_T>::type& walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryCondition_TypeExists ( const BoundaryUID uid,
const BoundariesTuple &  boundaryConditions,
typename std::enable_if< std::is_same< Boundary_T, typename std::tuple_element< N, BoundariesTuple >::type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryCondition_TypeExists() [4/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Boundary_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
const std::enable_if<(N!=0), Boundary_T>::type& walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryCondition_TypeExists ( const BoundaryUID uid,
const BoundariesTuple &  boundaryConditions,
typename std::enable_if< std::is_same< typename std::is_same< Boundary_T, typename std::tuple_element< N, BoundariesTuple >::type >::type, std::false_type >::value >::type *  = 0 
) const
inlineprivate

◆ getBoundaryConditions() [1/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryConditions ( const BoundariesTuple &  ,
std::vector< std::string > &   
) const
inlineprivate

◆ getBoundaryConditions() [2/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryConditions ( const BoundariesTuple &  boundaryConditions,
std::vector< std::string > &  bcs 
) const
private

◆ getBoundaryMask() [1/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
flag_t walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryMask ( ) const
inline

◆ getBoundaryMask() [2/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), flag_t>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryMask ( const BoundariesTuple &  ,
const BoundaryUID  
) const
inlineprivate

◆ getBoundaryMask() [3/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), typename BoundaryHandling< FlagField_T, Stencil, Boundaries... >::flag_t >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryMask ( const BoundariesTuple &  boundaryConditions,
const BoundaryUID uid 
) const
inlineprivate

◆ getBoundaryMask() [4/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
flag_t walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryMask ( const BoundaryUID uid) const
inline

◆ getBoundaryUID() [1/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), BoundaryUID>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryUID ( const BoundariesTuple &  ,
const flag_t  flagUID 
) const
inlineprivate

◆ getBoundaryUID() [2/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N==-1), BoundaryUID >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryUID ( const BoundariesTuple &  boundaryConditions,
const flag_t  flag 
) const
inlineprivate

◆ getBoundaryUID() [3/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
BoundaryUID walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryUID ( const flag_t  flag) const
inline

◆ getBoundaryUID() [4/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
BoundaryUID walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryUID ( const FlagUID &  flag) const
inline

◆ getBoundaryUIDs() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
std::vector< BoundaryUID > walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryUIDs
inlineprivate

◆ getBoundaryUIDs() [2/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryUIDs ( const BoundariesTuple &  ,
std::vector< BoundaryUID > &   
) const
inlineprivate

◆ getBoundaryUIDs() [3/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getBoundaryUIDs ( const BoundariesTuple &  boundaryConditions,
std::vector< BoundaryUID > &  uids 
) const
inlineprivate

◆ getDomainMask()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
flag_t walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getDomainMask ( ) const
inline

◆ getFlagField() [1/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
FlagField_T* walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getFlagField ( )
inline

◆ getFlagField() [2/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
const FlagField_T* walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getFlagField ( ) const
inline

◆ getFlagMapping()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
std::map< std::string, typename BoundaryHandling< FlagField_T, Stencil, Boundaries... >::flag_t > walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getFlagMapping
inlineprivate

◆ getGhostLayerCellInterval()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
CellInterval walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getGhostLayerCellInterval ( const uint_t  numberOfGhostLayersToInclude) const
private

◆ getNeighborFlagMapping() [1/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T >
std::vector< flag_t > walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getNeighborFlagMapping ( Buffer_T &  buffer,
const bool  assumeIdenticalFlagMapping,
bool &  identicalFlagMapping 
) const
private

◆ getNeighborFlagMapping() [2/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T >
std::vector< typename BoundaryHandling< FlagField_T, Stencil, Boundaries... >::flag_t > walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getNeighborFlagMapping ( Buffer_T &  buffer,
const bool  assumeIdenticalFlagMapping,
bool &  identicalFlagMapping 
) const

◆ getPackingInterval()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
CellInterval walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getPackingInterval ( stencil::Direction  direction,
const uint_t  numberOfLayers 
) const
private

◆ getUID()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
const BoundaryHandlingUID& walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getUID ( ) const
inline

◆ getUnpackingInterval()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
CellInterval walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::getUnpackingInterval ( stencil::Direction  direction,
const uint_t  numberOfLayers 
) const
private

◆ isBoundary() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isBoundary ( const Cell cell) const
inline

◆ isBoundary() [2/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isBoundary ( const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
) const
inline

◆ isBoundary() [3/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isBoundary ( const ConstFlagFieldBaseIterator it) const
inline

◆ isDomain() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isDomain ( const Cell cell) const
inline

◆ isDomain() [2/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isDomain ( const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
) const
inline

◆ isDomain() [3/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isDomain ( const ConstFlagFieldBaseIterator it) const
inline

◆ isEmpty() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isEmpty ( const Cell cell) const
inline

◆ isEmpty() [2/3]

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

◆ isEmpty() [3/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isEmpty ( const ConstFlagFieldBaseIterator it) const
inline

◆ isNearBoundary() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isNearBoundary ( const Cell cell) const
inline

◆ isNearBoundary() [2/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isNearBoundary ( const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
) const
inline

◆ isNearBoundary() [3/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::isNearBoundary ( const ConstFlagFieldBaseIterator it) const
inline

◆ numberOfMatchingBoundaryConditions() [1/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), uint_t>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::numberOfMatchingBoundaryConditions ( const BoundariesTuple &  ,
const BoundaryUID  
) const
inlineprivate

◆ numberOfMatchingBoundaryConditions() [2/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), uint_t>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::numberOfMatchingBoundaryConditions ( const BoundariesTuple &  ,
const  flag_t 
) const
inlineprivate

◆ numberOfMatchingBoundaryConditions() [3/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), uint_t >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::numberOfMatchingBoundaryConditions ( const BoundariesTuple &  boundaryConditions,
const BoundaryUID uid 
) const
inlineprivate

◆ numberOfMatchingBoundaryConditions() [4/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), uint_t >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::numberOfMatchingBoundaryConditions ( const BoundariesTuple &  boundaryConditions,
const flag_t  mask 
) const
inlineprivate

◆ numberOfMatchingBoundaryConditions() [5/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
uint_t walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::numberOfMatchingBoundaryConditions ( const BoundaryUID uid) const
inlineprivate

◆ numberOfMatchingBoundaryConditions() [6/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
uint_t walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::numberOfMatchingBoundaryConditions ( const flag_t  mask) const
inline

◆ operator!=()

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

◆ operator()() [1/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::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 Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::operator() ( const CellInterval cells)
inline

◆ operator()() [3/4]

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

◆ operator()() [4/4]

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

◆ operator==()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::operator== ( const BoundaryHandling< FlagField_T, Stencil, Boundaries > &  rhs) const
inline

◆ pack() [1/5]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::pack ( Buffer_T &  buffer,
const CellInterval interval,
const bool  assumeIdenticalFlagMapping = true 
) const

◆ pack() [2/5]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::pack ( Buffer_T &  buffer,
const flag_t  mask,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
) const
inlineprivate

◆ pack() [3/5]

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

◆ pack() [4/5]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::pack ( const BoundariesTuple &  ,
Buffer_T &  ,
const  flag_t,
const  cell_idx_t,
const  cell_idx_t,
const  cell_idx_t 
) const
inlineprivate

◆ pack() [5/5]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T , typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::pack ( const BoundariesTuple &  boundaryConditions,
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/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::refresh ( const CellInterval cells)

◆ refresh() [2/2]

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

◆ refreshOutermostLayer()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::refreshOutermostLayer ( cell_idx_t  thickness = 1)

◆ removeBoundary() [1/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( BoundariesTuple &  boundaryConditions,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z,
const bool  checkNearBoundaryFlags = true 
)
inlineprivate

◆ removeBoundary() [2/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = internal::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const BoundariesTuple &  ,
const  cell_idx_t,
const  cell_idx_t,
const  cell_idx_t,
const bool   
) const
inlineprivate

◆ removeBoundary() [3/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ removeBoundary() [4/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const CellInterval cells)
inline

◆ removeBoundary() [5/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ removeBoundary() [6/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const flag_t  mask,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ removeBoundary() [7/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const flag_t  mask,
const CellInterval cells 
)
inline

◆ removeBoundary() [8/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const flag_t  mask,
const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ removeBoundary() [9/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const FlagUID &  flag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ removeBoundary() [10/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const FlagUID &  flag,
const CellInterval cells 
)
inline

◆ removeBoundary() [11/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const FlagUID &  flag,
const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ removeBoundary() [12/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeBoundary ( const uint_t  numberOfGhostLayersToInclude = 0)
inline

◆ removeDomain() [1/7]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeDomain ( const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ removeDomain() [2/7]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeDomain ( const CellInterval cells)
inline

◆ removeDomain() [3/7]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeDomain ( const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ removeDomain() [4/7]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeDomain ( const flag_t  mask,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ removeDomain() [5/7]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeDomain ( const flag_t  mask,
const CellInterval cells 
)
inline

◆ removeDomain() [6/7]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeDomain ( const flag_t  mask,
const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ removeDomain() [7/7]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeDomain ( const uint_t  numberOfGhostLayersToInclude = 0)
inline

◆ removeFlag() [1/8]

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

◆ removeFlag() [2/8]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::removeFlag ( const flag_t  flag,
const CellInterval cells 
)
inline

◆ removeFlag() [3/8]

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

◆ removeFlag() [4/8]

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

◆ removeFlag() [5/8]

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

◆ removeFlag() [6/8]

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

◆ removeFlag() [7/8]

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

◆ removeFlag() [8/8]

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

◆ setBoundary() [1/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( BoundariesTuple &  boundaryConditions,
const flag_t  flag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z,
const BoundaryConfiguration parameter 
)
inlineprivate

◆ setBoundary() [2/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( BoundariesTuple &  boundaryConditions,
const flag_t  flag,
const CellInterval cells,
const BoundaryConfiguration parameter 
)
inlineprivate

◆ setBoundary() [3/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( BoundariesTuple &  boundaryConditions,
const flag_t  flag,
const CellVector cells,
const BoundaryConfiguration parameter 
)
inlineprivate

◆ setBoundary() [4/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N==-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( const BoundariesTuple &  ,
const flag_t  flag,
const  cell_idx_t,
const  cell_idx_t,
const  cell_idx_t,
const BoundaryConfiguration  
) const
inlineprivate

◆ setBoundary() [5/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N==-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( const BoundariesTuple &  ,
const flag_t  flag,
const CellInterval ,
const BoundaryConfiguration  
) const
inlineprivate

◆ setBoundary() [6/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N==-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( const BoundariesTuple &  ,
const flag_t  flag,
const CellVector ,
const BoundaryConfiguration  
) const
inlineprivate

◆ setBoundary() [7/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( 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

◆ setBoundary() [8/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( const flag_t  flag,
const CellInterval cells,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ setBoundary() [9/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( const flag_t  flag,
const CellIterator &  begin,
const CellIterator &  end,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ setBoundary() [10/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( const FlagUID &  flag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ setBoundary() [11/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( const FlagUID &  flag,
const CellInterval cells,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ setBoundary() [12/12]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setBoundary ( const FlagUID &  flag,
const CellIterator &  begin,
const CellIterator &  end,
const BoundaryConfiguration parameter = BoundaryConfiguration::null() 
)
inline

◆ setDomain() [1/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setDomain ( const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ setDomain() [2/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setDomain ( const CellInterval cells)
inline

◆ setDomain() [3/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setDomain ( const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ setDomain() [4/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setDomain ( const flag_t  domainSubFlag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inline

◆ setDomain() [5/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setDomain ( const flag_t  domainSubFlag,
const CellInterval cells 
)
inline

◆ setDomain() [6/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename CellIterator >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setDomain ( const flag_t  domainSubFlag,
const CellIterator &  begin,
const CellIterator &  end 
)
inline

◆ setFlag() [1/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::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/6]

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

◆ setFlag() [3/6]

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

◆ setFlag() [4/6]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::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/6]

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

◆ setFlag() [6/6]

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

◆ setupBoundaryConditions() [1/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setupBoundaryConditions ( BoundariesTuple &  boundaryConditions)
private

◆ setupBoundaryConditions() [2/2]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::setupBoundaryConditions ( const BoundariesTuple &  ) const
inlineprivate

◆ toStream()

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

◆ toString()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
std::string walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::toString
inline

◆ translateMask()

template<typename FlagField_T , typename Stencil , typename... Boundaries>
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::translateMask ( flag_t mask,
const std::vector< flag_t > &  flagMapping 
) const
private

◆ treatDirection() [1/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::treatDirection ( BoundariesTuple &  boundaryConditions,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z,
const stencil::Direction  dir,
const cell_idx_t  nx,
const cell_idx_t  ny,
const cell_idx_t  nz 
)
inlineprivate

◆ treatDirection() [2/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::treatDirection ( BoundariesTuple &  boundaryConditions,
const uint_t  index,
const std::vector< std::vector< std::pair< Cell, stencil::Direction > > > &  cellDirectionPairs 
)
inlineprivate

◆ treatDirection() [3/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::treatDirection ( const BoundariesTuple &  ,
const  cell_idx_t,
const  cell_idx_t,
const  cell_idx_t,
const stencil::Direction  ,
const  cell_idx_t,
const  cell_idx_t,
const  cell_idx_t 
) const
inlineprivate

◆ treatDirection() [4/4]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::treatDirection ( const BoundariesTuple &  ,
const  uint_t,
const std::vector< std::vector< std::pair< Cell, stencil::Direction > > > &   
) const
inlineprivate

◆ unpack() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::unpack ( Buffer_T &  buffer,
const CellInterval interval,
const bool  assumeIdenticalFlagMapping = true 
)

◆ unpack() [2/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::unpack ( Buffer_T &  buffer,
const flag_t  flag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inlineprivate

◆ unpack() [3/3]

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

◆ unpackBoundary() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T , typename BoundariesTuple , int N>
std::enable_if<(N!=-1), void >::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::unpackBoundary ( BoundariesTuple &  boundaryConditions,
Buffer_T &  buffer,
const flag_t  flag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inlineprivate

◆ unpackBoundary() [2/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T >
void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::unpackBoundary ( Buffer_T &  buffer,
const flag_t  flag,
const cell_idx_t  x,
const cell_idx_t  y,
const cell_idx_t  z 
)
inlineprivate

◆ unpackBoundary() [3/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename Buffer_T , typename BoundariesTuple , int N = std::tuple_size<BoundariesTuple>::value - 1>
std::enable_if<(N==-1), void>::type walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::unpackBoundary ( const BoundariesTuple &  ,
Buffer_T &  ,
const  flag_t,
const  cell_idx_t,
const  cell_idx_t,
const  cell_idx_t 
) const
inlineprivate

◆ valueToStream() [1/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
static void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::valueToStream ( std::ostream &  os,
const int8_t  value 
)
inlinestaticprivate

◆ valueToStream() [2/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename T >
static void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::valueToStream ( std::ostream &  os,
const T  value 
)
inlinestaticprivate

◆ valueToStream() [3/3]

template<typename FlagField_T , typename Stencil , typename... Boundaries>
static void walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::valueToStream ( std::ostream &  os,
const uint8_t  value 
)
inlinestaticprivate

Friends And Related Function Documentation

◆ BoundaryHandlingCollection

template<typename FlagField_T , typename Stencil , typename... Boundaries>
template<typename F , typename... T>
friend class BoundaryHandlingCollection
friend

Member Data Documentation

◆ bcMaskMapping_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
std::vector< flag_t > walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::bcMaskMapping_
private

◆ boundary_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
flag_t walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::boundary_
private

◆ boundaryConditions_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
Tuple walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::boundaryConditions_
private

◆ cellDirectionPairs_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
std::vector< std::vector< std::vector< std::pair< Cell, stencil::Direction > > > > walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::cellDirectionPairs_
private

◆ dirty_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::dirty_
private

Every time "near boundary" flags are set or removed, dirty_ is set to true.

Triggers a rebuild of vector cellDirectionPairs_ in "OPTIMIZED_SPARSE_TRAVERSAL" mode.

◆ domain_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
const flag_t walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::domain_
private

◆ flagField_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
FlagField_T* const walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::flagField_
private

◆ innerBB_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
const CellInterval walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::innerBB_
private

◆ mode_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
const Mode walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::mode_
private

◆ nearBoundary_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
const flag_t walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::nearBoundary_
private

◆ outerBB_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
const CellInterval walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::outerBB_
private

◆ rebuildCellDirectionPairs_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
std::vector< bool > walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::rebuildCellDirectionPairs_
private

◆ threadSafeBCs_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
bool walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::threadSafeBCs_
private

◆ uid_

template<typename FlagField_T , typename Stencil , typename... Boundaries>
const BoundaryHandlingUID walberla::boundary::BoundaryHandling< FlagField_T, Stencil, Boundaries >::uid_
private

The documentation for this class was generated from the following file: