Namespaces
	bg

	ccd

	communication

	cr

	debug

	fcd

	internal

	raytracing

Classes
class	BodyIterator

class	BodyStatistics

class	BodyStorage
	Body storage of the rigid body simulation world. More...

class	Box
	Box geometry. More...

class	Capsule
	Capsule geometry. More...

class	ConstRigidBodyCastIterator

class	ConstRigidBodyIterator

class	Contact
	Contact between rigid bodies. More...

class	Copper
	Specification of the material copper. More...

class	CylindricalBoundary

class	DefaultBodyVTKOutput

class	DoubleCast

struct	DoubleCast< TypeListA, TypeListB, Functor, ReturnType, -1 >

class	Ellipsoid
	Base class for the Ellipsoid geometry. More...

class	EllipsoidVtkOutput

class	Fir
	Specification of the material fir. More...

class	GeomPrimitive
	Base class for all primitive geometries. More...

class	Granite
	Specification of the material granite. More...

class	Iron
	Specification of the material iron. More...

class	LocalBodyIterator

class	Material
	Rigid body material. More...

class	MPIRigidBodyTrait
	Base class for a specialization of the RigidBodyTrait class template for MPI parallel solvers. More...

class	Oak
	Specification of the material oak. More...

struct	Owner

class	Plane
	Plane geometry. More...

class	RigidBody

class	RigidBodyCastIterator
	Dynamic cast iterator for polymorphic pointer vectors. More...

class	RigidBodyIterator
	Implementation of an iterator for pointer vectors. More...

struct	SetBodyTypeIDs

struct	SetBodyTypeIDs< BodyTypeTuple, -1 >

class	ShadowBodyIterator

class	SingleCast

struct	SingleCast< TypeList, Functor, ReturnType, -1 >

class	Sphere
	Base class for the sphere geometry. More...

class	SphereVtkOutput

class	Squirmer

class	StorageDataHandling

struct	StorageSelect

struct	StorageType
	Class enum for BodyStorages. More...

struct	Thresholds
	Collection of numerical threshold values. More...

class	Union
	Base class for the union geometry, a rigid assembly of bodies. More...

Typedefs
using	Vec2 = math::Vector2< real_t >

using	Vec3 = math::Vector3< real_t >

using	Mat2 = math::Matrix2< real_t >

using	Mat3 = math::Matrix3< real_t >

using	Quat = math::Quaternion< real_t >

using	MatN = math::MatrixMxN< real_t >

using	BodyType = RigidBody
	Type of the rigid bodies. More...

using	BodyID = RigidBody *
	Handle for a rigid body. More...

using	ConstBodyID = const RigidBody *
	Handle for a constant rigid body. More...

using	BodyPtr = std::unique_ptr< RigidBody >

using	GeomID = GeomPrimitive *

using	ConstGeomID = const GeomPrimitive *

using	BoxType = Box
	Type of the box geometric primitive. More...

using	BoxID = Box *
	Handle for a box primitive. More...

using	ConstBoxID = const Box *
	Handle for a constant box primitive. More...

using	BoxPtr = std::unique_ptr< Box >

using	CapsuleType = Capsule
	Type of the capsule geometric primitive. More...

using	CapsuleID = Capsule *
	Handle for a capsule primitive. More...

using	ConstCapsuleID = const Capsule *
	Handle for a constant capsule primitive. More...

using	CapsulePtr = std::unique_ptr< Capsule >

using	CylinderType = Cylinder
	Type of the cylinder geometric primitive. More...

using	CylinderID = Cylinder *
	Handle for a cylinder primitive. More...

using	ConstCylinderID = const Cylinder *
	Handle for a constant cylinder primitive. More...

using	CylinderPtr = std::unique_ptr< Cylinder >

using	CylindricalBoundaryType = CylindricalBoundary
	Type of the cylindrical boundary geometric primitive. More...

using	CylindricalBoundaryID = CylindricalBoundary *
	Handle for a cylindrical boundary primitive. More...

using	ConstCylindricalBoundaryID = const CylindricalBoundary *
	Handle for a constant cylindrical boundary primitive. More...

using	CylindricalBoundaryPtr = std::unique_ptr< CylindricalBoundary >

using	EllipsoidType = Ellipsoid
	Type of the ellipsoid geometric primitive. More...

using	EllipsoidID = Ellipsoid *
	Handle for a ellipsoid primitive. More...

using	ConstEllipsoidID = const Ellipsoid *
	Handle for a constant ellipsoid primitive. More...

using	EllipsoidPtr = std::unique_ptr< Ellipsoid >

using	PlaneType = Plane
	Type of the plane geometric primitive. More...

using	PlaneID = Plane *
	Handle for a plane primitive. More...

using	ConstPlaneID = const Plane *
	Handle for a constant plane primitive. More...

using	PlanePtr = std::unique_ptr< Plane >

using	SphereType = Sphere
	Type of the sphere geometric primitive. More...

using	SphereID = Sphere *
	Handle for a sphere primitive. More...

using	ConstSphereID = const Sphere *
	Handle for a constant sphere primitive. More...

using	SpherePtr = std::unique_ptr< Sphere >

using	SquirmerType = Squirmer
	Type of the squirmer geometric primitive. More...

using	SquirmerID = Squirmer *
	Handle for a squirmer primitive. More...

using	ConstSquirmerID = const Squirmer *
	Handle for a constant squirmer primitive. More...

using	SquirmerPtr = std::unique_ptr< Squirmer >

using	MeshType = TriangleMesh
	Type of the triangle mesh geometric primitive. More...

using	MeshID = TriangleMesh *
	Handle for a triangle mesh primitive. More...

using	ConstMeshID = const TriangleMesh *
	Handle for a constant triangle mesh primitive. More...

using	TriangleMeshPtr = std::unique_ptr< TriangleMesh >

using	ContactType = Contact
	Type of the contacts. More...

using	ContactID = Contact *
	Handle for a contact. More...

using	ConstContactID = const Contact *
	Handle for a constant contact. More...

using	ManagerID = BodyManager *
	Handle for a BodyManager. More...

using	ConstManagerID = const BodyManager *
	Handle for a constant BodyManager. More...

using	Materials = std::vector< Material >
	Vector for materials. More...

using	MaterialID = Materials::size_type
	Unique material ID. More...

using	PossibleContacts = std::vector< std::pair< BodyID, BodyID > >
	Output data type of coarse collision detection module. More...

using	Contacts = std::vector< Contact >
	Output data type of fine collision detection module. More...

using	Storage = std::array< BodyStorage, 2 >
	Container for local and shadow body storage. More...

Functions
void	createWithNeighborhoodLocalShadow (const BlockForest &bf, const BlockDataID storageID, blockforest::InfoCollection &ic)
	Fills InfoCollection with up to date information. More...

void	createWithNeighborhoodContactsShadow (BlockForest &bf, const BlockDataID storageID, const BlockDataID fcdID, blockforest::InfoCollection &ic)
	Fills InfoCollection with up to date information. More...

template<class BlockT >
bool	hasNeighborOwner (const BlockT &block, const Owner &owner)
	Checks if one of the neighbor blocks is owned by process with rank rank. More...

template<class BlockT >
Owner	findContainingProcess (const BlockT &block, const math::Vector3< real_t > pt)
	Looks through all neighboring blocks to find the one whose AABB contains pt. More...

std::ostream &	operator<< (std::ostream &os, const Contact &c)
	Global output operator for contacts. More...

std::ostream &	operator<< (std::ostream &os, ConstContactID c)
	Global output operator for contact handles. More...

bool	shouldContactBeTreated (ContactID c, const math::AABB &blkAABB)

real_t	getRestitution (ConstContactID c)

real_t	getStiffness (ConstContactID c)

real_t	getDampingN (ConstContactID c)

real_t	getDampingT (ConstContactID c)

real_t	getFriction (ConstContactID c)

bool	operator== (const BodyStorage &lhs, const BodyStorage &rhs)
	Compare if two BodyStorages are equal. More...

BoxID	createBox (BodyStorage &globalStorage, BlockStorage &blocks, BlockDataID storageID, id_t uid, const Vec3 &gpos, const Vec3 &lengths, MaterialID material=Material::find("iron"), bool global=false, bool communicating=true, bool infiniteMass=false)
	Setup of a new Box. More...

CapsuleID	createCapsule (BodyStorage &globalStorage, BlockStorage &blocks, BlockDataID storageID, id_t uid, const Vec3 &gpos, const real_t radius, const real_t length, MaterialID material=Material::find("iron"), bool global=false, bool communicating=true, bool infiniteMass=false)
	Setup of a new Capsule. More...

CylindricalBoundaryID	createCylindricalBoundary (BodyStorage &globalStorage, id_t uid, const Vec3 &gpos, const real_t radius, MaterialID material=Material::find("iron"))
	Setup of a new Cylindrical Boundary. More...

EllipsoidID	createEllipsoid (BodyStorage &globalStorage, BlockStorage &blocks, BlockDataID storageID, id_t uid, const Vec3 &gpos, const Vec3 &semiAxes, MaterialID material=Material::find("iron"), bool global=false, bool communicating=true, bool infiniteMass=false)
	Setup of a new Ellipsoid. More...

std::ostream &	operator<< (std::ostream &lhs, const Owner &rhs)

bool	operator== (const Owner &lhs, const Owner &rhs)

PlaneID	createPlane (BodyStorage &globalStorage, id_t uid, Vec3 normal, const Vec3 &gpos, MaterialID material=Material::find("iron"))
	Setup of a new Plane. More...

template<typename C >
bool	operator== (const RigidBodyCastIterator< C > &lhs, const RigidBodyCastIterator< C > &rhs)
	Equality comparison between two CastIterator objects. More...

template<typename C >
bool	operator!= (const RigidBodyCastIterator< C > &lhs, const RigidBodyCastIterator< C > &rhs)
	Inequality comparison between two CastIterator objects. More...

template<typename C >
bool	operator== (const ConstRigidBodyCastIterator< C > &lhs, const ConstRigidBodyCastIterator< C > &rhs)
	Equality comparison between two CastIterator objects. More...

template<typename C >
bool	operator!= (const ConstRigidBodyCastIterator< C > &lhs, const ConstRigidBodyCastIterator< C > &rhs)
	Inequality comparison between two CastIterator objects. More...

bool	operator== (const RigidBodyIterator &lhs, const RigidBodyIterator &rhs)
	Equality comparison between two PtrIterator objects. More...

bool	operator!= (const RigidBodyIterator &lhs, const RigidBodyIterator &rhs)
	Inequality comparison between two PtrIterator objects. More...

bool	operator< (const RigidBodyIterator &lhs, const RigidBodyIterator &rhs)
	Less-than comparison between two PtrIterator objects. More...

bool	operator> (const RigidBodyIterator &lhs, const RigidBodyIterator &rhs)
	Greater-than comparison between two PtrIterator objects. More...

bool	operator<= (const RigidBodyIterator &lhs, const RigidBodyIterator &rhs)
	Less-or-equal-than comparison between two PtrIterator objects. More...

bool	operator>= (const RigidBodyIterator &lhs, const RigidBodyIterator &rhs)
	Greater-or-equal-than comparison between two PtrIterator objects. More...

bool	operator== (const ConstRigidBodyIterator &lhs, const ConstRigidBodyIterator &rhs)
	Equality comparison between two PtrIterator objects. More...

bool	operator!= (const ConstRigidBodyIterator &lhs, const ConstRigidBodyIterator &rhs)
	Inequality comparison between two PtrIterator objects. More...

bool	operator< (const ConstRigidBodyIterator &lhs, const ConstRigidBodyIterator &rhs)
	Less-than comparison between two PtrIterator objects. More...

bool	operator> (const ConstRigidBodyIterator &lhs, const ConstRigidBodyIterator &rhs)
	Greater-than comparison between two PtrIterator objects. More...

bool	operator<= (const ConstRigidBodyIterator &lhs, const ConstRigidBodyIterator &rhs)
	Less-or-equal-than comparison between two PtrIterator objects. More...

bool	operator>= (const ConstRigidBodyIterator &lhs, const ConstRigidBodyIterator &rhs)
	Greater-or-equal-than comparison between two PtrIterator objects. More...

SphereID	createSphere (BodyStorage &globalStorage, BlockStorage &blocks, BlockDataID storageID, id_t uid, const Vec3 &gpos, real_t radius, MaterialID material=Material::find("iron"), bool global=false, bool communicating=true, bool infiniteMass=false)
	Setup of a new Sphere. More...

SquirmerID	createSquirmer (BodyStorage &globalStorage, BlockStorage &blocks, BlockDataID storageID, id_t uid, const Vec3 &gpos, real_t radius, real_t squirmerVelocity, real_t squirmerBeta, MaterialID material=Material::find("iron"), bool global=false, bool communicating=true, bool infiniteMass=false)
	Setup of a new Squirmer. More...

template<typename BodyTuple >
shared_ptr< StorageDataHandling< BodyTuple > >	createStorageDataHandling ()

template<typename... BodyTypes>
std::ostream &	operator<< (std::ostream &os, const Union< BodyTypes... > &u)
	Global output operator for unions. More...

template<typename... BodyTypes>
std::ostream &	operator<< (std::ostream &os, Union< BodyTypes... > const *u)
	Global output operator for union handles. More...

template<typename... BodyTypes>
Union< BodyTypes... > *	createUnion (BodyStorage &globalStorage, BlockStorage &blocks, BlockDataID storageID, id_t uid, const Vec3 &gpos, bool global=false, bool communicating=true, bool infiniteMass=false)
	Setup of a new Union. More...

template<typename... BodyTypes>
BoxID	createBox (Union< BodyTypes... > *un, id_t uid, const Vec3 &gpos, const Vec3 &lengths, MaterialID material=Material::find("iron"), bool global=false, bool communicating=true, bool infiniteMass=false)
	Setup of a new Box directly attached to a Union. More...

template<typename... BodyTypes>
CapsuleID	createCapsule (Union< BodyTypes... > *un, id_t uid, const Vec3 &gpos, const real_t radius, const real_t length, MaterialID material=Material::find("iron"), bool global=false, bool communicating=true, bool infiniteMass=false)
	Setup of a new Capsule directly attached to a Union. More...

template<typename... BodyTypes>
SphereID	createSphere (Union< BodyTypes... > *un, id_t uid, const Vec3 &gpos, real_t radius, MaterialID material=Material::find("iron"), bool global=false, bool communicating=true, bool infiniteMass=false)
	Setup of a new Sphere directly attached to a Union. More...

std::ostream &	operator<< (std::ostream &os, const BodyStatistics &bodyStatistics)

void	clearSynchronization (BlockStorage &blocks, BlockDataID storageID)
	Removes all synchronization information. More...

BodyStorage::iterator	removeAndNotify (Owner me, mpi::BufferSystem &bs, BodyStorage &localStorage, BodyStorage::iterator body)
	Removes a rigid body from the local body storage and informs shadow copy holders. More...

void	reduceForces (BlockStorage &blocks, BlockDataID storageID)

void	reduceForces (BlockStorage &blocks, BlockDataID storageID, BodyStorage &globalBodyStorage)

void	distributeForces (BlockStorage &blocks, BlockDataID storageID)

template<typename BodyTypeTuple >
void	generateSynchonizationMessages (mpi::BufferSystem &bs, const Block &block, BodyStorage &localStorage, BodyStorage &shadowStorage, const real_t dx, const bool syncNonCommunicatingBodies)

template<typename BodyTypeTuple >
void	syncNextNeighbors (BlockForest &forest, BlockDataID storageID, WcTimingTree *tt=nullptr, const real_t dx=real_t(0), const bool syncNonCommunicatingBodies=false)

template<typename BodyTypeTuple >
void	updateAndMigrate (BlockForest &forest, BlockDataID storageID, const bool syncNonCommunicatingBodies)

template<typename BodyTypeTuple >
void	checkAndResolveOverlap (BlockForest &forest, BlockDataID storageID, const real_t dx, const bool syncNonCommunicatingBodies)

template<typename BodyTypeTuple >
void	syncShadowOwners (BlockForest &forest, BlockDataID storageID, WcTimingTree *tt=nullptr, const real_t dx=real_t(0), const bool syncNonCommunicatingBodies=false)

void	destroyBodyBySID (BodyStorage &globalStorage, BlockStorage &blocks, BlockDataID storageID, const walberla::id_t sid)
	removes the rigid body with the given sid More...

void	destroyBodyByUID (BodyStorage &globalStorage, BlockStorage &blocks, BlockDataID storageID, const walberla::id_t uid)
	removes all rigid bodies matching the given uid More...

template<class UnaryPredicate >
void	destroyBody (BodyStorage &globalStorage, BlockStorage &blocks, BlockDataID storageID, const UnaryPredicate &p)
	Removes all rigid bodies which match the unary predicate p. More...

BodyID	getBody (BodyStorage &globalStorage, BlockStorage &blocks, BlockDataID storageID, walberla::id_t sid, int storageSelect=(StorageSelect::LOCAL\|StorageSelect::SHADOW\|StorageSelect::GLOBAL))
	Tries to locate a rigid body and to return a pointer. More...

std::pair< int64_t, int64_t >	getNumBodies (const domain_decomposition::BlockStorage &bs, const BlockDataID &storageID, const int rank)

real_t	getSphereSphereOverlap (const real_t d, const real_t r1, const real_t r2)
	Calculates overlap between two spheres. More...

Variables
const real_t	sleepThreshold = real_c( 0 )
	Sleep mode threshold value. More...

const real_t	sleepBias = real_c( 0.5 )
	Recency-weighted average bias value for the sleep mode \( [0..1] \). More...

const MaterialID	invalid_material = static_cast<MaterialID>( -1 )
	ID for an invalid material. More...

real_t	collisionThreshold = Thresholds<real_t>::collisionThreshold()
	Threshold for the contact classification. More...

real_t	contactThreshold = Thresholds<real_t>::contactThreshold()
	Threshold for the distance between two rigid bodies. More...

real_t	restitutionThreshold = Thresholds<real_t>::restitutionThreshold()
	Threshold for the restriction of the coefficient of restitution. More...

real_t	frictionThreshold = Thresholds<real_t>::frictionThreshold()
	Threshold for the separation between static and dynamic friction. More...

real_t	surfaceThreshold = Thresholds<real_t>::surfaceThreshold()
	Threshold for surface points/checks. More...

Typedef Documentation

◆ BodyID

using walberla::pe::BodyID = typedef RigidBody *

Handle for a rigid body.

◆ BodyPtr

using walberla::pe::BodyPtr = typedef std::unique_ptr<RigidBody>

◆ BodyType

using walberla::pe::BodyType = typedef RigidBody

Type of the rigid bodies.

◆ BoxID

using walberla::pe::BoxID = typedef Box *

Handle for a box primitive.

◆ BoxPtr

using walberla::pe::BoxPtr = typedef std::unique_ptr<Box>

◆ BoxType

using walberla::pe::BoxType = typedef Box

Type of the box geometric primitive.

◆ CapsuleID

using walberla::pe::CapsuleID = typedef Capsule *

Handle for a capsule primitive.

◆ CapsulePtr

using walberla::pe::CapsulePtr = typedef std::unique_ptr<Capsule>

◆ CapsuleType

using walberla::pe::CapsuleType = typedef Capsule

Type of the capsule geometric primitive.

◆ ConstBodyID

using walberla::pe::ConstBodyID = typedef const RigidBody *

Handle for a constant rigid body.

◆ ConstBoxID

using walberla::pe::ConstBoxID = typedef const Box *

Handle for a constant box primitive.

◆ ConstCapsuleID

using walberla::pe::ConstCapsuleID = typedef const Capsule *

Handle for a constant capsule primitive.

◆ ConstContactID

using walberla::pe::ConstContactID = typedef const Contact *

Handle for a constant contact.

◆ ConstCylinderID

using walberla::pe::ConstCylinderID = typedef const Cylinder *

Handle for a constant cylinder primitive.

◆ ConstCylindricalBoundaryID

using walberla::pe::ConstCylindricalBoundaryID = typedef const CylindricalBoundary *

Handle for a constant cylindrical boundary primitive.

◆ ConstEllipsoidID

using walberla::pe::ConstEllipsoidID = typedef const Ellipsoid *

Handle for a constant ellipsoid primitive.

◆ ConstGeomID

using walberla::pe::ConstGeomID = typedef const GeomPrimitive *

◆ ConstManagerID

using walberla::pe::ConstManagerID = typedef const BodyManager *

Handle for a constant BodyManager.

◆ ConstMeshID

using walberla::pe::ConstMeshID = typedef const TriangleMesh *

Handle for a constant triangle mesh primitive.

◆ ConstPlaneID

using walberla::pe::ConstPlaneID = typedef const Plane *

Handle for a constant plane primitive.

◆ ConstSphereID

using walberla::pe::ConstSphereID = typedef const Sphere *

Handle for a constant sphere primitive.

◆ ConstSquirmerID

using walberla::pe::ConstSquirmerID = typedef const Squirmer *

Handle for a constant squirmer primitive.

◆ ContactID

using walberla::pe::ContactID = typedef Contact *

Handle for a contact.

◆ Contacts

using walberla::pe::Contacts = typedef std::vector<Contact>

Output data type of fine collision detection module.

◆ ContactType

using walberla::pe::ContactType = typedef Contact

Type of the contacts.

◆ CylinderID

using walberla::pe::CylinderID = typedef Cylinder *

Handle for a cylinder primitive.

◆ CylinderPtr

using walberla::pe::CylinderPtr = typedef std::unique_ptr<Cylinder>

◆ CylinderType

using walberla::pe::CylinderType = typedef Cylinder

Type of the cylinder geometric primitive.

◆ CylindricalBoundaryID

using walberla::pe::CylindricalBoundaryID = typedef CylindricalBoundary *

Handle for a cylindrical boundary primitive.

◆ CylindricalBoundaryPtr

using walberla::pe::CylindricalBoundaryPtr = typedef std::unique_ptr<CylindricalBoundary>

◆ CylindricalBoundaryType

using walberla::pe::CylindricalBoundaryType = typedef CylindricalBoundary

Type of the cylindrical boundary geometric primitive.

◆ EllipsoidID

using walberla::pe::EllipsoidID = typedef Ellipsoid *

Handle for a ellipsoid primitive.

◆ EllipsoidPtr

using walberla::pe::EllipsoidPtr = typedef std::unique_ptr<Ellipsoid>

◆ EllipsoidType

using walberla::pe::EllipsoidType = typedef Ellipsoid

Type of the ellipsoid geometric primitive.

◆ GeomID

using walberla::pe::GeomID = typedef GeomPrimitive *

◆ ManagerID

using walberla::pe::ManagerID = typedef BodyManager *

Handle for a BodyManager.

◆ Mat2

using walberla::pe::Mat2 = typedef math::Matrix2<real_t>

◆ Mat3

using walberla::pe::Mat3 = typedef math::Matrix3<real_t>

◆ MaterialID

using walberla::pe::MaterialID = typedef Materials::size_type

Unique material ID.

Every registered material has a unique MaterialID that can be used wherever the material is required. The pe engine provides a couple of predefined materials (see the Materials module). However, it is possible to define a custom material via the createMaterial() function:

// Creates the material "myMaterial" with the following material properties:
//  - material density               : 2.54
//  - coefficient of restitution     : 0.8
//  - coefficient of static friction : 0.1
//  - coefficient of dynamic friction: 0.05
MaterialID myMaterial = createMaterial( "myMaterial", real_c(2.54), real_c(0.8), real_c(0.1), real_c(0.05) );

◆ Materials

using walberla::pe::Materials = typedef std::vector<Material>

Vector for materials.

◆ MatN

using walberla::pe::MatN = typedef math::MatrixMxN<real_t>

◆ MeshID

using walberla::pe::MeshID = typedef TriangleMesh *

Handle for a triangle mesh primitive.

◆ MeshType

using walberla::pe::MeshType = typedef TriangleMesh

Type of the triangle mesh geometric primitive.

◆ PlaneID

using walberla::pe::PlaneID = typedef Plane *

Handle for a plane primitive.

◆ PlanePtr

using walberla::pe::PlanePtr = typedef std::unique_ptr<Plane>

◆ PlaneType

using walberla::pe::PlaneType = typedef Plane

Type of the plane geometric primitive.

◆ PossibleContacts

using walberla::pe::PossibleContacts = typedef std::vector<std::pair<BodyID, BodyID> >

Output data type of coarse collision detection module.

◆ Quat

using walberla::pe::Quat = typedef math::Quaternion<real_t>

◆ SphereID

using walberla::pe::SphereID = typedef Sphere *

Handle for a sphere primitive.

◆ SpherePtr

using walberla::pe::SpherePtr = typedef std::unique_ptr<Sphere>

◆ SphereType

using walberla::pe::SphereType = typedef Sphere

Type of the sphere geometric primitive.

◆ SquirmerID

using walberla::pe::SquirmerID = typedef Squirmer *

Handle for a squirmer primitive.

◆ SquirmerPtr

using walberla::pe::SquirmerPtr = typedef std::unique_ptr<Squirmer>

◆ SquirmerType

using walberla::pe::SquirmerType = typedef Squirmer

Type of the squirmer geometric primitive.

◆ Storage

using walberla::pe::Storage = typedef std::array<BodyStorage, 2>

Container for local and shadow body storage.

◆ TriangleMeshPtr

using walberla::pe::TriangleMeshPtr = typedef std::unique_ptr<TriangleMesh>

◆ Vec2

using walberla::pe::Vec2 = typedef math::Vector2<real_t>

◆ Vec3

using walberla::pe::Vec3 = typedef math::Vector3<real_t>

Function Documentation

◆ checkAndResolveOverlap()

template<typename BodyTypeTuple >

void walberla::pe::checkAndResolveOverlap	(	BlockForest &	forest,
		BlockDataID	storageID,
		const real_t	dx,
		const bool	syncNonCommunicatingBodies
	)

◆ clearSynchronization()

void walberla::pe::clearSynchronization	(	BlockStorage &	blocks,
		BlockDataID	storageID
	)

inline

Removes all synchronization information.

Parameters

blocks	BlockStorage of the simulation.
storageID	BlockDataID of the pe storage.

◆ createMaterial() [1/2]

WALBERLA_PUBLIC MaterialID walberla::pe::createMaterial	(	const std::string &	name,
		real_t	density,
		real_t	cor,
		real_t	csf,
		real_t	cdf,
		real_t	poisson,
		real_t	young,
		real_t	stiffness,
		real_t	dampingN,
		real_t	dampingT
	)

Creating a new custom material.

Parameters

name	The name of the custom material.
density	The density of the custom material \( (0..\infty) \).
cor	The coefficient of restitution of the custom material \( [0..1] \).
csf	The coefficient of static friction of the custom material \( [0..\infty) \).
cdf	The coefficient of dynamic friction of the custom material \( [0..\infty) \).
poisson	The Poisson's ratio of the custom material \( [-1..0.5] \).
young	The Young's modulus of the custom material \( (0..\infty) \).
stiffness	The stiffness in normal direction of the material's contact region.
dampingN	The damping coefficient in normal direction of the material's contact region.
dampingT	The damping coefficient in tangential direction of the material's contact region.

Returns: The MaterialID for the new material.

Exceptions

std::invalid_argument	Invalid material parameter.
std::runtime_error	Invalid function call inside exclusive section.

This function creates the new, custom material name with the given properties. The following example illustrates the use of this function:

// Creates the material "myMaterial" with the following material properties:
//  - material density               : 2.54
//  - coefficient of restitution     : 0.8
//  - coefficient of static friction : 0.1
//  - coefficient of dynamic friction: 0.05
//  - Poisson's ratio                : 0.2
//  - Young's modulus                : 80
//  - Contact stiffness              : 100
//  - dampingN                       : 10
//  - dampingT                       : 11
MaterialID myMaterial = createMaterial( "myMaterial", 2.54, 0.8, 0.1, 0.05, 0.2, 80, 100, 10, 11 );

In case the name of the material is already in use or if any of the coefficients is not in its allowed range, a std::invalid_argument exception is thrown.
Note that the material has to be created on all processes in a MPI parallel simulation.

The coefficient of restitution is given for self-similar collisions that is collision of bodies made of similar material. The composite coefficient of restitution \(e_*\) is estimated as proposed by Stronge: \(\frac{e_*^2}{k_*} = \frac{e_1^2}{k_1} + \frac{e_2^2}{k_2}\).

◆ createMaterial() [2/2]

WALBERLA_PUBLIC MaterialID walberla::pe::createMaterial	(	real_t	density,
		real_t	cor,
		real_t	csf,
		real_t	cdf,
		real_t	poisson,
		real_t	young,
		real_t	stiffness,
		real_t	dampingN,
		real_t	dampingT
	)

Creating a new anonymous custom material.

Parameters

density	The density of the custom material \( (0..\infty) \).
cor	The coefficient of restitution of the custom material \( [0..1] \).
csf	The coefficient of static friction of the custom material \( [0..\infty) \).
cdf	The coefficient of dynamic friction of the custom material \( [0..\infty) \).
poisson	The Poisson's ratio of the custom material \( [-1..0.5] \).
young	The Young's modulus of the custom material \( (0..\infty) \).
stiffness	The stiffness in normal direction of the material's contact region.
dampingN	The damping coefficient in normal direction of the material's contact region.
dampingT	The damping coefficient in tangential direction of the material's contact region.

Returns: The MaterialID for the new material.

Exceptions

std::invalid_argument	Invalid material parameter.
std::runtime_error	Invalid function call inside exclusive section.

This function creates a new, custom material with the given properties. It will be named 'Material', followed by an incrementing number. Note that the material has to be created on all processes in an MPI parallel simulation.

◆ createStorageDataHandling()

template<typename BodyTuple >

shared_ptr<StorageDataHandling<BodyTuple> > walberla::pe::createStorageDataHandling ( )

◆ createWithNeighborhoodContactsShadow()

void walberla::pe::createWithNeighborhoodContactsShadow	(	BlockForest &	bf,
		const BlockDataID	storageID,
		const BlockDataID	fcdID,
		blockforest::InfoCollection &	ic
	)

Fills InfoCollection with up to date information.

The number of contacts is used as the computational weight. The number of shadow particles is used as the communication weight.

◆ createWithNeighborhoodLocalShadow()

void walberla::pe::createWithNeighborhoodLocalShadow	(	const BlockForest &	bf,
		const BlockDataID	storageID,
		blockforest::InfoCollection &	ic
	)

Fills InfoCollection with up to date information.

The number of local particles is used as the computational weight. The number of shadow particles is used as the communication weight.

◆ destroyBody()

template<class UnaryPredicate >

void walberla::pe::destroyBody	(	BodyStorage &	globalStorage,
		BlockStorage &	blocks,
		BlockDataID	storageID,
		const UnaryPredicate &	p
	)

Removes all rigid bodies which match the unary predicate p.

Attention: Has to be called the same way on all processes to work correctly!

◆ destroyBodyBySID()

void walberla::pe::destroyBodyBySID	(	BodyStorage &	globalStorage,
		BlockStorage &	blocks,
		BlockDataID	storageID,
		const walberla::id_t	sid
	)

removes the rigid body with the given sid

Attention: Has to be called the same way on all processes to work correctly!

◆ destroyBodyByUID()

void walberla::pe::destroyBodyByUID	(	BodyStorage &	globalStorage,
		BlockStorage &	blocks,
		BlockDataID	storageID,
		const walberla::id_t	uid
	)

removes all rigid bodies matching the given uid

Attention: Has to be called the same way on all processes to work correctly!

◆ distributeForces()

void walberla::pe::distributeForces	(	BlockStorage &	blocks,
		BlockDataID	storageID
	)

inline

◆ findContainingProcess()

template<class BlockT >

Owner walberla::pe::findContainingProcess	(	const BlockT &	block,
		const math::Vector3< real_t >	pt
	)

Looks through all neighboring blocks to find the one whose AABB contains pt.

Also checks if pt is located in the block itself. Returns -1 if no valid block is found otherwise the process rank of the containing block is returned.

Attention: If periodic boundaries are used you have to make sure the point is mapped to the domain before calling this function!

◆ generateSynchonizationMessages()

template<typename BodyTypeTuple >

void walberla::pe::generateSynchonizationMessages	(	mpi::BufferSystem &	bs,
		const Block &	block,
		BodyStorage &	localStorage,
		BodyStorage &	shadowStorage,
		const real_t	dx,
		const bool	syncNonCommunicatingBodies
	)

◆ getBody()

BodyID walberla::pe::getBody	(	BodyStorage &	globalStorage,
		BlockStorage &	blocks,
		BlockDataID	storageID,
		walberla::id_t	sid,
		int	storageSelect = `(StorageSelect::LOCAL\|StorageSelect::SHADOW\|StorageSelect::GLOBAL)`
	)

Tries to locate a rigid body and to return a pointer.

Tries to locate a rigidy body by its system ID (sid). If the body is found its BodyID is returned, otherwise NULL. The search space can be defined by storageType.

Returns: a pointer to the rigid body if it was found, NULL otherwise

◆ getDampingN()

real_t walberla::pe::getDampingN ( ConstContactID c )

inline

◆ getDampingT()

real_t walberla::pe::getDampingT ( ConstContactID c )

inline

◆ getFriction()

real_t walberla::pe::getFriction ( ConstContactID c )

inline

◆ getNumBodies()

std::pair< int64_t, int64_t > walberla::pe::getNumBodies	(	const domain_decomposition::BlockStorage &	bs,
		const BlockDataID &	storageID,
		const int	rank
	)

◆ getRestitution()

real_t walberla::pe::getRestitution ( ConstContactID c )

inline

◆ getSphereSphereOverlap()

real_t walberla::pe::getSphereSphereOverlap	(	const real_t	d,
		const real_t	r1,
		const real_t	r2
	)

Calculates overlap between two spheres.

Parameters

d	distance between two spheres
r1	radius of sphere 1
r2	radius of sphere 2

Returns: overlap volume

◆ getStiffness()

real_t walberla::pe::getStiffness ( ConstContactID c )

inline

◆ getSurfaceDistance() [1/3]

real_t walberla::pe::getSurfaceDistance	(	ConstPlaneID	p1,
		ConstPlaneID	p2
	)

inline

Distance calculation between two Plane primitives.

Parameters

p1	The first plane.
p2	The second plane.

Returns: The minimum distance between the two planes.

This function returns the distance between the two planes p1 and p2. Note that in case the two (infinite) planes overlap the returned distance is -math::Limits<real_t>::inf().

◆ getSurfaceDistance() [2/3]

real_t walberla::pe::getSurfaceDistance	(	ConstSphereID	s,
		ConstPlaneID	p
	)

inline

Distance calculation between a Sphere and a Plane.

Parameters

s	The sphere.
p	The plane.

Returns: The minimum distance between the sphere and the plane.

This function returns the distance between the sphere s and the plane p. Note that a negative distance indicates that the two bodies are overlapping.

◆ getSurfaceDistance() [3/3]

real_t walberla::pe::getSurfaceDistance	(	ConstSphereID	s1,
		ConstSphereID	s2
	)

inline

Distance calculation between two Sphere primitives.

Parameters

s1	The first sphere.
s2	The second sphere.

Returns: The minimum distance between the two spheres.

This function returns the distance between the two spheres s1 and s2. Note that a negative distance indicates that the two spheres are overlapping.

◆ hasNeighborOwner()

template<class BlockT >

bool walberla::pe::hasNeighborOwner	(	const BlockT &	block,
		const Owner &	owner
	)

Checks if one of the neighbor blocks is owned by process with rank rank.

◆ operator!=() [1/4]

template<typename C >

bool walberla::pe::operator!=	(	const ConstRigidBodyCastIterator< C > &	lhs,
		const ConstRigidBodyCastIterator< C > &	rhs
	)

inline

Inequality comparison between two CastIterator objects.

Parameters

lhs	The left hand side cast iterator.
rhs	The right hand side cast iterator.

Returns: true if the iterators don't point to the same element, false if they do.

◆ operator!=() [2/4]

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

inline

Inequality comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the iterators don't point to the same element, false if they do.

◆ operator!=() [3/4]

template<typename C >

bool walberla::pe::operator!=	(	const RigidBodyCastIterator< C > &	lhs,
		const RigidBodyCastIterator< C > &	rhs
	)

inline

Inequality comparison between two CastIterator objects.

Parameters

lhs	The left hand side cast iterator.
rhs	The right hand side cast iterator.

Returns: true if the iterators don't point to the same element, false if they do.

◆ operator!=() [4/4]

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

inline

Inequality comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the iterators don't point to the same element, false if they do.

◆ operator<() [1/2]

bool walberla::pe::operator<	(	const ConstRigidBodyIterator &	lhs,
		const ConstRigidBodyIterator &	rhs
	)

inline

Less-than comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the left-hand side iterator points to a lower element, false if not.

◆ operator<() [2/2]

bool walberla::pe::operator<	(	const RigidBodyIterator &	lhs,
		const RigidBodyIterator &	rhs
	)

inline

Less-than comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the left-hand side iterator points to a lower element, false if not.

◆ operator<<() [1/21]

std::ostream& walberla::pe::operator<<	(	std::ostream &	lhs,
		const Owner &	rhs
	)

inline

◆ operator<<() [2/21]

std::ostream& walberla::pe::operator<<	(	std::ostream &	os,
		const BodyStatistics &	bodyStatistics
	)

inline

◆ operator<<() [3/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		const Box &	b
	)

Global output operator for boxes.

Parameters

os	Reference to the output stream.
b	Reference to a constant box object.

Returns: Reference to the output stream.

◆ operator<<() [4/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		const Capsule &	c
	)

Global output operator for capsules.

Parameters

os	Reference to the output stream.
c	Reference to a constant capsule object.

Returns: Reference to the output stream.

◆ operator<<() [5/21]

std::ostream& walberla::pe::operator<<	(	std::ostream &	os,
		const Contact &	c
	)

inline

Global output operator for contacts.

Parameters

os	Reference to the output stream.
c	Reference to a constant contact object.

Returns: Reference to the output stream.

◆ operator<<() [6/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		const CylindricalBoundary &	c
	)

Global output operator for cylindrical boundaries.

Parameters

os	Reference to the output stream.
c	Reference to a cylindrical boundary object.

Returns: Reference to the output stream.

◆ operator<<() [7/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		const Ellipsoid &	s
	)

Global output operator for Ellipsoids.

Parameters

os	Reference to the output stream.
s	Reference to a constant Ellipsoid object.

Returns: Reference to the output stream.

◆ operator<<() [8/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		const Plane &	p
	)

Global output operator for planes.

Parameters

os	Reference to the output stream.
p	Reference to a constant plane object.

Returns: Reference to the output stream.

◆ operator<<() [9/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		const RigidBody &	b
	)

Global output operator for rigid bodies.

Parameters

os	Reference to the output stream.
b	Reference to a constant rigid body object.

Returns: Reference to the output stream.

◆ operator<<() [10/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		const Sphere &	s
	)

Global output operator for spheres.

Parameters

os	Reference to the output stream.
s	Reference to a constant sphere object.

Returns: Reference to the output stream.

◆ operator<<() [11/21]

template<typename... BodyTypes>

std::ostream& walberla::pe::operator<<	(	std::ostream &	os,
		const Union< BodyTypes... > &	u
	)

Global output operator for unions.

Parameters

os	Reference to the output stream.
u	Reference to a constant union object.

Returns: Reference to the output stream.

◆ operator<<() [12/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		ConstBodyID	b
	)

Global output operator for rigid body handles.

Parameters

os	Reference to the output stream.
b	Constant rigid body handle.

Returns: Reference to the output stream.

◆ operator<<() [13/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		ConstBoxID	b
	)

Global output operator for box handles.

Parameters

os	Reference to the output stream.
b	Constant box handle.

Returns: Reference to the output stream.

◆ operator<<() [14/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		ConstCapsuleID	c
	)

Global output operator for capsule handles.

Parameters

os	Reference to the output stream.
c	Constant capsule handle.

Returns: Reference to the output stream.

◆ operator<<() [15/21]

std::ostream& walberla::pe::operator<<	(	std::ostream &	os,
		ConstContactID	c
	)

inline

Global output operator for contact handles.

Parameters

os	Reference to the output stream.
c	Constant contact handle.

Returns: Reference to the output stream.

◆ operator<<() [16/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		ConstEllipsoidID	s
	)

Global output operator for Ellipsoid handles.

Parameters

os	Reference to the output stream.
s	Constant Ellipsoid handle.

Returns: Reference to the output stream.

◆ operator<<() [17/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		ConstPlaneID	p
	)

Global output operator for plane handles.

Parameters

os	Reference to the output stream.
p	Constant plane handle.

Returns: Reference to the output stream.

◆ operator<<() [18/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		ConstSphereID	s
	)

Global output operator for sphere handles.

Parameters

os	Reference to the output stream.
s	Constant sphere handle.

Returns: Reference to the output stream.

◆ operator<<() [19/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		Contact::ContactType	type
	)

Calculation of the normal relative acceleration between the two contacting rigid bodies.

Returns: The relative acceleration in normal direction.

Global output operator for ContactType.

Parameters

os	Reference to the output stream.
type	The ContactType to be put into the stream.

Returns: Reference to the output stream.

◆ operator<<() [20/21]

std::ostream & walberla::pe::operator<<	(	std::ostream &	os,
		CylindricalBoundaryID	c
	)

Global output operator for cylindrical boundaries handles.

Parameters

os	Reference to the output stream.
c	Constant cylindrical boundary handle.

Returns: Reference to the output stream.

◆ operator<<() [21/21]

template<typename... BodyTypes>

std::ostream& walberla::pe::operator<<	(	std::ostream &	os,
		Union< BodyTypes... > const *	u
	)

Global output operator for union handles.

Parameters

os	Reference to the output stream.
u	Constant union handle.

Returns: Reference to the output stream.

◆ operator<=() [1/2]

bool walberla::pe::operator<=	(	const ConstRigidBodyIterator &	lhs,
		const ConstRigidBodyIterator &	rhs
	)

inline

Less-or-equal-than comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the left-hand side iterator points to a lower or the same element, false if not.

◆ operator<=() [2/2]

bool walberla::pe::operator<=	(	const RigidBodyIterator &	lhs,
		const RigidBodyIterator &	rhs
	)

inline

Less-or-equal-than comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the left-hand side iterator points to a lower or the same element, false if not.

◆ operator==() [1/6]

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

inline

Compare if two BodyStorages are equal.

Since BodyStorages are uncopyable two BodyStorages are considered equal if their addresses are equal.

◆ operator==() [2/6]

template<typename C >

bool walberla::pe::operator==	(	const ConstRigidBodyCastIterator< C > &	lhs,
		const ConstRigidBodyCastIterator< C > &	rhs
	)

inline

Equality comparison between two CastIterator objects.

Parameters

lhs	The left hand side cast iterator.
rhs	The right hand side cast iterator.

Returns: true if the iterators point to the same element, false if not.

◆ operator==() [3/6]

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

inline

Equality comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the iterators point to the same element, false if not.

◆ operator==() [4/6]

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

inline

◆ operator==() [5/6]

template<typename C >

bool walberla::pe::operator==	(	const RigidBodyCastIterator< C > &	lhs,
		const RigidBodyCastIterator< C > &	rhs
	)

inline

Equality comparison between two CastIterator objects.

Parameters

lhs	The left hand side cast iterator.
rhs	The right hand side cast iterator.

Returns: true if the iterators point to the same element, false if not.

◆ operator==() [6/6]

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

inline

Equality comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the iterators point to the same element, false if not.

◆ operator>() [1/2]

bool walberla::pe::operator>	(	const ConstRigidBodyIterator &	lhs,
		const ConstRigidBodyIterator &	rhs
	)

inline

Greater-than comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the left-hand side iterator points to a higher element, false if not.

◆ operator>() [2/2]

bool walberla::pe::operator>	(	const RigidBodyIterator &	lhs,
		const RigidBodyIterator &	rhs
	)

inline

Greater-than comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the left-hand side iterator points to a higher element, false if not.

◆ operator>=() [1/2]

bool walberla::pe::operator>=	(	const ConstRigidBodyIterator &	lhs,
		const ConstRigidBodyIterator &	rhs
	)

inline

Greater-or-equal-than comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the left-hand side iterator points to a higher or the same element, false if not.

◆ operator>=() [2/2]

bool walberla::pe::operator>=	(	const RigidBodyIterator &	lhs,
		const RigidBodyIterator &	rhs
	)

inline

Greater-or-equal-than comparison between two PtrIterator objects.

Parameters

lhs	The left-hand side pointer iterator.
rhs	The right-hand side pointer iterator.

Returns: true if the left-hand side iterator points to a higher or the same element, false if not.

◆ reduceForces() [1/2]

void walberla::pe::reduceForces	(	BlockStorage &	blocks,
		BlockDataID	storageID
	)

inline

◆ reduceForces() [2/2]

void walberla::pe::reduceForces	(	BlockStorage &	blocks,
		BlockDataID	storageID,
		BodyStorage &	globalBodyStorage
	)

inline

◆ removeAndNotify()

BodyStorage::iterator walberla::pe::removeAndNotify	(	Owner	me,
		mpi::BufferSystem &	bs,
		BodyStorage &	localStorage,
		BodyStorage::iterator	body
	)

inline

Removes a rigid body from the local body storage and informs shadow copy holders.

Parameters

body	An iterator pointing to the rigid body to be removed from the collision system.

Returns: An iterator pointing to the rigid body after the erase body.

This function removes the rigid body from the body storage and generates deletion notifications.

◆ shouldContactBeTreated()

bool walberla::pe::shouldContactBeTreated	(	ContactID	c,
		const math::AABB &	blkAABB
	)

inline

◆ syncNextNeighbors()

template<typename BodyTypeTuple >

void walberla::pe::syncNextNeighbors	(	BlockForest &	forest,
		BlockDataID	storageID,
		WcTimingTree *	tt = `nullptr`,
		const real_t	dx = `real_t(0)`,
		const bool	syncNonCommunicatingBodies = `false`
	)

◆ syncShadowOwners()

template<typename BodyTypeTuple >

void walberla::pe::syncShadowOwners	(	BlockForest &	forest,
		BlockDataID	storageID,
		WcTimingTree *	tt = `nullptr`,
		const real_t	dx = `real_t(0)`,
		const bool	syncNonCommunicatingBodies = `false`
	)

◆ updateAndMigrate()

template<typename BodyTypeTuple >

void walberla::pe::updateAndMigrate	(	BlockForest &	forest,
		BlockDataID	storageID,
		const bool	syncNonCommunicatingBodies
	)

Variable Documentation

◆ collisionThreshold

real_t walberla::pe::collisionThreshold = Thresholds<real_t>::collisionThreshold()

Threshold for the contact classification.

This threshold separates between separating, resting and colliding contacts.

◆ contactThreshold

real_t walberla::pe::contactThreshold = Thresholds<real_t>::contactThreshold()

Threshold for the distance between two rigid bodies.

Rigid bodies with a distance smaller than this threshold are in contact.

◆ frictionThreshold

real_t walberla::pe::frictionThreshold = Thresholds<real_t>::frictionThreshold()

Threshold for the separation between static and dynamic friction.

This threshold represents the boundary between static and dynamic friction.

◆ invalid_material

const MaterialID walberla::pe::invalid_material = static_cast<MaterialID>( -1 )

ID for an invalid material.

This MaterialID is returned by the getMaterial() function in case no material with the specified name is returned. This value should not be used to create rigid bodies or in any other function!

◆ restitutionThreshold

real_t walberla::pe::restitutionThreshold = Thresholds<real_t>::restitutionThreshold()

Threshold for the restriction of the coefficient of restitution.

In case the relative velocity between two colliding rigid bodies is smaller than this threshold, a coefficient of restitution of 0 is used to avoid an infinite number of collisions during a single time step.

◆ sleepBias

const real_t walberla::pe::sleepBias = real_c( 0.5 )

Recency-weighted average bias value for the sleep mode \( [0..1] \).

The motion of a rigid body is calculated by a recency-weighted average. This value specifies the bias value for the calculation. It controls how much significance is given to previous values. The bias value has to be in the range \( [0..1] \): A value of zero makes the recency-weighted average equal to the current motion of the rigid body, a bias of one ignores the current motion altogether.

◆ sleepThreshold

const real_t walberla::pe::sleepThreshold = real_c( 0 )

Sleep mode threshold value.

This value specifies the threshold value for the sleep mode of a rigid body. In case the motion of a rigid body drops below this threshold, the body is put to sleep and is not moved during a simulation time step. The body is wakened again if its position or its orientation is changed or if forces or impulses are added to the body.
The sleep threshold can be set to any non-negative value \( [0..\infty) \). A value of zero switches off sleep mode entirely.
For more details about the calculation of the motion of a rigid body, see the description of the RigidBody::calcMotion() function.

◆ surfaceThreshold

real_t walberla::pe::surfaceThreshold = Thresholds<real_t>::surfaceThreshold()

Threshold for surface points/checks.

Only points with a distance to the surface smaller than this threshold are considered surface point.

Namespaces

Classes

Typedefs

Functions

Variables

Typedef Documentation

◆ BodyID

◆ BodyPtr

◆ BodyType

◆ BoxID

◆ BoxPtr

◆ BoxType

◆ CapsuleID

◆ CapsulePtr

◆ CapsuleType

◆ ConstBodyID

◆ ConstBoxID

◆ ConstCapsuleID

◆ ConstContactID

◆ ConstCylinderID

◆ ConstCylindricalBoundaryID

◆ ConstEllipsoidID

◆ ConstGeomID

◆ ConstManagerID

◆ ConstMeshID

◆ ConstPlaneID

◆ ConstSphereID

◆ ConstSquirmerID

◆ ContactID

◆ Contacts

◆ ContactType

◆ CylinderID

◆ CylinderPtr

◆ CylinderType

◆ CylindricalBoundaryID

◆ CylindricalBoundaryPtr

◆ CylindricalBoundaryType

◆ EllipsoidID

◆ EllipsoidPtr

◆ EllipsoidType

◆ GeomID

◆ ManagerID

◆ Mat2

◆ Mat3

◆ MaterialID

◆ Materials

◆ MatN

◆ MeshID

◆ MeshType

◆ PlaneID

◆ PlanePtr

◆ PlaneType

◆ PossibleContacts

◆ Quat

◆ SphereID

◆ SpherePtr

◆ SphereType

◆ SquirmerID

◆ SquirmerPtr

◆ SquirmerType

◆ Storage

◆ TriangleMeshPtr

◆ Vec2

◆ Vec3

Function Documentation

◆ checkAndResolveOverlap()

◆ clearSynchronization()

◆ createMaterial() [1/2]

◆ createMaterial() [2/2]

◆ createStorageDataHandling()

◆ createWithNeighborhoodContactsShadow()

◆ createWithNeighborhoodLocalShadow()

◆ destroyBody()

◆ destroyBodyBySID()

◆ destroyBodyByUID()

◆ distributeForces()

◆ findContainingProcess()

◆ generateSynchonizationMessages()

◆ getBody()

◆ getDampingN()