Detailed Description

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

[walberlaIncludes]

Replacement for the "full" ConvexPolyhedron, which will throw compile time errors if any of its features are actually used.

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]

Namespaces
namespace	blockforest

namespace	boundary

namespace	cell

namespace	communication

namespace	config

namespace	core

namespace	debug

namespace	domain_decomposition

namespace	executiontree

namespace	fft

namespace	field

namespace	filesystem

namespace	free_surface

namespace	gather

namespace	geometry

namespace	gpu

namespace	grid_generator

namespace	lbm

namespace	lbm_generated

namespace	lbm_mesapd_coupling

namespace	logging

namespace	math

namespace	mesa_pd

namespace	mesh

namespace	mpi

namespace	pde

namespace	postprocessing

namespace	python_coupling

namespace	real_comparison

namespace	selectable

namespace	simd

namespace	sqlite

namespace	stencil

namespace	timeloop

namespace	timing

namespace	uid

namespace	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	BoundarySetup

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	GameOfLifeSweepCUDA

class	GeneratedNonUniformFieldPackInfo

class	GeneratedNonUniformGPUFieldPackInfo

class	JacobiIteration

class	JacobiIterationResidual

class	JacobiSweep

class	JacobiSweepStencil

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...

class	ParameterList

class	RandomUUID
	Replacement for boost::uuids::uuid and boost::uuids::random_generator. More...

class	ReattachmentLengthFinder
	Class for determining (and logging) the normalized reattachment length after the backward-facing step. More...

class	Reinitialize

class	Set
	Wrapper class for managing sets that store elements of type T. More...

struct	Setup
	[variableDefines] More...

class	SharedFunctor

struct	ShearFlowInit
	Shear Flow Initialization Functor ///. More...

class	SimpleSweep

class	SRTCollideForce

class	SRTStream
	LBGK/SRT algorithm of the lattice Boltzmann method extended by an additional, simple force term (by Luo). More...

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< 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	VelocityFunctor
	[setupStruct] More...

Typedefs
using	Block = blockforest::Block

using	BlockID = blockforest::BlockID

using	PhantomBlock = blockforest::PhantomBlock

using	PhantomBlockForest = blockforest::PhantomBlockForest

using	int8_t = std::int8_t
	8 bit signed integer

using	int16_t = std::int16_t
	16 bit signed integer

using	int32_t = std::int32_t
	32 bit signed integer

using	int64_t = std::int64_t
	64 bit signed integer

using	uint8_t = std::uint8_t
	8 bit unsigned integer

using	uint16_t = std::uint16_t
	16 bit unsigned integer

using	uint32_t = std::uint32_t
	32 bit unsigned integer

using	uint64_t = std::uint64_t
	64 bit unsigned integer

using	byte_t = uint8_t

using	id_t = uint64_t

using	ptrdiff_t = std::ptrdiff_t

using	uint_t = std::size_t

using	size_t = std::size_t

using	cell_idx_t = int

using	real_t = float

using	float32 = float

using	float64 = double

using	omp_sched_t

using	omp_lock_t

using	omp_nest_lock_t

using	omp_lock_hint_t

using	omp_proc_bind_t

using	CpuTimer = timing::Timer<timing::CpuPolicy>

using	DeviceSynchronizeTimer = timing::Timer<timing::DeviceSynchronizePolicy>

using	WcTimer = timing::Timer<timing::WcPolicy>

using	WcTimingNode = timing::TimingNode<timing::WcPolicy>

using	DeviceSynchronizeTimingNode = timing::TimingNode<timing::DeviceSynchronizePolicy>

using	CpuTimingNode = timing::TimingNode<timing::CpuPolicy>

using	WcTimingPool = timing::TimingPool<timing::WcPolicy>

using	DeviceSynchronizeTimingPool = timing::TimingPool<timing::DeviceSynchronizePolicy>

using	CpuTimingPool = timing::TimingPool<timing::CpuPolicy>

using	WcTimingTree = timing::TimingTree<timing::WcPolicy>

using	DeviceSynchronizeTimingTree = timing::TimingTree<timing::DeviceSynchronizePolicy>

using	CpuTimingTree = timing::TimingTree<timing::CpuPolicy>

using	LevelFunction = std::function<void (const uint_t)>

using	SweepTimeloop = typename timeloop::SweepTimeloop < >

using	DeviceSynchronizeSweepTimeloop = typename timeloop::SweepTimeloop < timing::DeviceSynchronizePolicy >

using	Timeloop = typename timeloop::Timeloop < >

using	DeviceSynchronizeTimeloop = typename timeloop::Timeloop < timing::DeviceSynchronizePolicy >

using	ScalarField = GhostLayerField< real_t, 1 >

using	LatticeModel_T = lbm::SRTLatticeModel
	Typedef Aliases ///.

using	PackInfo_T = pystencils::SRTPackInfo
	Typedef Aliases ///.

using	Stencil_T = LatticeModel_T::Stencil

using	CommunicationStencil_T = LatticeModel_T::CommunicationStencil

using	PdfField_T = lbm::PdfField< LatticeModel_T >
	[typedefs]

using	flag_t = walberla::uint8_t

using	FlagField_T = FlagField< flag_t >

using	BHFactory = lbm::DefaultBoundaryHandlingFactory< LatticeModel_T, FlagField_T >

using	VectorField_T = field::GhostLayerField< real_t, Stencil_T::D >

using	NoSlip_T = lbm::CumulantMRTNoSlip
	[VelocityFunctor]

using	StorageSpecification_T = lbm::LBComplexGeometryStorageSpecification

using	LBMCommunicationStencil_T = StorageSpecification_T::CommunicationStencil

using	LBMPackInfo_T = lbm_generated::UniformGeneratedPdfPackInfo< PdfField_T >

using	SweepCollection_T = lbm::LBComplexGeometrySweepCollection

using	Mesh_T = mesh::TriangleMesh

using	BoundaryCollection_T = lbm::LBComplexGeometryBoundaryCollection< FlagField_T >

using	UBB_T = lbm::SimpleUBB<LatticeModel_T, flag_t>

using	BoundaryHandling_T = BoundaryHandling<FlagField_T, Stencil_T, NoSlip_T, UBB_T>

using	FreeSlip_T = lbm::FreeSlip< LatticeModel_T, FlagField_T >

using	SimpleUBB_T = lbm::SimpleUBB< LatticeModel_T, flag_t >

using	DynamicUBB_T = lbm::DynamicUBB< LatticeModel_T, flag_t, VelocityFunctor >

using	ParserUBB_T = lbm::ParserUBB< LatticeModel_T, flag_t >

using	SimplePressure_T = lbm::SimplePressure< LatticeModel_T, flag_t >

using	Pressure_T = lbm::Pressure< LatticeModel_T, flag_t >

using	Outlet_T = lbm::Outlet< LatticeModel_T, FlagField_T >

using	SimplePAB_T = lbm::SimplePAB< LatticeModel_T, FlagField_T >

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:

template<typename S , typename T >
S	numeric_cast (T t)

template<typename T >
int8_t	int8_c (T t)
	cast to type int8_t using "int8_c(x)"

template<typename T >
int16_t	int16_c (T t)
	cast to type int16_t using "int16_c(x)"

template<typename T >
int32_t	int32_c (T t)
	cast to type int32_t using "int32_c(x)"

template<typename T >
int64_t	int64_c (T t)
	cast to type int64_t using "int64_c(x)"

template<typename T >
uint8_t	uint8_c (T t)
	cast to type uint8_t using "uint8_c(x)"

template<typename T >
uint16_t	uint16_c (T t)
	cast to type uint16_t using "uint16_c(x)"

template<typename T >
uint32_t	uint32_c (T t)
	cast to type uint32_t using "uint32_c(x)"

template<typename T >
uint64_t	uint64_c (T t)
	cast to type uint64_t using "uint64_c(x)"

template<typename T >
int	int_c (T t)
	cast to type int using "int_c(x)"

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)"

template<typename UINT >
void	static_assert_uint_t ()

template<typename T >
cell_idx_t	cell_idx_c (T t)
	cast to type cell_idx_t using "cell_idx_c(x)"

constexpr real_t	operator""_r (long double t)

constexpr real_t	operator""_r (unsigned long long int t)

template<typename T >
real_t	real_c (T t)
	cast to type real_t using "real_c(x)"

template<typename T >
double	double_c (T t)
	cast to type double

template<typename T >
float	float_c (T t)
	cast to type float

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)

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)

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)

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)

template<typename... Args>
std::string	format (const std::string &formatString, Args &&... args)
	format uses the printf syntax to format a given formatString and return a std::string

uint_t	getpid ()

std::string	getHostName ()

long	getResidentMemorySize ()

void	printResidentMemoryStatistics ()
	Determines memory usage on all MPI processes and prints statistics.

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 ()

int	omp_get_dynamic ()

int	omp_get_nested ()

int	omp_get_max_threads ()

int	omp_get_thread_num ()

int	omp_get_num_procs ()

int	omp_in_parallel ()

int	omp_in_final ()

int	omp_get_active_level ()

int	omp_get_level ()

int	omp_get_ancestor_thread_num (int)

int	omp_get_team_size (int)

int	omp_get_thread_limit ()

int	omp_get_max_active_levels ()

void	omp_get_schedule (omp_sched_t , int )

int	omp_get_max_task_priority ()

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 ()

double	omp_get_wtick ()

int	omp_get_default_device ()

void	omp_set_default_device (int)

int	omp_is_initial_device ()

int	omp_get_num_devices ()

int	omp_get_num_teams ()

int	omp_get_team_num ()

int	omp_get_cancellation ()

int	omp_get_initial_device ()

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 ()

int	omp_get_num_places ()

int	omp_get_place_num_procs (int)

void	omp_get_place_proc_ids (int, int *)

int	omp_get_place_num ()

int	omp_get_partition_num_places ()

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)

template<typename S >
S	stringToNum (const std::string &t)

template<>
float	stringToNum (const std::string &t)

template<>
double	stringToNum (const std::string &t)

template<>
long double	stringToNum (const std::string &t)

template<>
int	stringToNum (const std::string &t)

template<>
long	stringToNum (const std::string &t)

template<>
long long	stringToNum (const std::string &t)

template<>
unsigned long	stringToNum (const std::string &t)

template<>
unsigned long long	stringToNum (const std::string &t)

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 T >
std::string	to_string_with_precision (T number, uint_t decimalPlaces)

template<typename T >
std::string	to_string_only_relevant_digits (T number)

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)

template<typename MeshDistanceType , typename MeshType >
BoundaryLocationFunction< MeshDistanceType, MeshType >	makeBoundaryLocationFunction (const shared_ptr< MeshDistanceType > &meshDistanceObject, const shared_ptr< mesh::BoundaryLocation< MeshType > > &boundaryLocation)

template<typename MeshDistanceType >
MeshDistanceFunction< MeshDistanceType >	makeMeshDistanceFunction (const shared_ptr< MeshDistanceType > &meshDistanceObject)

Field< real_t, 1 > *	createFields (IBlock const block, StructuredBlockStorage const storage)

int	main (int argc, char **argv)
	Main Function ///.

void	simpleSweep (IBlock *block, BlockDataID fieldBlockDataID)

void	swapFields (StructuredBlockForest &blocks, BlockDataID uID, BlockDataID uTmpID)

void	initDirichletBoundaryNorth (shared_ptr< StructuredBlockForest > blocks, BlockDataID uId, BlockDataID uTmpId)

void	initShearFlowVelocityField (const shared_ptr< StructuredBlockForest > &blocks, const BlockDataID &velocityFieldId, const Config::BlockHandle &config)
	Shear Flow Velocity Initialization ///.

template<typename T >
flag_t	flag_c (T t)

const FlagUID	FluidFlagUID ("Fluid")

const FlagUID	NoSlipFlagUID ("NoSlip")

const FlagUID	NoSlipQBBFlagUID ("NoSlipQBB")

const FlagUID	MeshObjNoSlipQBBFlagUID ("ObjNoSlipQBB")

const FlagUID	FreeSlipFlagUID ("FreeSlip")

const FlagUID	UBBFlagUID ("UBB")

const FlagUID	OutflowFlagUID ("Outflow")

const BoundaryUID	NoSlipBoundaryUID ("NoSlip")

template<typename MeshType >
void	vertexToFaceColor (MeshType &mesh, const typename MeshType::Color &defaultColor)
	[vertexToFaceColor]

__global__ void	gameOfLifeKernel (gpu::FieldAccessor< real_t > src, gpu::FieldAccessor< real_t > 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.

shared_ptr< vtk::VTKOutput >	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.

const FlagUID	FluidFlagUID ("Fluid Flag")

const FlagUID	NoSlipFlagUID ("NoSlip Flag")

const FlagUID	FreeSlipFlagUID ("FreeSlip Flag")

const FlagUID	SimpleUBBFlagUID ("SimpleUBB Flag")

const FlagUID	UBBFlagUID ("UBB Flag")

const FlagUID	DynamicUBBFlagUID ("DynamicUBB Flag")

const FlagUID	ParserUBBFlagUID ("ParserUBB Flag")

const FlagUID	SimplePressureFlagUID ("SimplePressure Flag")

const FlagUID	PressureFlagUID ("Pressure Flag")

const FlagUID	OutletFlagUID ("Outlet Flag")

const FlagUID	SimplePABFlagUID ("SimplePAB Flag")

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 int	ARBITRARY_VALUE = 424242

constexpr uint_t	FieldGhostLayer {1}

std::unordered_map< std::string, FlagUID >	flagMap

auto	velocityCallback

auto	wallDistanceCallback

uint_t	numGhostLayers = uint_t(1)

const uint_t	FieldGhostLayers = uint_t(1)
	[variableDefines]

Typedef Documentation

◆ BHFactory

using walberla::BHFactory = lbm::DefaultBoundaryHandlingFactory< LatticeModel_T, FlagField_T >

◆ Block

using walberla::Block = blockforest::Block

◆ BlockID

using walberla::BlockID = blockforest::BlockID

◆ BoundaryCollection_T

using walberla::BoundaryCollection_T = lbm::LBComplexGeometryBoundaryCollection< FlagField_T >

◆ BoundaryHandling_T

typedef BoundaryHandling< FlagField_T, Stencil_T, NoSlip_T, FreeSlip_T, SimpleUBB_T, UBB_T, DynamicUBB_T, ParserUBB_T, SimplePressure_T, Pressure_T, Outlet_T, SimplePAB_T > walberla::BoundaryHandling_T = BoundaryHandling<FlagField_T, Stencil_T, NoSlip_T, UBB_T>

◆ byte_t

using walberla::byte_t = uint8_t

◆ cell_idx_t

using walberla::cell_idx_t = int

◆ CommunicationStencil_T

typedef LatticeModel_T::CommunicationStencil walberla::CommunicationStencil_T = LatticeModel_T::CommunicationStencil

◆ CpuTimer

using walberla::CpuTimer = timing::Timer<timing::CpuPolicy>

◆ CpuTimingNode

using walberla::CpuTimingNode = timing::TimingNode<timing::CpuPolicy>

◆ CpuTimingPool

using walberla::CpuTimingPool = timing::TimingPool<timing::CpuPolicy>

◆ CpuTimingTree

using walberla::CpuTimingTree = timing::TimingTree<timing::CpuPolicy>

◆ DeviceSynchronizeSweepTimeloop

using walberla::DeviceSynchronizeSweepTimeloop = typename timeloop::SweepTimeloop < timing::DeviceSynchronizePolicy >

◆ DeviceSynchronizeTimeloop

using walberla::DeviceSynchronizeTimeloop = typename timeloop::Timeloop < timing::DeviceSynchronizePolicy >

◆ DeviceSynchronizeTimer

using walberla::DeviceSynchronizeTimer = timing::Timer<timing::DeviceSynchronizePolicy>

◆ DeviceSynchronizeTimingNode

using walberla::DeviceSynchronizeTimingNode = timing::TimingNode<timing::DeviceSynchronizePolicy>

◆ DeviceSynchronizeTimingPool

using walberla::DeviceSynchronizeTimingPool = timing::TimingPool<timing::DeviceSynchronizePolicy>

◆ DeviceSynchronizeTimingTree

using walberla::DeviceSynchronizeTimingTree = timing::TimingTree<timing::DeviceSynchronizePolicy>

◆ DynamicUBB_T

using walberla::DynamicUBB_T = lbm::DynamicUBB< LatticeModel_T, flag_t, VelocityFunctor >

◆ flag_t

typedef walberla::uint16_t walberla::flag_t = walberla::uint8_t

◆ FlagField_T

typedef FlagField< flag_t > walberla::FlagField_T = FlagField< flag_t >

◆ float32

using walberla::float32 = float

◆ float64

using walberla::float64 = double

◆ FreeSlip_T

using walberla::FreeSlip_T = lbm::FreeSlip< LatticeModel_T, FlagField_T >

◆ id_t

using walberla::id_t = uint64_t

◆ int16_t

using walberla::int16_t = std::int16_t

16 bit signed integer

◆ int32_t

using walberla::int32_t = std::int32_t

32 bit signed integer

◆ int64_t

using walberla::int64_t = std::int64_t

64 bit signed integer

◆ int8_t

using walberla::int8_t = std::int8_t

8 bit signed integer

◆ LatticeModel_T

typedef lbm::D2Q9< lbm::collision_model::SRT > walberla::LatticeModel_T = lbm::SRTLatticeModel

Typedef Aliases ///.

[typedefs]

◆ LBMCommunicationStencil_T

using walberla::LBMCommunicationStencil_T = StorageSpecification_T::CommunicationStencil

◆ LBMPackInfo_T

using walberla::LBMPackInfo_T = lbm_generated::UniformGeneratedPdfPackInfo< PdfField_T >

◆ LevelFunction

typedef std::function< void(const uint_t)> walberla::LevelFunction = std::function<void (const uint_t)>

◆ Mesh_T

using walberla::Mesh_T = mesh::TriangleMesh

◆ NoSlip_T

typedef lbm::NoSlip< LatticeModel_T, flag_t > walberla::NoSlip_T = lbm::CumulantMRTNoSlip

[VelocityFunctor]

[boundaryTypedefs] boundary handling

◆ omp_lock_hint_t

using walberla::omp_lock_hint_t

Initial value:

 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)
}

◆ omp_lock_t

using walberla::omp_lock_t

Initial value:

 struct omp_lock_t {
    void * _lk;
}

◆ omp_nest_lock_t

using walberla::omp_nest_lock_t

Initial value:

 struct omp_nest_lock_t {
    void * _lk;
}

◆ omp_proc_bind_t

using walberla::omp_proc_bind_t

Initial value:

 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
}

◆ omp_sched_t

using walberla::omp_sched_t

Initial value:

 enum omp_sched_t {
omp_sched_static  = 1,
omp_sched_dynamic = 2,
omp_sched_guided  = 3,
omp_sched_auto    = 4
}

◆ Outlet_T

using walberla::Outlet_T = lbm::Outlet< LatticeModel_T, FlagField_T >

◆ PackInfo_T

typedef pystencils::CumulantMRTPackInfo walberla::PackInfo_T = pystencils::SRTPackInfo

Typedef Aliases ///.

◆ ParserUBB_T

using walberla::ParserUBB_T = lbm::ParserUBB< LatticeModel_T, flag_t >

◆ PdfField_T

typedef lbm::PdfField< LatticeModel_T > walberla::PdfField_T = lbm::PdfField< LatticeModel_T >

[typedefs]

◆ PhantomBlock

using walberla::PhantomBlock = blockforest::PhantomBlock

◆ PhantomBlockForest

using walberla::PhantomBlockForest = blockforest::PhantomBlockForest

◆ Pressure_T

using walberla::Pressure_T = lbm::Pressure< LatticeModel_T, flag_t >

◆ ptrdiff_t

using walberla::ptrdiff_t = std::ptrdiff_t

◆ real_t

using walberla::real_t = float

◆ ScalarField

typedef GhostLayerField< real_t, 1 > walberla::ScalarField = GhostLayerField< real_t, 1 >

◆ SimplePAB_T

using walberla::SimplePAB_T = lbm::SimplePAB< LatticeModel_T, FlagField_T >

◆ SimplePressure_T

using walberla::SimplePressure_T = lbm::SimplePressure< LatticeModel_T, flag_t >

◆ SimpleUBB_T

using walberla::SimpleUBB_T = lbm::SimpleUBB< LatticeModel_T, flag_t >

◆ size_t

using walberla::size_t = std::size_t

◆ Stencil_T

typedef stencil::D2Q5 walberla::Stencil_T = LatticeModel_T::Stencil

◆ StorageSpecification_T

using walberla::StorageSpecification_T = lbm::LBComplexGeometryStorageSpecification

◆ SweepCollection_T

using walberla::SweepCollection_T = lbm::LBComplexGeometrySweepCollection

◆ SweepTimeloop

using walberla::SweepTimeloop = typename timeloop::SweepTimeloop < >

◆ Timeloop

using walberla::Timeloop = typename timeloop::Timeloop < >

◆ UBB_T

typedef lbm::UBB< LatticeModel_T, flag_t > walberla::UBB_T = lbm::SimpleUBB<LatticeModel_T, flag_t>

◆ uint16_t

using walberla::uint16_t = std::uint16_t

16 bit unsigned integer

◆ uint32_t

using walberla::uint32_t = std::uint32_t

32 bit unsigned integer

◆ uint64_t

using walberla::uint64_t = std::uint64_t

64 bit unsigned integer

◆ uint8_t

using walberla::uint8_t = std::uint8_t

8 bit unsigned integer

◆ uint_t

using walberla::uint_t = std::size_t

◆ VectorField_T

using walberla::VectorField_T = field::GhostLayerField< real_t, Stencil_T::D >

◆ WcTimer

using walberla::WcTimer = timing::Timer<timing::WcPolicy>

◆ WcTimingNode

using walberla::WcTimingNode = timing::TimingNode<timing::WcPolicy>

◆ WcTimingPool

using walberla::WcTimingPool = timing::TimingPool<timing::WcPolicy>

◆ WcTimingTree

using walberla::WcTimingTree = timing::TimingTree<timing::WcPolicy>

Function Documentation

◆ boolVectorToByteArray()

void walberla::boolVectorToByteArray	(	const std::vector< bool > &	boolVec,
		std::vector< uint8_t > &	array,
		const uint_t	offset )

inline

◆ byteArrayToBoolVector()

std::vector< bool > walberla::byteArrayToBoolVector	(	const std::vector< uint8_t > &	array,
		const uint_t	offset,
		const uint_t	bytes )

inline

◆ byteArrayToReal()

template<typename REAL_T >

REAL_T walberla::byteArrayToReal	(	const std::vector< uint8_t > &	array,
		const uint_t	offset )

◆ byteArrayToUint()

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')

◆ cell_idx_c()

template<typename T >

cell_idx_t walberla::cell_idx_c ( T t )

inline

cast to type cell_idx_t using "cell_idx_c(x)"

◆ convert() [1/2]

void walberla::convert	(	const std::vector< bool > &	from,
		std::vector< uint8_t > &	to )

◆ convert() [2/2]

void walberla::convert	(	const std::vector< uint8_t > &	from,
		std::vector< bool > &	to )

◆ createFields()

Field< real_t, 1 > * walberla::createFields	(	IBlock *const	block,
		StructuredBlockStorage *const	storage )

◆ createFluidFieldVTKWriter()

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.

◆ double_c()

template<typename T >

double walberla::double_c ( T t )

inline

cast to type double

◆ DynamicUBBFlagUID()

const FlagUID walberla::DynamicUBBFlagUID ( "DynamicUBB Flag" )

◆ flag_c()

template<typename T >

flag_t walberla::flag_c ( T t )

inline

◆ float_c()

template<typename T >

float walberla::float_c ( T t )

inline

cast to type float

◆ floatIsEqual() [1/3]

bool walberla::floatIsEqual	(	double	lhs,
		double	rhs,
		const double	epsilon = real_comparison::Epsilon<double>::value )

inline

◆ floatIsEqual() [2/3]

bool walberla::floatIsEqual	(	float	lhs,
		float	rhs,
		const float	epsilon = real_comparison::Epsilon<float>::value )

inline

◆ floatIsEqual() [3/3]

bool walberla::floatIsEqual	(	long double	lhs,
		long double	rhs,
		const long double	epsilon = real_comparison::Epsilon<long double>::value )

inline

◆ Fluid_Flag()

const FlagUID walberla::Fluid_Flag ( "fluid" )

◆ FluidFlagUID() [1/2]

const FlagUID walberla::FluidFlagUID ( "Fluid Flag" )

◆ FluidFlagUID() [2/2]

const FlagUID walberla::FluidFlagUID ( "Fluid" )

◆ format()

template<typename... Args>

std::string walberla::format	(	const std::string &	formatString,
		Args &&...	args )

format uses the printf syntax to format a given formatString and return a std::string

Parameters

formatString	the format string
args	all arguments which will be inserted into the string, these CANNOT be std::string but have to be converted using .c_str()

this size is arbitrary

◆ FreeSlipFlagUID() [1/2]

const FlagUID walberla::FreeSlipFlagUID ( "FreeSlip Flag" )

◆ FreeSlipFlagUID() [2/2]

const FlagUID walberla::FreeSlipFlagUID ( "FreeSlip" )

◆ gameOfLifeKernel()

__global__ void walberla::gameOfLifeKernel	(	gpu::FieldAccessor< real_t >	src,
		gpu::FieldAccessor< real_t >	dst )

◆ getHostName()

std::string walberla::getHostName ( )

◆ getpid()

uint_t walberla::getpid ( )

◆ getResidentMemorySize()

long walberla::getResidentMemorySize ( )

Returns: The current resident memory size of the calling process in kilobytes.

◆ initBC()

void walberla::initBC	(	const shared_ptr< StructuredBlockStorage > &	blocks,
		const BlockDataID &	srcID,
		const BlockDataID &	dstID )

◆ initDirichletBoundaryNorth()

void walberla::initDirichletBoundaryNorth	(	shared_ptr< StructuredBlockForest >	blocks,
		BlockDataID	uId,
		BlockDataID	uTmpId )

◆ initRHS()

void walberla::initRHS	(	const shared_ptr< StructuredBlockStorage > &	blocks,
		const BlockDataID &	rhsID )

◆ initShearFlowVelocityField()

void walberla::initShearFlowVelocityField	(	const shared_ptr< StructuredBlockForest > &	blocks,
		const BlockDataID &	velocityFieldId,
		const Config::BlockHandle &	config )

Shear Flow Velocity Initialization ///.

◆ initU()

void walberla::initU	(	const shared_ptr< StructuredBlockStorage > &	blocks,
		const BlockDataID &	uID )

◆ int16_c()

template<typename T >

int16_t walberla::int16_c ( T t )

inline

cast to type int16_t using "int16_c(x)"

◆ int32_c()

template<typename T >

int32_t walberla::int32_c ( T t )

inline

cast to type int32_t using "int32_c(x)"

◆ int64_c()

template<typename T >

int64_t walberla::int64_c ( T t )

inline

cast to type int64_t using "int64_c(x)"

◆ int8_c()

template<typename T >

int8_t walberla::int8_c ( T t )

inline

cast to type int8_t using "int8_c(x)"

◆ int_c()

template<typename T >

int walberla::int_c ( T t )

inline

cast to type int using "int_c(x)"

◆ isIdentical()

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:

◆ main()

int walberla::main	(	int	argc,
		char **	argv )

Main Function ///.

[vertexToFaceColor]

MAIN.

SIMULATION PARAMETERS ///

BLOCK STORAGE SETUP ///

FIELDS ///

COMMUNICATION ///

DIRICHLET BOUNDARY ///

NEUMANN BOUNDARY ///

TIMELOOP ///

Block Storage Creation and Simulation Parameter ///

Field Setup ///

Shear Flow Setup ///

Boundary Handling ///

Time Loop ///

Block Storage Creation and Simulation Parameter ///

PDF Field and Velocity Setup ///

Sweep ///

Boundary Handling ///

Time Loop ///

PARAMETER INPUT ///

[parseDomainParameters]

PROCESS MESH ///

[readMesh]

[triDist]

[octree]

[octreeVTK]

CREATE BLOCK FOREST ///

[aabb]

[bfc]

[blockForest]

CREATE AND INITIALIZE FIELDS ///

BOUNDARY HANDLING ///

[DefaultBoundaryHandling]

[colorToBoundary]

[VTKMesh]

[boundarySetup]

SET UP SWEEPS AND TIMELOOP ///

VTK OUTPUT ///

[Params]

[Params] [height]

[height]

[Omega]

[geomboundary]

[Logger]

[timeTracker]

[boundaryHandlingID]

[boundarySweep]

[timeTracker_coupling]

SIMULATION PARAMETERS ///

BLOCK STORAGE SETUP ///

FIELDS ///

COMMUNICATION ///

DIRICHLET BOUNDARY ///

NEUMANN BOUNDARY ///

TIMELOOP ///

Block Storage Creation and Simulation Parameter ///

Field Setup ///

Shear Flow Setup ///

Boundary Handling ///

Time Loop ///

Block Storage Creation and Simulation Parameter ///

PDF Field and Velocity Setup ///

Sweep ///

Boundary Handling ///

Time Loop ///

PARAMETER INPUT ///

[parseDomainParameters]

PROCESS MESH ///

[readMesh]

[triDist]

[octree]

[octreeVTK]

CREATE BLOCK FOREST ///

[aabb]

[bfc]

[blockForest]

CREATE AND INITIALIZE FIELDS ///

BOUNDARY HANDLING ///

[DefaultBoundaryHandling]

[colorToBoundary]

[VTKMesh]

[boundarySetup]

SET UP SWEEPS AND TIMELOOP ///

VTK OUTPUT ///

[Params]

[Params] [height]

[height]

[Omega]

[geomboundary]

[Logger]

[timeTracker]

[boundaryHandlingID]

[boundarySweep]

[timeTracker_coupling]

◆ makeBoundaryLocationFunction()

template<typename MeshDistanceType , typename MeshType >

BoundaryLocationFunction< MeshDistanceType, MeshType > walberla::makeBoundaryLocationFunction	(	const shared_ptr< MeshDistanceType > &	meshDistanceObject,
		const shared_ptr< mesh::BoundaryLocation< MeshType > > &	boundaryLocation )

inline

◆ makeMeshDistanceFunction()

template<typename MeshDistanceType >

MeshDistanceFunction< MeshDistanceType > walberla::makeMeshDistanceFunction ( const shared_ptr< MeshDistanceType > & meshDistanceObject )

inline

◆ makeSharedFunctor()

template<typename F >

SharedFunctor< F > walberla::makeSharedFunctor ( const shared_ptr< F > & functorPtr )

◆ MeshObjNoSlipQBBFlagUID()

const FlagUID walberla::MeshObjNoSlipQBBFlagUID ( "ObjNoSlipQBB" )

◆ NoSlip_Flag()

const FlagUID walberla::NoSlip_Flag ( "no slip" )

◆ NoSlipBoundaryUID()

const BoundaryUID walberla::NoSlipBoundaryUID ( "NoSlip" )

◆ NoSlipFlagUID() [1/2]

const FlagUID walberla::NoSlipFlagUID ( "NoSlip Flag" )

◆ NoSlipFlagUID() [2/2]

const FlagUID walberla::NoSlipFlagUID ( "NoSlip" )

◆ NoSlipQBBFlagUID()

const FlagUID walberla::NoSlipQBBFlagUID ( "NoSlipQBB" )

◆ numeric_cast()

template<typename S , typename T >

S walberla::numeric_cast ( T t )

inline

◆ omp_destroy_lock()

void walberla::omp_destroy_lock ( omp_lock_t * )

inline

◆ omp_destroy_nest_lock()

void walberla::omp_destroy_nest_lock ( omp_nest_lock_t * )

inline

◆ omp_get_active_level()

int walberla::omp_get_active_level ( )

inline

◆ omp_get_ancestor_thread_num()

int walberla::omp_get_ancestor_thread_num ( int )

inline

◆ omp_get_cancellation()

int walberla::omp_get_cancellation ( )

inline

◆ omp_get_default_device()

int walberla::omp_get_default_device ( )

inline

◆ omp_get_dynamic()

int walberla::omp_get_dynamic ( )

inline

◆ omp_get_initial_device()

int walberla::omp_get_initial_device ( )

inline

◆ omp_get_level()

int walberla::omp_get_level ( )

inline

◆ omp_get_max_active_levels()

int walberla::omp_get_max_active_levels ( )

inline

◆ omp_get_max_task_priority()

int walberla::omp_get_max_task_priority ( )

inline

◆ omp_get_max_threads()

int walberla::omp_get_max_threads ( )

inline

◆ omp_get_nested()

int walberla::omp_get_nested ( )

inline

◆ omp_get_num_devices()

int walberla::omp_get_num_devices ( )

inline

◆ omp_get_num_places()

int walberla::omp_get_num_places ( )

inline

◆ omp_get_num_procs()

int walberla::omp_get_num_procs ( )

inline

◆ omp_get_num_teams()

int walberla::omp_get_num_teams ( )

inline

◆ omp_get_num_threads()

int walberla::omp_get_num_threads ( )

inline

◆ omp_get_partition_num_places()

int walberla::omp_get_partition_num_places ( )

inline

◆ omp_get_partition_place_nums()

void walberla::omp_get_partition_place_nums ( int * )

inline

◆ omp_get_place_num()

int walberla::omp_get_place_num ( )

inline

◆ omp_get_place_num_procs()

int walberla::omp_get_place_num_procs ( int )

inline

◆ omp_get_place_proc_ids()

void walberla::omp_get_place_proc_ids	(	int	,
		int *	)

inline

◆ omp_get_proc_bind()

omp_proc_bind_t walberla::omp_get_proc_bind ( )

inline

◆ omp_get_schedule()

void walberla::omp_get_schedule	(	omp_sched_t *	,
		int *	)

inline

◆ omp_get_team_num()

int walberla::omp_get_team_num ( )

inline

◆ omp_get_team_size()

int walberla::omp_get_team_size ( int )

inline

◆ omp_get_thread_limit()

int walberla::omp_get_thread_limit ( )

inline

◆ omp_get_thread_num()

int walberla::omp_get_thread_num ( )

inline

◆ omp_get_wtick()

double walberla::omp_get_wtick ( )

inline

◆ omp_get_wtime()

double walberla::omp_get_wtime ( )

inline

◆ omp_in_final()

int walberla::omp_in_final ( )

inline

◆ omp_in_parallel()

int walberla::omp_in_parallel ( )

inline

◆ omp_init_lock()

void walberla::omp_init_lock ( omp_lock_t * )

inline

◆ omp_init_lock_with_hint()

void walberla::omp_init_lock_with_hint	(	omp_lock_t *	,
		omp_lock_hint_t	)

inline

◆ omp_init_nest_lock()

void walberla::omp_init_nest_lock ( omp_nest_lock_t * )

inline

◆ omp_init_nest_lock_with_hint()

void walberla::omp_init_nest_lock_with_hint	(	omp_nest_lock_t *	,
		omp_lock_hint_t	)

inline

◆ omp_is_initial_device()

int walberla::omp_is_initial_device ( )

inline

◆ omp_set_default_device()

void walberla::omp_set_default_device ( int )

inline

◆ omp_set_dynamic()

void walberla::omp_set_dynamic ( int )

inline

◆ omp_set_lock()

void walberla::omp_set_lock ( omp_lock_t * )

inline

◆ omp_set_max_active_levels()

void walberla::omp_set_max_active_levels ( int )

inline

◆ omp_set_nest_lock()

void walberla::omp_set_nest_lock ( omp_nest_lock_t * )

inline

◆ omp_set_nested()

void walberla::omp_set_nested ( int )

inline

◆ omp_set_num_threads()

void walberla::omp_set_num_threads ( int )

inline

◆ omp_set_schedule()

void walberla::omp_set_schedule	(	omp_sched_t	,
		int	)

inline

◆ omp_target_alloc()

void * walberla::omp_target_alloc	(	size_t	,
		int	)

inline

◆ omp_target_associate_ptr()

int walberla::omp_target_associate_ptr	(	void *	,
		void *	,
		size_t	,
		size_t	,
		int	)

inline

◆ omp_target_disassociate_ptr()

int walberla::omp_target_disassociate_ptr	(	void *	,
		int	)

inline

◆ omp_target_free()

void walberla::omp_target_free	(	void *	,
		int	)

inline

◆ omp_target_is_present()

int walberla::omp_target_is_present	(	void *	,
		int	)

inline

◆ omp_target_memcpy()

int walberla::omp_target_memcpy	(	void *	,
		void *	,
		size_t	,
		size_t	,
		size_t	,
		int	,
		int	)

inline

◆ omp_target_memcpy_rect()

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

◆ omp_test_lock()

int walberla::omp_test_lock ( omp_lock_t * )

inline

◆ omp_test_nest_lock()

int walberla::omp_test_nest_lock ( omp_nest_lock_t * )

inline

◆ omp_unset_lock()

void walberla::omp_unset_lock ( omp_lock_t * )

inline

◆ omp_unset_nest_lock()

void walberla::omp_unset_nest_lock ( omp_nest_lock_t * )

inline

◆ operator!=()

bool walberla::operator!=	(	const RandomUUID &	lhs,
		const RandomUUID &	rhs )

◆ operator""_r() [1/2]

real_t walberla::operator""_r ( long double t )

inlineconstexpr

◆ operator""_r() [2/2]

real_t walberla::operator""_r ( unsigned long long int t )

inlineconstexpr

◆ operator<<() [1/7]

template<typename T >

std::ostream & walberla::operator<<	(	std::ostream &	os,
		const AllSet< T > &	set )

inline

◆ operator<<() [2/7]

template<typename T >

std::ostream & walberla::operator<<	(	std::ostream &	os,
		const Array< T > &	array )

inline

◆ operator<<() [3/7]

template<typename FlagField_T , typename Stencil , typename... Boundaries>

std::ostream & walberla::operator<<	(	std::ostream &	os,
		const BoundaryHandling< FlagField_T, Stencil, Boundaries... > &	boundaryHandling )

inline

◆ operator<<() [4/7]

template<typename FlagField_T , typename... Handlers>

std::ostream & walberla::operator<<	(	std::ostream &	os,
		const BoundaryHandlingCollection< FlagField_T, Handlers... > &	bhc )

inline

◆ operator<<() [5/7]

template<typename Type >

std::ostream & walberla::operator<<	(	std::ostream &	os,
		const ParameterList< Type > &	v )

◆ operator<<() [6/7]

std::ostream & walberla::operator<<	(	std::ostream &	os,
		const RandomUUID &	uuid )

◆ operator<<() [7/7]

template<typename T >

std::ostream & walberla::operator<<	(	std::ostream &	os,
		const Set< T > &	set )

inline

◆ operator==()

bool walberla::operator==	(	const RandomUUID &	lhs,
		const RandomUUID &	rhs )

◆ operator>>()

template<typename Type >

std::istream & walberla::operator>>	(	std::istream &	is,
		ParameterList< Type > &	v )

◆ OutflowFlagUID()

const FlagUID walberla::OutflowFlagUID ( "Outflow" )

◆ OutletFlagUID()

const FlagUID walberla::OutletFlagUID ( "Outlet Flag" )

◆ ParserUBBFlagUID()

const FlagUID walberla::ParserUBBFlagUID ( "ParserUBB Flag" )

◆ PressureFlagUID()

const FlagUID walberla::PressureFlagUID ( "Pressure Flag" )

◆ printResidentMemoryStatistics()

void walberla::printResidentMemoryStatistics ( )

Determines memory usage on all MPI processes and prints statistics.

Output is in kilobytes.

Attention: uses mpi gather operation

◆ real_c()

template<typename T >

real_t walberla::real_c ( T t )

inline

cast to type real_t using "real_c(x)"

◆ realIsEqual()

bool walberla::realIsEqual	(	const real_t	a,
		const real_t	b,
		const real_t	eps = real_comparison::Epsilon<real_t>::value )

inline

◆ realIsIdentical()

bool walberla::realIsIdentical	(	const real_t	a,
		const real_t	b )

inline

◆ realToByteArray()

template<typename REAL_T >

uint_t walberla::realToByteArray	(	const REAL_T	value,
		std::vector< uint8_t > &	array,
		const uint_t	offset )

◆ setDifference() [1/2]

template<typename T >

AllSet< T > walberla::setDifference	(	const AllSet< T > &	a,
		const AllSet< T > &	b )

inline

◆ setDifference() [2/2]

template<typename T >

Set< T > walberla::setDifference	(	const Set< T > &	a,
		const Set< T > &	b )

inline

◆ setFlags()

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.

◆ setIntersection() [1/2]

template<typename T >

AllSet< T > walberla::setIntersection	(	const AllSet< T > &	a,
		const AllSet< T > &	b )

inline

◆ setIntersection() [2/2]

template<typename T >

Set< T > walberla::setIntersection	(	const Set< T > &	a,
		const Set< T > &	b )

inline

◆ setIsEqual() [1/2]

template<typename T >

bool walberla::setIsEqual	(	const AllSet< T > &	a,
		const AllSet< T > &	b )

inline

◆ setIsEqual() [2/2]

template<typename T >

bool walberla::setIsEqual	(	const Set< T > &	a,
		const Set< T > &	b )

inline

◆ setUnion() [1/2]

template<typename T >

AllSet< T > walberla::setUnion	(	const AllSet< T > &	a,
		const AllSet< T > &	b )

inline

◆ setUnion() [2/2]

template<typename T >

Set< T > walberla::setUnion	(	const Set< T > &	a,
		const Set< T > &	b )

inline

◆ SimplePABFlagUID()

const FlagUID walberla::SimplePABFlagUID ( "SimplePAB Flag" )

◆ SimplePressureFlagUID()

const FlagUID walberla::SimplePressureFlagUID ( "SimplePressure Flag" )

◆ simpleSweep()

void walberla::simpleSweep	(	IBlock *	block,
		BlockDataID	fieldBlockDataID )

◆ SimpleUBBFlagUID()

const FlagUID walberla::SimpleUBBFlagUID ( "SimpleUBB Flag" )

◆ sleep()

void walberla::sleep ( uint_t seconds )

◆ static_assert_int_t()

template<typename INT >

void walberla::static_assert_int_t ( )

inline

◆ static_assert_uint_t()

template<typename UINT >

void walberla::static_assert_uint_t ( )

inline

◆ string_ends_with()

bool walberla::string_ends_with	(	const std::string &	s,
		const std::string &	substr )

inline

◆ string_icompare()

int walberla::string_icompare	(	const std::string &	s1,
		const std::string &	s2 )

inline

◆ string_replace_all()

void walberla::string_replace_all	(	std::string &	s,
		const std::string &	oldSubstr,
		const std::string &	newSubstr )

inline

◆ string_replace_all_copy()

std::string walberla::string_replace_all_copy	(	const std::string &	s,
		const std::string &	oldSubstr,
		const std::string &	newSubstr )

inline

◆ string_split()

std::vector< std::string > walberla::string_split	(	std::string	s,
		const std::string &	delimiters )

inline

◆ string_to_lower()

void walberla::string_to_lower ( std::string & s )

inline

◆ string_to_lower_copy()

std::string walberla::string_to_lower_copy ( const std::string & s )

inline

◆ string_to_upper()

void walberla::string_to_upper ( std::string & s )

inline

◆ string_to_upper_copy()

std::string walberla::string_to_upper_copy ( const std::string & s )

inline

◆ string_trim()

void walberla::string_trim ( std::string & s )

inline

◆ string_trim_copy()

std::string walberla::string_trim_copy ( const std::string & s )

inline

◆ string_trim_left()

void walberla::string_trim_left ( std::string & s )

inline

◆ string_trim_left_copy()

std::string walberla::string_trim_left_copy ( const std::string & s )

inline

◆ string_trim_right()

void walberla::string_trim_right ( std::string & s )

inline

◆ string_trim_right_copy()

std::string walberla::string_trim_right_copy ( const std::string & s )

inline

◆ stringToNum() [1/9]

template<typename S >

S walberla::stringToNum ( const std::string & t )

inline

◆ stringToNum() [2/9]

template<>

float walberla::stringToNum ( const std::string & t )

inline

◆ stringToNum() [3/9]

template<>

double walberla::stringToNum ( const std::string & t )

inline

◆ stringToNum() [4/9]

template<>

long double walberla::stringToNum ( const std::string & t )

inline

◆ stringToNum() [5/9]

template<>

int walberla::stringToNum ( const std::string & t )

inline

◆ stringToNum() [6/9]

template<>

long walberla::stringToNum ( const std::string & t )

inline

◆ stringToNum() [7/9]

template<>

long long walberla::stringToNum ( const std::string & t )

inline

◆ stringToNum() [8/9]

template<>

unsigned long walberla::stringToNum ( const std::string & t )

inline

◆ stringToNum() [9/9]

template<>

unsigned long long walberla::stringToNum ( const std::string & t )

inline

◆ swapFields()

void walberla::swapFields	(	StructuredBlockForest &	blocks,
		BlockDataID	uID,
		BlockDataID	uTmpID )

◆ to_string_only_relevant_digits()

template<typename T >

std::string walberla::to_string_only_relevant_digits ( T number )

inline

◆ to_string_with_precision()

template<typename T >

std::string walberla::to_string_with_precision	(	T	number,
		uint_t	decimalPlaces )

inline

◆ typeToString() [1/2]

template<typename T >

const char * walberla::typeToString ( )

inline

◆ typeToString() [2/2]

template<typename T >

const char * walberla::typeToString ( T )

inline

◆ typeToString< bool >()

template<>

const char * walberla::typeToString< bool > ( )

inline

◆ typeToString< char >()

template<>

const char * walberla::typeToString< char > ( )

inline

◆ typeToString< double >()

template<>

const char * walberla::typeToString< double > ( )

inline

◆ typeToString< float >()

template<>

const char * walberla::typeToString< float > ( )

inline

◆ typeToString< int >()

template<>

const char * walberla::typeToString< int > ( )

inline

◆ typeToString< long >()

template<>

const char * walberla::typeToString< long > ( )

inline

◆ typeToString< long long >()

template<>

const char * walberla::typeToString< long long > ( )

inline

◆ typeToString< short >()

template<>

const char * walberla::typeToString< short > ( )

inline

◆ typeToString< unsigned char >()

template<>

const char * walberla::typeToString< unsigned char > ( )

inline

◆ typeToString< unsigned int >()

template<>

const char * walberla::typeToString< unsigned int > ( )

inline

◆ typeToString< unsigned long >()

template<>

const char * walberla::typeToString< unsigned long > ( )

inline

◆ typeToString< unsigned long long >()

template<>

const char * walberla::typeToString< unsigned long long > ( )

inline

◆ typeToString< unsigned short >()

template<>

const char * walberla::typeToString< unsigned short > ( )

inline

◆ UBB_Flag()

const FlagUID walberla::UBB_Flag ( "velocity bounce back" )

◆ UBBFlagUID() [1/2]

const FlagUID walberla::UBBFlagUID ( "UBB Flag" )

◆ UBBFlagUID() [2/2]

const FlagUID walberla::UBBFlagUID ( "UBB" )

◆ uint16_c()

template<typename T >

uint16_t walberla::uint16_c ( T t )

inline

cast to type uint16_t using "uint16_c(x)"

◆ uint32_c()

template<typename T >

uint32_t walberla::uint32_c ( T t )

inline

cast to type uint32_t using "uint32_c(x)"

◆ uint64_c()

template<typename T >

uint64_t walberla::uint64_c ( T t )

inline

cast to type uint64_t using "uint64_c(x)"

◆ uint8_c()

template<typename T >

uint8_t walberla::uint8_c ( T t )

inline

cast to type uint8_t using "uint8_c(x)"

◆ uint_c()

template<typename T >

uint_t walberla::uint_c ( T t )

inline

cast to type uint_t using "uint_c(x)"

◆ uintToByteArray()

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)

◆ vertexToFaceColor()

template<typename MeshType >

void walberla::vertexToFaceColor	(	MeshType &	mesh,
		const typename MeshType::Color &	defaultColor )

[vertexToFaceColor]

Variable Documentation

◆ ARBITRARY_VALUE

const int walberla::ARBITRARY_VALUE = 424242

◆ FieldGhostLayer

uint_t walberla::FieldGhostLayer {1}

constexpr

◆ FieldGhostLayers

const uint_t walberla::FieldGhostLayers = uint_t(1)

[variableDefines]

◆ flagMap

std::unordered_map<std::string, FlagUID> walberla::flagMap

Initial value:

= {  {"NoSlip", NoSlipFlagUID},
                                                      {"NoSlipQBB", NoSlipQBBFlagUID},
                                                      {"ObjNoSlipQBB", MeshObjNoSlipQBBFlagUID},
                                                      {"FreeSlip", FreeSlipFlagUID},
                                                      {"UBB", UBBFlagUID},
                                                      {"Outflow", OutflowFlagUID} 
                                                      
                                                   }

◆ numGhostLayers

uint_t walberla::numGhostLayers = uint_t(1)

◆ velocityCallback

auto walberla::velocityCallback

Initial value:

= [](const Cell & , const shared_ptr< StructuredBlockForest > & , IBlock & , const real_t & velocity )
{
   const real_t v = velocity;
 
   const Vector3< real_t > result(real_c(v), real_c(0.0), real_c(0.0));
 
   return result;
}

◆ wallDistanceCallback

auto walberla::wallDistanceCallback

Initial value:

= [](const Cell& , const Cell& , const shared_ptr< StructuredBlockForest >& , IBlock& , const real_t & q )
{
   return q;
}

Detailed Description

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ BHFactory

◆ Block

◆ BlockID

◆ BoundaryCollection_T

◆ BoundaryHandling_T

◆ byte_t

◆ cell_idx_t

◆ CommunicationStencil_T

◆ CpuTimer

◆ CpuTimingNode

◆ CpuTimingPool

◆ CpuTimingTree

◆ DeviceSynchronizeSweepTimeloop

◆ DeviceSynchronizeTimeloop

◆ DeviceSynchronizeTimer

◆ DeviceSynchronizeTimingNode

◆ DeviceSynchronizeTimingPool

◆ DeviceSynchronizeTimingTree

◆ DynamicUBB_T

◆ flag_t

◆ FlagField_T

◆ float32

◆ float64

◆ FreeSlip_T

◆ id_t

◆ int16_t

◆ int32_t

◆ int64_t

◆ int8_t

◆ LatticeModel_T

◆ LBMCommunicationStencil_T

◆ LBMPackInfo_T

◆ LevelFunction

◆ Mesh_T

◆ NoSlip_T

◆ omp_lock_hint_t

◆ omp_lock_t

◆ omp_nest_lock_t

◆ omp_proc_bind_t

◆ omp_sched_t

◆ Outlet_T

◆ PackInfo_T

◆ ParserUBB_T

◆ PdfField_T

◆ PhantomBlock

◆ PhantomBlockForest

◆ Pressure_T

◆ ptrdiff_t

◆ real_t

◆ ScalarField

◆ SimplePAB_T

◆ SimplePressure_T

◆ SimpleUBB_T

◆ size_t

◆ Stencil_T

◆ StorageSpecification_T

◆ SweepCollection_T

◆ SweepTimeloop

◆ Timeloop

◆ UBB_T

◆ uint16_t

◆ uint32_t

◆ uint64_t

◆ uint8_t

◆ uint_t

◆ VectorField_T

◆ WcTimer

◆ WcTimingNode

◆ WcTimingPool

◆ WcTimingTree

Function Documentation

◆ boolVectorToByteArray()

◆ byteArrayToBoolVector()