Detailed Description

\file TimestepTracker.h \ingroup lbm \author Frederik Hennig frede.nosp@m.rik..nosp@m.henni.nosp@m.g@fa.nosp@m.u.de

[walberlaIncludes]

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

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

\file D3Q27BoundaryCollection.h \author lbmpy

\file D3Q19BoundaryCollection.h \author lbmpy

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

	debug

	domain_decomposition

	executiontree

	fft

	field

	filesystem

	free_surface

	gather

	geometry

	gpu

	grid_generator

	gui

	lbm

	lbm_generated

	lbm_mesapd_coupling

	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	GameOfLifeSweepCUDA

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, typename std::enable_if< std::is_arithmetic< T >::value >::type >

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

using	int16_t = std::int16_t
	16 bit signed integer More...

using	int32_t = std::int32_t
	32 bit signed integer More...

using	int64_t = std::int64_t
	64 bit signed integer More...

using	uint8_t = std::uint8_t
	8 bit unsigned integer More...

using	uint16_t = std::uint16_t
	16 bit unsigned integer More...

using	uint32_t = std::uint32_t
	32 bit unsigned integer More...

using	uint64_t = std::uint64_t
	64 bit unsigned integer More...

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
	Half precision support. More...

using	float64 = double

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

using	omp_lock_t = struct omp_lock_t { void *_lk

using	omp_nest_lock_t = struct omp_nest_lock_t { void *_lk

using	omp_lock_hint_t = 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) }

using	omp_proc_bind_t = 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 }

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

typedef pystencils::SRTPackInfo	PackInfo_T
	Typedef Aliases ///. More...

using	Stencil_T = LatticeModel_T::Stencil

using	CommunicationStencil_T = LatticeModel_T::CommunicationStencil

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

using	flag_t = walberla::uint8_t

using	FlagField_T = FlagField< flag_t >

typedef lbm::DefaultBoundaryHandlingFactory< LatticeModel_T, FlagField_T >	BHFactory

typedef field::GhostLayerField< real_t, Stencil_T::D >	VectorField_T

using	NoSlip_T = lbm::CumulantMRTNoSlip
	[VelocityFunctor] More...

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 >

using	BodyTypeTuple = std::tuple< Sphere, Plane >
	[BodyTypeTuple] More...

using	BodyTuple = std::tuple< Sphere, Plane >

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 >
S	numeric_cast (T t)

template<typename INT >
void	static_assert_int_t ()

template<typename UINT >
void	static_assert_uint_t ()

constexpr real_t	operator""_r (long double t)

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

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

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

uint_t	getpid ()

std::string	getHostName ()

long	getResidentMemorySize ()

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

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)

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

template<>
float	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)

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 Function ///. More...

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

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

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

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

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

uint_t	numGhostLayers = uint_t(1)

const uint_t	FieldGhostLayers = uint_t(1)
	[variableDefines] More...

Typedef Documentation

◆ BHFactory

typedef lbm::DefaultBoundaryHandlingFactory< LatticeModel_T, FlagField_T > walberla::BHFactory

◆ Block

using walberla::Block = typedef blockforest::Block

◆ BlockID

using walberla::BlockID = typedef blockforest::BlockID

◆ BodyTuple

using walberla::BodyTuple = typedef std::tuple<Sphere, Plane>

◆ BodyTypeTuple

using walberla::BodyTypeTuple = typedef std::tuple<Sphere, Plane>

[BodyTypeTuple]

◆ 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

◆ byte_t

using walberla::byte_t = typedef uint8_t

◆ cell_idx_t

using walberla::cell_idx_t = typedef int

◆ CommunicationStencil_T

typedef LatticeModel_T::CommunicationStencil walberla::CommunicationStencil_T

◆ CpuTimer

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

◆ CpuTimingNode

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

◆ CpuTimingPool

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

◆ CpuTimingTree

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

◆ DeviceSynchronizeSweepTimeloop

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

◆ DeviceSynchronizeTimeloop

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

◆ DeviceSynchronizeTimer

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

◆ DeviceSynchronizeTimingNode

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

◆ DeviceSynchronizeTimingPool

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

◆ DeviceSynchronizeTimingTree

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

◆ DynamicUBB_T

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

◆ flag_t

typedef walberla::uint16_t walberla::flag_t

◆ FlagField_T

typedef FlagField< flag_t > walberla::FlagField_T

◆ float32

using walberla::float32 = typedef float

Half precision support.

Experimental. Use carefully.

This feature is experimental, since it strictly depends on the underlying architecture and compiler support. On x86 architectures, what you can expect is that the data format is supported natively only for storage and interchange. Arithmetic operations will likely involve casting to fp32 (C++ float) and truncation to fp16. Only bandwidth bound code may therefore benefit. None of this is guaranteed, and may change in the future.

◆ float64

using walberla::float64 = typedef double

◆ FreeSlip_T

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

◆ id_t

using walberla::id_t = typedef uint64_t

◆ int16_t

using walberla::int16_t = typedef std::int16_t

16 bit signed integer

◆ int32_t

using walberla::int32_t = typedef std::int32_t

32 bit signed integer

◆ int64_t

using walberla::int64_t = typedef std::int64_t

64 bit signed integer

◆ int8_t

using walberla::int8_t = typedef std::int8_t

8 bit signed integer

◆ LatticeModel_T

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

Typedef Aliases ///.

[typedefs]

◆ NoSlip_T

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

[VelocityFunctor]

[boundaryTypedefs] boundary handling

◆ omp_lock_hint_t

using walberla::omp_lock_hint_t = typedef 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 = typedef struct omp_lock_t { void * _lk

◆ omp_nest_lock_t

using walberla::omp_nest_lock_t = typedef struct omp_nest_lock_t { void * _lk

◆ omp_proc_bind_t

using walberla::omp_proc_bind_t = typedef 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 = typedef 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 = typedef lbm::Outlet< LatticeModel_T, FlagField_T >

◆ PackInfo_T

typedef pystencils::CumulantMRTPackInfo walberla::PackInfo_T

Typedef Aliases ///.

◆ ParserUBB_T

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

◆ PdfField_T

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

[typedefs]

◆ PhantomBlock

using walberla::PhantomBlock = typedef blockforest::PhantomBlock

◆ PhantomBlockForest

using walberla::PhantomBlockForest = typedef blockforest::PhantomBlockForest

◆ Pressure_T

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

◆ ptrdiff_t

using walberla::ptrdiff_t = typedef std::ptrdiff_t

◆ real_t

using walberla::real_t = typedef float

◆ ScalarField

typedef GhostLayerField< real_t, 1 > walberla::ScalarField

◆ SimplePAB_T

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

◆ SimplePressure_T

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

◆ SimpleUBB_T

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

◆ size_t

using walberla::size_t = typedef std::size_t

◆ Stencil_T

typedef stencil::D2Q5 walberla::Stencil_T

◆ SweepTimeloop

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

◆ Timeloop

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

◆ UBB_T

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

◆ uint16_t

using walberla::uint16_t = typedef std::uint16_t

16 bit unsigned integer

◆ uint32_t

using walberla::uint32_t = typedef std::uint32_t

32 bit unsigned integer

◆ uint64_t

using walberla::uint64_t = typedef std::uint64_t

64 bit unsigned integer

◆ uint8_t

using walberla::uint8_t = typedef std::uint8_t

8 bit unsigned integer

◆ uint_t

using walberla::uint_t = typedef std::size_t

◆ VectorField_T

typedef field::GhostLayerField< real_t, Stencil_T::D > walberla::VectorField_T

◆ WcTimer

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

◆ WcTimingNode

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

◆ WcTimingPool

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

◆ WcTimingTree

using walberla::WcTimingTree = typedef 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')

◆ configure()

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

inline

configures HardContactSemiImplicitTimesteppingSolvers with parameters from config file

Parameters

config	handle to config block
cr	collision resolution object to configure

◆ configureGlobalState()

void walberla::configureGlobalState ( const shared_ptr< Config > & config )

Configures the global state given a config object.

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

◆ DynamicUBBFlagUID()

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

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

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

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

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

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

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

[BodyTypeTuple]

[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 ///

RUN SIMULATION ///

[Params]

[Params] [height]

[height]

[Omega]

[geomboundary]

[Logger]

[timeTracker]

[boundaryHandlingID]

[boundarySweep]

[timeTracker_coupling]

[Parameters]

[GlobalBodyStorage]

[BlockForest]

[StorageDataHandling]

[StorageDataHandling] [AdditionalBlockData]

[AdditionalBlockData]

[Integrator]

[SetBodyTypeIDs]

[Material]

[Planes]

[Gas]

[GameLoop]

[PostProcessing]

[SQLProperties]

[Bind Sync Call]

[Raytracer Init]

[VTK Domain Output]

[VTK Domain Output] [VTK Sphere Output]

[VTK Sphere Output]

[TT Example]

[VTK Output]

[VTK Output] [Image Output]

[Image Output]

[TT Log]

[SQL Save]

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

RUN SIMULATION ///

[Params]

[Params] [height]

[height]

[Omega]

[geomboundary]

[Logger]

[timeTracker]

[boundaryHandlingID]

[boundarySweep]

[timeTracker_coupling]

[Parameters]

[GlobalBodyStorage]

[BlockForest]

[StorageDataHandling]

[StorageDataHandling] [AdditionalBlockData]

[AdditionalBlockData]

[Integrator]

[SetBodyTypeIDs]

[Material]

[Planes]

[Gas]

[GameLoop]

[PostProcessing]

[SQLProperties]

[Bind Sync Call]

[Raytracer Init]

[VTK Domain Output]

[VTK Domain Output] [VTK Sphere Output]

[VTK Sphere Output]

[TT Example]

[VTK Output]

[VTK Output] [Image Output]

[Image Output]

[TT Log]

[SQL Save]

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

◆ NoSlip_Flag()

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

◆ NoSlipFlagUID()

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

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

inline

◆ omp_get_ancestor_thread_num()

int walberla::omp_get_ancestor_thread_num ( int )

inline

◆ omp_get_cancellation()

int walberla::omp_get_cancellation ( void )

inline

◆ omp_get_default_device()

int walberla::omp_get_default_device ( void )

inline

◆ omp_get_dynamic()

int walberla::omp_get_dynamic ( void )

inline

◆ omp_get_initial_device()

int walberla::omp_get_initial_device ( void )

inline

◆ omp_get_level()

int walberla::omp_get_level ( void )

inline

◆ omp_get_max_active_levels()

int walberla::omp_get_max_active_levels ( void )

inline

◆ omp_get_max_task_priority()

int walberla::omp_get_max_task_priority ( void )

inline

◆ omp_get_max_threads()

int walberla::omp_get_max_threads ( void )

inline

◆ omp_get_nested()

int walberla::omp_get_nested ( void )

inline

◆ omp_get_num_devices()

int walberla::omp_get_num_devices ( void )

inline

◆ omp_get_num_places()

int walberla::omp_get_num_places ( void )

inline

◆ omp_get_num_procs()

int walberla::omp_get_num_procs ( void )

inline

◆ omp_get_num_teams()

int walberla::omp_get_num_teams ( void )

inline

◆ omp_get_num_threads()

int walberla::omp_get_num_threads ( void )

inline

◆ omp_get_partition_num_places()

int walberla::omp_get_partition_num_places ( void )

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

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

inline

◆ omp_get_schedule()

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

inline

◆ omp_get_team_num()

int walberla::omp_get_team_num ( void )

inline

◆ omp_get_team_size()

int walberla::omp_get_team_size ( int )

inline

◆ omp_get_thread_limit()

int walberla::omp_get_thread_limit ( void )

inline

◆ omp_get_thread_num()

int walberla::omp_get_thread_num ( void )

inline

◆ omp_get_wtick()

double walberla::omp_get_wtick ( void )

inline

◆ omp_get_wtime()

double walberla::omp_get_wtime ( void )

inline

◆ omp_in_final()

int walberla::omp_in_final ( void )

inline

◆ omp_in_parallel()

int walberla::omp_in_parallel ( void )

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

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]

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

inlineconstexpr

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

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

◆ 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

◆ 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/2]

template<typename S >

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

inline

◆ stringToNum() [2/2]

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

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

◆ 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

◆ FieldGhostLayers

const uint_t walberla::FieldGhostLayers = uint_t(1)

[variableDefines]

◆ numGhostLayers

uint_t walberla::numGhostLayers = uint_t(1)

Detailed Description

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ BHFactory

◆ Block

◆ BlockID

◆ BodyTuple

◆ BodyTypeTuple

◆ 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

◆ 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

◆ SweepTimeloop

◆ Timeloop

◆ UBB_T

◆ uint16_t

◆ uint32_t

◆ uint64_t

◆ uint8_t

◆ uint_t

◆ VectorField_T

◆ WcTimer

◆ WcTimingNode

◆ WcTimingPool

◆ WcTimingTree

Function Documentation

◆ boolVectorToByteArray()

◆ byteArrayToBoolVector()

◆ byteArrayToReal()

◆ byteArrayToUint()

◆ configure()

◆ configureGlobalState()

◆ convert() [1/2]