walberla Namespace Reference

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	sweepgen
namespace	v8
namespace	blockforest
namespace	domain_decomposition
namespace	mpi
namespace	boundary
namespace	communication
namespace	cell
namespace	config
namespace	real_comparison
namespace	debug
namespace	grid_generator
namespace	core
namespace	logging
namespace	math
namespace	selectable
namespace	timing
namespace	uid
namespace	executiontree
namespace	fft
namespace	field
namespace	gather
namespace	geometry
namespace	gpu
namespace	lbm
namespace	free_surface
namespace	lbm_generated
namespace	lbm_mesapd_coupling
namespace	mesa_pd
namespace	mesh
namespace	pde
namespace	postprocessing
namespace	python_coupling
namespace	simd
namespace	sqlite
namespace	stencil
namespace	timeloop
namespace	vtk
namespace	ExampleTimingPool

Classes
class	GeneratedNonUniformFieldPackInfo
class	Abort
class	AllSet
	A class for managing sets that supports the ability to define a set that represents all possible elements. More...
class	ConcatIterator
struct	never_true
	workaround to implement static_assert(false) (CWG 2518 / P2593R1) More...
class	Environment
	RAII Object to initialize waLBerla using command line parameters. 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	TimestepTracker
struct	VectorTrait< Matrix2< T > >
struct	VectorTrait< Matrix3< T > >
struct	MPITrait< Matrix3< T > >
struct	VectorTrait< Quaternion< T > >
struct	MPITrait< Vector2< T > >
struct	VectorTrait< Vector2< T > >
struct	MPITrait< Vector3< T > >
struct	VectorTrait< Vector3< T > >
class	RandomUUID
	Replacement for boost::uuids::uuid and boost::uuids::random_generator. More...
class	Set
	Wrapper class for managing sets that store elements of type T. More...
class	SharedFunctor
class	ParameterList
class	ContainerStreamReader
	RAII Object to read an STL container (e.g. 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< T >
class	GeneratedNonUniformGPUFieldPackInfo
struct	BoundaryLocationFunction
struct	MeshDistanceFunction
class	SimpleSweep
class	GameOfLifeSweep
struct	ShearFlowInit
	Shear Flow Initialization Functor ///. More...
class	BoundarySetup
class	GameOfLifeSweepCUDA
class	VelDensLogger
	Class for determining (and logging) the minimum and maximum velocity as well as the minimum and maximum density. More...
class	ForceLogger
	Class for calculating (and logging) the force exerted by the fluid on an obstacle inside the domain. More...
class	SRTStream
	LBGK/SRT algorithm of the lattice Boltzmann method extended by an additional, simple force term (by Luo). More...
class	SRTCollideForce
class	MyBoundaryHandling
	Functor that is used to add a boundary handling object to each block. More...
class	ReattachmentLengthFinder
	Class for determining (and logging) the normalized reattachment length after the backward-facing step. More...
struct	Setup
	[variableDefines] More...
class	VelocityFunctor
	[setupStruct] More...
class	JacobiSweep
class	JacobiSweepStencil
class	JacobiIteration
class	Reinitialize
class	JacobiIterationResidual
class	VelocityGradientRefinement
	Adaptive refinement criterion. More...
class	AABBRefinement
class	BlockForest
class	SetupBlock
class	SetupBlockForest
class	StructuredBlockForest
class	BoundaryConfiguration
	Base class for all boundary configuration parameters. More...
class	Boundary
	Base class for all boundary classes. More...
class	BoundaryHandling
class	BoundaryHandlingCollection
class	Cell
	A representation of a Cell's coordinates (in 3D). More...
class	CellInterval
class	CellSet
	A set of cells. More...
class	CellVector
	A vector of cells. More...
class	Config
	Configuration handler & parameter file parser. More...
class	shared_ptr
	STL class. More...
class	weak_ptr
	STL class. More...
class	Matrix2
	Efficient, generic implementation of a 2x2 matrix. More...
class	Matrix3
	Efficient, generic implementation of a 3x3 matrix. More...
class	Quaternion
	Efficient implementation of a quaternion. More...
class	Vector2
	Efficient, generic implementation of a 2-dimensional vector. More...
class	Vector3
	Efficient, generic implementation of a 3-dimensional vector. More...
class	MPIManager
	Encapsulates MPI Rank/Communicator information. More...
class	RemainingTimeLogger
class	UID
	Class for creating, storing, and managing unique identifiers. More...
class	BlockDataID
class	ConstBlockDataID
struct	BlockDataCreator
class	BlockStorage
	Base class for block storage data structures (the entire simulation space is partitioned into blocks [see class 'IBlock'], and block storage data structures manage these blocks). More...
class	BlockSweepWrapper
	Takes an existing block 'sweep' functor and wrapps it into a void-void functor. More...
class	IBlock
	Base class for blocks (blocks are used to partition the simulation space: blocks are rectangular parts of the simulation space that manage all the data that is assigned to their part of the simulation space). More...
class	IBlockID
	Interface/base class for block IDs (unique identifiers for blocks). More...
struct	StructuredBlockDataCreator
class	StructuredBlockStorage
	Base class for structured block storages (the entire simulation space is partitioned into blocks [see class 'IBlock'], the blocks are partitioned into cells, and structured block storages manage those blocks). More...
class	Field
	A four dimensional field/lattice. More...
class	FlagField
	GhostLayerField that stores bit masks. More...
class	GhostLayerField
	Extends the Field with ghost-layer information. More...
class	UniformPackInfo
	Data packing/unpacking for ghost layer based communication of a field. More...
class	NonUniformGPUScheme
class	GeneratedGPUPackInfo
	Data packing/unpacking for ghost layer based communication of a GPUField. More...
class	NonUniformBufferedScheme
struct	SweepOnBlock
struct	BeforeFunction
struct	AfterFunction
class	UniformBufferedScheme
	Communication scheme for buffered communication in uniform block grids. 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	WcTimer = timing::Timer<timing::WcPolicy>
using	WcTimingNode = timing::TimingNode<timing::WcPolicy>
using	CpuTimingNode = timing::TimingNode<timing::CpuPolicy>
using	WcTimingPool = timing::TimingPool<timing::WcPolicy>
using	CpuTimingPool = timing::TimingPool<timing::CpuPolicy>
using	WcTimingTree = timing::TimingTree<timing::WcPolicy>
using	CpuTimingTree = timing::TimingTree<timing::CpuPolicy>
using	DeviceSynchronizeSweepTimeloop = typename timeloop::SweepTimeloop < timing::DeviceSynchronizePolicy >
using	DeviceSynchronizeTimeloop = typename timeloop::Timeloop < timing::DeviceSynchronizePolicy >
using	DeviceSynchronizeTimer = timing::Timer<timing::DeviceSynchronizePolicy>
using	DeviceSynchronizeTimingNode = timing::TimingNode<timing::DeviceSynchronizePolicy>
using	DeviceSynchronizeTimingPool = timing::TimingPool<timing::DeviceSynchronizePolicy>
using	DeviceSynchronizeTimingTree = timing::TimingTree< timing::DeviceSynchronizePolicy >
using	LevelFunction = std::function<void (const uint_t)>
using	SweepTimeloop = typename timeloop::SweepTimeloop < >
using	Timeloop = typename timeloop::Timeloop < >
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 >
using	workload_t
using	memory_t
using	BoundaryUID
using	AABB
using	SUID
	unified state/selection UID
using	Sweep

Enumerations
enum	Direction
enum	Direction

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)
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) noexcept
constexpr real_t	operator""_r (unsigned long long int t) noexcept
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 lhs, const real_t rhs, const real_t epsilon=real_comparison::Epsilon< real_t >::value)
template<typename T1, typename T2>
bool	floatIsEqual (T1 lhs, T2 rhs, const std::common_type_t< T1, T2 > epsilon=real_comparison::Epsilon< std::common_type_t< T1, T2 > >::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)
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)
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 ()
const FlagUID &	NoSlipFlagUID ()
const FlagUID &	NoSlipQBBFlagUID ()
const FlagUID &	MeshObjNoSlipQBBFlagUID ()
const FlagUID &	FreeSlipFlagUID ()
const FlagUID &	UBBFlagUID ()
const FlagUID &	OutflowFlagUID ()
const BoundaryUID &	NoSlipBoundaryUID ()
const std::unordered_map< std::string, FlagUID > &	flagMap ()
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 ()
const FlagUID &	UBB_Flag ()
const FlagUID &	NoSlip_Flag ()
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 &	SimpleUBBFlagUID ()
const FlagUID &	DynamicUBBFlagUID ()
const FlagUID &	ParserUBBFlagUID ()
const FlagUID &	SimplePressureFlagUID ()
const FlagUID &	PressureFlagUID ()
const FlagUID &	OutletFlagUID ()
const FlagUID &	SimplePABFlagUID ()
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)
const FlagUID	FluidFlagUID ("Fluid")
const FlagUID	NoSlipFlagUID ("NoSlip")
const FlagUID	UBBFlagUID ("UBB")
const FlagUID	OutflowFlagUID ("Outflow")
const FlagUID	FreeSlipFlagUID ("FreeSlip")
template<class T, typename... Args>
std::function< T *(const IBlock *const block) >	makeBlockDataInitFunction (Args &&... args)
template<typename T>
internal::SharedSweep< T >	makeSharedSweep (const shared_ptr< T > &sweepPtr)
template<typename T, typename FieldPtrOrIterator>
void	addMask (const FieldPtrOrIterator &it, T mask)
template<class T, typename FieldPtrOrIterator>
void	removeMask (const FieldPtrOrIterator &it, T mask)
template<class T, typename FieldPtrOrIterator>
bool	isMaskSet (const FieldPtrOrIterator &it, T mask)
template<class T, typename FieldPtrOrIterator>
bool	isPartOfMaskSet (const FieldPtrOrIterator &it, T mask)
template<typename T, typename FieldPtrOrIterator>
void	addFlag (const FieldPtrOrIterator &it, T flag)
template<class T, typename FieldPtrOrIterator>
void	removeFlag (const FieldPtrOrIterator &it, T flag)
template<class T, typename FieldPtrOrIterator>
bool	isFlagSet (const FieldPtrOrIterator &it, T flag)
template<class Sten, typename FieldPtrOrIterator>
bool	isFlagInNeighborhood (const FieldPtrOrIterator &it, typename FieldPtrOrIterator::value_type mask)
	Ores the neighborhood of the specified stencil and checks whether the bits of mask are set.
template<class Sten, typename FieldPtrOrIterator>
std::remove_const_t< typename FieldPtrOrIterator::value_type >	getOredNeighborhood (const FieldPtrOrIterator &it)
	Ores the neighborhood of the specified stencil and returns mask.
template<typename T, typename FieldPtrOrIterator>
void	addMask (const FieldPtrOrIterator &it, T mask)
template<class T, typename FieldPtrOrIterator>
void	removeMask (const FieldPtrOrIterator &it, T mask)
template<class T, typename FieldPtrOrIterator>
bool	isMaskSet (const FieldPtrOrIterator &it, T mask)
template<class T, typename FieldPtrOrIterator>
bool	isPartOfMaskSet (const FieldPtrOrIterator &it, T mask)
template<typename T, typename FieldPtrOrIterator>
void	addFlag (const FieldPtrOrIterator &it, T flag)
template<class T, typename FieldPtrOrIterator>
void	removeFlag (const FieldPtrOrIterator &it, T flag)
template<class T, typename FieldPtrOrIterator>
bool	isFlagSet (const FieldPtrOrIterator &it, T flag)

Variables
const int	ARBITRARY_VALUE = 424242
constexpr uint_t	FieldGhostLayer {1}
auto	velocityCallback
auto	wallDistanceCallback
uint_t	numGhostLayers = uint_t{1}
const uint_t	FieldGhostLayers = uint_t{1}
	[variableDefines]

Typedef Documentation

AABB

using walberla::math::AABB

BHFactory

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

Block

using walberla::Block = blockforest::Block

BlockID

using walberla::BlockID = blockforest::BlockID

BoundaryCollection_T

typedef lbm::MeshRefinementExampleBoundaryCollection< FlagField_T > 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>

BoundaryUID

using walberla::boundary::BoundaryUID

byte_t

using walberla::byte_t = uint8_t

cell_idx_t

using walberla::cell_idx_t = int

CommunicationStencil_T

using 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::uint32_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)>

memory_t

using walberla::blockforest::memory_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_generated::PdfField< StorageSpecification_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

typedef lbm::MeshRefinementExampleStorageSpecification walberla::StorageSpecification_T = lbm::LBComplexGeometryStorageSpecification

SUID

using walberla::uid::SUID

unified state/selection UID

Sweep

using walberla::timeloop::Sweep

SweepCollection_T

typedef lbm::MeshRefinementExampleSweepCollection 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>

workload_t

using walberla::blockforest::workload_t

Enumeration Type Documentation

Direction [1/2]

enum walberla::stencil::Direction

Direction [2/2]

enum walberla::stencil::Direction

Function Documentation

addFlag() [1/2]

template<typename T, typename FieldPtrOrIterator>

void walberla::field::addFlag ( const FieldPtrOrIterator & it, T flag )

inline

addFlag() [2/2]

template<typename T, typename FieldPtrOrIterator>

void walberla::field::addFlag ( const FieldPtrOrIterator & it, T flag )

inline

addMask() [1/2]

template<typename T, typename FieldPtrOrIterator>

void walberla::field::addMask ( const FieldPtrOrIterator & it, T mask )

inline

addMask() [2/2]

template<typename T, typename FieldPtrOrIterator>

void walberla::field::addMask ( const FieldPtrOrIterator & it, T mask )

inline

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

(

)

flag_c()

template<typename T>

flag_t walberla::flag_c ( T t )

inline

flagMap()

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

(

)

float_c()

template<typename T>

float walberla::float_c ( T t )

inline

cast to type float

floatIsEqual()

template<typename T1, typename T2>

bool walberla::floatIsEqual ( T1 lhs, T2 rhs, const std::common_type_t< T1, T2 > epsilon = real_comparison::Epsilon< std::common_type_t< T1, T2 > >::value )

inline

Fluid_Flag()

const FlagUID & walberla::Fluid_Flag

(

)

FluidFlagUID() [1/2]

const FlagUID walberla::FluidFlagUID

(

"Fluid"

)

FluidFlagUID() [2/2]

const FlagUID & walberla::FluidFlagUID

(

)

FreeSlipFlagUID() [1/2]

const FlagUID walberla::FreeSlipFlagUID

(

"FreeSlip"

)

FreeSlipFlagUID() [2/2]

const FlagUID & walberla::FreeSlipFlagUID

(

)

gameOfLifeKernel()

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

getHostName()

std::string walberla::getHostName

(

)

getOredNeighborhood()

template<class Sten, typename FieldPtrOrIterator>

std::remove_const_t< typename FieldPtrOrIterator::value_type > walberla::field::getOredNeighborhood ( const FieldPtrOrIterator & it )

inline

Ores the neighborhood of the specified stencil and returns mask.

Parameters

[in]

it

field pointer.

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

isFlagInNeighborhood()

template<class Sten, typename FieldPtrOrIterator>

bool walberla::field::isFlagInNeighborhood ( const FieldPtrOrIterator & it, typename FieldPtrOrIterator::value_type mask )

inline

Ores the neighborhood of the specified stencil and checks whether the bits of mask are set.

Parameters

[in]	it	field pointer.
[in]	mask	bit mask. Test if a cell is added: (content & mask) == true

isFlagSet() [1/2]

template<class T, typename FieldPtrOrIterator>

bool walberla::field::isFlagSet ( const FieldPtrOrIterator & it, T flag )

inline

isFlagSet() [2/2]

template<class T, typename FieldPtrOrIterator>

bool walberla::field::isFlagSet ( const FieldPtrOrIterator & it, T flag )

inline

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:

isMaskSet() [1/2]

template<class T, typename FieldPtrOrIterator>

bool walberla::field::isMaskSet ( const FieldPtrOrIterator & it, T mask )

inline

isMaskSet() [2/2]

template<class T, typename FieldPtrOrIterator>

bool walberla::field::isMaskSet ( const FieldPtrOrIterator & it, T mask )

inline

isPartOfMaskSet() [1/2]

template<class T, typename FieldPtrOrIterator>

bool walberla::field::isPartOfMaskSet ( const FieldPtrOrIterator & it, T mask )

inline

isPartOfMaskSet() [2/2]

template<class T, typename FieldPtrOrIterator>

bool walberla::field::isPartOfMaskSet ( const FieldPtrOrIterator & it, T mask )

inline

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]

[parseDomainParameters]

PROCESS MESH ///

[readMesh]

[readMesh]

[triDist]

[triDist]

[octree]

[octree]

[octreeVTK]

[octreeVTK]

CREATE BLOCK FOREST ///

[aabb]

[aabb]

[bfc]

[bfc]

[blockForest]

[blockForest]

CREATE AND INITIALIZE FIELDS ///

BOUNDARY HANDLING ///

[DefaultBoundaryHandling]

[DefaultBoundaryHandling]

[colorToBoundary]

[colorToBoundary]

[VTKMesh]

[VTKMesh]

[boundarySetup]

[boundarySetup]

SET UP SWEEPS AND TIMELOOP ///

VTK OUTPUT ///

[Params]

[Params] [height]

[height]

[Omega]

[Omega]

[geomboundary]

[geomboundary]

[Logger]

[Logger]

[timeTracker]

[timeTracker]

[boundaryHandlingID]

[boundaryHandlingID]

[boundarySweep]

[boundarySweep]

[timeTracker_coupling]

[timeTracker_coupling]

makeBlockDataInitFunction()

template<class T, typename... Args>

std::function< T *(const IBlock *const block) > walberla::domain_decomposition::makeBlockDataInitFunction

(

Args &&...

args

)

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

)

makeSharedSweep()

template<typename T>

internal::SharedSweep< T > walberla::domain_decomposition::makeSharedSweep

(

const shared_ptr< T > &

sweepPtr

)

MeshObjNoSlipQBBFlagUID()

const FlagUID & walberla::MeshObjNoSlipQBBFlagUID

(

)

NoSlip_Flag()

const FlagUID & walberla::NoSlip_Flag

(

)

NoSlipBoundaryUID()

const BoundaryUID & walberla::NoSlipBoundaryUID

(

)

NoSlipFlagUID() [1/2]

const FlagUID walberla::NoSlipFlagUID

(

"NoSlip"

)

NoSlipFlagUID() [2/2]

const FlagUID & walberla::NoSlipFlagUID

(

)

NoSlipQBBFlagUID()

const FlagUID & walberla::NoSlipQBBFlagUID

(

)

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 )

inlineconstexprnoexcept

operator""_r() [2/2]

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

inlineconstexprnoexcept

operator<<() [1/6]

template<typename T>

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

inline

operator<<() [2/6]

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

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

inline

operator<<() [3/6]

template<typename FlagField_T, typename... Handlers>

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

inline

operator<<() [4/6]

template<typename Type>

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

operator<<() [5/6]

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

operator<<() [6/6]

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() [1/2]

const FlagUID walberla::OutflowFlagUID

(

"Outflow"

)

OutflowFlagUID() [2/2]

const FlagUID & walberla::OutflowFlagUID

(

)

OutletFlagUID()

const FlagUID & walberla::OutletFlagUID

(

)

ParserUBBFlagUID()

const FlagUID & walberla::ParserUBBFlagUID

(

)

PressureFlagUID()

const FlagUID & walberla::PressureFlagUID

(

)

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 lhs, const real_t rhs, const real_t epsilon = 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 )

removeFlag() [1/2]

template<class T, typename FieldPtrOrIterator>

void walberla::field::removeFlag ( const FieldPtrOrIterator & it, T flag )

inline

removeFlag() [2/2]

template<class T, typename FieldPtrOrIterator>

void walberla::field::removeFlag ( const FieldPtrOrIterator & it, T flag )

inline

removeMask() [1/2]

template<class T, typename FieldPtrOrIterator>

void walberla::field::removeMask ( const FieldPtrOrIterator & it, T mask )

inline

removeMask() [2/2]

template<class T, typename FieldPtrOrIterator>

void walberla::field::removeMask ( const FieldPtrOrIterator & it, T mask )

inline

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

(

)

SimplePressureFlagUID()

const FlagUID & walberla::SimplePressureFlagUID

(

)

simpleSweep()

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

SimpleUBBFlagUID()

const FlagUID & walberla::SimpleUBBFlagUID

(

)

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

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

inline

stringToNum() [2/9]

template<>

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

inline

stringToNum() [3/9]

template<>

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

inline

stringToNum() [4/9]

template<>

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

inline

stringToNum() [5/9]

template<>

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

inline

stringToNum() [6/9]

template<>

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

inline

stringToNum() [7/9]

template<>

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

inline

stringToNum() [8/9]

template<>

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

inline

stringToNum() [9/9]

template<typename S>

S 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

(

)

UBBFlagUID() [1/2]

const FlagUID walberla::UBBFlagUID

(

"UBB"

)

UBBFlagUID() [2/2]

const FlagUID & walberla::UBBFlagUID

(

)

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]

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