walberla Namespace Reference

Detailed Description

Storage for detected contacts which can be used to perform actions for all contacts, e.g.

[walberlaIncludes]

resolving, relaxation schemes... The InsertIntoContactStorage-Kernel can be used to insert a contact.

Warning
: if you include this header you also have to include Python.h as first header in your cpp file

[walberlaIncludes] [mesapdIncludes] [mesapdIncludes]

[Includes]

Namespaces

 blockforest
 
 boundary
 
 cell
 
 communication
 
 config
 
 core
 
 cuda
 
 debug
 
 domain_decomposition
 
 executiontree
 
 fft
 
 field
 
 filesystem
 
 gather
 
 geometry
 
 grid_generator
 
 gui
 
 lbm
 
 logging
 
 math
 
 mesa_pd
 
 mesh
 
 mpi
 
 pde
 
 pe
 
 pe_coupling
 
 postprocessing
 
 python_coupling
 
 real_comparison
 
 selectable
 
 simd
 
 sqlite
 
 stencil
 
 timeloop
 
 timing
 
 uid
 
 vtk
 

Classes

class  Abort
 
class  AllSet
 A class for managing sets that supports the ability to define a set that represents all possible elements. More...
 
class  Array
 Fixed size, dynamically allocated array. More...
 
struct  BoundaryLocationFunction
 
class  ConcatIterator
 
class  ContainerStreamReader
 RAII Object to read an STL container (e.g. More...
 
class  Environment
 RAII Object to initialize waLBerla using command line parameters. More...
 
class  ForceLogger
 Class for calculating (and logging) the force exerted by the fluid on an obstacle inside the domain. More...
 
struct  FunctionTraits
 Gives a function's return type as well as the number and type of arguments accepted by a function. More...
 
struct  FunctionTraits< R(Args...) >
 
class  GameOfLifeSweep
 
class  JacobiIteration
 
class  JacobiIterationResidual
 
class  JacobiSweep
 
class  JacobiSweepStencil
 
struct  leastUnsignedInteger
 Provides the smallest unsigned integer type that has at least minSize bits. More...
 
struct  MeshDistanceFunction
 
struct  MPITrait< Matrix3< T > >
 
struct  MPITrait< Vector2< T > >
 
struct  MPITrait< Vector3< T > >
 
class  MyBoundaryHandling
 Functor that is used to add a boundary handling object to each block. More...
 
struct  never_true
 
class  NonCopyable
 Ensures that any derived class can not be copied. More...
 
class  NonCreateable
 Ensures that any derived class can not be constructed (static member functions can still be called!) More...
 
struct  omp_lock_t
 
struct  omp_nest_lock_t
 
class  ParameterList
 
class  RandomUUID
 Replacement for boost::uuids::uuid and boost::uuids::random_generator. More...
 
class  Reinitialize
 
class  Set
 Wrapper class for managing sets that store elements of type T. More...
 
class  SharedFunctor
 
class  SimpleSweep
 
class  SRTCollideForce
 
class  SRTStream
 LBGK/SRT algorithm of the lattice Boltzmann method extended by an additional, simple force term (by Luo). More...
 
struct  uintFromBitWidth
 
struct  uintFromBitWidth< 16 >
 
struct  uintFromBitWidth< 32 >
 
struct  uintFromBitWidth< 64 >
 
struct  uintFromBitWidth< 8 >
 
class  UniqueID
 Generation of unique IDs in MPI environments. More...
 
struct  VectorTrait
 Provides information on how to serialize (=extract components) from a compound data type. More...
 
struct  VectorTrait< Matrix2< T > >
 
struct  VectorTrait< Matrix3< T > >
 
struct  VectorTrait< Quaternion< T > >
 
struct  VectorTrait< Vector2< T > >
 
struct  VectorTrait< Vector3< T > >
 
class  VelDensLogger
 Class for determining (and logging) the minimum and maximum velocity as well as the minimum and maximum density. More...
 
class  weak_ptr_wrapper
 

Typedefs

typedef blockforest::Block Block
 
typedef blockforest::BlockID BlockID
 
typedef blockforest::PhantomBlock PhantomBlock
 
typedef blockforest::PhantomBlockForest PhantomBlockForest
 
typedef std::int8_t int8_t
 8 bit signed integer More...
 
typedef std::int16_t int16_t
 16 bit signed integer More...
 
typedef std::int32_t int32_t
 32 bit signed integer More...
 
typedef std::int64_t int64_t
 64 bit signed integer More...
 
typedef std::uint8_t uint8_t
 8 bit unsigned integer More...
 
typedef std::uint16_t uint16_t
 16 bit unsigned integer More...
 
typedef std::uint32_t uint32_t
 32 bit unsigned integer More...
 
typedef std::uint64_t uint64_t
 64 bit unsigned integer More...
 
typedef uint8_t byte_t
 
typedef uint64_t id_t
 
typedef size_t uint_t
 
typedef int cell_idx_t
 
typedef float real_t
 
typedef enum walberla::omp_sched_t omp_sched_t
 
typedef struct walberla::omp_lock_t omp_lock_t
 
typedef struct walberla::omp_nest_lock_t omp_nest_lock_t
 
typedef enum walberla::omp_lock_hint_t omp_lock_hint_t
 
typedef enum walberla::omp_proc_bind_t omp_proc_bind_t
 
typedef timing::Timer< timing::CpuPolicyCpuTimer
 
typedef timing::Timer< timing::WcPolicyWcTimer
 
typedef timing::TimingNode< timing::WcPolicyWcTimingNode
 
typedef timing::TimingNode< timing::CpuPolicyCpuTimingNode
 
typedef timing::TimingPool< timing::WcPolicyWcTimingPool
 
typedef timing::TimingPool< timing::CpuPolicyCpuTimingPool
 
typedef timing::TimingTree< timing::WcPolicyWcTimingTree
 
typedef timing::TimingTree< timing::CpuPolicyCpuTimingTree
 
using LatticeModel_T = lbm::D2Q9< lbm::collision_model::SRT >
 
using Stencil_T = LatticeModel_T::Stencil
 
using CommunicationStencil_T = LatticeModel_T::CommunicationStencil
 
using PdfField_T = lbm::PdfField< LatticeModel_T >
 
using flag_t = walberla::uint8_t
 
using FlagField_T = FlagField< flag_t >
 
typedef lbm::NoSlip< LatticeModel_T, flag_tNoSlip_T
 
typedef lbm::SimpleUBB< LatticeModel_T, flag_tUBB_T
 
typedef BoundaryHandling< FlagField_T, Stencil_T, NoSlip_T, UBB_TBoundaryHandling_T
 
typedef GhostLayerField< real_t, 1 > ScalarField
 
typedef std::tuple< Sphere, PlaneBodyTypeTuple
 [BodyTypeTuple] More...
 
typedef std::tuple< Sphere, PlaneBodyTuple
 

Enumerations

enum  omp_sched_t { omp_sched_static = 1, omp_sched_dynamic = 2, omp_sched_guided = 3, omp_sched_auto = 4 }
 
enum  omp_lock_hint_t {
  omp_lock_hint_none = 0, omp_lock_hint_uncontended = 1, omp_lock_hint_contended = (1<<1 ), omp_lock_hint_nonspeculative = (1<<2 ),
  omp_lock_hint_speculative = (1<<3 ), kmp_lock_hint_hle = (1<<16), kmp_lock_hint_rtm = (1<<17), kmp_lock_hint_adaptive = (1<<18)
}
 
enum  omp_proc_bind_t {
  omp_proc_bind_false = 0, omp_proc_bind_true = 1, omp_proc_bind_master = 2, omp_proc_bind_close = 3,
  omp_proc_bind_spread = 4
}
 

Functions

template<typename FlagField_T , typename Stencil , typename... Boundaries>
std::ostream & operator<< (std::ostream &os, const BoundaryHandling< FlagField_T, Stencil, Boundaries... > &boundaryHandling)
 
template<typename FlagField_T , typename... Handlers>
std::ostream & operator<< (std::ostream &os, const BoundaryHandlingCollection< FlagField_T, Handlers... > &bhc)
 
template<typename T >
AllSet< T > setIntersection (const AllSet< T > &a, const AllSet< T > &b)
 
template<typename T >
AllSet< T > setUnion (const AllSet< T > &a, const AllSet< T > &b)
 
template<typename T >
AllSet< T > setDifference (const AllSet< T > &a, const AllSet< T > &b)
 
template<typename T >
bool setIsEqual (const AllSet< T > &a, const AllSet< T > &b)
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const AllSet< T > &set)
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const Array< T > &array)
 
void convert (const std::vector< bool > &from, std::vector< uint8_t > &to)
 
void convert (const std::vector< uint8_t > &from, std::vector< bool > &to)
 
template<typename T >
bool isIdentical (const T a, const T b)
 If you want to compare two reals using operator == and you really know what you are doing, you can use the following function: More...
 
template<typename S , typename T >
numeric_cast (T t)
 
template<typename S >
string_to_num (std::string &t)
 
template<>
float string_to_num (std::string &t)
 
template<>
double string_to_num (std::string &t)
 
template<>
long double string_to_num (std::string &t)
 
template<>
int string_to_num (std::string &t)
 
template<>
long string_to_num (std::string &t)
 
template<>
long long string_to_num (std::string &t)
 
template<>
unsigned long string_to_num (std::string &t)
 
template<>
unsigned long long string_to_num (std::string &t)
 
template<typename T >
int8_t int8_c (T t)
 cast to type int8_t using "int8_c(x)" More...
 
template<typename T >
int16_t int16_c (T t)
 cast to type int16_t using "int16_c(x)" More...
 
template<typename T >
int32_t int32_c (T t)
 cast to type int32_t using "int32_c(x)" More...
 
template<typename T >
int64_t int64_c (T t)
 cast to type int64_t using "int64_c(x)" More...
 
template<typename T >
uint8_t uint8_c (T t)
 cast to type uint8_t using "uint8_c(x)" More...
 
template<typename T >
uint16_t uint16_c (T t)
 cast to type uint16_t using "uint16_c(x)" More...
 
template<typename T >
uint32_t uint32_c (T t)
 cast to type uint32_t using "uint32_c(x)" More...
 
template<typename T >
uint64_t uint64_c (T t)
 cast to type uint64_t using "uint64_c(x)" More...
 
template<typename T >
int int_c (T t)
 cast to type int using "int_c(x)" More...
 
template<typename INT >
void static_assert_int_t ()
 
template<typename T >
uint_t uint_c (T t)
 cast to type uint_t using "uint_c(x)" More...
 
template<typename UINT >
void static_assert_uint_t ()
 
constexpr uint_t leastUnsignedIntegerBitWidth (uint_t width)
 
template<typename T >
cell_idx_t cell_idx_c (T t)
 cast to type cell_idx_t using "cell_idx_c(x)" More...
 
template<typename T >
real_t real_c (T t)
 cast to type real_t using "real_c(x)" More...
 
template<typename T >
double double_c (T t)
 cast to type double More...
 
template<typename T >
float float_c (T t)
 cast to type float More...
 
bool realIsIdentical (const real_t a, const real_t b)
 
bool realIsEqual (const real_t a, const real_t b, const real_t eps=real_comparison::Epsilon< real_t >::value)
 
bool floatIsEqual (long double lhs, long double rhs, const long double epsilon=real_comparison::Epsilon< long double >::value)
 
bool floatIsEqual (double lhs, double rhs, const double epsilon=real_comparison::Epsilon< double >::value)
 
bool floatIsEqual (float lhs, float rhs, const float epsilon=real_comparison::Epsilon< float >::value)
 
template<typename T >
const char * typeToString ()
 
template<>
const char * typeToString< bool > ()
 
template<>
const char * typeToString< char > ()
 
template<>
const char * typeToString< short > ()
 
template<>
const char * typeToString< int > ()
 
template<>
const char * typeToString< long > ()
 
template<>
const char * typeToString< long long > ()
 
template<>
const char * typeToString< unsigned char > ()
 
template<>
const char * typeToString< unsigned short > ()
 
template<>
const char * typeToString< unsigned int > ()
 
template<>
const char * typeToString< unsigned long > ()
 
template<>
const char * typeToString< unsigned long long > ()
 
template<>
const char * typeToString< float > ()
 
template<>
const char * typeToString< double > ()
 
template<typename T >
const char * typeToString (T)
 
std::string demangle (const std::string &name)
 
void uintToByteArray (uint_t value, std::vector< uint8_t > &array, const uint_t offset, const uint_t bytes)
 Stores the 'bytes' least significant bytes of 'value' in 'array' starting at 'array[offset]' (complementary operation/function: byteArrayToUint) More...
 
uint_t byteArrayToUint (const std::vector< uint8_t > &array, const uint_t offset, const uint_t bytes)
 Converts 'bytes' bytes stored in 'array' starting at 'array[offset]' into a value of type uint_t (complementary operation/function: uintToByteArray) More...
 
template<typename REAL_T >
uint_t realToByteArray (const REAL_T value, std::vector< uint8_t > &array, const uint_t offset)
 
template<typename REAL_T >
REAL_T byteArrayToReal (const std::vector< uint8_t > &array, const uint_t offset)
 
void boolVectorToByteArray (const std::vector< bool > &boolVec, std::vector< uint8_t > &array, const uint_t offset)
 
std::vector< bool > byteArrayToBoolVector (const std::vector< uint8_t > &array, const uint_t offset, const uint_t bytes)
 
void configureGlobalState (const shared_ptr< Config > &config)
 Configures the global state given a config object. More...
 
uint_t getpid ()
 
std::string getHostName ()
 
void omp_set_num_threads (int)
 
void omp_set_dynamic (int)
 
void omp_set_nested (int)
 
void omp_set_max_active_levels (int)
 
void omp_set_schedule (omp_sched_t, int)
 
int omp_get_num_threads (void)
 
int omp_get_dynamic (void)
 
int omp_get_nested (void)
 
int omp_get_max_threads (void)
 
int omp_get_thread_num (void)
 
int omp_get_num_procs (void)
 
int omp_in_parallel (void)
 
int omp_in_final (void)
 
int omp_get_active_level (void)
 
int omp_get_level (void)
 
int omp_get_ancestor_thread_num (int)
 
int omp_get_team_size (int)
 
int omp_get_thread_limit (void)
 
int omp_get_max_active_levels (void)
 
void omp_get_schedule (omp_sched_t *, int *)
 
int omp_get_max_task_priority (void)
 
void omp_init_lock (omp_lock_t *)
 
void omp_set_lock (omp_lock_t *)
 
void omp_unset_lock (omp_lock_t *)
 
void omp_destroy_lock (omp_lock_t *)
 
int omp_test_lock (omp_lock_t *)
 
void omp_init_nest_lock (omp_nest_lock_t *)
 
void omp_set_nest_lock (omp_nest_lock_t *)
 
void omp_unset_nest_lock (omp_nest_lock_t *)
 
void omp_destroy_nest_lock (omp_nest_lock_t *)
 
int omp_test_nest_lock (omp_nest_lock_t *)
 
void omp_init_lock_with_hint (omp_lock_t *, omp_lock_hint_t)
 
void omp_init_nest_lock_with_hint (omp_nest_lock_t *, omp_lock_hint_t)
 
double omp_get_wtime (void)
 
double omp_get_wtick (void)
 
int omp_get_default_device (void)
 
void omp_set_default_device (int)
 
int omp_is_initial_device (void)
 
int omp_get_num_devices (void)
 
int omp_get_num_teams (void)
 
int omp_get_team_num (void)
 
int omp_get_cancellation (void)
 
int omp_get_initial_device (void)
 
void * omp_target_alloc (size_t, int)
 
void omp_target_free (void *, int)
 
int omp_target_is_present (void *, int)
 
int omp_target_memcpy (void *, void *, size_t, size_t, size_t, int, int)
 
int omp_target_memcpy_rect (void *, void *, size_t, int, const size_t *, const size_t *, const size_t *, const size_t *, const size_t *, int, int)
 
int omp_target_associate_ptr (void *, void *, size_t, size_t, int)
 
int omp_target_disassociate_ptr (void *, int)
 
omp_proc_bind_t omp_get_proc_bind (void)
 
int omp_get_num_places (void)
 
int omp_get_place_num_procs (int)
 
void omp_get_place_proc_ids (int, int *)
 
int omp_get_place_num (void)
 
int omp_get_partition_num_places (void)
 
void omp_get_partition_place_nums (int *)
 
bool operator== (const RandomUUID &lhs, const RandomUUID &rhs)
 
bool operator!= (const RandomUUID &lhs, const RandomUUID &rhs)
 
std::ostream & operator<< (std::ostream &os, const RandomUUID &uuid)
 
template<typename T >
Set< T > setIntersection (const Set< T > &a, const Set< T > &b)
 
template<typename T >
Set< T > setUnion (const Set< T > &a, const Set< T > &b)
 
template<typename T >
Set< T > setDifference (const Set< T > &a, const Set< T > &b)
 
template<typename T >
bool setIsEqual (const Set< T > &a, const Set< T > &b)
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const Set< T > &set)
 
template<typename F >
SharedFunctor< F > makeSharedFunctor (const shared_ptr< F > &functorPtr)
 
void sleep (uint_t seconds)
 
template<typename Type >
std::ostream & operator<< (std::ostream &os, const ParameterList< Type > &v)
 
template<typename Type >
std::istream & operator>> (std::istream &is, ParameterList< Type > &v)
 
void string_to_upper (std::string &s)
 
std::string string_to_upper_copy (const std::string &s)
 
void string_to_lower (std::string &s)
 
std::string string_to_lower_copy (const std::string &s)
 
void string_trim_left (std::string &s)
 
void string_trim_right (std::string &s)
 
void string_trim (std::string &s)
 
std::string string_trim_left_copy (const std::string &s)
 
std::string string_trim_right_copy (const std::string &s)
 
std::string string_trim_copy (const std::string &s)
 
std::vector< std::string > string_split (std::string s, const std::string &delimiters)
 
void string_replace_all (std::string &s, const std::string &oldSubstr, const std::string &newSubstr)
 
std::string string_replace_all_copy (const std::string &s, const std::string &oldSubstr, const std::string &newSubstr)
 
bool string_ends_with (const std::string &s, const std::string &substr)
 
int string_icompare (const std::string &s1, const std::string &s2)
 
template<typename MeshDistanceType , typename MeshType >
BoundaryLocationFunction< MeshDistanceType, MeshTypemakeBoundaryLocationFunction (const shared_ptr< MeshDistanceType > &meshDistanceObject, const shared_ptr< mesh::BoundaryLocation< MeshType > > &boundaryLocation)
 
template<typename MeshDistanceType >
MeshDistanceFunction< MeshDistanceType > makeMeshDistanceFunction (const shared_ptr< MeshDistanceType > &meshDistanceObject)
 
void configure (const Config::BlockHandle &config, pe::cr::HCSITS &cr)
 configures HardContactSemiImplicitTimesteppingSolvers with parameters from config file More...
 
Field< real_t, 1 > * createFields (IBlock *const block, StructuredBlockStorage *const storage)
 
int main (int argc, char **argv)
 MAIN. More...
 
void simpleSweep (IBlock *block, BlockDataID fieldBlockDataID)
 
__global__ void gameOfLifeKernel (cuda::FieldAccessor< double > src, cuda::FieldAccessor< double > dst)
 
const FlagUID Fluid_Flag ("fluid")
 
const FlagUID UBB_Flag ("velocity bounce back")
 
const FlagUID NoSlip_Flag ("no slip")
 
void setFlags (shared_ptr< StructuredBlockForest > &blocks, const BlockDataID &boundaryHandlingId)
 Initialization function used for setting flags in the flag field. More...
 
shared_ptr< vtk::VTKOutputcreateFluidFieldVTKWriter (shared_ptr< StructuredBlockForest > &blocks, const BlockDataID &pdfFieldId, const BlockDataID &flagFieldId)
 Helper function for setting up a VTK output instance that generates output for the fluid field. More...
 
template<typename MeshType >
void vertexToFaceColor (MeshType &mesh, const typename MeshType::Color &defaultColor)
 
void initBC (const shared_ptr< StructuredBlockStorage > &blocks, const BlockDataID &srcID, const BlockDataID &dstID)
 
void initRHS (const shared_ptr< StructuredBlockStorage > &blocks, const BlockDataID &rhsID)
 
void initU (const shared_ptr< StructuredBlockStorage > &blocks, const BlockDataID &uID)
 

Variables

const boost::none_t nullopt = boost::none
 
const int ARBITRARY_VALUE = 424242
 
uint_t numGhostLayers = uint_t(1)
 

Typedef Documentation

typedef std::tuple<Sphere, Plane> walberla::BodyTuple
typedef std::tuple<Sphere, Plane> walberla::BodyTypeTuple

[BodyTypeTuple]

typedef int walberla::cell_idx_t
typedef FlagField< flag_t > walberla::FlagField_T
typedef std::int16_t walberla::int16_t

16 bit signed integer

typedef std::int32_t walberla::int32_t

32 bit signed integer

typedef std::int64_t walberla::int64_t

64 bit signed integer

typedef std::int8_t walberla::int8_t

8 bit signed integer

typedef float walberla::real_t
typedef GhostLayerField< real_t, 1 > walberla::ScalarField
typedef stencil::D2Q5 walberla::Stencil_T
typedef std::uint16_t walberla::uint16_t

16 bit unsigned integer

typedef std::uint32_t walberla::uint32_t

32 bit unsigned integer

typedef std::uint64_t walberla::uint64_t

64 bit unsigned integer

typedef std::uint8_t walberla::uint8_t

8 bit unsigned integer

typedef size_t walberla::uint_t

Enumeration Type Documentation

Enumerator
omp_lock_hint_none 
omp_lock_hint_uncontended 
omp_lock_hint_contended 
omp_lock_hint_nonspeculative 
omp_lock_hint_speculative 
kmp_lock_hint_hle 
kmp_lock_hint_rtm 
kmp_lock_hint_adaptive 
Enumerator
omp_proc_bind_false 
omp_proc_bind_true 
omp_proc_bind_master 
omp_proc_bind_close 
omp_proc_bind_spread 
Enumerator
omp_sched_static 
omp_sched_dynamic 
omp_sched_guided 
omp_sched_auto 

Function Documentation

void walberla::boolVectorToByteArray ( const std::vector< bool > &  boolVec,
std::vector< uint8_t > &  array,
const uint_t  offset 
)
inline
std::vector< bool > walberla::byteArrayToBoolVector ( const std::vector< uint8_t > &  array,
const uint_t  offset,
const uint_t  bytes 
)
inline
template<typename REAL_T >
REAL_T walberla::byteArrayToReal ( const std::vector< uint8_t > &  array,
const uint_t  offset 
)
uint_t walberla::byteArrayToUint ( const std::vector< uint8_t > &  array,
const uint_t  offset,
const uint_t  bytes 
)
inline

Converts 'bytes' bytes stored in 'array' starting at 'array[offset]' into a value of type uint_t (complementary operation/function: uintToByteArray)

std::vector< uint8_t > byteStream( 10, uint8_c(0) );
byteStream[0] = uint8_c(114); // '0111 0010'
byteStream[1] = uint8_c( 85); // '0101 0101'
byteStream[2] = uint8_c(213); // '1101 0101'
uint_t value = byteArrayToUint( byteStream, 1, 2 );
std::cout << value << std::endl; // prints: "54613" ('[...] 0000 1101 0101 0101 0101')
template<typename T >
cell_idx_t walberla::cell_idx_c ( t)
inline

cast to type cell_idx_t using "cell_idx_c(x)"

void walberla::configure ( const Config::BlockHandle &  config,
pe::cr::HCSITS cr 
)
inline

configures HardContactSemiImplicitTimesteppingSolvers with parameters from config file

Parameters
confighandle to config block
crcollision resolution object to configure
void walberla::configureGlobalState ( const shared_ptr< Config > &  config)

Configures the global state given a config object.

void walberla::convert ( const std::vector< bool > &  from,
std::vector< uint8_t > &  to 
)
void walberla::convert ( const std::vector< uint8_t > &  from,
std::vector< bool > &  to 
)
Field< real_t, 1 > * walberla::createFields ( IBlock *const  block,
StructuredBlockStorage *const  storage 
)
shared_ptr< vtk::VTKOutput> walberla::createFluidFieldVTKWriter ( shared_ptr< StructuredBlockForest > &  blocks,
const BlockDataID &  pdfFieldId,
const BlockDataID &  flagFieldId 
)

Helper function for setting up a VTK output instance that generates output for the fluid field.

std::string walberla::demangle ( const std::string &  name)
inline
template<typename T >
double walberla::double_c ( t)
inline

cast to type double

template<typename T >
float walberla::float_c ( t)
inline

cast to type float

bool walberla::floatIsEqual ( long double  lhs,
long double  rhs,
const long double  epsilon = real_comparison::Epsilon<long double>::value 
)
inline
bool walberla::floatIsEqual ( double  lhs,
double  rhs,
const double  epsilon = real_comparison::Epsilon<double>::value 
)
inline
bool walberla::floatIsEqual ( float  lhs,
float  rhs,
const float  epsilon = real_comparison::Epsilon<float>::value 
)
inline
const FlagUID walberla::Fluid_Flag ( "fluid"  )
__global__ void walberla::gameOfLifeKernel ( cuda::FieldAccessor< double >  src,
cuda::FieldAccessor< double >  dst 
)
std::string walberla::getHostName ( )
uint_t walberla::getpid ( )
void walberla::initBC ( const shared_ptr< StructuredBlockStorage > &  blocks,
const BlockDataID &  srcID,
const BlockDataID &  dstID 
)
void walberla::initRHS ( const shared_ptr< StructuredBlockStorage > &  blocks,
const BlockDataID &  rhsID 
)
void walberla::initU ( const shared_ptr< StructuredBlockStorage > &  blocks,
const BlockDataID &  uID 
)
template<typename T >
int16_t walberla::int16_c ( t)
inline

cast to type int16_t using "int16_c(x)"

template<typename T >
int32_t walberla::int32_c ( t)
inline

cast to type int32_t using "int32_c(x)"

template<typename T >
int64_t walberla::int64_c ( t)
inline

cast to type int64_t using "int64_c(x)"

template<typename T >
int8_t walberla::int8_c ( t)
inline

cast to type int8_t using "int8_c(x)"

template<typename T >
int walberla::int_c ( t)
inline

cast to type int using "int_c(x)"

template<typename T >
bool walberla::isIdentical ( const T  a,
const T  b 
)
inline

If you want to compare two reals using operator == and you really know what you are doing, you can use the following function:

constexpr uint_t walberla::leastUnsignedIntegerBitWidth ( uint_t  width)
int walberla::main ( int  argc,
char **  argv 
)

MAIN.

[BodyTypeTuple]

PARAMETER INPUT ///

PROCESS MESH ///

CREATE BLOCK FOREST ///

CREATE AND INITIALIZE FIELDS ///

BOUNDARY HANDLING ///

SET UP SWEEPS AND TIMELOOP ///

VTK OUTPUT ///

RUN SIMULATION ///

[Parameters]

[Parameters]

[GlobalBodyStorage]

[GlobalBodyStorage]

[BlockForest]

[BlockForest]

[StorageDataHandling]

[StorageDataHandling] [AdditionalBlockData]

[AdditionalBlockData]

[Integrator]

[Integrator]

[SetBodyTypeIDs]

[SetBodyTypeIDs]

[Material]

[Material]

[Planes]

[Planes]

[Gas]

[Gas]

[GameLoop]

[GameLoop]

[PostProcessing]

[PostProcessing]

[SQLProperties]

[SQLProperties]

[Bind Sync Call]

[Bind Sync Call]

[Raytracer Init]

[Raytracer Init]

[VTK Domain Output]

[VTK Domain Output] [VTK Sphere Output]

[VTK Sphere Output]

[TT Example]

[TT Example]

[VTK Output]

[VTK Output] [Image Output]

[Image Output]

[TT Log]

[TT Log]

[SQL Save]

[SQL Save]

PARAMETER INPUT ///

PROCESS MESH ///

CREATE BLOCK FOREST ///

CREATE AND INITIALIZE FIELDS ///

BOUNDARY HANDLING ///

SET UP SWEEPS AND TIMELOOP ///

VTK OUTPUT ///

RUN SIMULATION ///

[Parameters]

[Parameters]

[GlobalBodyStorage]

[GlobalBodyStorage]

[BlockForest]

[BlockForest]

[StorageDataHandling]

[StorageDataHandling] [AdditionalBlockData]

[AdditionalBlockData]

[Integrator]

[Integrator]

[SetBodyTypeIDs]

[SetBodyTypeIDs]

[Material]

[Material]

[Planes]

[Planes]

[Gas]

[Gas]

[GameLoop]

[GameLoop]

[PostProcessing]

[PostProcessing]

[SQLProperties]

[SQLProperties]

[Bind Sync Call]

[Bind Sync Call]

[Raytracer Init]

[Raytracer Init]

[VTK Domain Output]

[VTK Domain Output] [VTK Sphere Output]

[VTK Sphere Output]

[TT Example]

[TT Example]

[VTK Output]

[VTK Output] [Image Output]

[Image Output]

[TT Log]

[TT Log]

[SQL Save]

[SQL Save]

template<typename MeshDistanceType , typename MeshType >
BoundaryLocationFunction< MeshDistanceType, MeshType > walberla::makeBoundaryLocationFunction ( const shared_ptr< MeshDistanceType > &  meshDistanceObject,
const shared_ptr< mesh::BoundaryLocation< MeshType > > &  boundaryLocation 
)
inline
template<typename MeshDistanceType >
MeshDistanceFunction<MeshDistanceType> walberla::makeMeshDistanceFunction ( const shared_ptr< MeshDistanceType > &  meshDistanceObject)
inline
template<typename F >
SharedFunctor<F> walberla::makeSharedFunctor ( const shared_ptr< F > &  functorPtr)
const FlagUID walberla::NoSlip_Flag ( "no slip"  )
template<typename S , typename T >
S walberla::numeric_cast ( t)
inline
void walberla::omp_destroy_lock ( omp_lock_t )
inline
void walberla::omp_destroy_nest_lock ( omp_nest_lock_t )
inline
int walberla::omp_get_active_level ( void  )
inline
int walberla::omp_get_ancestor_thread_num ( int  )
inline
int walberla::omp_get_cancellation ( void  )
inline
int walberla::omp_get_default_device ( void  )
inline
int walberla::omp_get_dynamic ( void  )
inline
int walberla::omp_get_initial_device ( void  )
inline
int walberla::omp_get_level ( void  )
inline
int walberla::omp_get_max_active_levels ( void  )
inline
int walberla::omp_get_max_task_priority ( void  )
inline
int walberla::omp_get_max_threads ( void  )
inline
int walberla::omp_get_nested ( void  )
inline
int walberla::omp_get_num_devices ( void  )
inline
int walberla::omp_get_num_places ( void  )
inline
int walberla::omp_get_num_procs ( void  )
inline
int walberla::omp_get_num_teams ( void  )
inline
int walberla::omp_get_num_threads ( void  )
inline
int walberla::omp_get_partition_num_places ( void  )
inline
void walberla::omp_get_partition_place_nums ( int *  )
inline
int walberla::omp_get_place_num ( void  )
inline
int walberla::omp_get_place_num_procs ( int  )
inline
void walberla::omp_get_place_proc_ids ( int  ,
int *   
)
inline
omp_proc_bind_t walberla::omp_get_proc_bind ( void  )
inline
void walberla::omp_get_schedule ( omp_sched_t ,
int *   
)
inline
int walberla::omp_get_team_num ( void  )
inline
int walberla::omp_get_team_size ( int  )
inline
int walberla::omp_get_thread_limit ( void  )
inline
int walberla::omp_get_thread_num ( void  )
inline
double walberla::omp_get_wtick ( void  )
inline
double walberla::omp_get_wtime ( void  )
inline
int walberla::omp_in_final ( void  )
inline
int walberla::omp_in_parallel ( void  )
inline
void walberla::omp_init_lock ( omp_lock_t )
inline
void walberla::omp_init_lock_with_hint ( omp_lock_t ,
omp_lock_hint_t   
)
inline
void walberla::omp_init_nest_lock ( omp_nest_lock_t )
inline
void walberla::omp_init_nest_lock_with_hint ( omp_nest_lock_t ,
omp_lock_hint_t   
)
inline
int walberla::omp_is_initial_device ( void  )
inline
void walberla::omp_set_default_device ( int  )
inline
void walberla::omp_set_dynamic ( int  )
inline
void walberla::omp_set_lock ( omp_lock_t )
inline
void walberla::omp_set_max_active_levels ( int  )
inline
void walberla::omp_set_nest_lock ( omp_nest_lock_t )
inline
void walberla::omp_set_nested ( int  )
inline
void walberla::omp_set_num_threads ( int  )
inline
void walberla::omp_set_schedule ( omp_sched_t  ,
int   
)
inline
void* walberla::omp_target_alloc ( size_t  ,
int   
)
inline
int walberla::omp_target_associate_ptr ( void *  ,
void *  ,
size_t  ,
size_t  ,
int   
)
inline
int walberla::omp_target_disassociate_ptr ( void *  ,
int   
)
inline
void walberla::omp_target_free ( void *  ,
int   
)
inline
int walberla::omp_target_is_present ( void *  ,
int   
)
inline
int walberla::omp_target_memcpy ( void *  ,
void *  ,
size_t  ,
size_t  ,
size_t  ,
int  ,
int   
)
inline
int walberla::omp_target_memcpy_rect ( void *  ,
void *  ,
size_t  ,
int  ,
const size_t *  ,
const size_t *  ,
const size_t *  ,
const size_t *  ,
const size_t *  ,
int  ,
int   
)
inline
int walberla::omp_test_lock ( omp_lock_t )
inline
int walberla::omp_test_nest_lock ( omp_nest_lock_t )
inline
void walberla::omp_unset_lock ( omp_lock_t )
inline
void walberla::omp_unset_nest_lock ( omp_nest_lock_t )
inline
bool walberla::operator!= ( const RandomUUID lhs,
const RandomUUID rhs 
)
template<typename Type >
std::ostream& walberla::operator<< ( std::ostream &  os,
const ParameterList< Type > &  v 
)
std::ostream & walberla::operator<< ( std::ostream &  os,
const RandomUUID uuid 
)
template<typename T >
std::ostream& walberla::operator<< ( std::ostream &  os,
const Array< T > &  array 
)
inline
template<typename T >
std::ostream& walberla::operator<< ( std::ostream &  os,
const Set< T > &  set 
)
inline
template<typename T >
std::ostream& walberla::operator<< ( std::ostream &  os,
const AllSet< T > &  set 
)
inline
template<typename FlagField_T , typename... Handlers>
std::ostream& walberla::operator<< ( std::ostream &  os,
const BoundaryHandlingCollection< FlagField_T, Handlers... > &  bhc 
)
inline
template<typename FlagField_T , typename Stencil , typename... Boundaries>
std::ostream& walberla::operator<< ( std::ostream &  os,
const BoundaryHandling< FlagField_T, Stencil, Boundaries... > &  boundaryHandling 
)
inline
bool walberla::operator== ( const RandomUUID lhs,
const RandomUUID rhs 
)
template<typename Type >
std::istream& walberla::operator>> ( std::istream &  is,
ParameterList< Type > &  v 
)
template<typename T >
real_t walberla::real_c ( t)
inline

cast to type real_t using "real_c(x)"

bool walberla::realIsEqual ( const real_t  a,
const real_t  b,
const real_t  eps = real_comparison::Epsilon<real_t>::value 
)
inline
bool walberla::realIsIdentical ( const real_t  a,
const real_t  b 
)
inline
template<typename REAL_T >
uint_t walberla::realToByteArray ( const REAL_T  value,
std::vector< uint8_t > &  array,
const uint_t  offset 
)
template<typename T >
AllSet< T > walberla::setDifference ( const AllSet< T > &  a,
const AllSet< T > &  b 
)
inline
template<typename T >
Set< T > walberla::setDifference ( const Set< T > &  a,
const Set< T > &  b 
)
inline
void walberla::setFlags ( shared_ptr< StructuredBlockForest > &  blocks,
const BlockDataID &  boundaryHandlingId 
)

Initialization function used for setting flags in the flag field.

Since the goal of this simulation is a lid driven cavity, all cells at the domain border need to be set to no slip, except for the cells at the top: they have to be marked with the velocity bounce back flag. Additionally, all the remaining cells have to be marked as fluid cells.

template<typename T >
AllSet< T > walberla::setIntersection ( const AllSet< T > &  a,
const AllSet< T > &  b 
)
inline
template<typename T >
Set< T > walberla::setIntersection ( const Set< T > &  a,
const Set< T > &  b 
)
inline
template<typename T >
bool walberla::setIsEqual ( const AllSet< T > &  a,
const AllSet< T > &  b 
)
inline
template<typename T >
bool walberla::setIsEqual ( const Set< T > &  a,
const Set< T > &  b 
)
inline
template<typename T >
AllSet< T > walberla::setUnion ( const AllSet< T > &  a,
const AllSet< T > &  b 
)
inline
template<typename T >
Set< T > walberla::setUnion ( const Set< T > &  a,
const Set< T > &  b 
)
inline
void walberla::simpleSweep ( IBlock *  block,
BlockDataID  fieldBlockDataID 
)
void walberla::sleep ( uint_t  seconds)
template<typename INT >
void walberla::static_assert_int_t ( )
inline
template<typename UINT >
void walberla::static_assert_uint_t ( )
inline
bool walberla::string_ends_with ( const std::string &  s,
const std::string &  substr 
)
inline
int walberla::string_icompare ( const std::string &  s1,
const std::string &  s2 
)
inline
void walberla::string_replace_all ( std::string &  s,
const std::string &  oldSubstr,
const std::string &  newSubstr 
)
inline
std::string walberla::string_replace_all_copy ( const std::string &  s,
const std::string &  oldSubstr,
const std::string &  newSubstr 
)
inline
std::vector< std::string > walberla::string_split ( std::string  s,
const std::string &  delimiters 
)
inline
void walberla::string_to_lower ( std::string &  s)
inline
std::string walberla::string_to_lower_copy ( const std::string &  s)
inline
template<typename S >
S walberla::string_to_num ( std::string &  t)
inline
template<>
float walberla::string_to_num ( std::string &  t)
inline
template<>
double walberla::string_to_num ( std::string &  t)
inline
template<>
long double walberla::string_to_num ( std::string &  t)
inline
template<>
int walberla::string_to_num ( std::string &  t)
inline
template<>
long walberla::string_to_num ( std::string &  t)
inline
template<>
long long walberla::string_to_num ( std::string &  t)
inline
template<>
unsigned long walberla::string_to_num ( std::string &  t)
inline
template<>
unsigned long long walberla::string_to_num ( std::string &  t)
inline
void walberla::string_to_upper ( std::string &  s)
inline
std::string walberla::string_to_upper_copy ( const std::string &  s)
inline
void walberla::string_trim ( std::string &  s)
inline
std::string walberla::string_trim_copy ( const std::string &  s)
inline
void walberla::string_trim_left ( std::string &  s)
inline
std::string walberla::string_trim_left_copy ( const std::string &  s)
inline
void walberla::string_trim_right ( std::string &  s)
inline
std::string walberla::string_trim_right_copy ( const std::string &  s)
inline
template<typename T >
const char* walberla::typeToString ( )
inline
template<typename T >
const char* walberla::typeToString ( )
inline
template<>
const char* walberla::typeToString< bool > ( )
inline
template<>
const char* walberla::typeToString< char > ( )
inline
template<>
const char* walberla::typeToString< double > ( )
inline
template<>
const char* walberla::typeToString< float > ( )
inline
template<>
const char* walberla::typeToString< int > ( )
inline
template<>
const char* walberla::typeToString< long > ( )
inline
template<>
const char* walberla::typeToString< long long > ( )
inline
template<>
const char* walberla::typeToString< short > ( )
inline
template<>
const char* walberla::typeToString< unsigned char > ( )
inline
template<>
const char* walberla::typeToString< unsigned int > ( )
inline
template<>
const char* walberla::typeToString< unsigned long > ( )
inline
template<>
const char* walberla::typeToString< unsigned long long > ( )
inline
template<>
const char* walberla::typeToString< unsigned short > ( )
inline
const FlagUID walberla::UBB_Flag ( "velocity bounce back"  )
template<typename T >
uint16_t walberla::uint16_c ( t)
inline

cast to type uint16_t using "uint16_c(x)"

template<typename T >
uint32_t walberla::uint32_c ( t)
inline

cast to type uint32_t using "uint32_c(x)"

template<typename T >
uint64_t walberla::uint64_c ( t)
inline

cast to type uint64_t using "uint64_c(x)"

template<typename T >
uint8_t walberla::uint8_c ( t)
inline

cast to type uint8_t using "uint8_c(x)"

template<typename T >
uint_t walberla::uint_c ( t)
inline

cast to type uint_t using "uint_c(x)"

void walberla::uintToByteArray ( uint_t  value,
std::vector< uint8_t > &  array,
const uint_t  offset,
const uint_t  bytes 
)
inline

Stores the 'bytes' least significant bytes of 'value' in 'array' starting at 'array[offset]' (complementary operation/function: byteArrayToUint)

uint_t number = uint_c(199994); // '[...] 0000 0011 0000 1101 0011 1010'
std::vector< uint8_t > byteStream( 10, uint8_c(0) );
uintToByteArray( number, byteStream, 1, 2 );
for( int i = 0; i != 10; ++i )
std::cout << byteStream[i] << " ";
// prints: "0 58 13 0 0 0 0 0 0 0" (58 <-> 0011 1010 -- 13 <-> 0000 1101)
template<typename MeshType >
void walberla::vertexToFaceColor ( MeshType mesh,
const typename MeshType::Color &  defaultColor 
)

Variable Documentation

const int walberla::ARBITRARY_VALUE = 424242
const boost::none_t walberla::nullopt = boost::none
uint_t walberla::numGhostLayers = uint_t(1)