walberla::lbm Namespace Reference

Namespaces
namespace	internal
namespace	communication
namespace	evaluations
namespace	initializer
namespace	collision_model
namespace	force_model
namespace	refinement
namespace	internal_fixeddensityd3q19_even
namespace	internal_fixeddensityd3q27_even
namespace	internal_freeslipd3q19_even
namespace	internal_freeslipd3q27_even
namespace	internal_noslipd3q19_even
namespace	internal_noslipd3q27_even
namespace	internal_outflowd3q19_even
namespace	internal_outflowd3q27_even
namespace	internal_ubbd3q19_even
namespace	internal_ubbd3q27_even
namespace	internal_d3q19storagespecification_pack_ALL
namespace	internal_d3q19storagespecification_unpack_ALL
namespace	internal_d3q19storagespecification_localCopy_ALL
namespace	internal_d3q19storagespecification_pack_B
namespace	internal_d3q19storagespecification_pack_BW
namespace	internal_d3q19storagespecification_pack_T
namespace	internal_d3q19storagespecification_pack_NW
namespace	internal_d3q19storagespecification_pack_SW
namespace	internal_d3q19storagespecification_pack_BS
namespace	internal_d3q19storagespecification_pack_N
namespace	internal_d3q19storagespecification_pack_BE
namespace	internal_d3q19storagespecification_pack_W
namespace	internal_d3q19storagespecification_pack_TS
namespace	internal_d3q19storagespecification_pack_E
namespace	internal_d3q19storagespecification_pack_SE
namespace	internal_d3q19storagespecification_pack_BN
namespace	internal_d3q19storagespecification_pack_TN
namespace	internal_d3q19storagespecification_pack_NE
namespace	internal_d3q19storagespecification_pack_TW
namespace	internal_d3q19storagespecification_pack_TE
namespace	internal_d3q19storagespecification_pack_S
namespace	internal_d3q19storagespecification_unpack_N
namespace	internal_d3q19storagespecification_unpack_TW
namespace	internal_d3q19storagespecification_unpack_NW
namespace	internal_d3q19storagespecification_unpack_S
namespace	internal_d3q19storagespecification_unpack_BS
namespace	internal_d3q19storagespecification_unpack_NE
namespace	internal_d3q19storagespecification_unpack_BW
namespace	internal_d3q19storagespecification_unpack_BN
namespace	internal_d3q19storagespecification_unpack_TN
namespace	internal_d3q19storagespecification_unpack_W
namespace	internal_d3q19storagespecification_unpack_SW
namespace	internal_d3q19storagespecification_unpack_SE
namespace	internal_d3q19storagespecification_unpack_E
namespace	internal_d3q19storagespecification_unpack_TS
namespace	internal_d3q19storagespecification_unpack_BE
namespace	internal_d3q19storagespecification_unpack_B
namespace	internal_d3q19storagespecification_unpack_TE
namespace	internal_d3q19storagespecification_unpack_T
namespace	internal_d3q19storagespecification_localCopy_BE
namespace	internal_d3q19storagespecification_localCopy_NE
namespace	internal_d3q19storagespecification_localCopy_TE
namespace	internal_d3q19storagespecification_localCopy_N
namespace	internal_d3q19storagespecification_localCopy_NW
namespace	internal_d3q19storagespecification_localCopy_BS
namespace	internal_d3q19storagespecification_localCopy_TN
namespace	internal_d3q19storagespecification_localCopy_SE
namespace	internal_d3q19storagespecification_localCopy_B
namespace	internal_d3q19storagespecification_localCopy_W
namespace	internal_d3q19storagespecification_localCopy_TS
namespace	internal_d3q19storagespecification_localCopy_TW
namespace	internal_d3q19storagespecification_localCopy_BW
namespace	internal_d3q19storagespecification_localCopy_SW
namespace	internal_d3q19storagespecification_localCopy_BN
namespace	internal_d3q19storagespecification_localCopy_E
namespace	internal_d3q19storagespecification_localCopy_T
namespace	internal_d3q19storagespecification_localCopy_S
namespace	internal_d3q27storagespecification_pack_ALL
namespace	internal_d3q27storagespecification_unpack_ALL
namespace	internal_d3q27storagespecification_localCopy_ALL
namespace	internal_d3q27storagespecification_pack_BE
namespace	internal_d3q27storagespecification_pack_SE
namespace	internal_d3q27storagespecification_pack_BW
namespace	internal_d3q27storagespecification_pack_BSW
namespace	internal_d3q27storagespecification_pack_N
namespace	internal_d3q27storagespecification_pack_SW
namespace	internal_d3q27storagespecification_pack_T
namespace	internal_d3q27storagespecification_pack_B
namespace	internal_d3q27storagespecification_pack_TNW
namespace	internal_d3q27storagespecification_pack_W
namespace	internal_d3q27storagespecification_pack_TSW
namespace	internal_d3q27storagespecification_pack_E
namespace	internal_d3q27storagespecification_pack_BSE
namespace	internal_d3q27storagespecification_pack_TN
namespace	internal_d3q27storagespecification_pack_BNW
namespace	internal_d3q27storagespecification_pack_TS
namespace	internal_d3q27storagespecification_pack_NW
namespace	internal_d3q27storagespecification_pack_TW
namespace	internal_d3q27storagespecification_pack_S
namespace	internal_d3q27storagespecification_pack_TNE
namespace	internal_d3q27storagespecification_pack_TSE
namespace	internal_d3q27storagespecification_pack_BS
namespace	internal_d3q27storagespecification_pack_TE
namespace	internal_d3q27storagespecification_pack_BN
namespace	internal_d3q27storagespecification_pack_NE
namespace	internal_d3q27storagespecification_pack_BNE
namespace	internal_d3q27storagespecification_unpack_SE
namespace	internal_d3q27storagespecification_unpack_BS
namespace	internal_d3q27storagespecification_unpack_BNW
namespace	internal_d3q27storagespecification_unpack_BSW
namespace	internal_d3q27storagespecification_unpack_W
namespace	internal_d3q27storagespecification_unpack_TN
namespace	internal_d3q27storagespecification_unpack_E
namespace	internal_d3q27storagespecification_unpack_TS
namespace	internal_d3q27storagespecification_unpack_TW
namespace	internal_d3q27storagespecification_unpack_NE
namespace	internal_d3q27storagespecification_unpack_NW
namespace	internal_d3q27storagespecification_unpack_TE
namespace	internal_d3q27storagespecification_unpack_S
namespace	internal_d3q27storagespecification_unpack_B
namespace	internal_d3q27storagespecification_unpack_BN
namespace	internal_d3q27storagespecification_unpack_TSE
namespace	internal_d3q27storagespecification_unpack_TNE
namespace	internal_d3q27storagespecification_unpack_BW
namespace	internal_d3q27storagespecification_unpack_TNW
namespace	internal_d3q27storagespecification_unpack_BNE
namespace	internal_d3q27storagespecification_unpack_BSE
namespace	internal_d3q27storagespecification_unpack_N
namespace	internal_d3q27storagespecification_unpack_BE
namespace	internal_d3q27storagespecification_unpack_SW
namespace	internal_d3q27storagespecification_unpack_T
namespace	internal_d3q27storagespecification_unpack_TSW
namespace	internal_d3q27storagespecification_localCopy_TNE
namespace	internal_d3q27storagespecification_localCopy_S
namespace	internal_d3q27storagespecification_localCopy_E
namespace	internal_d3q27storagespecification_localCopy_TE
namespace	internal_d3q27storagespecification_localCopy_SW
namespace	internal_d3q27storagespecification_localCopy_TS
namespace	internal_d3q27storagespecification_localCopy_BSE
namespace	internal_d3q27storagespecification_localCopy_BNE
namespace	internal_d3q27storagespecification_localCopy_TSW
namespace	internal_d3q27storagespecification_localCopy_SE
namespace	internal_d3q27storagespecification_localCopy_W
namespace	internal_d3q27storagespecification_localCopy_TSE
namespace	internal_d3q27storagespecification_localCopy_BW
namespace	internal_d3q27storagespecification_localCopy_TW
namespace	internal_d3q27storagespecification_localCopy_B
namespace	internal_d3q27storagespecification_localCopy_N
namespace	internal_d3q27storagespecification_localCopy_NW
namespace	internal_d3q27storagespecification_localCopy_TNW
namespace	internal_d3q27storagespecification_localCopy_NE
namespace	internal_d3q27storagespecification_localCopy_BN
namespace	internal_d3q27storagespecification_localCopy_T
namespace	internal_d3q27storagespecification_localCopy_BNW
namespace	internal_d3q27storagespecification_localCopy_BS
namespace	internal_d3q27storagespecification_localCopy_BSW
namespace	internal_d3q27storagespecification_localCopy_TN
namespace	internal_d3q27storagespecification_localCopy_BE
namespace	internal_d3q19srt_kernel_streamCollide
namespace	internal_d3q19srt_kernel_collide
namespace	internal_d3q19srt_kernel_stream
namespace	internal_d3q19srt_kernel_streamOnlyNoAdvancement
namespace	internal_d3q19srt_kernel_initialise
namespace	internal_d3q19srt_kernel_getter
namespace	internal_d3q27srt_kernel_streamCollide
namespace	internal_d3q27srt_kernel_collide
namespace	internal_d3q27srt_kernel_stream
namespace	internal_d3q27srt_kernel_streamOnlyNoAdvancement
namespace	internal_d3q27srt_kernel_initialise
namespace	internal_d3q27srt_kernel_getter

Classes
class	CombinedInPlaceGpuPackInfo
class	PostProcessing
class	MarkerFieldGenerator
class	MarkerData
class	BlockForestEvaluationBase
	Class for evaluating the BlockForest data structure of an LBM simulation. More...
class	BlockForestEvaluation
class	Curved
class	DiffusionDirichlet
class	DynamicUBB
class	DefaultBoundaryHandlingFactory
	Creates a default boundary handling for LBM simulations. More...
class	DefaultBoundaryHandlingCollectionFactory
class	DefaultDiffusionBoundaryHandlingFactory
class	ExtendedBoundaryHandlingFactory
	Creates a default boundary handling for LBM simulations. More...
class	FreeDiffusion
class	FreeSlip
class	NoDiffusion
class	NoSlip
class	Outlet
class	ParserUBB
class	Pressure
class	SimpleDiffusionDirichlet
class	SimplePAB
class	SimplePressure
class	SimpleUBB
class	SimpleVelocityBoundary
class	UBB
class	VelocityBoundary
class	CombinedInPlaceCpuPackInfo
class	SparsePdfFieldPackInfo
	Optimized PackInfo for sparse PDF fields. More...
class	DensityAdaptionFunction
class	VelocityVectorAdaptionFunction
class	MomentumDensityVectorAdaptionFunction
class	VelocityAdaptionFunction
class	MomentumDensityAdaptionFunction
class	ShearRateAdaptionFunction
struct	Adaptor
struct	PdfFieldCreator
struct	Density
struct	Density< LatticeModel_T >
struct	DensityAndMomentumDensity
struct	DensityAndMomentumDensity< LatticeModel_T >
struct	DensityAndVelocity
struct	DensityAndVelocityRange
struct	DensityAndVelocityRange< LatticeModel_T, FieldIteratorXYZ >
class	DefaultDensityEquilibriumVelocityCalculation
class	AdvectionDiffusionDensityEquilibriumVelocityCalculation
class	DefaultDensityVelocityCallback
class	VelocityCallback
class	VelocityCallback< VelocityField_T >
class	DensityCallback
class	DensityVelocityCallback
struct	Equilibrium
struct	Equilibrium< LatticeModel_T >
struct	EquilibriumRange
struct	EquilibriumRange< LatticeModel_T, FieldIteratorXYZ >
struct	MomentumDensity
struct	MomentumDensity< LatticeModel_T >
class	PdfField
	Specialized field class for PDF fields (fields containing multiple particle distribution functions per cell). More...
struct	PressureTensor
struct	QCriterion
class	QCriterionFieldWriter
struct	ShearRate
class	VelocityFieldWriter
struct	Vorticity
class	D2Q9
class	D3Q15
class	D3Q19
class	D3Q27
class	EquilibriumDistribution
class	EquilibriumDistribution< LatticeModel_T >
class	LatticeModelBase
	Base class that is supposed (but not required) to be used for defining specific lattice models. More...
struct	NeighborsStencil
struct	NeighborsStencil< LatticeModel_T >
class	SmagorinskyLES
	Can be used together with the collision model "SRTField". More...
class	PerformanceEvaluationBase
	Class for evaluating the performance of LBM simulations. More...
class	PerformanceEvaluation
	Class for evaluating the performance of LBM simulations using fields. More...
class	PerformanceLogger
	Class for using the PerformanceEvaluation in a timeloop. More...
class	TimeTracker
	Keeps track of the simulation time (One step on the coarsest level counts as '1', one step on the next finer level counts as '0.5', one step on the next level as '0.25' etc.). More...
class	AdvectionDiffusionSweep
class	AdvectionDiffusionSweep< LM_AdvDiff, VelocityAdapter_T, FlagField_T, VectorField_T >
class	AdvectionDiffusionCellOperation< LM_AdvDiff, LM_Hydro >
class	DefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	DefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::Guo_tag > > >
class	DefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	DefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	SplitPureSweep< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	SplitPureSweep< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	SplitSweep< LatticeModel_T, FlagField_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	SplitSweep< LatticeModel_T, FlagField_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&LatticeModel_T::CollisionModel::constant &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	ActiveCellSweep
class	AdvectionDiffusionCellOperation
class	DefaultCellOperation
class	CellwiseSweep
	Class for performing the streaming and collision step of the LBM. More...
class	FlagFieldSweepBase
class	SplitPureSweep
class	SplitSweep
struct	Stream
struct	StreamEverything
struct	StreamPullEverything
struct	StreamPull
class	SweepBase
class	StreamSweep
class	CollideSweep
class	DefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&! std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	DefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	DefaultCellOperation< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	SplitPureSweep< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	SplitPureSweep< LatticeModel_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	SplitSweep< LatticeModel_T, FlagField_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	SplitSweep< LatticeModel_T, FlagField_T, typename std::enable_if_t< std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&LatticeModel_T::compressible &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > > >
class	CurlMagnitudeVTKWriter
	lengthScaleWeight is only used to be able to derive quantities for the adaptive mesh refinement criterium of curl. More...
class	DensityVTKWriter
class	DensitySIVTKWriter
class	NonEqulibriumVTKWriter
class	PressureTensorVTKWriter
class	QCriterionVTKWriter
class	VelocityVTKWriter
class	VelocityMagnitudeVTKWriter
class	VelocitySIVTKWriter
class	VelocitySIMagnitudeVTKWriter
class	VorticityComponentVTKWriter
class	VTKOutput
	Default setup for VTK in LBM simulations. More...
class	D3Q19BoundaryCollection
class	D3Q27BoundaryCollection
class	FixedDensityD3Q19
class	FixedDensityD3Q27
class	FreeSlipD3Q19
class	FreeSlipD3Q27
class	NoSlipD3Q19
class	NoSlipD3Q27
class	OutflowD3Q19
class	OutflowD3Q27
class	UBBD3Q19
class	UBBD3Q27
class	D3Q19StorageSpecification
class	D3Q27StorageSpecification
class	D3Q19SRT
class	D3Q27SRT

Typedefs
template<typename LatticeModel_T>
using	PdfFieldPackInfo
	Optimized PackInfo for PDF fields (communicates only components pointing to neighbor).

Functions
	WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM ((std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::Cumulant_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q27 > &&LatticeModel_T::compressible &&LatticeModel_T::equilibriumAccuracyOrder==2 &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > &&std::is_same_v< DensityVelocityIn_T, DefaultDensityEquilibriumVelocityCalculation >)) WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_HEAD((std
	WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_FOOT () WALBERLA_LBM_CELLWISE_SWEEP_COLLIDE_HEAD((std
template<typename LatticeModel_T, typename BlockStorage_T>
BlockDataID	addPdfFieldToStorage (const shared_ptr< BlockStorage_T > &blocks, const std::string &identifier, const LatticeModel_T &latticeModel, const field::Layout &layout=field::fzyx, const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet(), const shared_ptr< field::FieldAllocator< real_t > > alloc=nullptr)
template<typename LatticeModel_T, typename BlockStorage_T>
BlockDataID	addPdfFieldToStorage (const shared_ptr< BlockStorage_T > &blocks, const std::string &identifier, const LatticeModel_T &latticeModel, const uint_t ghostLayers, const field::Layout &layout=field::fzyx, const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet(), const shared_ptr< field::FieldAllocator< real_t > > alloc=nullptr)
template<typename LatticeModel_T, typename BlockStorage_T>
BlockDataID	addPdfFieldToStorage (const shared_ptr< BlockStorage_T > &blocks, const std::string &identifier, const LatticeModel_T &latticeModel, const Vector3< real_t > &initialVelocity, const real_t initialDensity, const field::Layout &layout=field::fzyx, const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet(), const shared_ptr< field::FieldAllocator< real_t > > alloc=nullptr)
template<typename LatticeModel_T, typename BlockStorage_T>
BlockDataID	addPdfFieldToStorage (const shared_ptr< BlockStorage_T > &blocks, const std::string &identifier, const LatticeModel_T &latticeModel, const Vector3< real_t > &initialVelocity, const real_t initialDensity, const uint_t ghostLayers, const field::Layout &layout=field::fzyx, const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet(), const shared_ptr< field::FieldAllocator< real_t > > alloc=nullptr)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
void	setDensityAndVelocity (FieldPtrOrIterator &it, const LatticeModel_T &latticeModel, const Vector3< real_t > &velocity=Vector3< real_t >(0.0_r), const real_t rho=1.0_r)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
void	setToEquilibrium (FieldPtrOrIterator &it, const Vector3< real_t > &velocity=Vector3< real_t >(0.0_r), const real_t rho=1.0_r)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
real_t	getDensity (const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
real_t	getDensitySI (const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it, const real_t rho_SI)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
Vector3< real_t >	getMomentumDensity (const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
void	getMomentumDensity (Vector3< real_t > &momentumDensity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
Vector3< real_t >	getEquilibriumMomentumDensity (const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
void	getEquilibriumMomentumDensity (Vector3< real_t > &momentumDensity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
Vector3< real_t >	getVelocity (const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
void	getVelocity (Vector3< real_t > &velocity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
Vector3< real_t >	getEquilibriumVelocity (const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
void	getEquilibriumVelocity (Vector3< real_t > &velocity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
Vector3< real_t >	getVelocitySI (const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it, const real_t dx_SI, const real_t dt_SI)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
void	getVelocitySI (Vector3< real_t > &velocity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it, const real_t dx_SI, const real_t dt_SI)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
Vector3< real_t >	getVelocitySI (const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it, const real_t dxDividedByDt_SI)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
void	getVelocitySI (Vector3< real_t > &velocity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it, const real_t dxDividedByDt_SI)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
real_t	getDensityAndMomentumDensity (Vector3< real_t > &momentumDensity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
real_t	getDensityAndEquilibriumMomentumDensity (Vector3< real_t > &momentumDensity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
real_t	getDensityAndVelocity (Vector3< real_t > &velocity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
real_t	getDensityAndEquilibriumVelocity (Vector3< real_t > &velocity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
real_t	getDensityAndVelocitySI (Vector3< real_t > &velocity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it, const real_t rho_SI, const real_t dx_SI, const real_t dt_SI)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
real_t	getDensityAndVelocitySI (Vector3< real_t > &velocity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it, const real_t rho_SI, const real_t dxDividedByDt_SI)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
real_t	getShearRate (const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
Matrix3< real_t >	getPressureTensor (const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename LatticeModel_T, typename FieldPtrOrIterator>
void	getPressureTensor (Matrix3< real_t > &velocity, const LatticeModel_T &latticeModel, const FieldPtrOrIterator &it)
template<typename VelocityField_T, typename Filter_T>
real_t	getQCriterion (const VelocityField_T &velocityField, const Filter_T &filter, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, real_t dx=1_r, real_t dy=1_r, real_t dz=1_r)
template<typename VelocityField_T, typename Filter_T>
Vector3< real_t >	getVorticity (const VelocityField_T &velocityField, const Filter_T &filter, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, real_t dx=1_r, real_t dy=1_r, real_t dz=1_r)
real_t	intersectionRatioSphere (const geometry::Sphere &sphere, const Vector3< real_t > &fluidPoint, const Vector3< real_t > &direction)
template<typename Body>
real_t	intersectionRatioBisection (const Body &body, const Vector3< real_t > &fluidPoint, const Vector3< real_t > &direction, const real_t epsilon)
template<typename Body>
real_t	intersectionRatio (const Body &body, const Vector3< real_t > &fluidPoint, const Vector3< real_t > &direction, const real_t epsilon)
	Computes the intersection of a ray segment with a body surface.
real_t	intersectionRatio (const geometry::Sphere &sphere, const Vector3< real_t > &fluidPoint, const Vector3< real_t > &direction, const real_t=0_r)
template<typename DensityField_T>
shared_ptr< walberla::field::MassEvaluation< DensityField_T > >	makeMassEvaluation (const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const uint_t plotFrequency, const uint_t logFrequency, const std::string &filename=std::string(walberla::field::internal::massEvaluationFilename), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, typename FlagField_T>
shared_ptr< walberla::field::MassEvaluation< DensityField_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T > > >	makeMassEvaluation (const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &fluid, const uint_t plotFrequency, const uint_t logFrequency, const std::string &filename=std::string(walberla::field::internal::massEvaluationFilename), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, typename Filter_T>
shared_ptr< walberla::field::MassEvaluation< DensityField_T, Filter_T > >	makeMassEvaluation (const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const Filter_T &filter, const uint_t plotFrequency, const uint_t logFrequency, const std::string &filename=std::string(walberla::field::internal::massEvaluationFilename), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, bool Pseudo2D>
shared_ptr< walberla::field::MassEvaluation< DensityField_T, field::DefaultEvaluationFilter, Pseudo2D > >	makeMassEvaluation (const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const uint_t plotFrequency, const uint_t logFrequency, const std::string &filename=std::string(walberla::field::internal::massEvaluationFilename), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, typename FlagField_T, bool Pseudo2D>
shared_ptr< walberla::field::MassEvaluation< DensityField_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, Pseudo2D > >	makeMassEvaluation (const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &fluid, const uint_t plotFrequency, const uint_t logFrequency, const std::string &filename=std::string(walberla::field::internal::massEvaluationFilename), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, typename Filter_T, bool Pseudo2D>
shared_ptr< walberla::field::MassEvaluation< DensityField_T, Filter_T, Pseudo2D > >	makeMassEvaluation (const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const Filter_T &filter, const uint_t plotFrequency, const uint_t logFrequency, const std::string &filename=std::string(walberla::field::internal::massEvaluationFilename), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, typename Config_T>
shared_ptr< walberla::field::MassEvaluation< DensityField_T > >	makeMassEvaluation (const Config_T &config, const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const std::string &configBlockName=std::string(walberla::field::internal::massEvaluationConfigBlock), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, typename FlagField_T, typename Config_T>
shared_ptr< walberla::field::MassEvaluation< DensityField_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T > > >	makeMassEvaluation (const Config_T &config, const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &fluid, const std::string &configBlockName=std::string(walberla::field::internal::massEvaluationConfigBlock), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, typename Filter_T, typename Config_T>
shared_ptr< walberla::field::MassEvaluation< DensityField_T, Filter_T > >	makeMassEvaluation (const Config_T &config, const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const Filter_T &filter, const std::string &configBlockName=std::string(walberla::field::internal::massEvaluationConfigBlock), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, bool Pseudo2D, typename Config_T>
shared_ptr< walberla::field::MassEvaluation< DensityField_T, field::DefaultEvaluationFilter, Pseudo2D > >	makeMassEvaluation (const Config_T &config, const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const std::string &configBlockName=std::string(walberla::field::internal::massEvaluationConfigBlock), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, typename FlagField_T, bool Pseudo2D, typename Config_T>
shared_ptr< walberla::field::MassEvaluation< DensityField_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, Pseudo2D > >	makeMassEvaluation (const Config_T &config, const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &fluid, const std::string &configBlockName=std::string(walberla::field::internal::massEvaluationConfigBlock), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
template<typename DensityField_T, typename Filter_T, bool Pseudo2D, typename Config_T>
shared_ptr< walberla::field::MassEvaluation< DensityField_T, Filter_T, Pseudo2D > >	makeMassEvaluation (const Config_T &config, const shared_ptr< StructuredBlockStorage > &blocks, const uint_t level, const ConstBlockDataID &fieldId, const Filter_T &filter, const std::string &configBlockName=std::string(walberla::field::internal::massEvaluationConfigBlock), const Set< SUID > &requiredSelectors=Set< SUID >::emptySet(), const Set< SUID > &incompatibleSelectors=Set< SUID >::emptySet())
	WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM (std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::MRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&LatticeModel_T::equilibriumAccuracyOrder==2 &&std::is_same_v< DensityVelocityIn_T, DefaultDensityEquilibriumVelocityCalculation >) WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_HEAD(std
	WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM ((std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D2Q9 > &&LatticeModel_T::CollisionModel::constant &&! LatticeModel_T::compressible &&LatticeModel_T::equilibriumAccuracyOrder==2 &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > &&std::is_same_v< DensityVelocityIn_T, DefaultDensityEquilibriumVelocityCalculation >)) WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_HEAD((std
	WALBERLA_LBM_CELLWISE_SWEEP_COLLIDE_FOOT () WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM((std
template<typename LatticeModel_T, typename Filter_T, typename DensityVelocityIn_T, typename DensityVelocityOut_T>
shared_ptr< CellwiseSweep< LatticeModel_T, Filter_T, DensityVelocityIn_T, DensityVelocityOut_T > >	makeCellwiseSweep (const BlockDataID &pdfFieldId, const Filter_T &filter, const DensityVelocityIn_T &densityVelocityIn, const DensityVelocityOut_T &densityVelocityOut)
template<typename LatticeModel_T, typename Filter_T, typename DensityVelocityIn_T, typename DensityVelocityOut_T>
shared_ptr< CellwiseSweep< LatticeModel_T, Filter_T, DensityVelocityIn_T, DensityVelocityOut_T > >	makeCellwiseSweep (const BlockDataID &src, const BlockDataID &dst, const Filter_T &filter, const DensityVelocityIn_T &densityVelocityIn, const DensityVelocityOut_T &densityVelocityOut)
template<typename LatticeModel_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, DefaultDensityEquilibriumVelocityCalculation, DefaultDensityVelocityCallback > >	makeCellwiseSweep (const BlockDataID &pdfFieldId)
template<typename LatticeModel_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, DefaultDensityEquilibriumVelocityCalculation, DefaultDensityVelocityCallback > >	makeCellwiseSweep (const BlockDataID &src, const BlockDataID &dst)
template<typename LatticeModel_T, typename FlagField_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, DefaultDensityVelocityCallback > >	makeCellwiseSweep (const BlockDataID &pdfFieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate)
template<typename LatticeModel_T, typename FlagField_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, DefaultDensityVelocityCallback > >	makeCellwiseSweep (const BlockDataID &src, const BlockDataID &dst, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate)
template<typename LatticeModel_T, typename FlagField_T, typename VelocityField_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, VelocityCallback< VelocityField_T > > >	makeCellwiseSweep (const BlockDataID &pdfFieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldId)
template<typename LatticeModel_T, typename FlagField_T, typename VelocityField_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, VelocityCallback< VelocityField_T > > >	makeCellwiseSweep (const BlockDataID &src, const BlockDataID &dst, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldId)
template<typename LatticeModel_T, typename FlagField_T, typename VelocityField_T, typename DensityField_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, DensityVelocityCallback< VelocityField_T, DensityField_T > > >	makeCellwiseSweep (const BlockDataID &pdfFieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldId, const BlockDataID &densityFieldId)
template<typename LatticeModel_T, typename FlagField_T, typename VelocityField_T, typename DensityField_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, DensityVelocityCallback< VelocityField_T, DensityField_T > > >	makeCellwiseSweep (const BlockDataID &src, const BlockDataID &dst, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldId, const BlockDataID &densityFieldId)
template<typename LatticeModel_T, typename VelocityField_T, typename Filter_T, typename DensityVelocityOut_T>
shared_ptr< CellwiseSweep< LatticeModel_T, Filter_T, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DensityVelocityOut_T > >	makeCellwiseAdvectionDiffusionSweep (const BlockDataID &pdfFieldId, const ConstBlockDataID &velocityFieldId, const Filter_T &filter, const DensityVelocityOut_T &densityVelocityOut)
template<typename LatticeModel_T, typename VelocityField_T, typename Filter_T, typename DensityVelocityOut_T>
shared_ptr< CellwiseSweep< LatticeModel_T, Filter_T, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DensityVelocityOut_T > >	makeCellwiseAdvectionDiffusionSweep (const BlockDataID &src, const BlockDataID &dst, const ConstBlockDataID &velocityFieldId, const Filter_T &filter, const DensityVelocityOut_T &densityVelocityOut)
template<typename LatticeModel_T, typename VelocityField_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DefaultDensityVelocityCallback > >	makeCellwiseAdvectionDiffusionSweep (const BlockDataID &pdfFieldId, const ConstBlockDataID &velocityFieldId)
template<typename LatticeModel_T, typename VelocityField_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DefaultDensityVelocityCallback > >	makeCellwiseAdvectionDiffusionSweep (const BlockDataID &src, const BlockDataID &dst, const ConstBlockDataID &velocityFieldId)
template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DefaultDensityVelocityCallback > >	makeCellwiseAdvectionDiffusionSweep (const BlockDataID &pdfFieldId, const ConstBlockDataID &velocityFieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate)
template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DefaultDensityVelocityCallback > >	makeCellwiseAdvectionDiffusionSweep (const BlockDataID &src, const BlockDataID &dst, const ConstBlockDataID &velocityFieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate)
template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T, typename VelocityFieldOut_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, VelocityCallback< VelocityFieldOut_T > > >	makeCellwiseAdvectionDiffusionSweep (const BlockDataID &pdfFieldId, const ConstBlockDataID &velocityFieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldOutId)
template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T, typename VelocityFieldOut_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, VelocityCallback< VelocityFieldOut_T > > >	makeCellwiseAdvectionDiffusionSweep (const BlockDataID &src, const BlockDataID &dst, const ConstBlockDataID &velocityFieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldOutId)
template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T, typename VelocityFieldOut_T, typename DensityFieldOut_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DensityVelocityCallback< VelocityFieldOut_T, DensityFieldOut_T > > >	makeCellwiseAdvectionDiffusionSweep (const BlockDataID &pdfFieldId, const ConstBlockDataID &velocityFieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldOutId, const BlockDataID &densityFieldOutId)
template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T, typename VelocityFieldOut_T, typename DensityFieldOut_T>
shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DensityVelocityCallback< VelocityFieldOut_T, DensityFieldOut_T > > >	makeCellwiseAdvectionDiffusionSweep (const BlockDataID &src, const BlockDataID &dst, const ConstBlockDataID &velocityFieldId, const ConstBlockDataID &flagFieldId, const Set< FlagUID > &cellsToEvaluate, const BlockDataID &velocityFieldOutId, const BlockDataID &densityFieldOutId)
template<typename Kernel>
StreamSweep< Kernel >	makeStreamSweep (const shared_ptr< Kernel > &kernel)
template<typename Kernel>
CollideSweep< Kernel >	makeCollideSweep (const shared_ptr< Kernel > &kernel)
	WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM ((std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D2Q9 > &&! LatticeModel_T::compressible &&LatticeModel_T::equilibriumAccuracyOrder==2 &&std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > &&std::is_same_v< DensityVelocityIn_T, DefaultDensityEquilibriumVelocityCalculation >)) WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_HEAD((std

Variables
template<typename CM, bool C, typename FM, int EAO>
const char *	D2Q9< CM, C, FM, EAO >::NAME = "D2Q9"
template<typename CM, bool C, typename FM, int EAO>
const real_t	D2Q9< CM, C, FM, EAO >::w_0 = 4.0_r / 9.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D2Q9< CM, C, FM, EAO >::w_1 = 1.0_r / 9.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D2Q9< CM, C, FM, EAO >::w_2 = 1.0_r / 36.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D2Q9< CM, C, FM, EAO >::w [9]
template<typename CM, bool C, typename FM, int EAO>
const real_t	D2Q9< CM, C, FM, EAO >::wInv [9]
template<typename CM, bool C, typename FM, int EAO>
const char *	D3Q15< CM, C, FM, EAO >::NAME = "D3Q15"
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q15< CM, C, FM, EAO >::w_0 = 2.0_r / 9.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q15< CM, C, FM, EAO >::w_1 = 1.0_r / 9.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q15< CM, C, FM, EAO >::w_2 = 1.0_r / 72.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q15< CM, C, FM, EAO >::w [15]
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q15< CM, C, FM, EAO >::wInv [15]
template<typename CM, bool C, typename FM, int EAO>
const char *	D3Q19< CM, C, FM, EAO >::NAME = "D3Q19"
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q19< CM, C, FM, EAO >::w_0 = 1.0_r / 3.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q19< CM, C, FM, EAO >::w_1 = 1.0_r / 18.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q19< CM, C, FM, EAO >::w_2 = 1.0_r / 36.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q19< CM, C, FM, EAO >::w [19]
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q19< CM, C, FM, EAO >::wInv [19]
template<typename CM, bool C, typename FM, int EAO>
const char *	D3Q27< CM, C, FM, EAO >::NAME = "D3Q27"
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q27< CM, C, FM, EAO >::w_0 = 8.0_r / 27.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q27< CM, C, FM, EAO >::w_1 = 2.0_r / 27.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q27< CM, C, FM, EAO >::w_2 = 1.0_r / 54.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q27< CM, C, FM, EAO >::w_3 = 1.0_r / 216.0_r
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q27< CM, C, FM, EAO >::w [27]
template<typename CM, bool C, typename FM, int EAO>
const real_t	D3Q27< CM, C, FM, EAO >::wInv [27]

Typedef Documentation

PdfFieldPackInfo

template<typename LatticeModel_T>

using walberla::lbm::PdfFieldPackInfo

Initial value:

field::communication::StencilRestrictedPackInfo< PdfField<LatticeModel_T>,
                                                                         typename LatticeModel_T::Stencil>

Optimized PackInfo for PDF fields (communicates only components pointing to neighbor).

In principle a PDF field can be communicated using a FieldPackInfo which copies all entries (=values for f) of the ghost layer.

For PDF fields, however, it is sufficient to communicate only those discrete velocities which point into the direction of the neighboring block

This PackInfo sends only these required components and therefore the sizes of the messages decrease.

see also documentation for FieldPackInfo

Warning

For fields with nrOfGhostLayers > 1: only the components pointing towards the boundary are communicated, which may not be the desired behavior for the 'inner' ghost layers

Function Documentation

addPdfFieldToStorage() [1/4]

template<typename LatticeModel_T, typename BlockStorage_T>

BlockDataID walberla::lbm::addPdfFieldToStorage	(	const shared_ptr< BlockStorage_T > &	blocks,
		const std::string &	identifier,
		const LatticeModel_T &	latticeModel,
		const field::Layout &	layout = field::fzyx,
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet(),
		const shared_ptr< field::FieldAllocator< real_t > >	alloc = nullptr )

addPdfFieldToStorage() [2/4]

template<typename LatticeModel_T, typename BlockStorage_T>

BlockDataID walberla::lbm::addPdfFieldToStorage	(	const shared_ptr< BlockStorage_T > &	blocks,
		const std::string &	identifier,
		const LatticeModel_T &	latticeModel,
		const uint_t	ghostLayers,
		const field::Layout &	layout = field::fzyx,
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet(),
		const shared_ptr< field::FieldAllocator< real_t > >	alloc = nullptr )

addPdfFieldToStorage() [3/4]

template<typename LatticeModel_T, typename BlockStorage_T>

BlockDataID walberla::lbm::addPdfFieldToStorage	(	const shared_ptr< BlockStorage_T > &	blocks,
		const std::string &	identifier,
		const LatticeModel_T &	latticeModel,
		const Vector3< real_t > &	initialVelocity,
		const real_t	initialDensity,
		const field::Layout &	layout = field::fzyx,
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet(),
		const shared_ptr< field::FieldAllocator< real_t > >	alloc = nullptr )

addPdfFieldToStorage() [4/4]

template<typename LatticeModel_T, typename BlockStorage_T>

BlockDataID walberla::lbm::addPdfFieldToStorage	(	const shared_ptr< BlockStorage_T > &	blocks,
		const std::string &	identifier,
		const LatticeModel_T &	latticeModel,
		const Vector3< real_t > &	initialVelocity,
		const real_t	initialDensity,
		const uint_t	ghostLayers,
		const field::Layout &	layout = field::fzyx,
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet(),
		const shared_ptr< field::FieldAllocator< real_t > >	alloc = nullptr )

getDensity()

template<typename LatticeModel_T, typename FieldPtrOrIterator>

real_t walberla::lbm::getDensity ( const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getDensityAndEquilibriumMomentumDensity()

template<typename LatticeModel_T, typename FieldPtrOrIterator>

real_t walberla::lbm::getDensityAndEquilibriumMomentumDensity ( Vector3< real_t > & momentumDensity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getDensityAndEquilibriumVelocity()

template<typename LatticeModel_T, typename FieldPtrOrIterator>

real_t walberla::lbm::getDensityAndEquilibriumVelocity ( Vector3< real_t > & velocity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getDensityAndMomentumDensity()

template<typename LatticeModel_T, typename FieldPtrOrIterator>

real_t walberla::lbm::getDensityAndMomentumDensity ( Vector3< real_t > & momentumDensity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getDensityAndVelocity()

template<typename LatticeModel_T, typename FieldPtrOrIterator>

real_t walberla::lbm::getDensityAndVelocity ( Vector3< real_t > & velocity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getDensityAndVelocitySI() [1/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

real_t walberla::lbm::getDensityAndVelocitySI ( Vector3< real_t > & velocity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it, const real_t rho_SI, const real_t dx_SI, const real_t dt_SI )

inline

getDensityAndVelocitySI() [2/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

real_t walberla::lbm::getDensityAndVelocitySI ( Vector3< real_t > & velocity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it, const real_t rho_SI, const real_t dxDividedByDt_SI )

inline

getDensitySI()

template<typename LatticeModel_T, typename FieldPtrOrIterator>

real_t walberla::lbm::getDensitySI ( const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it, const real_t rho_SI )

inline

getEquilibriumMomentumDensity() [1/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

Vector3< real_t > walberla::lbm::getEquilibriumMomentumDensity ( const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getEquilibriumMomentumDensity() [2/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

void walberla::lbm::getEquilibriumMomentumDensity ( Vector3< real_t > & momentumDensity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getEquilibriumVelocity() [1/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

Vector3< real_t > walberla::lbm::getEquilibriumVelocity ( const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getEquilibriumVelocity() [2/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

void walberla::lbm::getEquilibriumVelocity ( Vector3< real_t > & velocity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getMomentumDensity() [1/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

Vector3< real_t > walberla::lbm::getMomentumDensity ( const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getMomentumDensity() [2/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

void walberla::lbm::getMomentumDensity ( Vector3< real_t > & momentumDensity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getPressureTensor() [1/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

Matrix3< real_t > walberla::lbm::getPressureTensor ( const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getPressureTensor() [2/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

void walberla::lbm::getPressureTensor ( Matrix3< real_t > & velocity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getQCriterion()

template<typename VelocityField_T, typename Filter_T>

real_t walberla::lbm::getQCriterion ( const VelocityField_T & velocityField, const Filter_T & filter, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, real_t dx = 1_r, real_t dy = 1_r, real_t dz = 1_r )

inline

getShearRate()

template<typename LatticeModel_T, typename FieldPtrOrIterator>

real_t walberla::lbm::getShearRate ( const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getVelocity() [1/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

Vector3< real_t > walberla::lbm::getVelocity ( const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getVelocity() [2/2]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

void walberla::lbm::getVelocity ( Vector3< real_t > & velocity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it )

inline

getVelocitySI() [1/4]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

Vector3< real_t > walberla::lbm::getVelocitySI ( const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it, const real_t dx_SI, const real_t dt_SI )

inline

getVelocitySI() [2/4]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

Vector3< real_t > walberla::lbm::getVelocitySI ( const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it, const real_t dxDividedByDt_SI )

inline

getVelocitySI() [3/4]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

void walberla::lbm::getVelocitySI ( Vector3< real_t > & velocity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it, const real_t dx_SI, const real_t dt_SI )

inline

getVelocitySI() [4/4]

template<typename LatticeModel_T, typename FieldPtrOrIterator>

void walberla::lbm::getVelocitySI ( Vector3< real_t > & velocity, const LatticeModel_T & latticeModel, const FieldPtrOrIterator & it, const real_t dxDividedByDt_SI )

inline

getVorticity()

template<typename VelocityField_T, typename Filter_T>

Vector3< real_t > walberla::lbm::getVorticity ( const VelocityField_T & velocityField, const Filter_T & filter, const cell_idx_t x, const cell_idx_t y, const cell_idx_t z, real_t dx = 1_r, real_t dy = 1_r, real_t dz = 1_r )

inline

intersectionRatio() [1/2]

template<typename Body>

real_t walberla::lbm::intersectionRatio	(	const Body &	body,
		const Vector3< real_t > &	fluidPoint,
		const Vector3< real_t > &	direction,
		const real_t	epsilon )

Computes the intersection of a ray segment with a body surface.

Let P_i be the intersection point

Parameters

body	surface
fluidPoint	(P_f), start point of ray
direction	(d) of ray (length of d is the length of the ray segment)
epsilon	abortion criterion for iterative methods. Epsilon relates to the distance of P_i to the surface

Returns

Intersection ratio: | P_i - P_f | / | d |

intersectionRatio() [2/2]

real_t walberla::lbm::intersectionRatio ( const geometry::Sphere & sphere, const Vector3< real_t > & fluidPoint, const Vector3< real_t > & direction, const real_t = 0_r )

inline

intersectionRatioBisection()

template<typename Body>

real_t walberla::lbm::intersectionRatioBisection	(	const Body &	body,
		const Vector3< real_t > &	fluidPoint,
		const Vector3< real_t > &	direction,
		const real_t	epsilon )

intersectionRatioSphere()

real_t walberla::lbm::intersectionRatioSphere	(	const geometry::Sphere &	sphere,
		const Vector3< real_t > &	fluidPoint,
		const Vector3< real_t > &	direction )

makeCellwiseAdvectionDiffusionSweep() [1/10]

template<typename LatticeModel_T, typename VelocityField_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DefaultDensityVelocityCallback > > walberla::lbm::makeCellwiseAdvectionDiffusionSweep	(	const BlockDataID &	pdfFieldId,
		const ConstBlockDataID &	velocityFieldId )

makeCellwiseAdvectionDiffusionSweep() [2/10]

template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DefaultDensityVelocityCallback > > walberla::lbm::makeCellwiseAdvectionDiffusionSweep	(	const BlockDataID &	pdfFieldId,
		const ConstBlockDataID &	velocityFieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate )

makeCellwiseAdvectionDiffusionSweep() [3/10]

template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T, typename VelocityFieldOut_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, VelocityCallback< VelocityFieldOut_T > > > walberla::lbm::makeCellwiseAdvectionDiffusionSweep	(	const BlockDataID &	pdfFieldId,
		const ConstBlockDataID &	velocityFieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate,
		const BlockDataID &	velocityFieldOutId )

makeCellwiseAdvectionDiffusionSweep() [4/10]

template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T, typename VelocityFieldOut_T, typename DensityFieldOut_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DensityVelocityCallback< VelocityFieldOut_T, DensityFieldOut_T > > > walberla::lbm::makeCellwiseAdvectionDiffusionSweep	(	const BlockDataID &	pdfFieldId,
		const ConstBlockDataID &	velocityFieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate,
		const BlockDataID &	velocityFieldOutId,
		const BlockDataID &	densityFieldOutId )

makeCellwiseAdvectionDiffusionSweep() [5/10]

template<typename LatticeModel_T, typename VelocityField_T, typename Filter_T, typename DensityVelocityOut_T>

shared_ptr< CellwiseSweep< LatticeModel_T, Filter_T, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DensityVelocityOut_T > > walberla::lbm::makeCellwiseAdvectionDiffusionSweep	(	const BlockDataID &	pdfFieldId,
		const ConstBlockDataID &	velocityFieldId,
		const Filter_T &	filter,
		const DensityVelocityOut_T &	densityVelocityOut )

makeCellwiseAdvectionDiffusionSweep() [6/10]

template<typename LatticeModel_T, typename VelocityField_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DefaultDensityVelocityCallback > > walberla::lbm::makeCellwiseAdvectionDiffusionSweep	(	const BlockDataID &	src,
		const BlockDataID &	dst,
		const ConstBlockDataID &	velocityFieldId )

makeCellwiseAdvectionDiffusionSweep() [7/10]

template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DefaultDensityVelocityCallback > > walberla::lbm::makeCellwiseAdvectionDiffusionSweep	(	const BlockDataID &	src,
		const BlockDataID &	dst,
		const ConstBlockDataID &	velocityFieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate )

makeCellwiseAdvectionDiffusionSweep() [8/10]

template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T, typename VelocityFieldOut_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, VelocityCallback< VelocityFieldOut_T > > > walberla::lbm::makeCellwiseAdvectionDiffusionSweep	(	const BlockDataID &	src,
		const BlockDataID &	dst,
		const ConstBlockDataID &	velocityFieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate,
		const BlockDataID &	velocityFieldOutId )

makeCellwiseAdvectionDiffusionSweep() [9/10]

template<typename LatticeModel_T, typename VelocityField_T, typename FlagField_T, typename VelocityFieldOut_T, typename DensityFieldOut_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DensityVelocityCallback< VelocityFieldOut_T, DensityFieldOut_T > > > walberla::lbm::makeCellwiseAdvectionDiffusionSweep	(	const BlockDataID &	src,
		const BlockDataID &	dst,
		const ConstBlockDataID &	velocityFieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate,
		const BlockDataID &	velocityFieldOutId,
		const BlockDataID &	densityFieldOutId )

makeCellwiseAdvectionDiffusionSweep() [10/10]

template<typename LatticeModel_T, typename VelocityField_T, typename Filter_T, typename DensityVelocityOut_T>

shared_ptr< CellwiseSweep< LatticeModel_T, Filter_T, AdvectionDiffusionDensityEquilibriumVelocityCalculation< VelocityField_T >, DensityVelocityOut_T > > walberla::lbm::makeCellwiseAdvectionDiffusionSweep	(	const BlockDataID &	src,
		const BlockDataID &	dst,
		const ConstBlockDataID &	velocityFieldId,
		const Filter_T &	filter,
		const DensityVelocityOut_T &	densityVelocityOut )

makeCellwiseSweep() [1/10]

template<typename LatticeModel_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, DefaultDensityEquilibriumVelocityCalculation, DefaultDensityVelocityCallback > > walberla::lbm::makeCellwiseSweep

(

const BlockDataID &

pdfFieldId

)

makeCellwiseSweep() [2/10]

template<typename LatticeModel_T, typename FlagField_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, DefaultDensityVelocityCallback > > walberla::lbm::makeCellwiseSweep	(	const BlockDataID &	pdfFieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate )

makeCellwiseSweep() [3/10]

template<typename LatticeModel_T, typename FlagField_T, typename VelocityField_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, VelocityCallback< VelocityField_T > > > walberla::lbm::makeCellwiseSweep	(	const BlockDataID &	pdfFieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate,
		const BlockDataID &	velocityFieldId )

makeCellwiseSweep() [4/10]

template<typename LatticeModel_T, typename FlagField_T, typename VelocityField_T, typename DensityField_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, DensityVelocityCallback< VelocityField_T, DensityField_T > > > walberla::lbm::makeCellwiseSweep	(	const BlockDataID &	pdfFieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate,
		const BlockDataID &	velocityFieldId,
		const BlockDataID &	densityFieldId )

makeCellwiseSweep() [5/10]

template<typename LatticeModel_T, typename Filter_T, typename DensityVelocityIn_T, typename DensityVelocityOut_T>

shared_ptr< CellwiseSweep< LatticeModel_T, Filter_T, DensityVelocityIn_T, DensityVelocityOut_T > > walberla::lbm::makeCellwiseSweep	(	const BlockDataID &	pdfFieldId,
		const Filter_T &	filter,
		const DensityVelocityIn_T &	densityVelocityIn,
		const DensityVelocityOut_T &	densityVelocityOut )

makeCellwiseSweep() [6/10]

template<typename LatticeModel_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::DefaultEvaluationFilter, DefaultDensityEquilibriumVelocityCalculation, DefaultDensityVelocityCallback > > walberla::lbm::makeCellwiseSweep	(	const BlockDataID &	src,
		const BlockDataID &	dst )

makeCellwiseSweep() [7/10]

template<typename LatticeModel_T, typename FlagField_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, DefaultDensityVelocityCallback > > walberla::lbm::makeCellwiseSweep	(	const BlockDataID &	src,
		const BlockDataID &	dst,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate )

makeCellwiseSweep() [8/10]

template<typename LatticeModel_T, typename FlagField_T, typename VelocityField_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, VelocityCallback< VelocityField_T > > > walberla::lbm::makeCellwiseSweep	(	const BlockDataID &	src,
		const BlockDataID &	dst,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate,
		const BlockDataID &	velocityFieldId )

makeCellwiseSweep() [9/10]

template<typename LatticeModel_T, typename FlagField_T, typename VelocityField_T, typename DensityField_T>

shared_ptr< CellwiseSweep< LatticeModel_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, DefaultDensityEquilibriumVelocityCalculation, DensityVelocityCallback< VelocityField_T, DensityField_T > > > walberla::lbm::makeCellwiseSweep	(	const BlockDataID &	src,
		const BlockDataID &	dst,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	cellsToEvaluate,
		const BlockDataID &	velocityFieldId,
		const BlockDataID &	densityFieldId )

makeCellwiseSweep() [10/10]

template<typename LatticeModel_T, typename Filter_T, typename DensityVelocityIn_T, typename DensityVelocityOut_T>

shared_ptr< CellwiseSweep< LatticeModel_T, Filter_T, DensityVelocityIn_T, DensityVelocityOut_T > > walberla::lbm::makeCellwiseSweep	(	const BlockDataID &	src,
		const BlockDataID &	dst,
		const Filter_T &	filter,
		const DensityVelocityIn_T &	densityVelocityIn,
		const DensityVelocityOut_T &	densityVelocityOut )

makeCollideSweep()

template<typename Kernel>

CollideSweep< Kernel > walberla::lbm::makeCollideSweep ( const shared_ptr< Kernel > & kernel )

inline

makeMassEvaluation() [1/12]

template<typename DensityField_T, typename FlagField_T, bool Pseudo2D, typename Config_T>

shared_ptr< walberla::field::MassEvaluation< DensityField_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, Pseudo2D > > walberla::lbm::makeMassEvaluation	(	const Config_T &	config,
		const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	fluid,
		const std::string &	configBlockName = std::string(walberla::field::internal::massEvaluationConfigBlock),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [2/12]

template<typename DensityField_T, typename FlagField_T, typename Config_T>

shared_ptr< walberla::field::MassEvaluation< DensityField_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T > > > walberla::lbm::makeMassEvaluation	(	const Config_T &	config,
		const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	fluid,
		const std::string &	configBlockName = std::string(walberla::field::internal::massEvaluationConfigBlock),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [3/12]

template<typename DensityField_T, typename Filter_T, bool Pseudo2D, typename Config_T>

shared_ptr< walberla::field::MassEvaluation< DensityField_T, Filter_T, Pseudo2D > > walberla::lbm::makeMassEvaluation	(	const Config_T &	config,
		const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const Filter_T &	filter,
		const std::string &	configBlockName = std::string(walberla::field::internal::massEvaluationConfigBlock),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [4/12]

template<typename DensityField_T, typename Filter_T, typename Config_T>

shared_ptr< walberla::field::MassEvaluation< DensityField_T, Filter_T > > walberla::lbm::makeMassEvaluation	(	const Config_T &	config,
		const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const Filter_T &	filter,
		const std::string &	configBlockName = std::string(walberla::field::internal::massEvaluationConfigBlock),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [5/12]

template<typename DensityField_T, bool Pseudo2D, typename Config_T>

shared_ptr< walberla::field::MassEvaluation< DensityField_T, field::DefaultEvaluationFilter, Pseudo2D > > walberla::lbm::makeMassEvaluation	(	const Config_T &	config,
		const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const std::string &	configBlockName = std::string(walberla::field::internal::massEvaluationConfigBlock),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [6/12]

template<typename DensityField_T, typename Config_T>

shared_ptr< walberla::field::MassEvaluation< DensityField_T > > walberla::lbm::makeMassEvaluation	(	const Config_T &	config,
		const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const std::string &	configBlockName = std::string(walberla::field::internal::massEvaluationConfigBlock),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [7/12]

template<typename DensityField_T, typename FlagField_T, bool Pseudo2D>

shared_ptr< walberla::field::MassEvaluation< DensityField_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T >, Pseudo2D > > walberla::lbm::makeMassEvaluation	(	const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	fluid,
		const uint_t	plotFrequency,
		const uint_t	logFrequency,
		const std::string &	filename = std::string(walberla::field::internal::massEvaluationFilename),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [8/12]

template<typename DensityField_T, typename FlagField_T>

shared_ptr< walberla::field::MassEvaluation< DensityField_T, walberla::field::FlagFieldEvaluationFilter< FlagField_T > > > walberla::lbm::makeMassEvaluation	(	const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const ConstBlockDataID &	flagFieldId,
		const Set< FlagUID > &	fluid,
		const uint_t	plotFrequency,
		const uint_t	logFrequency,
		const std::string &	filename = std::string(walberla::field::internal::massEvaluationFilename),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [9/12]

template<typename DensityField_T, typename Filter_T, bool Pseudo2D>

shared_ptr< walberla::field::MassEvaluation< DensityField_T, Filter_T, Pseudo2D > > walberla::lbm::makeMassEvaluation	(	const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const Filter_T &	filter,
		const uint_t	plotFrequency,
		const uint_t	logFrequency,
		const std::string &	filename = std::string(walberla::field::internal::massEvaluationFilename),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [10/12]

template<typename DensityField_T, typename Filter_T>

shared_ptr< walberla::field::MassEvaluation< DensityField_T, Filter_T > > walberla::lbm::makeMassEvaluation	(	const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const Filter_T &	filter,
		const uint_t	plotFrequency,
		const uint_t	logFrequency,
		const std::string &	filename = std::string(walberla::field::internal::massEvaluationFilename),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [11/12]

template<typename DensityField_T, bool Pseudo2D>

shared_ptr< walberla::field::MassEvaluation< DensityField_T, field::DefaultEvaluationFilter, Pseudo2D > > walberla::lbm::makeMassEvaluation	(	const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const uint_t	plotFrequency,
		const uint_t	logFrequency,
		const std::string &	filename = std::string(walberla::field::internal::massEvaluationFilename),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

makeMassEvaluation() [12/12]

template<typename DensityField_T>

shared_ptr< walberla::field::MassEvaluation< DensityField_T > > walberla::lbm::makeMassEvaluation	(	const shared_ptr< StructuredBlockStorage > &	blocks,
		const uint_t	level,
		const ConstBlockDataID &	fieldId,
		const uint_t	plotFrequency,
		const uint_t	logFrequency,
		const std::string &	filename = std::string(walberla::field::internal::massEvaluationFilename),
		const Set< SUID > &	requiredSelectors = Set<SUID>::emptySet(),
		const Set< SUID > &	incompatibleSelectors = Set<SUID>::emptySet() )

Mass Evaluation for the LBM

Some 'makeMassEvaluation' functions for evaluating the mass evolution of LBM-based simulations. For an extensive documentation see Mass Evaluation in 'field/MassEvaluation.h'.

Please note that the 'makeMassEvaluation' functions for the LBM pre-configure the domain normalization such that the volume of a cell on level 'level' (0 by default) is equal to 1. This is in accordance with dimensionless lattice units.

If you do not have a dedicated field for storing the density of your LBM-based simulation, you can use

BlockDataID densityId = field::addFieldAdaptor< lbm::Adaptor<LatticeModel_T>::Density >( blocks, pdfFieldId,
                                                                                         "density adaptor" );

for creating a density adaptor. The type of this adaptor/field is 'lbm::Adaptor<LatticeModel_T>::Density'. An example for using a SharedFunctor that can be used to register the mass evaluation at a time loop might look like as follows:

makeSharedFunctor( lbm::makeMassEvaluation< lbm::Adaptor<LatticeModel_T>::Density >( config, blocks,
                                                                                     uint_t{0}, densityId ) )

Note that for this example the plot and log frequency can be controlled via the configuration file. In this example, all cells are processed. If not all of your cells are actually fluid cells, you should use a 'makeMassEvaluation' function that only processes cells marked as fluid cells in a flag field:

makeSharedFunctor( lbm::makeMassEvaluation< lbm::Adaptor<LatticeModel_T>::Density, FlagField_T >(
                      config, blocks, uint_t{0}, densityId, flagFieldId, fluidFlagUID ) )

makeStreamSweep()

template<typename Kernel>

StreamSweep< Kernel > walberla::lbm::makeStreamSweep ( const shared_ptr< Kernel > & kernel )

inline

setDensityAndVelocity()

template<typename LatticeModel_T, typename FieldPtrOrIterator>

void walberla::lbm::setDensityAndVelocity ( FieldPtrOrIterator & it, const LatticeModel_T & latticeModel, const Vector3< real_t > & velocity = Vector3< real_t >( 0.0_r ), const real_t rho = 1.0_r )

inline

setToEquilibrium()

template<typename LatticeModel_T, typename FieldPtrOrIterator>

void walberla::lbm::setToEquilibrium ( FieldPtrOrIterator & it, const Vector3< real_t > & velocity = Vector3< real_t >( 0.0_r ), const real_t rho = 1.0_r )

inline

WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM() [1/4]

walberla::lbm::WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM

(

(std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::Cumulant_tag > && std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q27 > && LatticeModel_T::compressible && LatticeModel_T::equilibriumAccuracyOrder==2 && std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > && std::is_same_v< DensityVelocityIn_T, DefaultDensityEquilibriumVelocityCalculation >)

)

WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM() [2/4]

walberla::lbm::WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM

(

(std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::SRT_tag > && std::is_same_v< typename LatticeModel_T::Stencil, stencil::D2Q9 > && LatticeModel_T::CollisionModel::constant && ! LatticeModel_T::compressible && LatticeModel_T::equilibriumAccuracyOrder==2 && std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > && std::is_same_v< DensityVelocityIn_T, DefaultDensityEquilibriumVelocityCalculation >)

)

WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM() [3/4]

walberla::lbm::WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM

(

(std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::TRT_tag > && std::is_same_v< typename LatticeModel_T::Stencil, stencil::D2Q9 > && ! LatticeModel_T::compressible && LatticeModel_T::equilibriumAccuracyOrder==2 && std::is_same_v< typename LatticeModel_T::ForceModel::tag, force_model::None_tag > && std::is_same_v< DensityVelocityIn_T, DefaultDensityEquilibriumVelocityCalculation >)

)

WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM() [4/4]

walberla::lbm::WALBERLA_LBM_CELLWISE_SWEEP_CLASS_HEAD_AND_STREAM

(

std::is_same_v< typename LatticeModel_T::CollisionModel::tag, collision_model::MRT_tag > &&std::is_same_v< typename LatticeModel_T::Stencil, stencil::D3Q19 > &&! LatticeModel_T::compressible &&LatticeModel_T::equilibriumAccuracyOrder

= = 2 && std::is_same_v< DensityVelocityIn_T, DefaultDensityEquilibriumVelocityCalculation >

)

WALBERLA_LBM_CELLWISE_SWEEP_COLLIDE_FOOT()

walberla::lbm::WALBERLA_LBM_CELLWISE_SWEEP_COLLIDE_FOOT

(

)

WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_FOOT()

walberla::lbm::WALBERLA_LBM_CELLWISE_SWEEP_STREAM_COLLIDE_FOOT

(

)

Variable Documentation

D2Q9< CM, C, FM, EAO >::NAME

template<typename CM, bool C, typename FM, int EAO>

const char* walberla::lbm::D2Q9< CM, C, FM, EAO >::NAME = "D2Q9"

D2Q9< CM, C, FM, EAO >::w

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D2Q9< CM, C, FM, EAO >::w[9]

Initial value:

= { 4.0_r / 9.0_r,   
                                                      1.0_r / 9.0_r,   
                                                      1.0_r / 9.0_r,   
                                                      1.0_r / 9.0_r,   
                                                      1.0_r / 9.0_r,   
                                                      1.0_r / 36.0_r,   
                                                      1.0_r / 36.0_r,   
                                                      1.0_r / 36.0_r,   
                                                      1.0_r / 36.0_r }

D2Q9< CM, C, FM, EAO >::w_0

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D2Q9< CM, C, FM, EAO >::w_0 = 4.0_r / 9.0_r

D2Q9< CM, C, FM, EAO >::w_1

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D2Q9< CM, C, FM, EAO >::w_1 = 1.0_r / 9.0_r

D2Q9< CM, C, FM, EAO >::w_2

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D2Q9< CM, C, FM, EAO >::w_2 = 1.0_r / 36.0_r

D2Q9< CM, C, FM, EAO >::wInv

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D2Q9< CM, C, FM, EAO >::wInv[9]

Initial value:

= { 9.0_r / 4.0_r,   
                                                      9.0_r,                 
                                                      9.0_r,                 
                                                      9.0_r,                 
                                                      9.0_r,                 
                                                      36.0_r,                 
                                                      36.0_r,                 
                                                      36.0_r,                 
                                                      36.0_r }

D3Q15< CM, C, FM, EAO >::NAME

template<typename CM, bool C, typename FM, int EAO>

const char* walberla::lbm::D3Q15< CM, C, FM, EAO >::NAME = "D3Q15"

D3Q15< CM, C, FM, EAO >::w

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q15< CM, C, FM, EAO >::w[15]

Initial value:

= { 2.0_r / 9.0_r,   
                                                       1.0_r / 9.0_r,   
                                                       1.0_r / 9.0_r,   
                                                       1.0_r / 9.0_r,   
                                                       1.0_r / 9.0_r,   
                                                       1.0_r / 9.0_r,   
                                                       1.0_r / 9.0_r,   
                                                       1.0_r / 72.0_r,   
                                                       1.0_r / 72.0_r,   
                                                       1.0_r / 72.0_r,   
                                                       1.0_r / 72.0_r,   
                                                       1.0_r / 72.0_r,   
                                                       1.0_r / 72.0_r,   
                                                       1.0_r / 72.0_r,   
                                                       1.0_r / 72.0_r }

D3Q15< CM, C, FM, EAO >::w_0

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q15< CM, C, FM, EAO >::w_0 = 2.0_r / 9.0_r

D3Q15< CM, C, FM, EAO >::w_1

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q15< CM, C, FM, EAO >::w_1 = 1.0_r / 9.0_r

D3Q15< CM, C, FM, EAO >::w_2

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q15< CM, C, FM, EAO >::w_2 = 1.0_r / 72.0_r

D3Q15< CM, C, FM, EAO >::wInv

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q15< CM, C, FM, EAO >::wInv[15]

Initial value:

= { 4.5_r,   
                                                       9.0_r,   
                                                       9.0_r,   
                                                       9.0_r,   
                                                       9.0_r,   
                                                       9.0_r,   
                                                       9.0_r,   
                                                       72.0_r,   
                                                       72.0_r,   
                                                       72.0_r,   
                                                       72.0_r,   
                                                       72.0_r,   
                                                       72.0_r,   
                                                       72.0_r,   
                                                       72.0_r }

D3Q19< CM, C, FM, EAO >::NAME

template<typename CM, bool C, typename FM, int EAO>

const char* walberla::lbm::D3Q19< CM, C, FM, EAO >::NAME = "D3Q19"

D3Q19< CM, C, FM, EAO >::w

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q19< CM, C, FM, EAO >::w[19]

Initial value:

= { 1.0_r / 3.0_r,   
                                                       1.0_r / 18.0_r,   
                                                       1.0_r / 18.0_r,   
                                                       1.0_r / 18.0_r,   
                                                       1.0_r / 18.0_r,   
                                                       1.0_r / 18.0_r,   
                                                       1.0_r / 18.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r,   
                                                       1.0_r / 36.0_r }

D3Q19< CM, C, FM, EAO >::w_0

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q19< CM, C, FM, EAO >::w_0 = 1.0_r / 3.0_r

D3Q19< CM, C, FM, EAO >::w_1

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q19< CM, C, FM, EAO >::w_1 = 1.0_r / 18.0_r

D3Q19< CM, C, FM, EAO >::w_2

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q19< CM, C, FM, EAO >::w_2 = 1.0_r / 36.0_r

D3Q19< CM, C, FM, EAO >::wInv

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q19< CM, C, FM, EAO >::wInv[19]

Initial value:

= { 3.0_r,   
                                                       18.0_r,   
                                                       18.0_r,   
                                                       18.0_r,   
                                                       18.0_r,   
                                                       18.0_r,   
                                                       18.0_r,   
                                                       36.0_r,   
                                                       36.0_r,   
                                                       36.0_r,   
                                                       36.0_r,   
                                                       36.0_r,   
                                                       36.0_r,   
                                                       36.0_r,   
                                                       36.0_r,   
                                                       36.0_r,   
                                                       36.0_r,   
                                                       36.0_r,   
                                                       36.0_r }

D3Q27< CM, C, FM, EAO >::NAME

template<typename CM, bool C, typename FM, int EAO>

const char* walberla::lbm::D3Q27< CM, C, FM, EAO >::NAME = "D3Q27"

D3Q27< CM, C, FM, EAO >::w

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q27< CM, C, FM, EAO >::w[27]

Initial value:

= { 8.0_r / 27.0_r,   
                                                       2.0_r / 27.0_r,   
                                                       2.0_r / 27.0_r,   
                                                       2.0_r / 27.0_r,   
                                                       2.0_r / 27.0_r,   
                                                       2.0_r / 27.0_r,   
                                                       2.0_r / 27.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 54.0_r,   
                                                       1.0_r / 216.0_r,   
                                                       1.0_r / 216.0_r,   
                                                       1.0_r / 216.0_r,   
                                                       1.0_r / 216.0_r,   
                                                       1.0_r / 216.0_r,   
                                                       1.0_r / 216.0_r,   
                                                       1.0_r / 216.0_r,   
                                                       1.0_r / 216.0_r }

D3Q27< CM, C, FM, EAO >::w_0

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q27< CM, C, FM, EAO >::w_0 = 8.0_r / 27.0_r

D3Q27< CM, C, FM, EAO >::w_1

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q27< CM, C, FM, EAO >::w_1 = 2.0_r / 27.0_r

D3Q27< CM, C, FM, EAO >::w_2

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q27< CM, C, FM, EAO >::w_2 = 1.0_r / 54.0_r

D3Q27< CM, C, FM, EAO >::w_3

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q27< CM, C, FM, EAO >::w_3 = 1.0_r / 216.0_r

D3Q27< CM, C, FM, EAO >::wInv

template<typename CM, bool C, typename FM, int EAO>

const real_t walberla::lbm::D3Q27< CM, C, FM, EAO >::wInv[27]

Initial value:

= { 27.0_r / 8.0_r,   
                                                       27.0_r / 2.0_r,   
                                                       27.0_r / 2.0_r,   
                                                       27.0_r / 2.0_r,   
                                                       27.0_r / 2.0_r,   
                                                       27.0_r / 2.0_r,   
                                                       27.0_r / 2.0_r,   
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       54.0_r,                 
                                                       216.0_r,                 
                                                       216.0_r,                 
                                                       216.0_r,                 
                                                       216.0_r,                 
                                                       216.0_r,                 
                                                       216.0_r,                 
                                                       216.0_r,                 
                                                       216.0_r }