Top level namespace for all of OpenLB. More...

Namespaces
namespace	boundaryhelper

namespace	collision

namespace	concepts

namespace	contact

namespace	cpu
	Implementations of CPU specifics.

namespace	descriptors
	Descriptors for the 2D and 3D lattices.

namespace	dynamics

namespace	equilibria

namespace	fd

namespace	forcing
	Dynamics combination rules for various forcing schemes.

namespace	FreeSurface

namespace	functor_dsl
	Helper functions for building functors via composition.

namespace	gpu
	Implementations of GPU specifics.

namespace	graphics

namespace	guoZhao

namespace	heatmap

namespace	interaction

namespace	legacy

namespace	meta

namespace	momenta

namespace	names
	Define names as empty structs in order to enable calls like lattice(NavierStokes()).

namespace	opti
	All optimization code is contained in this namespace.

namespace	parameters

namespace	particles

namespace	powerlaw

namespace	sdf

namespace	singleton

namespace	stage

namespace	statistics

namespace	TotalEnthalpy

namespace	util

namespace	utilities

Classes
struct	AbstractBlockO
	Base of any block operator. More...

struct	AbstractCollisionO
	Base of collision operations performed by BlockDynamicsMap. More...

struct	AbstractColumn
	Abstract declarator of Column-like storage. More...

struct	AbstractCouplingO
	Base of block-wide coupling operators executed by SuperLatticeCoupling. More...

struct	AbstractCyclicColumn
	Abstract declarator of cyclic Column-like storage. More...

struct	AbstractedConcreteParameters
	Abstract base of ConcreteParametersD. More...

class	AbstractFieldArrayD
	Platform-agnostic interface to concrete host-side field arrays. More...

struct	AbstractParameters
	Dynamic access interface for FIELD-valued parameters. More...

class	AdeUnitConverter

class	AdeUnitConverterFromResolutionAndLatticeVelocity

class	AdeUnitConverterFromResolutionAndRelaxationTime

class	AdsorptionConverter

class	AdsorptionConverterFromSchmidtNumberAndRelaxation

class	AdsorptionCouplingPostProcessor3D
	Coupling post processor for adsorption on moving particles. More...

class	AdsorptionCouplingPostProcessorGenerator3D
	Generates post processor AdsorptionCouplingPostProcessor3D. More...

class	AdsorptionFullCouplingPostProcessor3D

class	AdsorptionFullCouplingPostProcessorGenerator3D

class	AdsorptionReaction
	Describes adsorption reactions in conjunction with a Isotherm class. More...

class	AdvDiffBuoyancyForce3D

class	AdvDiffDragForce3D

class	AdvDiffMagneticWireForce3D

class	AdvDiffRotatingForce3D

class	AdvDiffSNDragForce3D

struct	AdvectionDiffusionBoundariesDynamics

struct	AdvectionDiffusionCornerDynamics2D

struct	AdvectionDiffusionCornerDynamics3D

class	AdvectionDiffusionEdgesDynamics

struct	AdvectionDiffusionExternalVelocityCollision

class	AdvectionDiffusionForce3D

class	AdvectionDiffusionParticleCouplingGenerator3D

class	AdvectionDiffusionParticleCouplingPostProcessor3D

class	AggParticle3D

class	AnalyticalComposed

class	AnalyticalConcatenation

class	AnalyticalConst
	AnalyticalConst: DD -> XD, where XD is defined by value.size() More...

class	AnalyticalCuboidwiseConst
	Returns a constant value on every cuboids. More...

class	AnalyticalDerivativeAD

class	AnalyticalDerivativeAD1D
	Class for AD Differentiation of 1-dim Functor F: S -> T. More...

class	AnalyticalDerivativeFD1D
	Class for computing the derivative of a given 1D functor with a finite difference. More...

class	AnalyticalF
	AnalyticalF are applications from DD to XD, where X is set by the constructor. More...

class	AnalyticalFfromBlockF2D
	Converts block functors to analytical functors. More...

class	AnalyticalFfromBlockF3D
	Converts block functors to analytical functors. More...

class	AnalyticalFfromIndicatorF3D
	Converts IndicatorF to AnalyticalF (used for Analytical operands for Identity) More...

class	AnalyticalFfromSuperF2D
	Converts super functions to analytical functions. More...

class	AnalyticalFfromSuperF3D
	Converts super functors to analytical functors. More...

class	AnalyticalIdentity
	AnalyticalIdentity stores vectors, result of addition,multiplication, ... More...

class	AnalyticalLinear1D
	AnalyticalLinear1D: 1D -> 1D troughout given points (x0,v0) and (x1,v1) More...

class	AnalyticalLinear2D
	AnalyticalLinear2D: 2D -> 1D troughout given points (x0,y0,v0), (x1,y1,v1), (x2,y2,v2) More...

class	AnalyticalLinear3D
	3D//////////////////////////////////////////// AnalyticalLinear3D: 3D -> 1D troughout given points (x0,y0,z0,v0), (x1,y1,z1,v1), (x2,y2,z2,v2), (x3,y3,z3,v3) More...

class	AnalyticalNormal
	AnalyticalNormal: DD -> XD, where XD is defined by value.size() More...

class	AnalyticalParticleAdsorptionLinear2D
	AnalyticalRandom2D: 2D -> 1D with maxValue in the center decreasing linearly with the distrance to the center to zero at the radius and zero outside. More...

class	AnalyticalPorosityVolumeF

class	AnalyticalPorousVelocity2D
	Analytical solution of porous media channel flow with low Reynolds number See Spaid and Phelan (doi:10.1063/1.869392) More...

class	AnalyticalPorousVelocity3D
	Analytical solution of porous media channel flow with low Reynolds number See Spaid and Phelan (doi:10.1063/1.869392) More...

class	AnalyticalRandomBase
	AnalyticalRandomBase: virtual base class for all the random functionals. More...

class	AnalyticalRandomNormal
	AnalyticalRandomNormal: DD -> 1D with random image in (0,1) More...

class	AnalyticalRandomOld
	AnalyticalRandomOld: DD -> 1D with random image in (0,1) More...

class	AnalyticalRandomSeededBase
	AnalyticalRamdomSeededBase: alternative version with seed specification. More...

class	AnalyticalRandomSeededNormal
	AnalyticalRamdomSeededNormal: alternative version with seed specification. More...

class	AnalyticalRandomTruncatedNormal
	AnalyticalRandomNormal: DD -> 1D with random image in (0,1) Normal distribution cut off outside [mean-nstdDev, mean+nstdDev]. More...

class	AnalyticalRandomUniform
	AnalyticalRandomUniform: DD -> 1D with random image in (0,1) More...

class	AnalyticalScaled3D
	AnalyticalScaled3D: 3D -> Image(AnalyticalF) scales AnalyticalF by _scale. More...

class	AnalyticalSmoothedSquareWave
	Smoothed square wave. epsilon = width of the mollified interval. More...

class	AnalyticalSquare1D
	represents an inverse parabola profile like it is used in Poiseuille inflow note: output depends only on first parameter, maps 1D,2D,3D->1D More...

class	AnalyticalSquareWave
	Square wave with given period length, amplitude, difference (= length of positive time / length of period) More...

class	AnalyticalTypecast
	Perform explicit typecast for the arguments and results of functor. More...

class	AnalyticalVelocityVolumeF

class	AnalyticalWindProfileF3D

class	AnalyticCalcF
	arithmetic helper class for analytical functors More...

class	AngleBetweenVectors3D
	This class calculates the angle alpha between vector _referenceVector and any other vector x. More...

class	AntiBounceBackPostProcessor2D

class	AntiBounceBackPostProcessorGenerator2D

class	AnyFieldType
	Helper for referring to arbitrary data instances. More...

struct	Array
	Describe FieldArray of a FIELD in Data. More...

struct	AXIS_DIRECTION

class	BackCouplingModel
	Abstact base class for BaseBackCouplingModel. More...

class	Base64Decoder

class	Base64Encoder

class	BaseBackCouplingModel
	Abstact class for all the back-coupling models, viz., momentum coupling from particle to fluid. More...

class	BaseForwardCouplingModel
	Abstact base class for all the local/non-local forward-coupling models. More...

class	BaseLocalBackCouplingModel
	Abstact class for all the local back-coupling models. More...

class	BaseNonLocalBackCouplingModel
	Abstact class for all the non-local back-coupling models. More...

class	BaseSolver
	BaseSolver implements the solving process of an instationary simulation, consisting of preSimulationTasks, time-stepping and postprocessing. More...

class	BaseVTIreader

class	BaseVTIreader3D

class	batteryCouplingGenerator2D

class	batteryCouplingPostProcessor2D
	Coupling of ADlattice[0] with the other AD lattices (tpartners) More...

class	BlockAverage2D
	BlockAverage2D returns the average in each component of f on a indicated subset. More...

class	BlockAverage3D
	BlockAverage3D returns the average in each component of f on a indicated subset. More...

class	BlockCalcF2D
	Block level arithmetic operations for BlockF2D functors. More...

class	BlockCalcF3D
	Block level arithmetic operations for BlockF3D functors. More...

struct	BlockCollisionO
	Collision operation on concrete blocks of PLATFORM. More...

class	BlockCommunicationNeighborhood
	Configurable overlap communication neighborhood of a block. More...

struct	BlockCommunicator
	Generic communicator for the overlap neighborhood of a block. More...

class	BlockData

class	BlockData3D

class	BlockDataF2D
	BlockDataF2D can store data of any BlockFunctor2D. More...

class	BlockDataF3D
	BlockDataF3D can store data of any BlockFunctor3D. More...

class	BlockDiscretizationF2D
	Block functor for discretizing values by an interval (bottomBoundary,topBoundary), as well as restricting the value by setting n equal-distributed points and rounding the value to the nearest point If n = 1, there won't be restricting, and for n>=1 there will be n-1 restricting points. More...

class	BlockDiscretizationF3D
	Block functor for discretizing values by an interval (bottomBoundary,topBoundary), as well as restricting the value by setting n equal-distributed points and rounding the value to the nearest point If n = 1, there won't be restricting, and for n>=1 there will be n-1 restricting points. More...

class	BlockDynamicsMap
	Map between cell indices and concrete dynamics. More...

class	BlockEuklidNorm2D
	BlockL2Norm2D returns pointwise the l2-norm, e.g. of a velocity. More...

class	BlockEuklidNorm3D
	functor returns pointwise the l2-norm, e.g. of a velocity More...

class	BlockExtractComponentF2D
	functor to extract one component More...

class	BlockExtractComponentF3D
	functor to extract one component More...

class	BlockExtractComponentIndicatorF2D
	functor to extract one component inside an indicator More...

class	BlockExtractComponentIndicatorF3D
	functor to extract one component inside an indicator More...

class	BlockExtractIndicatorF2D
	functor to extract data inside an indicator More...

class	BlockExtractIndicatorF3D
	functor to extract data inside an indicator More...

class	BlockF2D
	represents all functors that operate on a cuboid in general, mother class of BlockLatticeF, .. More...

class	BlockF3D
	represents all functors that operate on a cuboid in general, mother class of BlockLatticeF, .. More...

class	BlockFiniteDifference3D
	functor to get pointwise finite difference Dissipation on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	BlockGeometry
	Representation of a block geometry. More...

class	BlockGeometryFaces2D

class	BlockGeometryFaces3D

class	BlockGeometryFacesIndicator2D

class	BlockGeometryFacesIndicator3D

class	BlockGeometryStatistics2D

class	BlockGeometryStatistics3D

class	BlockGifWriter
	BlockGifWriter writes given functor data to image file of format .ppm. More...

class	BlockIdentity2D
	identity functor More...

class	BlockIdentity3D
	identity functor More...

class	BlockIndicatorBoundaryNeighbor2D
	Block indicator identifying neighbors of boundary cells. More...

class	BlockIndicatorBoundaryNeighbor3D
	Block indicator identifying neighbors of boundary cells. More...

class	BlockIndicatorF2D
	Base block indicator functor (discrete) More...

class	BlockIndicatorF3D
	Base block indicator functor. More...

class	BlockIndicatorFfromIndicatorF2D
	BlockIndicatorF2D from IndicatorF2D. More...

class	BlockIndicatorFfromIndicatorF3D
	BlockIndicatorF3D from IndicatorF3D. More...

class	BlockIndicatorFfromSmoothIndicatorF2D
	BlockIndicatorF2D from SmoothIndicatorF2D. More...

class	BlockIndicatorFfromSmoothIndicatorF3D
	BlockIndicatorF3D from SmoothIndicatorF3D. More...

class	BlockIndicatorIdentity2D
	Block indicator identity. More...

class	BlockIndicatorIdentity3D
	Block indicator identity. More...

class	BlockIndicatorLayer3D
	Block indicator extended by a layer. More...

class	BlockIndicatorMaterial2D
	Block indicator functor from material numbers. More...

class	BlockIndicatorMaterial3D
	Block indicator functor from material numbers. More...

class	BlockIndicatorMultiplication3D
	Block indicator intersection. More...

class	BlockIntegral2D
	BlockIntegral2D integrates f on a indicated subset. More...

class	BlockIntegral3D
	BlockIntegral3D integrates f on a indicated subset. More...

class	BlockIsotropicHomogeneousTKE3D
	functor that returns pointwise the turbulent, kinetic energy More...

class	BlockL1Norm2D

class	BlockL1Norm3D
	BlockL1Norm3D returns componentwise the l1 norm. More...

class	BlockL222D
	BlockL223D returns componentwise the squared l2-norm. More...

class	BlockL223D
	BlockL223D returns componentwise the squared l2-norm. More...

class	BlockLaplacian3D
	functor to get pointwise finite difference Laplacian operator More...

class	BlockLattice
	Platform-abstracted block lattice for external access and inter-block interaction. More...

class	BlockLatticeAverage2D
	BlockLatticeAverage2D returns pointwise local average of a passed functor with a given material and radius on local lattice. More...

class	BlockLatticeCellList

class	BlockLatticeCoords2D
	BlockLatticeCoords2D returns pointwise density rho on local lattices. More...

class	BlockLatticeCoords3D
	BlockLatticeCoords3D returns pointwise density rho on local lattices. More...

class	BlockLatticeCuboid2D
	BlockLatticeCuboid2D returns pointwise the cuboid no. + 1 on local lattice. More...

class	BlockLatticeCuboid3D
	functor to get pointwise the cuboid no. + 1 on local lattice More...

class	BlockLatticeDensity2D
	BlockLatticeDensity2D returns pointwise density rho on local lattices. More...

class	BlockLatticeDensity3D
	functor returns pointwise density rho on local lattices More...

class	BlockLatticeDiscreteNormal2D
	BlockLatticeDiscreteNormal2D returns pointwise the discrete normal vector of the local lattice boundary cells. More...

class	BlockLatticeDiscreteNormal3D
	BlockLatticeDiscreteNormal3D returns pointwise the discrete normal vector of the local lattice boundary cells. More...

class	BlockLatticeDiscreteNormalType2D
	BlockLatticeDiscreteNormalType2D returns pointwise the type of a discrete normal vector. More...

class	BlockLatticeDiscreteNormalType3D
	BlockLatticeDiscreteNormalType3D returns pointwise the type of a discrete normal vector. More...

class	BlockLatticeDissipation3D
	functor returns pointwise dissipation density on local lattices More...

class	BlockLatticeDissipationFD3D

class	BlockLatticeEul2LagrDensity3D
	functor returns pointwise external field for Lagrangian particle density, converted to Eulerian More...

class	BlockLatticeExternal2D
	BlockLatticeExternal2D returns pointwise density rho on local lattices. More...

class	BlockLatticeExternal3D
	BlockLatticeExternal3D returns pointwise density rho on local lattices. More...

class	BlockLatticeExternalScalarField2D
	BlockLatticeExternalScalarField2D returns pointwise density rho on local lattices. More...

class	BlockLatticeExternalScalarField3D
	functor returns pointwise density rho on local lattices More...

class	BlockLatticeExternalVelocity3D
	functor returns pointwise external velocity (external field) on local lattice More...

class	BlockLatticeExternalVelocityGradientFD3D

class	BlockLatticeF2D
	represents all functors that operate on a DESCRIPTOR in general, e.g. getVelocity(), getForce(), getPressure() More...

class	BlockLatticeF3D
	represents all functors that operate on a DESCRIPTOR in general, e.g. getVelocity(), getForce(), getPressure() More...

class	BlockLatticeFfromAnalyticalF2D
	Block level functor for conversion of analytical to lattice functors. More...

class	BlockLatticeFfromAnalyticalF3D
	Block level functor for conversion of analytical to lattice functors. More...

class	BlockLatticeField2D

class	BlockLatticeField3D
	functor to get pointwise, lattice-dependent external field More...

class	BlockLatticeFlux3D
	functor returns pointwise lattice flux on local lattice More...

class	BlockLatticeFpop3D
	functor returns pointwise f population on local lattices More...

class	BlockLatticeGeometry2D
	BlockLatticeGeometry2D returns pointwise the material no. presenting the geometry on local lattice. More...

class	BlockLatticeGeometry3D
	functor returns pointwise the material no. presenting the geometry on local lattice More...

class	BlockLatticeHighOrderKnudsen3D

class	BlockLatticeIdentity2D
	identity functor More...

class	BlockLatticeIdentity3D
	identity functor More...

class	BlockLatticeIndicatorSmoothIndicatorIntersection2D
	functor that returns 1 if SmoothIndicatorF A intersects IndicatorF B; otherwise, 0 More...

class	BlockLatticeIndicatorSmoothIndicatorIntersection3D
	functor that returns 1 if SmoothIndicatorF A intersects IndicatorF B; otherwise, 0 More...

class	BlockLatticeInterpDensity3Degree3D

class	BlockLatticeInterpPhysVelocity2D

class	BlockLatticeInterpPhysVelocity3D

class	BlockLatticeInterpPhysVelocity3Degree3D

class	BlockLatticeKineticEnergy3D
	functor returns pointwise velocity on local lattice More...

class	BlockLatticeKnudsen2D

class	BlockLatticeKnudsen3D

class	BlockLatticeMomentumExchangeForce
	Functor that returns forces acting on a particle surface, returns data in output for every particle in a row(described are return values for the first particle). More...

class	BlockLatticeMomentumExchangeForceLocal
	functor to get pointwise momentum exchange on local lattice (block level) More...

class	BlockLatticePhysBoundaryDistance3D
	functor returns pointwise minimum distance to boundary given by indicators More...

class	BlockLatticePhysBoundaryForce2D
	BlockLatticePhysBoundaryForce2D returns pointwise phys force acting on a boundary. More...

class	BlockLatticePhysBoundaryForce3D
	functor returns pointwise phys force acting on a boundary with a given material on local lattice More...

class	BlockLatticePhysCorrBoundaryForce2D
	functor returns pointwise phys force acting on a indicated boundary on local lattice see: Caiazzo, Junk: Boundary Forces in lattice Boltzmann: Analysis of MEA More...

class	BlockLatticePhysCorrBoundaryForce3D
	functor returns pointwise phys force acting on a indicated boundary on local lattice see: Caiazzo, Junk: Boundary Forces in lattice Boltzmann: Analysis of MEA More...

class	BlockLatticePhysCorrDrag2D
	functor to get pointwise phys force acting on a indicated boundary on local lattice More...

class	BlockLatticePhysCorrDrag3D
	functor to get pointwise phys force acting on a indicated boundary on local lattice More...

class	BlockLatticePhysCroppedPermeability3D
	functor to get pointwise mesh-independent permeability values in (0,inf) in combination with (Extended)PorousBGKdynamics note: result is cropped to 1 More...

class	BlockLatticePhysDarcyForce2D
	BlockLatticePhysDarcyForce2D computes pointwise -nu/K*u on the lattice. can be used with BlockSum2D as objective. More...

class	BlockLatticePhysDarcyForce3D
	functor returns pointwise -nu/K*u on the lattice, can be used with BlockSum3D as objective More...

class	BlockLatticePhysDissipation2D
	BlockLatticePhysDissipation2D returns pointwise physical dissipation density on local lattices. More...

class	BlockLatticePhysDissipation3D
	functor returns pointwise dissipation density on local lattices More...

class	BlockLatticePhysDissipationFD3D

class	BlockLatticePhysDrag2D
	functor to get pointwise phys force acting on a indicated boundary on local lattice More...

class	BlockLatticePhysDrag3D
	functor to get pointwise phys force acting on a indicated boundary on local lattice More...

class	BlockLatticePhysEffectiveDissipation3D
	functor returns pointwise turbulent dissipation density on local lattices More...

class	BlockLatticePhysEffectiveDissipationFD3D

class	BlockLatticePhysEnstrophyFD3D
	functor that returns pointwise the enstrophy More...

class	BlockLatticePhysExternalParticleVelocity2D

class	BlockLatticePhysExternalParticleVelocity3D

class	BlockLatticePhysExternalPorosity2D

class	BlockLatticePhysExternalPorosity3D

class	BlockLatticePhysExternalScalar2D

class	BlockLatticePhysExternalScalar3D

class	BlockLatticePhysExternalVelocity2D

class	BlockLatticePhysExternalVelocity3D

class	BlockLatticePhysExternalZeta2D
	Zeta-Field (Geng2019) More...

class	BlockLatticePhysF2D
	represents all functors that operate on a DESCRIPTOR with output in Phys, e.g. physVelocity(), physForce(), physPressure() More...

class	BlockLatticePhysF3D
	represents all functors that operate on a DESCRIPTOR with output in Phys, e.g. physVelocity(), physForce(), physPressure() More...

class	BlockLatticePhysHeatFlux2D
	BlockLatticePhysHeatFlux2D returns pointwise phys heat flux on local lattice. More...

class	BlockLatticePhysHeatFlux3D
	BlockLatticePhysHeatFlux3D returns pointwise phys heat flux on local lattice. More...

class	BlockLatticePhysHeatFluxBoundary3D
	functor returns pointwise phys heat flux on a boundary with a given material on local lattice More...

class	BlockLatticePhysPermeability2D
	BlockLatticePhysPermeability2D returns pointwise mesh-independent permeability values in (0,inf) in combination with (Extended)PorousBGKdynamics note: result is cropped to 999999. More...

class	BlockLatticePhysPermeability3D
	functor to get pointwise mesh-independent permeability values in (0,inf) in combination with (Extended)PorousBGKdynamics note: result is cropped to 999999 More...

class	BlockLatticePhysPoreSizeDistribution3D
	functor returns pointwise pore radius for packings of spheres given by indicators returns NAN for non-pore voxels More...

class	BlockLatticePhysPressure2D
	BlockLatticePhysPressure2D returns pointwise phys pressure from rho on local lattices. More...

class	BlockLatticePhysPressure3D
	functor returns pointwise phys pressure from rho on local lattices More...

class	BlockLatticePhysShearRateMag3D
	functor returns pointwise phys shear rate magnitude on local lattice More...

class	BlockLatticePhysStrainRate2D
	BlockLatticePhysStrainRate2D returns pointwise phys strain rate on local lattice. More...

class	BlockLatticePhysStrainRate3D
	functor returns pointwise phys strain rate on local lattice, s_ij = 1/2*(du_idr_j + du_jdr_i) More...

class	BlockLatticePhysStrainRateFD3D

class	BlockLatticePhysStressFD3D

class	BlockLatticePhysTauFromBoundaryDistance3D
	functor returns pointwise pore radius for packings of spheres given by indicators returns NAN for non-pore voxels More...

class	BlockLatticePhysTemperature2D
	BlockLatticePhysTemperature2D returns pointwise phys temperature from rho on local lattices. More...

class	BlockLatticePhysTemperature3D

class	BlockLatticePhysVelocity2D
	BlockLatticePhysVelocity2D returns pointwise phys velocity on local lattice. More...

class	BlockLatticePhysVelocity3D
	functor returns pointwise phys velocity on local lattice More...

class	BlockLatticePhysVelocityGradientFD3D

class	BlockLatticePhysViscosity2D
	functor returns pointwise phys viscosity on local lattices More...

class	BlockLatticePhysViscosity3D
	functor returns pointwise phys viscosity on local lattices More...

class	BlockLatticePhysVorticityFD3D

class	BlockLatticePhysWallShearStress2D
	BlockLatticePhysBoundaryForce2D returns pointwise wall shear stress. More...

class	BlockLatticePhysWallShearStress3D
	functor returns pointwise phys wall shear stress acting on a boundary with a given material on local lattice More...

struct	BlockLatticePlatform

class	BlockLatticePorosity2D
	BlockLatticePorosity2D returns pointwise, lattice-dependent porosity values in [0,1] in combination with (Extended)PorousBGKdynamics: 0->solid, 1->fluid. More...

class	BlockLatticePorosity3D
	functor returns pointwise, lattice-dependent porosity values in [0,1] in combination with (Extended)PorousBGKdynamics: 0->solid, 1->fluid More...

class	BlockLatticePSMPhysForce2D
	functor returns pointwise phys force for PSM dynamics More...

class	BlockLatticePSMPhysForce2DMod
	functor returns pointwise phys force for PSM dynamics More...

class	BlockLatticePSMPhysForce3D
	functor returns pointwise phys force for PSM dynamics More...

class	BlockLatticeRank2D
	BlockLatticeRank2D returns pointwise the rank no. + 1 on local lattice. More...

class	BlockLatticeRank3D
	functor to get pointwise the rank no. + 1 on local lattice More...

class	BlockLatticeRefinementMetricKnudsen2D

class	BlockLatticeRefinementMetricKnudsen3D

class	BlockLatticeSmoothDiracDelta3D

class	BlockLatticeSTLreader

class	BlockLatticeStokesDragForce

class	BlockLatticeStrainRate2D
	BlockLatticeStrainRate2D returns pointwise strain rate on local lattice. More...

class	BlockLatticeStrainRate3D
	functor returns pointwise strain rate on local lattice, s_ij = 1/2*(du_idr_j + du_jdr_i) More...

class	BlockLatticeStrainRateFD3D

class	BlockLatticeStructure2D
	An interface to all the variants of (more or less) regular lattices. More...

class	BlockLatticeStructure3D
	BlockLatticeStructure3D is a interface class for defining dynamics on a BlockStructure3D. More...

class	BlockLatticeThermalComfort3D
	BlockLatticeThermalComfort3D returns pointwise PMV and PPD on local lattice. More...

class	BlockLatticeThermalPhysF2D
	represents all thermal functors that operate on a DESCRIPTOR with output in Phys, e.g. physTemperature(), physHeatFlux() More...

class	BlockLatticeThermalPhysF3D
	represents all thermal functors that operate on a DESCRIPTOR with output in Phys, e.g. physTemperature(), physHeatFlux() More...

class	BlockLatticeTimeStepScale3D
	functor to scale particle distributions to a time step More...

class	BlockLatticeVelocity2D
	BlockLatticeVelocity2D returns pointwise velocity on local lattices. More...

class	BlockLatticeVelocity3D
	functor returns pointwise velocity on local lattice More...

class	BlockLatticeVelocityDenominator3D

class	BlockLatticeVelocityGradientFD3D
	functor to get pointwise explicit filtering on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	BlockLatticeVolumeFractionApproximation2D
	functor returns pointwise an approximation for the volume fraction More...

class	BlockLatticeVolumeFractionApproximation3D
	functor returns pointwise an approximation for the volume fraction More...

class	BlockLatticeVolumeFractionPolygonApproximation2D
	functor returns pointwise an approximation for the volume fraction More...

class	BlockLatticeVorticityFD3D

class	BlockLoadBalancer

class	BlockLocalAverage2D
	Averages given functor inside the local sphere. More...

class	BlockLocalAverage3D
	Averages given functor inside the local sphere. More...

class	BlockLpNorm2D
	Block level functor that returns the Lp norm over omega of the euklid norm of the input block functor. More...

class	BlockLpNorm3D
	Block level functor that returns the Lp norm over omega of the euklid norm of the input block functor. More...

class	BlockMax2D
	BlockMax2D returns the max in each component of f on a indicated subset. More...

class	BlockMax3D
	BlockMax3D returns the max in each component of f on a indicated subset. More...

class	BlockMin2D
	BlockMin2D returns the min in each component of f on a indicated subset. More...

class	BlockMin3D
	BlockMin3D returns the min in each component of f on a indicated subset. More...

struct	BlockO
	Base of block-wide operators such as post processors. More...

class	BlockPhysFiniteDifference3D

class	BlockPhysLaplacian3D
	functor to get pointwise finite difference Laplacian operator More...

class	BlockPostProcessorMap
	Map of post processors of a single priority and stage. More...

class	BlockReduction2D1D
	BlockReduction2D1D reduces the data of a SuperF2D functor to the intersection between a given 2D hyperplane and the super geometry. More...

class	BlockReduction2D2D
	BlockReduction2D2D interpolates the data of a SuperF2D functor in a given resolution. More...

class	BlockReduction3D2D
	BlockReduction3D2D reduces the data of a SuperF3D functor to the intersection between a given hyperplane and the super geometry. More...

class	BlockRoundingF2D
	Block functor for rounding the value in a certain mode: None := No rounding NearestInteger := rounding to nearest integer Floor:= rounding to nearest lower integer Ceil := rounding to nearest higher integer. More...

class	BlockRoundingF3D
	Block functor for rounding the value in a certain mode: None := No rounding NearestInteger := rounding to nearest integer Floor:= rounding to nearest lower integer Ceil := rounding to nearest higher integer. More...

class	BlockStdDeviationF3D
	BlockStdDeviationF3D returns the Deviation in each component of f on a indicated subset calcutalted with Steiner translation theorem. More...

class	BlockStructure2D

class	BlockStructureD
	Base of a regular block. More...

class	BlockSum2D
	BlockSum2D sums all components of f over a indicated subset. More...

class	BlockSum3D
	BlockSum3D sums all components of f over a indicated subset. More...

class	BlockTypecastF3D
	perform explicit typecast from output type T2 to T More...

class	BlockVarianceF3D
	BlockVarianceF3D returns the Variance in each component of f on a indicated subset calcutalted with Steiner translation theorem. More...

class	BlockVTIreader3D

class	BlockVTKwriter2D
	BlockVTKwriter2D writes any BLockF2D to vtk-based output files. More...

class	BlockVTKwriter3D
	BlockVTKwriter3D writes any BLockF3D to vtk-based output files. More...

class	Boundary3D
	Prototype for all particle boundaries. More...

struct	BoundaryHelpers
	All boundary helper functions are inside this structure. More...

class	BoundaryStreamPostProcessor2D

class	BoundaryStreamPostProcessorGenerator2D

class	BouzidiAdeDirichletPostProcessor

class	BouzidiPostProcessor
	Post processor for the zero-velocity Bouzidi boundary. More...

class	BouzidiVelocityPostProcessor
	Post processor for the velocity Bouzidi boundary. More...

class	BufferSerializable
	Base class for serializable objects of dynamic size More...

class	BuoyancyForce3D

class	CarnahanStarling

class	CartesianToCylinder3D
	This class converts Cartesian coordinates of point x to cylindrical coordinates wrote into output field (output[0] = radius, output[1] = phi, output[2] = z). More...

class	CartesianToPolar2D
	This class converts Cartesian coordinates of point x to polar coordinates wrote into output field (output[0] = radius>= 0, output[1] = phi in [0, 2Pi). More...

class	CartesianToSpherical3D
	This class converts Cartesian coordinates of point x to spherical coordinates wrote into output field (output[0] = radius, output[1] = phi, output[2] = theta). More...

class	Cell
	Highest-level interface to Cell data. More...

class	CellD
	Single cell implementing the full field data interface. More...

class	CellIndexListD
	List of cell indices and associated field data. More...

struct	CellStatistic
	Return value of any collision. More...

struct	CellStatistic< cpu::simd::Pack< T > >

struct	ChemicalPotentialCoupling2D

struct	ChemicalPotentialCoupling3D

class	CirclePoiseuille3D
	Velocity profile for util::round pipes and a laminar flow of a Newtonian fluid: u(r)=u_max*(1-(r/R)^2) More...

class	CirclePoiseuilleStrainRate3D
	Strain rate for util::round pipes and laminar flow of a Newtonian fluid. More...

class	CirclePowerLaw3D
	This functor returns a quadratic Poiseuille profile for use with a pipe with util::round cross-section. More...

class	CirclePowerLawTurbulent3D
	Velocity profile for util::round pipes and turbulent flows: u(r)=u_max(1-r/R)^(1/n) The exponent n can be calculated by n = 1.03 ln(Re) - 3.6 n=7 is used for many flow applications. More...

class	CLIreader
	Very simple CLI argument parser. More...

struct	CollisionSubdomainMask
	Mask describing the subdomain on which to apply the collision step. More...

class	ColumnVector
	Vector of columns. More...

struct	ColumnVectorBase
	Base of all ColumnVector specializations. More...

class	CombinedAdvectionDiffusionRLBdynamics

class	CombinedRLBdynamics
	Regularized BGK collision followed by any other Dynamics. More...

struct	Communicatable

class	Communicator2D

class	Communicator3D

class	ComposedSuperLatticeF3D

class	ConcentrationAdvectionDiffusionCouplingGenerator2D

class	ConcentrationAdvectionDiffusionCouplingGenerator3D

class	ConcentrationAdvectionDiffusionCouplingPostProcessor2D
	Coupling of ADlattice[0] with the other AD lattices (tpartners) More...

class	ConcentrationAdvectionDiffusionCouplingPostProcessor3D
	Coupling of ADlattice[0] with the other AD lattices (tpartners) More...

class	ConcreteBlockCollisionO
	Collision operation of concrete DYNAMICS on concrete block lattices of PLATFORM. More...

class	ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SIMD, DYNAMICS >
	Application of the collision step on a concrete SIMD block. More...

class	ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::CPU_SISD, DYNAMICS >
	Application of the collision step on a concrete SISD block. More...

class	ConcreteBlockCollisionO< T, DESCRIPTOR, Platform::GPU_CUDA, DYNAMICS >
	Application of the collision step on a concrete CUDA block. More...

class	ConcreteBlockCommunicator

class	ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, PLATFORM > >

class	ConcreteBlockCommunicator< ConcreteBlockLattice< T, DESCRIPTOR, Platform::GPU_CUDA > >

class	ConcreteBlockCouplingO
	Coupling of COUPLEES using concrete OPERATOR with SCOPE on PLATFORM lattices. More...

class	ConcreteBlockCouplingO< COUPLEES, PLATFORM, COUPLER, OperatorScope::PerCell >

class	ConcreteBlockCouplingO< COUPLEES, PLATFORM, COUPLER, OperatorScope::PerCellWithParameters >

class	ConcreteBlockCouplingO< COUPLEES, Platform::GPU_CUDA, COUPLER, OperatorScope::PerCell >
	Application of a block-wise COUPLER on concrete CUDA COUPLEES. More...

class	ConcreteBlockCouplingO< COUPLEES, Platform::GPU_CUDA, COUPLER, OperatorScope::PerCellWithParameters >
	Application of a block-wise COUPLER on concrete CUDA COUPLEES with parameters. More...

class	ConcreteBlockLattice
	Implementation of BlockLattice on a concrete PLATFORM. More...

class	ConcreteBlockMask

class	ConcreteBlockMask< T, Platform::CPU_SIMD >

class	ConcreteBlockMask< T, Platform::CPU_SISD >

class	ConcreteBlockMask< T, Platform::GPU_CUDA >

class	ConcreteBlockO
	Block application of concrete OPERATOR called using SCOPE on PLATFORM. More...

class	ConcreteBlockO< T, DESCRIPTOR, Platform::CPU_SIMD, OPERATOR, OperatorScope::PerBlock >
	Application of a block-wise OPERATOR on a concrete vector CPU block. More...

class	ConcreteBlockO< T, DESCRIPTOR, Platform::CPU_SIMD, OPERATOR, OperatorScope::PerCell >
	Application of a cell-wise OPERATOR on a concrete vector CPU block. More...

class	ConcreteBlockO< T, DESCRIPTOR, Platform::CPU_SIMD, OPERATOR, OperatorScope::PerCellWithParameters >

class	ConcreteBlockO< T, DESCRIPTOR, Platform::CPU_SISD, OPERATOR, OperatorScope::PerBlock >
	Application of a block-wise OPERATOR on a concrete scalar CPU block. More...

class	ConcreteBlockO< T, DESCRIPTOR, Platform::CPU_SISD, OPERATOR, OperatorScope::PerCell >
	Application of a cell-wise OPERATOR on a concrete scalar CPU block. More...

class	ConcreteBlockO< T, DESCRIPTOR, Platform::CPU_SISD, OPERATOR, OperatorScope::PerCellWithParameters >

class	ConcreteBlockO< T, DESCRIPTOR, Platform::GPU_CUDA, OPERATOR, OperatorScope::PerBlock >
	Application of a block-wise OPERATOR on a concrete CUDA block. More...

class	ConcreteBlockO< T, DESCRIPTOR, Platform::GPU_CUDA, OPERATOR, OperatorScope::PerCell >
	Application of a cell-wise OPERATOR on a concrete CUDA block. More...

class	ConcreteBlockO< T, DESCRIPTOR, Platform::GPU_CUDA, OPERATOR, OperatorScope::PerCellWithParameters >
	Application of a parametrized cell-wise OPERATOR on a concrete CUDA block. More...

class	ConcreteCommunicatable

class	ConcreteCommunicatable< ColumnVector< COLUMN, D > >

class	ConcreteCommunicatable< cpu::simd::CyclicColumn< T > >

class	ConcreteCommunicatable< FieldArrayD< T, DESCRIPTOR, PLATFORM, FIELD > >

class	ConcreteCommunicatable< gpu::cuda::Column< T > >
	Communicatable implementation for a single gpu::cuda::Column. More...

class	ConcreteCommunicatable< gpu::cuda::CyclicColumn< T > >
	Communicatable implementation for a single gpu::cuda::CyclicColumn. More...

class	ConcreteCommunicatable< MultiFieldArrayD< T, DESCRIPTOR, PLATFORM, FIELDS... > >

class	ConcreteCommunicatable< std::vector< COLUMN > >

struct	ConcreteHeterogeneousCopyTask
	Private implementation of HeterogeneousCopyTask (PIMPL) More...

struct	ConcreteParametersD
	Concrete storage of ParametersD in olb::Data. More...

class	ConcreteParametersD< T, DESCRIPTOR, Platform::GPU_CUDA, PARAMETERS >
	Representation of (Dynamics,Operator)Parameters<DYNAMICS> for CUDA block lattice. More...

struct	ConcretizableBlockData
	Curried BlockData template for use in callUsingConcretePlatform. More...

struct	ConcretizableBlockGeometry
	Curried BlockGeometry template for use in callUsingConcretePlatform. More...

struct	ConcretizableBlockLattice
	Curried ConcreteBlockLattice template for use in callUsingConcretePlatform. More...

struct	ConcretizableFieldArrayD
	Curried FieldArrayD template for use in callUsingConcretePlatform. More...

class	ConsoleWriter

class	ConstantRate

class	ConstCell
	Highest-level interface to read-only Cell data. More...

class	ConstSpan

class	ContactDetection

class	Container
	Container is a std::vector inspired data wrapper that allows for simple content manipulation of its owned data. More...

class	ContainerF
	ContainerF is a NON-PARALLELIZED (no block/super differentiation) functor intended to extract data from Container objects as used e.g. More...

class	ConvectionBoundaryProcessor3D
	This class interpolates missing f_i from values near the boundary to get a more stable outflow condition for the density. More...

class	ConvectionBoundaryProcessorGenerator3D

struct	CONVERSION_FACTOR_LENGTH

struct	CONVERSION_FACTOR_VELOCITY

class	Cosinus
	Cosinus: Cosinus with period and amplitude. More...

class	CosinusComposite
	CosinusComposite: Composition of two Cosinus to shift the low point within a period - difference denotes the share of the period in which the low point is located. Calculated with case discrimination (xperiod < d or d <= xperiod) More...

class	CSV

class	CubicDeltaBackCouplingModel
	Back-coupling is performed on the cell containing the particle and its neighbours within a cube of one lattice spacing, as per in Maier et al. More...

class	Cuboid2D
	A regular single 2D cuboid is the basic component of a 2D cuboid structure which defines the grid. More...

class	Cuboid3D
	A regular single 3D cuboid is the basic component of a 3D cuboid structure which defines the grid. More...

class	CuboidGeometry2D
	A cuboid structure represents the grid of a considered domain. More...

class	CuboidGeometry3D
	A cuboid geometry represents a voxel mesh. More...

struct	cum

class	CylinderToCartesian3D
	This class converts cylindrical of point x (x[0] = radius, x[1] = phi, x[2] = z) to Cartesian coordinates (wrote into output field). More...

class	Data
	Storage of any FIELD_TYPE data on PLATFORM. More...

class	DeenSmoothingFunctional
	Smoothing functional as in Deen et al (2004), Chem. More...

struct	DensityOutletCoupling2D

class	DewsburyDragModel
	Class to compute the drag coefficient for gas bubbles in a liquid fluid phase as in Dewsbury et al. More...

class	DragModel
	Abstact base class for DragModelBase. More...

class	DragModelBase
	Abstact class for all the drag models. More...

class	DynamicFieldGroupsD
	Storage for dynamic field groups (Prototype for ParticleSystem) More...

class	DynamicFieldGroupsD< T, meta::list< GROUPS... > >

struct	Dynamics
	Interface for per-cell dynamics. More...

struct	DynamicsMask
	Describe mask of DYNAMICS in Data. More...

class	DynamicsPromise
	Factory for instances of a specific Dynamics type. More...

class	EccentricLatticeVelocityField
	Computes resulting lattice velocity of an object from translational and rotational velocity. More...

class	EccentricVelocityField
	Computes resulting velocity of an object from translational and rotational velocity. More...

class	EllipticPoiseuille3D
	This functor returns a quadratic Poiseuille profile for use with a pipe with elliptic cross-section. More...

class	ElParticle3D

class	EntityF

class	EntropicDynamics
	Implementation of the entropic collision step. More...

class	EntropicEqDynamics
	Implementation of the entropic collision step. More...

struct	entropicLbHelpers

struct	entropicLbHelpers< T, descriptors::D2Q9<> >

struct	entropicLbHelpers< T, descriptors::D3Q19<> >

struct	equilibrium

class	Eul2LagrNormDistrPostProcessor3D

class	Eul2LagrNormDistrPostProcessorGenerator3D

class	Eul2LagrOperation3D

class	Eul2LagrOperator3D

class	Eul2LagrOperatorBase3D

class	Eul2LagrPostProcessor3D

class	Eul2LagrPostProcessorGenerator3D

class	ExpOn1stSpecieRate
	Class implementing exponentially-decreasing reaction rate on the 1st reacting species, that is: nu = [A]/t0, with t0 being the time constant in lattice units. More...

class	Expr
	Basic value-substitute enabling extraction of expression trees for code generation. More...

struct	ExprBase

class	ExtendedFdPlaneBoundaryPostProcessor3D
	This class computes the finite difference approximation to LB boundary conditions on a plane wall in 3D with all the terms of the CE expansion. More...

class	ExtendedFdPlaneBoundaryProcessorGenerator3D

class	ExtendedStraightFdBoundaryPostProcessor2D
	This class computes the finite difference approximation to LB boundary conditions on a flat wall in 2D with all the terms of the CE expansion. More...

class	ExtendedStraightFdBoundaryProcessorGenerator2D

class	ExtFieldBoundaryProcessor3D
	This class copies missing values in the external field from the neighbour in normal direction. More...

class	ExtFieldBoundaryProcessorGenerator3D

class	FdAdvectionDiffusionModel

class	FdBasePostProcessor2D

class	FdBasePostProcessor3D

class	FdBoundaryPostProcessor2D

class	FdBoundaryPostProcessor3D

class	FdPostProcessor2D

class	FdPostProcessor3D

class	FdUpdater

class	FdUpdaterBase

class	FieldArrayD
	SoA storage for instances of a single FIELD. More...

class	FieldTypeRegistry
	Efficient indexing of dynamically allocated data fields. More...

class	FieldTypeRegistry< T, DESCRIPTOR, Platform::GPU_CUDA >
	Maintain on-device structure for dynamic field access. More...

class	FileName
	FileName class. More...

class	FiniteDifferenceReactingSpecies2D

class	FiniteDifferenceReactingSpecies3D

class	Force3D
	Prototype for all particle forces. More...

struct	ForceCoupling2D

struct	ForceCoupling3D

class	ForcedEntropicDynamics
	Implementation of the forced entropic collision step. More...

class	ForcedEntropicEqDynamics
	Implementation of the forced entropic collision step. More...

class	ForcedPSMBGKdynamics
	Implementation of the Partially Saturated Method (PSM), see Krüger, Timm, et al. More...

struct	ForcedVANSBGKdynamics
	VANS BGK collision step with external force. More...

class	ForceFromExtField3D

class	ForwardCouplingModel
	Abstact base class for all the forward-coupling models Its raison d'etre consists of not being templetized in Lattice. More...

class	FreeEnergyChemicalPotentialCoupling2D
	This class calculates the chemical potential and stores it in the external field of the respective lattice. More...

class	FreeEnergyChemicalPotentialCoupling3D
	This class calculates the chemical potential and stores it in the external field of the respective lattice. More...

class	FreeEnergyChemicalPotentialGenerator2D
	Generator class for the PostProcessors calculating the chemical potential. More...

class	FreeEnergyChemicalPotentialGenerator3D
	Generator class for the PostProcessors calculating the chemical potential. More...

class	FreeEnergyChemPotBoundaryProcessor2DA
	PostProcessors for the chemical potential boundary condition in the free energy model. More...

class	FreeEnergyChemPotBoundaryProcessor2DB

class	FreeEnergyChemPotBoundaryProcessor3DA
	PostProcessors for the chemical potential boundary condition in the free energy model. More...

class	FreeEnergyChemPotBoundaryProcessor3DB

class	FreeEnergyConvectiveProcessor2D
	PostProcessor for pressure / velocity outflow boundaries in the free energy model. More...

class	FreeEnergyConvectiveProcessor3D
	PostProcessor for the density / velocity outflow boundaries in the free energy model. More...

class	FreeEnergyDensityOutletCoupling2D
	PostProcessor for setting a constant density outlet. More...

class	FreeEnergyDensityOutletCoupling3D
	PostProcessor for setting a constant density outlet. More...

class	FreeEnergyDensityOutletGenerator2D
	Generator class for the PostProcessors assigning the density boundary condition at the outlet. More...

class	FreeEnergyDensityOutletGenerator3D
	Generator class for the PostProcessors assigning the density boundary condition at the outlet. More...

class	FreeEnergyForceCoupling2D
	PostProcessor calculating the interfacial force in the free energy model. More...

class	FreeEnergyForceCoupling3D
	PostProcessor calculating the interfacial force in the free energy model. More...

class	FreeEnergyForceGenerator2D
	Generator class for the PostProcessors calculating the interfacial force. More...

class	FreeEnergyForceGenerator3D
	Generator class for the PostProcessors calculating the interfacial force. More...

class	FreeEnergyInletOutletCoupling2D
	PostProcessor for assigning the velocity at inlet and outlets to lattice two and three. More...

class	FreeEnergyInletOutletCoupling3D
	PostProcessor for assigning the velocity at inlet and outlets to lattice two and three. More...

class	FreeEnergyInletOutletGenerator2D
	Generator class for the PostProcessors assigning the velocity at the outlet to lattice two and three. More...

class	FreeEnergyInletOutletGenerator3D
	Generator class for the PostProcessors assigning the velocity at the outlet to lattice two and three. More...

class	FreeEnergyWallProcessor2D
	PostProcessor for the wetting boundary condition in the free energy model. More...

class	FreeEnergyWallProcessor3D
	PostProcessor for the wetting boundary condition in the free energy model. More...

class	FreeSurface2DSetup
	Generator class for the PostProcessors tracking the interface. More...

class	FreeSurface3DSetup

class	FreeSurfaceFinalizeConversionPostProcessor2D
	Free Surface Processor 7 Finishes up left over cell conversions and prepares the state for the next simulation step. More...

class	FreeSurfaceFinalizeConversionPostProcessor3D
	Free Surface Processor 7 Finishes up left over cell conversions and prepares the state for the next simulation step. More...

class	FreeSurfaceMassExcessPostProcessor2D
	Free Surface Processor 6 Calculates mass excess from the cell type conversions and distributes them to neighbouring interface cells Keeps mass local if no neighbour exists until an interface reappears at this position. More...

class	FreeSurfaceMassExcessPostProcessor3D
	Free Surface Processor 6 Calculates mass excess from the cell type conversions and distributes them to neighbouring interface cells Keeps mass local if no neighbour exists until an interface reappears at this position. More...

class	FreeSurfaceMassFlowPostProcessor2D
	Free Surface Processor 1-3 Mass Flow Cleans up leftover flags from the previous simulation step. More...

class	FreeSurfaceMassFlowPostProcessor3D
	Free Surface Processor 1-3 Mass Flow Cleans up leftover flags from the previous simulation step. More...

class	FreeSurfaceToFluidCellConversionPostProcessor2D

class	FreeSurfaceToFluidCellConversionPostProcessor3D

class	FreeSurfaceToGasCellConversionPostProcessor2D
	Free Surface Processor 5 ToGas Converts cells to interface from fluid if a neighbouring cell was converted to a gas cell. More...

class	FreeSurfaceToGasCellConversionPostProcessor3D
	Free Surface Processor 5 ToGas Converts cells to interface from fluid if a neighbouring cell was converted to a gas cell. More...

class	FreundlichIsotherm

class	Fringe2D

class	Fringe3D

struct	FullSlipBoundaryPostProcessor2D

struct	FullSlipBoundaryPostProcessor3D

class	FunctorPtr
	Smart pointer for managing the various ways of passing functors around. More...

class	GaussDistribution
	Functor for a Gaussian (normal) distribution. More...

class	GaussianHill2D
	8.6.1 Gauss Hill inital values More...

class	GaussianHillTimeEvolution2D
	8.6.1 Gauss Hill time evolution More...

class	GenericF
	GenericF is a base class, that can represent continuous as well as discrete functions. More...

struct	GenericVector
	Generic vector of values supporting basic arithmetic. More...

struct	GlobalPostProcessor2D

struct	GlobalPostProcessor3D

class	Gnuplot

struct	GranularCoupling
	granular flow More...

class	GroupedDataCommunicatable

struct	GroupedDataCommunicatableHelper
	Declare GroupedDataCommunicatable containing each GROUP in DESCRIPTOR::fields_t. More...

class	GroupedFieldF
	GroupedFieldF is a NON-PARALLELIZED (no block/super differentiation) functor. More...

class	HaiderLevenspielDragForce3D

class	HaiderLevenspielParticle3D

class	HaldaneRate
	Class implementing Haldane kinetics, with 1st field being substrate concentration [S], 2nd being bacteria concentration [X]: nu = mu * [X]; mu = muMax * [S] / ([S] + Ks + [S]^2/KI) More...

class	HarmonicOscillatingRotatingForceField3D
	This functor gives a parabolic profile for a given point x as it computes the distance between x and the axis. More...

class	HertzMindlinDeresiewicz3D

struct	HeterogeneousCopyTask
	Wrapper for a local heterogeneous block communication request. More...

class	HeterogeneousCopyTask< T, DESCRIPTOR, Platform::GPU_CUDA, TARGET >
	Wrapper for a local heterogeneous block communication request. More...

class	HeterogeneousCopyTask< T, DESCRIPTOR, SOURCE, Platform::GPU_CUDA >
	Wrapper for a local heterogeneous block communication request. More...

class	HeterogeneousCopyTaskDataForGpuSource
	Private implementation of heterogeneous copy task between GPU_CUDA source and CPU_* target. More...

class	HeterogeneousCopyTaskDataForGpuTarget
	Private implementation of heterogeneous copy task between CPU_* source and GPU_CUDA target. More...

class	HeterogeneousLoadBalancer
	Load balancer for heterogeneous CPU-GPU systems. More...

class	HeuristicLoadBalancer
	Constructs a load balancer from a given cuboid geometry using a heurist. More...

struct	Hyperplane2D
	Definition of a analytical line embedded in 2D space. More...

struct	Hyperplane3D
	Definition of a analytical 2D plane embedded in 3D space. More...

class	HyperplaneLattice2D
	Parametrization of a hyperplane lattice (i.e. a line lattice). More...

class	HyperplaneLattice3D
	Parametrization of a hyperplane lattice. More...

struct	ImplementationOf
	Specializable declarator for concrete implementations of abstract storage types. More...

struct	ImplementationOf< AbstractColumn< T >, Platform::CPU_SIMD >
	Declare cpu::sisd::Column as the AbstractColumn implementation for CPU SISD targets. More...

struct	ImplementationOf< AbstractColumn< T >, Platform::CPU_SISD >
	Declare cpu::sisd::Column as the AbstractColumn implementation for CPU SISD targets. More...

struct	ImplementationOf< AbstractColumn< T >, Platform::GPU_CUDA >
	Declare gpu::cuda::Column as the AbstractColumn implementation for GPU CUDA targets. More...

struct	ImplementationOf< AbstractCyclicColumn< T >, Platform::CPU_SIMD >
	Declare cpu::sisd::CyclicColumn as the AbstractCyclicColumn implementation for CPU SISD targets. More...

struct	ImplementationOf< AbstractCyclicColumn< T >, Platform::CPU_SISD >
	Declare cpu::sisd::CyclicColumn as the AbstractCyclicColumn implementation for CPU SISD targets. More...

struct	ImplementationOf< AbstractCyclicColumn< T >, Platform::GPU_CUDA >
	Declare gpu::cuda::CyclicColumn as the AbstractCyclicColumn implementation for GPU CUDA targets. More...

class	InamuroAnalyticalDynamics
	Implementation of Inamuro boundary condition following the paper "A non-slip boundary condition for lattice Boltzmann simulations", Inamuro, Takaji; Yoshino, Masato; Ogino, Fumimaru, (1995). More...

class	InamuroNewtonRaphsonDynamics
	This class computes the inamuro BC with general dynamics. More...

class	IndicatorBlockData2D
	indicator from VTIreader More...

class	IndicatorBlockData3D

class	IndicatorCircle2D
	indicator function for a 2D circle More...

class	IndicatorCircle3D
	indicator function for a 3D circle More...

class	IndicatorCone3D
	indicator function for a 3d frustum More...

class	IndicatorCuboid2D
	indicator function for a 2D-cuboid, parallel to the planes x=0, y=0; theta rotates cuboid around its center, theta in radian measure More...

class	IndicatorCuboid3D
	indicator function for a 3d-cuboid, parallel to the planes x=0, y=0, z=0. More...

class	IndicatorCuboidRotate3D
	indicator function for a 3d-cuboid, turned by an angle theta around an axis of rotation More...

class	IndicatorCylinder3D
	indicator function for a 3d-cylinder More...

class	IndicatorEllipsoid3D
	indicator function for an ellipsoid More...

class	IndicatorEquiTriangle2D
	indicator function for a 2D equilateral triangle More...

class	IndicatorF1D
	IndicatorF1D is an application from $\Omega \subset R \to {0,1}$ . More...

class	IndicatorF2D
	IndicatorF2D is an application from $\Omega \subset R^2 \to {0,1}$ . More...

class	IndicatorF2DfromIndicatorF3D
	indicator function for a 2D-cuboid, parallel to the planes x=0, y=0; theta rotates cuboid around its center, theta in radian measure More...

class	IndicatorF3D
	IndicatorF3D is an application from $\Omega \subset R^3 \to \{0,1\}$ . More...

class	IndicatorIdentity2D

class	IndicatorIdentity3D

class	IndicatorInternal3D
	indicator function for the internal part of an input indicator More...

class	IndicatorLayer2D
	Indicator function creating an layer around an input indicator (for positive `layerSize`) or reducing the input indicator by a layer (for negative `layerSize`). More...

class	IndicatorLayer3D
	indicator function for a layer More...

class	IndicatorSDF2D

class	IndicatorSDF3D

class	IndicatorSphere3D
	indicator function for a 3D-sphere More...

class	IndicatorSuperEllipsoid3D
	indicator function for a super ellipsoid More...

class	IndicatorTranslate3D

class	IndicatorTriangle2D
	indicator function for a 2D triangle More...

class	IndicCalc1D
	IndicCalc1D //////////////////////////////// arithmetic helper class for Indicator 1d functors. More...

class	IndicCalc2D
	indicCalc2D //////////////////////////////// arithmetic helper class for Indicator 2D functors More...

class	IndicComb3D
	IndicComb3D //////////////////////////////// arithmetic helper class for Indicator 3d functors. More...

class	IndicElongation

class	IndicInverse

class	IndicMinus1D
	subtraction functor acts as without More...

class	IndicMinus2D
	Subtraction. More...

class	IndicMinus3D
	Subtraction. More...

class	IndicMultiplication1D
	multiplication functor acts as intersection More...

class	IndicMultiplication2D
	Intersection. More...

class	IndicMultiplication3D
	Intersection. More...

class	IndicPlus1D
	addition functor acts as union More...

class	IndicPlus2D
	Union. More...

class	IndicPlus3D
	Union. More...

class	IndicScale

struct	InletOutletCoupling2D

struct	InletOutletCoupling3D

class	InterpMagForceForMagP3D

class	Isotherm
	Base class for isotherms. More...

class	Krause

class	LaddForwardCouplingModel
	Class for a forward-coupling model following the Ladd's mechanism. More...

class	LaddMomentumExchange
	Using Ladd mechanism. More...

class	LangmuirIsotherm

class	LatticeBoltzmannReactingSpecies2D

class	LatticeBoltzmannReactingSpecies3D

class	LatticeCouplingGenerator2D

class	LatticeCouplingGenerator3D

struct	LatticePosAndWeight
	Data structure for smoothing functionals. More...

class	LatticeStatistics

struct	lbHelpers

struct	lbm
	Collection of common computations for LBM. More...

class	LbSolver
	LbSolver is a generic solver for Lattice-Boltzmann problems. More...

class	LegacyBlockCollisionO
	Concrete collision operator for legacy dynamics. More...

class	LegacyBlockPostProcessorO
	Block operator for supporting legacy post processor in the new operator-centric framework. More...

class	LegacyConcreteDynamics
	Concrete CPU dynamics for legacy dynamics. More...

struct	LESADECoupling
	LES-ADE coupling with Schmidt number stabilization. More...

struct	LESReactionCoupling
	LES-ADE coupling for multiple reactions. More...

class	LightSourceCylindrical3D
	light source as a cylinder along z-axis More...

class	LinearAveragingSmoothingFunctional
	Abstact class for all the linear-averaging smoothing functionals. More...

class	LinearContactForce3D

class	LinearDampingForceForMagDipoleMoment3D

class	LinearIsotherm

class	LoadBalancer
	Base class for all LoadBalancer. More...

class	LocalBackCouplingModel
	Back-coupling is performed only on the cell containing the particle. More...

class	LocalBaseForwardCouplingModel
	Abstact class for all the local forward-coupling models, viz., momentum coupling from fluid to particle. More...

struct	LocalPostProcessor2D

struct	LocalPostProcessor3D

class	LogNormalDistribution
	Functor for a logarithmic normal distribution. More...

struct	LongitudinalMixingReactionCoupling
	Reaction Coupling for the In-Bulk appraoch of lognitudinalMixing3d example. More...

struct	LpNormImpl
	Lp norm functor implementation details specific to the P parameter. More...

struct	LpNormImpl< T, W, 0 >
	Linf norm functor implementation details. More...

struct	LpNormImpl< T, W, 1 >
	L1 norm functor implementation details. More...

struct	LpNormImpl< T, W, 2 >
	L2 norm functor implementation details. More...

class	MagneticFieldFromCylinder3D

class	MagneticForceForMagP3D

class	MagneticForceFromCylinder3D
	Magnetic field that creates magnetization in wire has to be orthogonal to the wire. More...

class	MagneticParticle3D

class	MaterialBoundary3D

class	MaterialSTLBoundary3D

class	Matrix
	Matrix with a defined number of ROWS and columns (COLS) More...

struct	MCMPForcedPostProcessor
	Multi-Component-Multi-Phase Shan-Chen force with thermodynamic equation of state based on. More...

class	MixedScaleBoussinesqCouplingGenerator2D

class	MixedScaleBoussinesqCouplingGenerator3D

class	MixedScaleBoussinesqCouplingPostProcessor2D

class	MixedScaleBoussinesqCouplingPostProcessor3D

class	MonodRate
	Class implementing Monod kinetics, with 1st field being substrate concentration [S], 2nd being bacteria concentration [X]: nu = mu * [X]; mu = muMax * [S] / ([S] + Ks) More...

class	MorsiDragModel
	Class to compute the standard drag coefficient as in Morsi and Alexander (1972). More...

class	MPI_Group_Wrapper

class	MpiRecvRequest
	Non-blocking MPI receive request. More...

class	MpiRequest
	Basic wrapper around a single MPI_Request. More...

class	MpiSendRequest
	Non-blocking MPI send request. More...

struct	mrt

class	MultiComponentPengRobinson

class	MultiConcreteCommunicatable

class	MultiFieldArrayD
	Storage for a fixed set of static FIELDS and arbitrary custom fields. More...

struct	MultiFieldArrayForDescriptorHelper
	Declare MultiFieldArrayD containing each field in DESCRIPTOR::fields_t. More...

class	MultiPhaseUnitConverter
	Conversion between physical and lattice units, as well as discretization for multiple component lattices. More...

class	Musker
	Musker profile. More...

class	NaiveForwardCouplingModel
	Class for a naive forward-coupling model. More...

class	NaiveMomentumExchange
	Naive way. More...

class	NaiveNonLocalForwardCouplingModel
	Class for a naive, non-local forward-coupling model as in Sungkorn et al. More...

class	NanoflannContact

class	NanoflannParticleAdaptor

struct	NavierStokesAdvectionDiffusionCoupling
	Coupling between a Navier-Stokes and an Advection-Diffusion lattice. More...

struct	NavierStokesAdvectionDiffusionVelocityCoupling
	Velocity coupling between Navier-Stokes and an Advection-Diffusion lattice. More...

class	NewtonianParticleReynoldsNumber
	Class class for Newtonian particle Reynolds number computation within drag model. More...

class	NonLocalBaseBackCouplingModel
	Class for a generic non-local back-coupling model (but this is NOT VIRTUAL!), viz., momentum coupling from particle to fluid, for model more complicated that CubicDeltaBackCouplingModel. More...

class	NonLocalBaseForwardCouplingModel
	Abstact class for all the non-local forward-coupling models, viz., momentum coupling from fluid to particle. More...

class	Normal

class	Octree

class	olb_fstream

class	olb_ifstream

class	olb_ofstream

class	OMBuf
	userdefined stream buffer for OstreamManager More...

struct	ompManager

struct	OperatorParameters
	Describe paramaters of OPERATOR in Data. More...

class	OrthogonalHeterogeneousLoadBalancer
	Load balancer for heterogeneous CPU-GPU systems. More...

class	OstreamManager
	class for marking output with some text More...

class	OuterVelocityCornerProcessor2D
	This class computes the skordos BC in 2D on a convex corner but with a limited number of terms added to the equilibrium distributions (i.e. More...

struct	OuterVelocityCornerProcessor3D

class	OuterVelocityEdgeProcessor3D
	This class computes the skordos BC on a convex edge wall in 3D but with a limited number of terms added to the equilibrium distributions (i.e. More...

class	ParameterD
	Storage of a single FIELD-valued parameter. More...

struct	ParametersD
	Set of FIELD-valued parameters. More...

class	ParBuf

class	PartialSlipBoundaryProcessor2D
	This class computes a partial slip BC in 2D. More...

class	PartialSlipBoundaryProcessor3D
	This class computes a partial slip BC in 3D. More...

class	PartialSlipBoundaryProcessorGenerator2D

class	PartialSlipBoundaryProcessorGenerator3D

class	Particle3D

struct	ParticleAdvectionDiffusionBGKdynamics
	This approach contains a slight error in the diffusion term. More...

class	ParticleCircumRadiusF
	ParticleCircumRadiusF NON-PARALLELIZED (no block/super differentiation) functor, which returns the circumRadius of a smoothIndicator. More...

class	ParticleDistribution
	Particle distribution for time and size discretization. More...

class	ParticleIndicatorF3D

class	ParticleOperation3D

class	ParticleReynoldsNumber
	Abstract class for particle Reynolds number computation within drag model. More...

class	ParticleReynoldsNumberBase
	Abstract class for particle Reynolds number computation within drag model. More...

class	ParticleSystem3D

class	PassiveAdvectionOperation3D

class	PassiveSoluteCouplingPostProcessor3D
	Coupler for solute that is only coupled to the fluid velocity. More...

class	PassiveSoluteCouplingPostProcessorGenerator3D

class	PengRobinson

class	PeriodicBoundary3D

struct	PhaseFieldAdvectionDiffusionBGKdynamics

class	PhaseFieldCouplingGenerator2D

class	PhaseFieldCouplingGenerator3D

class	PhaseFieldCouplingPostProcessor2D

class	PhaseFieldCouplingPostProcessor3D

class	PlaneFdBoundaryProcessor3D
	This class computes the skordos BC on a plane wall in 3D but with a limited number of terms added to the equilibrium distributions (i.e. More...

class	PLattice

class	PLSsolution3D
	see Mink et al. 2016 in Sec.3.1. More...

class	Poiseuille2D

class	PoiseuilleStrainRate2D

class	PolarToCartesian2D
	This class converts polar coordinates of point x (x[0] = radius, x[1] = phi) to Cartesian coordinates (wrote into output field). More...

class	PolynomialStartScale
	PolynomialStartScale: 1D -> 1D a start curve based on a polynomial fifth order for a continuous transition at 0 and 1: maxValue(6y^5-15y^4+10y^3) More...

class	PopulationCellD
	Minimal cell storing only population data. More...

class	PorousAdvectionDiffusionBGKdynamics
	This approach contains a slight error in the diffusion term. More...

class	PorousNavierStokesAdvectionDiffusionCouplingGenerator3D

class	PorousNavierStokesAdvectionDiffusionCouplingPostProcessor3D

class	PostProcessor2D
	Interface of 2D post-processing steps. More...

class	PostProcessor3D

class	PostProcessorGenerator2D

class	PostProcessorGenerator3D

class	PostProcessorPromise
	Factory for instances of a specific POST_PROCESSOR type. More...

class	PowerLaw2D

class	PowerLawDewsburyDragModel
	Class to compute the drag coefficient for gas bubbles in a liquid fluid phase as in Dewsbury et al. More...

class	PowerLawMorsiDragModel
	Class to compute the standard drag coefficient as in Morsi and Alexander (1972), in a power-law fluid. More...

class	PowerLawParticleReynoldsNumber
	Class class for power-law particle Reynolds number computation within drag model. More...

class	PowerLawProfile
	PowerLaw profile. More...

class	PowerLawSchillerNaumannDragModel
	Class to compute the standard drag coefficient as in Schiller and Naumann (1935), in a power-law fluid. More...

class	PowerLawSunDragModel
	Class to compute the drag coefficient for gas bubbles in a liquid fluid phase as in Sun, Guo, Wang et al. More...

class	PsiEqualsRho

class	RadiativeUnitConverter
	Conversion between physical and lattice units, as well as discretization. More...

struct	RandomLoadBalancer
	Basic Random Load Balancer. More...

class	RandomTruncatedWalkOperation3D

class	RandomWalkOperation3D

class	Rate

class	ReactingSpecies2D

class	ReactingSpecies3D

class	ReactionGenerator2D

class	ReactionGenerator3D

class	ReactionPostProcessor2D

class	ReactionPostProcessor3D

class	RectanglePoiseuille3D
	This functor returns a Poiseuille profile for use with a pipe with square shaped cross-section. More...

class	RectangleTrigonometricPoiseuille3D

class	ReflectBoundary3D

class	RegularCachedIndicatorF3D

struct	RhoStatistics
	Multiphysics class for coupling between different lattices. More...

struct	robinBoundaryExtendedPostProcessor3DCorners

struct	robinBoundaryExtendedPostProcessor3DEdges

struct	robinBoundaryLatticePostProcessor3D
	First scheme adapted from Xuhui Meng and Zhaoli Guo. More...

struct	robinBoundaryLatticePostProcessor3Dother

class	RotatingForceField3D
	This functor gives a parabolic profile for a given point x as it computes the distance between x and the axis. More...

class	RotatingLinear3D
	This functor gives a linar profile for a given point x as it computes the distance between x and the axis. More...

class	RotatingLinearAnnulus3D
	This functor gives a linar profile in an annulus for a given point x between the inner and outer radius as it computes the distance between x and the inner and outer radius. More...

class	RotatingParticle3D

class	RotatingQuadratic1D
	This functor gives a parabolic profile for a given point x as it computes the distance between x and the axis. More...

class	RotationRoundAxis3D
	This class saves coordinates of the resulting point after rotation in the output field. More...

class	RtlbmDiffuseBoundaryDynamics
	Defines incoming (axis parallel) directions on flat walls. More...

class	RtlbmDiffuseConstBoundaryDynamics
	Defines incoming directions on flat walls. More...

class	RtlbmDiffuseConstCornerBoundaryDynamics
	Defines incoming directions on corner boundaries. More...

class	RtlbmDiffuseConstEdgeBoundaryDynamics
	Defines incoming directions on edge boundaries. More...

class	RtlbmDiffuseCornerBoundaryDynamics

class	RtlbmDiffuseEdgeBoundaryDynamics

class	RtlbmDirectedBoundaryDynamics

class	RtlbmDirectedCornerBoundaryDynamics

class	RtlbmDirectedEdgeBoundaryDynamics

class	RTLBMdynamicsMcHardy
	Solves RTE according Christopher McHardy et al 2016. More...

class	RTLBMdynamicsMcHardyRK

struct	SCALAR2

struct	ScalarVector
	Vector of scalars. More...

class	SchillerNaumannDragForce3D

class	SchillerNaumannDragModel
	Class to compute the standard drag coefficient as in Schiller and Naumann (1935). More...

struct	SEEDS

struct	SEEDS_COUNT

struct	SEEDS_VORTICITY

class	Serializable
	Base class for serializable objects of constant size. For dynamic size use `BufferSerializable`. More...

class	Serializer
	Class for writing, reading, sending and receiving `Serializable` objects. More...

class	ShanChen93

class	ShanChen94

class	ShanChenDynOmegaForcedGenerator2D

class	ShanChenDynOmegaForcedGenerator3D

class	ShanChenDynOmegaForcedPostProcessor2D
	Multiphysics class for coupling between different lattices. More...

class	ShanChenDynOmegaForcedPostProcessor3D
	Multiphysics class for coupling between different lattices. More...

struct	ShanChenForcedPostProcessor

class	ShanChenForcedSingleComponentGenerator2D

class	ShanChenForcedSingleComponentGenerator3D

struct	ShanChenForcedSingleComponentPostProcessor

class	ShanChenForcedSingleComponentPostProcessor2D
	Multiphysics class for coupling between different lattices. More...

class	ShanChenForcedSingleComponentPostProcessor3D
	Multiphysics class for coupling between different lattices. More...

struct	SIGMA

struct	SimdBase

class	SimpleReflectBoundary3D

class	SimulateParticles

class	SimulateParticles< T, HaiderLevenspielParticle3D >

class	SimulateParticles< T, MagneticParticle3D >

class	SimulateParticles< T, RotatingParticle3D >

class	Sinus
	Sinus: Sinus with period and amplitude. More...

class	SinusStartScale
	SinusStartScale: 1D -> 1D a start curve based on sinus for a continuous transition at 0 and 1. More...

struct	SlipBoundaryPostProcessor3D

class	SlipBoundaryProcessor2D
	This class computes a slip BC in 2D. More...

class	SlipBoundaryProcessor3D
	This class computes a slip BC in 3D. More...

class	SlipBoundaryProcessorGenerator2D

class	SlipBoundaryProcessorGenerator3D

struct	SmagorinskyBoussinesqCoupling
	AD coupling with Boussinesq bouancy for Smagorinsky-LES. More...

class	SmagorinskyBoussinesqCouplingGenerator2D

class	SmagorinskyBoussinesqCouplingGenerator3D

class	SmagorinskyBoussinesqCouplingPostProcessor2D

class	SmagorinskyBoussinesqCouplingPostProcessor3D

class	SmoothBlockIndicator3D

class	SmoothIndicatorCircle2D
	implements a smooth circle in 2D with an _epsilon sector More...

class	SmoothIndicatorCone3D
	implements a smooth particle cone in 3D with an _epsilon sector More...

class	SmoothIndicatorCuboid2D
	implements a smooth cuboid in 2D with an _epsilon sector. More...

class	SmoothIndicatorCuboid3D
	implements a smooth particle cuboid in 3D with an _epsilon sector. More...

class	SmoothIndicatorCustom2D

class	SmoothIndicatorCustom3D

class	SmoothIndicatorCylinder3D
	implements a smooth particle cylinder in 3D with an _epsilon sector. More...

class	SmoothIndicatorEllipsoid3D
	implements a smooth particle ellipsoid in 3D with an _epsilon sector. More...

class	SmoothIndicatorF2D

class	SmoothIndicatorF2D< T, S, false >
	SmoothIndicatorF2D is an application from $\Omega \subset R^3 \to [0,1]$ . More...

class	SmoothIndicatorF2D< T, S, true >
	SmoothIndicatorF2D is an application from $\Omega \subset R^3 \to [0,1]$ . More...

class	SmoothIndicatorF3D

class	SmoothIndicatorF3D< T, S, false >
	SmoothIndicatorF3D is an application from $\Omega \subset R^3 \to [0,1]$ . More...

class	SmoothIndicatorF3D< T, S, true >
	SmoothIndicatorF3D is an application from $\Omega \subset R^3 \to [0,1]$ . More...

class	SmoothIndicatorFactoredCircle2D
	factorizable output smooth circle in 2D with a tangiant or ramp epsilon sector More...

class	SmoothIndicatorFactoredCircle3D
	factorizable output smooth sphere in 3D with a tangiant or ramp epsilon sector More...

class	SmoothIndicatorFactoredCuboid2D
	factorizable output smooth cuboid in 2D with a tangiant or ramp epsilon sector More...

class	SmoothIndicatorHTCircle2D
	implements a smooth circle in 2D with an tangiant _epsilon sector More...

class	SmoothIndicatorIdentity2D

class	SmoothIndicatorIdentity3D

class	SmoothIndicatorSphere3D
	implements a smooth sphere in 3D with an _epsilon sector More...

class	SmoothIndicatorSuperEllipsoid3D
	implements a smooth particle super-ellipsoid in 3D. The epsilon sector is currently missing. More...

class	SmoothIndicatorTriangle2D
	implements a smooth triangle in 2D with an _epsilon sector More...

class	SmoothIndicCalc2D
	IndicSmoothCalc2D //////////////////////////////// arithmetic helper class for Indicator 2d functors. More...

class	SmoothIndicCalc3D
	IndicSmoothCalc3D //////////////////////////////// arithmetic helper class for Indicator 3d functors. More...

class	SmoothIndicPlus2D
	addition functor acts as union More...

class	SmoothIndicPlus3D
	addition functor acts as union More...

class	SmoothingFunctional
	Abstact class for all the smoothing functionals. More...

struct	SolidBoundary

struct	SourcedAdvectionDiffusionBGKdynamics

struct	SourcedLimitedAdvectionDiffusionBGKdynamics

class	SpecialAnalyticalFfromBlockF3D
	Converts block functors to analytical functors (special) More...

class	SphericalToCartesian3D
	This class converts spherical coordinates of point x (x[0] = radius, x[1] = phi, x[2] = theta) to Cartesian coordinates wrote into output field. More...

class	Spotlight

struct	StatisticsPostProcessor

class	StepSmoothingFunctional
	Stepwise smoothing functional. More...

class	STLmesh

class	STLreader

struct	STLtriangle

class	StochasticSGSdynamics
	Implementation of the MRT collision step with stochastic relaxation based on " A stochastic subgrid model with application to turbulent flow and scalar mixing"; Phys. More...

class	StokesDragForce3D

class	StokesDragForceForHomVelField3D

class	StokesSimplifiedDragModel
	Class to compute a drag coefficient Cd=1.83 for low-Re Stokes drag. More...

class	StraightConvectionBoundaryProcessor2D
	This class computes a convection BC on a flat wall in 2D. More...

class	StraightConvectionBoundaryProcessor3D

class	StraightConvectionBoundaryProcessorGenerator2D

class	StraightFdBoundaryProcessor2D
	This class computes the skordos BC on a flat wall in 2D but with a limited number of terms added to the equilibrium distributions (i.e. More...

struct	StripeOffDensityOffsetO
	Operator for striping off density offset. More...

class	SunDragModel
	Class to compute the drag coefficient for gas bubbles in a liquid fluid phase as in Sun, Guo, Wang et al. More...

class	SuperAbsoluteErrorLpNorm2D
	Absolute error norm functor. More...

class	SuperAbsoluteErrorLpNorm3D
	Absolute error norm functor. More...

class	SuperAverage2D
	SuperAverage2D returns the average in each component of f on a indicated subset. More...

class	SuperAverage3D
	SuperAverage3D returns the average in each component of f on a indicated subset. More...

class	SuperCalcF2D
	Arithmetic operations for SuperF2D functors. More...

class	SuperCalcF3D
	Arithmetic operations for SuperF3D functors. More...

class	SuperCommunicationTagCoordinator
	Communication-free negotation of unique tags for inter-cuboid communication. More...

class	SuperCommunicator
	Generic communicator for overlaps between blocks of SUPER. More...

class	SuperConst2D
	Functor returning a constant vector for all inputs. More...

class	SuperConst3D
	Functor returning a constant vector for all inputs. More...

class	SuperContainerF

class	SuperData

class	SuperData3D

class	SuperDataF2D
	Functor from `SuperData2D` More...

class	SuperDataF3D
	Functor from `SuperData3D` More...

class	SuperDiscretizationF2D
	Super functor for discretizing values by an interval (bottomBoundary,topBoundary), as well as restricting the value by setting n equal-distributed points and rounding the value to the nearest point If n = 1, there won't be restricting, and for n>=1 there will be n-1 restricting points. More...

class	SuperDiscretizationF3D
	Super functor for discretizing values by an interval (bottomBoundary,topBoundary), as well as restricting the value by setting n equal-distributed points and rounding the value to the nearest point If n = 1, there won't be restricting, and for n>=1 there will be n-1 restricting points. More...

class	SuperEntityF

class	SuperEuklidNorm2D
	functor that returns pointwise the l2-norm, e.g. of a velocity More...

class	SuperEuklidNorm3D
	functor that returns pointwise the l2-norm, e.g. of a velocity More...

class	SuperExtractComponentF3D
	functor to extract one component More...

class	SuperExtractComponentIndicatorF3D
	functor to extract one component inside an indicator More...

class	SuperExtractIndicatorF3D
	functor to extract data inside an indicator More...

class	SuperF2D
	represents all functors that operate on a SuperStructure<T,2> in general More...

class	SuperF3D
	represents all functors that operate on a SuperStructure<T,3> in general More...

class	SuperField2D

class	SuperField3D

class	SuperFieldArrayD

class	SuperFiniteDifference3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperGeometry
	Representation of a statistic for a parallel 2D geometry. More...

class	SuperGeometryFaces2D
	Accumulates the discrete surface of indicated cells facing unit directions and returns the individual as well as the total surface in phys units. More...

class	SuperGeometryFaces3D
	Accumulates the discrete surface of indicated cells facing unit directions and returns the individual as well as the total surface in phys units. More...

class	SuperGeometryFacesIndicator2D
	functor counts to get the discrete surface for a material no. and SmoothIndicator in direction (1,0,0), (0,1,0), (0,0,1), (-1,0,0), (0,-1,0), (0,0,-1) and total surface, then it converts it into phys units More...

class	SuperGeometryFacesIndicator3D
	functor counts to get the discrete surface for a material no. and SmoothIndicator in direction (1,0,0), (0,1,0), (0,0,1), (-1,0,0), (0,-1,0), (0,0,-1) and total surface, then it converts it into phys units More...

class	SuperGeometryStatistics2D

class	SuperGeometryStatistics3D

class	SuperIdentity2D
	identity functor for memory management More...

class	SuperIdentity3D
	identity functor for memory management More...

class	SuperIdentityOnSuperIndicatorF3D
	identity functor for memory management More...

class	SuperIndicatorBoundaryNeighbor2D
	Indicator identifying neighbors of boundary cells. More...

class	SuperIndicatorBoundaryNeighbor3D
	Indicator identifying neighbors of boundary cells. More...

class	SuperIndicatorF2D

class	SuperIndicatorF3D
	Base indicator functor (discrete) More...

class	SuperIndicatorFfromIndicatorF2D
	SuperIndicatorF2D from IndicatorF2D. More...

class	SuperIndicatorFfromIndicatorF3D
	SuperIndicatorF3D from IndicatorF3D. More...

class	SuperIndicatorFfromSmoothIndicatorF2D
	SuperIndicatorF2D from SmoothIndicatorF2D. More...

class	SuperIndicatorFfromSmoothIndicatorF3D
	SuperIndicatorF3D from SmoothIndicatorF3D. More...

class	SuperIndicatorIdentity2D
	Indicator identity functor. More...

class	SuperIndicatorIdentity3D
	Indicator identity functor. More...

class	SuperIndicatorLayer3D
	Indicator extended by a layer. More...

class	SuperIndicatorMaterial2D
	Indicator functor from material numbers. More...

class	SuperIndicatorMaterial3D
	Indicator functor from material numbers. More...

class	SuperIndicatorMultiplication3D
	Indicator intersection functor. More...

class	SuperIntegral2D
	SuperIntegral2D integrates f on a indicated subset. More...

class	SuperIntegral3D
	SuperIntegral3D integrates f on a indicated subset. More...

class	SuperIsotropicHomogeneousTKE3D

class	SuperLaplacian3D
	functor to get pointwise finite difference Laplacian operator More...

class	SuperLattice
	Super class maintaining block lattices for a cuboid decomposition. More...

class	SuperLatticeCellList

class	SuperLatticeCoords2D
	functor to get pointwise density rho on local lattices More...

class	SuperLatticeCoords3D
	functor to get pointwise density rho on local lattices More...

class	SuperLatticeCoupling
	Coupling operator COUPLER on named COUPLEES. More...

class	SuperLatticeCuboid2D
	functor to get pointwise the cuboid no. + 1 on local lattice More...

class	SuperLatticeCuboid3D
	functor to get pointwise the cuboid no. + 1 on local lattice More...

class	SuperLatticeDensity2D
	functor to get pointwise density rho on local lattices More...

class	SuperLatticeDensity3D
	functor to get pointwise density rho on local lattices More...

class	SuperLatticeDiscreteNormal2D
	functor to get pointwise the discrete normal vector of local lattice boundary cells More...

class	SuperLatticeDiscreteNormal3D
	functor to get pointwise the discrete normal vector of local lattice boundary cells More...

class	SuperLatticeDiscreteNormalType2D
	functor to get pointwise the type of a discrete normal vector More...

class	SuperLatticeDiscreteNormalType3D
	functor to get pointwise the type of a discrete normal vector More...

class	SuperLatticeDissipation3D
	functor to get pointwise dissipation density on local lattices More...

class	SuperLatticeDissipationFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticeEul2LagrDensity3D
	functor to get pointwise external field for Lagrangian particle density, converted to Eulerian More...

class	SuperLatticeExternal2D
	functor to get pointwise density rho on local lattices More...

class	SuperLatticeExternal3D
	functor to get pointwise density rho on local lattices More...

class	SuperLatticeExternalScalarField2D
	functor to get pointwise density rho on local lattices More...

class	SuperLatticeExternalScalarField3D
	functor to get pointwise density rho on local lattices More...

class	SuperLatticeExternalVelocity3D
	functor to get pointwise velocity on local lattice More...

class	SuperLatticeExternalVelocityGradientFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticeF2D
	represents all functors that operate on a SuperLattice in general, e.g. getVelocity(), getForce(), getPressure() More...

class	SuperLatticeF3D
	represents all functors that operate on a SuperLattice in general, e.g. getVelocity(), getForce(), getPressure() More...

class	SuperLatticeFfromAnalyticalF2D
	Functor used to convert analytical functions to lattice functions. More...

class	SuperLatticeFfromAnalyticalF3D
	Functor used to convert analytical functions to lattice functions. More...

class	SuperLatticeField2D

class	SuperLatticeField3D
	functor to get pointwise, lattice-dependent external field More...

class	SuperLatticeFlux3D
	functor to get pointwise flux on local lattice More...

class	SuperLatticeFpop3D
	functor to get pointwise f population on local lattices More...

class	SuperLatticeGeometry2D
	functor to get pointwise the material no. presenting the geometry on local lattice More...

class	SuperLatticeGeometry3D
	functor to get pointwise the material no. presenting the geometry on local lattice More...

class	SuperLatticeHighOrderKnudsen3D

class	SuperLatticeIdentity3D
	identity functor for memory management More...

class	SuperLatticeIndicatorSmoothIndicatorIntersection2D
	functor that returns 1 if SmoothIndicatorF A intersects IndicatorF B; otherwise, 0 More...

class	SuperLatticeIndicatorSmoothIndicatorIntersection3D
	functor that returns 1 if SmoothIndicatorF A intersects IndicatorF B; otherwise, 0 More...

class	SuperLatticeInterpDensity3Degree3D

class	SuperLatticeInterpPhysVelocity2D

class	SuperLatticeInterpPhysVelocity3D

class	SuperLatticeInterpPhysVelocity3Degree3D

class	SuperLatticeInterpVelocity3D

class	SuperLatticeKineticEnergy3D
	functor to get pointwise velocity on local lattice More...

class	SuperLatticeKnudsen2D
	SuperLatticeKnudsen2D measures cell-local ratio between non-equilibrium and equilibrium distribution. More...

class	SuperLatticeKnudsen3D
	SuperLatticeKnudsen3D measures cell-local ratio between non-equilibrium and equilibrium distribution. More...

class	SuperLatticeMomentumExchangeForceLocal
	The following are functors that work in the traditional (output[], input[]) sense, They can therefore be used e.g. More...

class	SuperLatticeMomentumExchangeForceLocalParallel
	functor to get pointwise momentum exchange on local lattice (parallel particle version) More...

class	SuperLatticeParticleForce
	Functor that returns forces acting on a particle surface, returns data in output for every particle in a row(described are return values for the first particle). More...

class	SuperLatticePhysBoundaryDistance3D
	functor that returns the minimum distance (in m) to a set of indicators given by an xmlReader More...

class	SuperLatticePhysBoundaryForce2D
	functor to get pointwise phys force acting on a boundary with a given material on local lattice More...

class	SuperLatticePhysBoundaryForce3D
	functor to get pointwise phys force acting on a boundary with a given material on local lattice More...

class	SuperLatticePhysCorrBoundaryForce2D
	functor to get pointwise phys force acting on a boundary with a given material on local lattice see: Caiazzo, Junk: Boundary Forces in lattice Boltzmann: Analysis of MEA More...

class	SuperLatticePhysCorrBoundaryForce3D
	functor to get pointwise phys force acting on a boundary with a given material on local lattice see: Caiazzo, Junk: Boundary Forces in lattice Boltzmann: Analysis of MEA More...

class	SuperLatticePhysCorrDrag2D
	functor to get pointwise phys force acting on a indicated boundary on local lattice More...

class	SuperLatticePhysCorrDrag3D
	functor to get pointwise phys force acting on a indicated boundary on local lattice More...

class	SuperLatticePhysCroppedPermeability3D
	functor to get pointwise mesh-independent permeability values in (0,inf) in combination with (Extended)PorousBGKdynamics note: result is cropped to 1 More...

class	SuperLatticePhysDarcyForce2D
	computes pointwise -nu/K*u on the lattice, can be used with SuperSum2D as objective More...

class	SuperLatticePhysDarcyForce3D
	computes pointwise -nu/K*u on the lattice, can be used with SuperSum3D as objective More...

class	SuperLatticePhysDissipation2D
	functor to get pointwise dissipation density on local lattices More...

class	SuperLatticePhysDissipation3D
	functor to get pointwise dissipation density on local lattices More...

class	SuperLatticePhysDissipationFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticePhysDrag2D
	functor to get pointwise phys force acting on a indicated boundary on local lattice More...

class	SuperLatticePhysDrag3D
	functor to get pointwise phys force acting on a indicated boundary on local lattice More...

class	SuperLatticePhysEffectiveDissipation3D
	functor to get pointwise turbulent dissipation density on local lattices More...

class	SuperLatticePhysEffectiveDissipationFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticePhysEnstrophyFD3D

class	SuperLatticePhysExternalParticleVelocity2D

class	SuperLatticePhysExternalParticleVelocity3D

class	SuperLatticePhysExternalPorosity2D

class	SuperLatticePhysExternalPorosity3D

class	SuperLatticePhysExternalScalar2D

class	SuperLatticePhysExternalScalar3D

class	SuperLatticePhysExternalVelocity2D

class	SuperLatticePhysExternalVelocity3D

class	SuperLatticePhysExternalZeta2D

class	SuperLatticePhysF2D
	represents all functors that operate on a DESCRIPTOR with output in Phys, e.g. physVelocity(), physForce(), physPressure() More...

class	SuperLatticePhysF3D
	represents all functors that operate on a DESCRIPTOR with output in Phys, e.g. physVelocity(), physForce(), physPressure() More...

struct	SuperLatticePhysField2D

struct	SuperLatticePhysField3D

class	SuperLatticePhysHeatFlux2D
	functor to get pointwise heat flux on local lattice More...

class	SuperLatticePhysHeatFlux3D
	functor to get pointwise heat flux on local lattice More...

class	SuperLatticePhysHeatFluxBoundary3D
	functor to get pointwise phys heat flux on a boundary with a given material on local lattice More...

class	SuperLatticePhysPermeability2D
	functor to get pointwise mesh-independent permeability values in (0,inf) in combination with (Extended)PorousBGKdynamics note: result is cropped to 999999 More...

class	SuperLatticePhysPermeability3D
	functor to get pointwise mesh-independent permeability values in (0,inf) in combination with (Extended)PorousBGKdynamics note: result is cropped to 999999 More...

class	SuperLatticePhysPoreSizeDistribution3D
	functor returns pointwise pore radius (in m) for packings of spheres given by an xmlReader returns NAN for non-pore voxels More...

class	SuperLatticePhysPressure2D
	functor to get pointwise phys pressure from rho on local lattices More...

class	SuperLatticePhysPressure3D
	functor to get pointwise phys pressure from rho on local lattices More...

class	SuperLatticePhysShearRateMag3D
	functor to get pointwise phys shear rate magnitude on local lattice More...

class	SuperLatticePhysStrainRate2D
	functor to get pointwise phys strain rate on local lattice s_ij = 1/2*(du_idr_j + du_jdr_i) More...

class	SuperLatticePhysStrainRate3D
	functor to get pointwise phys strain rate on local lattice s_ij = 1/2*(du_idr_j + du_jdr_i) More...

class	SuperLatticePhysStrainRateFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticePhysStressFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticePhysTauFromBoundaryDistance3D
	functor returns pointwise pore radius (in m) for packings of spheres given by an xmlReader returns NAN for non-pore voxels More...

class	SuperLatticePhysTemperature2D
	functor to get pointwise phys temperature from rho on local lattices More...

class	SuperLatticePhysTemperature3D
	functor to get pointwise phys temperature from rho on local lattices More...

class	SuperLatticePhysVelocity2D
	functor to get pointwise phys velocity on local lattice More...

class	SuperLatticePhysVelocity3D
	functor to get pointwise phys velocity on local lattice More...

class	SuperLatticePhysVelocityGradientFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticePhysViscosity2D
	functor to get pointwise phys viscosity on local lattices More...

class	SuperLatticePhysViscosity3D
	functor to get pointwise phys viscosity on local lattices More...

class	SuperLatticePhysVorticityFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticePhysWallShearStress2D
	functor to get pointwise phys wall shear stress with a given material on local lattice More...

class	SuperLatticePhysWallShearStress3D
	functor to get pointwise phys wall shear stress with a given material on local lattice More...

struct	SuperLatticePlatform

class	SuperLatticePorosity2D
	functor to get pointwise, lattice-dependent porosity values in [0,1] in combination with (Extended)PorousBGKdynamics: 0->solid, 1->fluid More...

class	SuperLatticePorosity3D
	functor to get pointwise, lattice-dependent porosity values in [0,1] in combination with (Extended)PorousBGKdynamics: 0->solid, 1->fluid More...

class	SuperLatticePSMPhysForce2D
	functor to get pointwise phys force for the PSM dynamics More...

class	SuperLatticePSMPhysForce2DMod
	functor to get pointwise phys force for the PSM dynamics More...

class	SuperLatticePSMPhysForce3D
	functor to get pointwise phys force for the PSM dynamics More...

class	SuperLatticeRank2D
	functor to get pointwise the rank no. + 1 on local lattice More...

class	SuperLatticeRank3D
	functor to get pointwise the rank no. + 1 on local lattice More...

class	SuperLatticeRefinementMetricKnudsen2D
	SuperLatticeRefinementMetricKnudsen2D suggests a per-block grid refinement factor. More...

class	SuperLatticeRefinementMetricKnudsen3D
	SuperLatticeRefinementMetricKnudsen3D suggests a per-block grid refinement factor. More...

class	SuperLatticeSmoothDiracDelta3D

class	SuperLatticeStrainRate3D
	functor to get pointwise strain rate on local lattice s_ij = 1/2*(du_idr_j + du_jdr_i) More...

class	SuperLatticeStrainRateFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticeThermalComfort3D
	functor to get pointwise PMV and PPD on local lattices to evaluate thermal comfort More...

class	SuperLatticeThermalPhysF2D
	represents all thermal functors that operate on a DESCRIPTOR with output in Phys, e.g. physTemperature(), physHeatFlux() More...

class	SuperLatticeThermalPhysF3D
	represents all thermal functors that operate on a DESCRIPTOR with output in Phys, e.g. physTemperature(), physHeatFlux() More...

class	SuperLatticeTimeAveraged2DL2Norm

class	SuperLatticeTimeAveraged3DL2Norm

class	SuperLatticeTimeAveragedCrossCorrelationF2D

class	SuperLatticeTimeAveragedCrossCorrelationF3D

class	SuperLatticeTimeAveragedF2D

class	SuperLatticeTimeAveragedF3D

class	SuperLatticeTimeAveragedMagnitudesF3D

class	SuperLatticeTimeStepScale3D
	functor to scale particle distributions to a time step More...

class	SuperLatticeVelocity2D
	functor to get pointwise velocity on local lattice More...

class	SuperLatticeVelocity3D
	functor to get pointwise velocity on local lattice More...

class	SuperLatticeVelocityDenominator3D

class	SuperLatticeVelocityGradientFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticeVolumeFractionApproximation2D
	functor to get pointwise an approx. for the volume fraction More...

class	SuperLatticeVolumeFractionApproximation3D
	functor to get pointwise an approx. for the volume fraction More...

class	SuperLatticeVolumeFractionPolygonApproximation2D
	functor to get pointwise an approx. for the volume fraction More...

class	SuperLatticeVorticityFD3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperLatticeYplus3D
	functor to get pointwise yPlus from rho, shear stress and local density on local lattices More...

class	SuperLocalAverage2D
	Averages given functor inside the local sphere. More...

class	SuperLocalAverage3D
	Averages given functor inside the local sphere. More...

class	SuperLpNorm2D
	Functor that returns the Lp norm over omega of the the euklid norm of the input functor. More...

class	SuperLpNorm3D
	Functor that returns the Lp norm over omega of the the euklid norm of the input functor. More...

class	SuperMax2D
	SuperMax2D returns the max in each component of f on a indicated subset. More...

class	SuperMax3D
	SuperMax3D returns the max in each component of f on a indicated subset. More...

class	SuperMin2D
	SuperMin2D returns the min in each component of f on a indicated subset. More...

class	SuperMin3D
	SuperMin3D returns the min in each component of f on a indicated subset. More...

class	SuperParticleGroupedFieldF

class	SuperParticleSystem3D
	The class superParticleSystem is the basis for particulate flows within OpenLB. More...

class	SuperParticleSysVtuWriter

class	SuperParticleSysVtuWriterMag

class	SuperPhysFiniteDifference3D
	functor to get pointwise explicit filter on local lattice, if globIC is not on the local processor, the returned vector is empty More...

class	SuperPhysLaplacian3D
	functor to get pointwise finite difference Laplacian operator More...

class	SuperPlaneIntegralF2D
	Surface integral of a subset of a interpolated hyperplane. More...

class	SuperPlaneIntegralF3D
	Surface integral of a subset of a interpolated hyperplane. More...

class	SuperPlaneIntegralFluxF2D
	Template class for building flux integrals based on SuperLatticePhysF2D functors. More...

class	SuperPlaneIntegralFluxF3D
	Template class for building flux integrals based on SuperLatticePhysF3D functors. More...

class	SuperPlaneIntegralFluxMass2D
	Mass flux line integral. More...

class	SuperPlaneIntegralFluxMass3D
	Mass flux plane integral. More...

class	SuperPlaneIntegralFluxPressure2D
	Pressure flux line integral. More...

class	SuperPlaneIntegralFluxPressure3D
	Pressure flux plane integral. More...

class	SuperPlaneIntegralFluxVelocity2D
	Velocity flux line integral. More...

class	SuperPlaneIntegralFluxVelocity3D
	Velocity flux plane integral. More...

class	SuperRelativeErrorLpNorm2D
	Relative error norm functor. More...

class	SuperRelativeErrorLpNorm3D
	Relative error norm functor. More...

class	SuperRoundingF2D
	Super functor for rounding the value in a certain mode: None := No rounding NearestInteger := rounding to nearest integer Floor:= rounding to nearest lower integer Ceil := rounding to nearest higher integer. More...

class	SuperRoundingF3D
	Super functor for rounding the value in a certain mode: None := No rounding NearestInteger := rounding to nearest integer Floor:= rounding to nearest lower integer Ceil := rounding to nearest higher integer. More...

class	SuperStdDeviationF3D
	SuperStdDeviaitonF3D returns the standard deviation in each component of f on a indicated subset calcutalted with Steiner translation theorem. More...

class	SuperStructure

class	SuperStructure2D

class	SuperStructure3D

class	SuperSum2D
	SuperSum2D sums all components of f over a indicated subset. More...

class	SuperSum3D
	SuperSum3D sums all components of f over a indicated subset. More...

class	SuperTypecastF3D
	perform explicit typecast from output type W2 to W More...

class	SuperVarianceF3D
	SuperVarianceF3D returns the Variance in each component of f on a indicated subset calcutalted with Steiner translation theorem. More...

class	SuperVTIreader3D

class	SuperVTMwriter2D
	SuperVTMwriter2D writes any SuperF2D to vtk-based output files. More...

class	SuperVTMwriter3D
	SuperVTMwriter3D writes any SuperF3D to vtk-based output files. More...

class	ThermalUnitConverter
	Conversion between physical and lattice units, as well as discretization specialized for thermal applications with boussinesq approximation. More...

class	ThreadPool
	Pool of threads for CPU-based background processing. More...

struct	TotalEnthalpyAdvectionDiffusionBGKdynamics

struct	TotalEnthalpyAdvectionDiffusionTRTdynamics

struct	TotalEnthalpyPhaseChangeCoupling
	TotalEnthalpyPhaseChange between a Navier-Stokes and an Advection-Diffusion lattice. More...

class	TotalEnthalpyPhaseChangeCouplingGenerator2D

class	TotalEnthalpyPhaseChangeCouplingGenerator3D

class	TotalEnthalpyPhaseChangeCouplingPostProcessor2D

class	TotalEnthalpyPhaseChangeCouplingPostProcessor3D

class	TransferExternalForce3D

class	TwoWayHelperFunctional
	Abstact class for all the local forward-coupling models, viz., momentum coupling from fluid to particle. More...

struct	U_PROFILE

class	UnitConverter
	Conversion between physical and lattice units, as well as discretization. More...

struct	UnitConverterBase

class	UnitConverterFromRelaxationTimeAndLatticeVelocity

class	UnitConverterFromResolutionAndLatticeVelocity

class	UnitConverterFromResolutionAndRelaxationTime

struct	VANSADECoupling
	VANS-ADE coupling. More...

class	vanWachemForwardCouplingModel
	Class for a forward-coupling model as in Evrard, Denner and van Wachem (2019), but with an extra-normalization of the smoothing function. More...

class	vanWachemSmoothingFunctional
	Smoothing functional as in Evrard, Denner and van Wachem (2019). More...

class	Vector
	Plain old scalar vector. More...

struct	VELOCITY_OLD

class	VelocityBounceBackPostProcessor2D

class	VelocityBounceBackPostProcessor3D

class	VelocityBounceBackPostProcessorGenerator2D

class	VelocityBounceBackPostProcessorGenerator3D

class	VelocityBouzidiLinearPostProcessor2D

class	VelocityBouzidiLinearPostProcessor3D

class	VelocityBouzidiLinearPostProcessorGenerator2D

class	VelocityBouzidiLinearPostProcessorGenerator3D

struct	Vertex

class	VolumeAveragedNavierStokesAdvectionDiffusionParticleCouplingGenerator3D

class	VolumeAveragedNavierStokesAdvectionDiffusionParticleCouplingPostProcessor3D

class	VolumeAveragingSmoothingFunctional
	Abstact class for all the volume-averaging smoothing functionals. More...

struct	VortexMethodPostProcessor

struct	VortexMethodPreProcessor

class	VortexMethodTurbulentVelocityBoundary

class	VTIwriter3D

class	VTKwriter

class	WallFunctionBoundaryProcessor3D

class	WallFunctionBoundaryProcessorGenerator3D

struct	wallFunctionParam

class	WeightForce3D

class	WeisbrodKrause

class	WireBoundaryForMagP3D

struct	WriteCellFunctional

class	XMLreader

class	XMLreaderOutput

class	YuPostProcessor

class	ZeroDistributionBoundaryProcessor3D
	This class resets some values of the distribution on the boundary that can have arbitrary values to be zero and thus ensures a correct computation of the density that is about to leave the domain. More...

class	ZeroDistributionBoundaryProcessorGenerator3D

struct	ZeroDistributionDynamics
	Models a density sink by enforcing a zero distribution on the cell. More...

struct	zeroGradientLatticePostProcessor3D

class	ZeroVelocityBounceBackPostProcessor2D

class	ZeroVelocityBounceBackPostProcessor3D

class	ZeroVelocityBounceBackPostProcessorGenerator2D

class	ZeroVelocityBounceBackPostProcessorGenerator3D

class	ZeroVelocityBouzidiLinearPostProcessor2D

class	ZeroVelocityBouzidiLinearPostProcessor3D
	This class computes the Linear Bouzidi BC. More...

class	ZeroVelocityBouzidiLinearPostProcessorGenerator2D

class	ZeroVelocityBouzidiLinearPostProcessorGenerator3D
	Linear Bouzidi BC Generator. More...

class	ZouHeDynamics
	Implementation of Zou-He boundary condition following the paper from Zou and He. More...

Typedefs
template<typename T , typename DESCRIPTOR , typename DYNAMICS , typename MOMENTA , int... ARGS>
using	AdvectionLocalDiffusionBoundariesDynamics

template<typename T , typename DESCRIPTOR , typename DYNAMICS , typename MOMENTA , int... ARGS>
using	AdvectionLocalDiffusionEdgesDynamics

template<typename T , typename DESCRIPTOR , typename DYNAMICS , typename MOMENTA , int... NORMAL>
using	AdvectionLocalDiffusionCornerDynamics2D

template<typename T , typename DESCRIPTOR , typename DYNAMICS , typename MOMENTA , int... NORMAL>
using	AdvectionLocalDiffusionCornerDynamics3D

template<typename T >
using	BaseType = typename util::BaseTypeHelper<T>::type

using	CellID = std::uint32_t
	Type for sequential block-local cell indices.

using	CellDistance = std::int64_t
	Type for in-memory distance of block-local cell indices.

template<unsigned D>
using	LatticeR = Vector<std::int32_t,D>
	Type for spatial block-local lattice coordinates.

template<typename T , unsigned D>
using	PhysR = Vector<T,D>
	Type for spatial (physical) coordinates.

template<typename DESCRIPTOR >
using	BlockStructure = BlockStructureD<DESCRIPTOR::d>

template<typename T , typename DESCRIPTOR , typename FIELD >
using	FieldD
	Vector storing a single field instance.

template<typename T , typename DESCRIPTOR , Platform PLATFORM = Platform::CPU_SISD>
using	MultiFieldArrayForDescriptorD = typename MultiFieldArrayForDescriptorHelper<T,DESCRIPTOR,PLATFORM>::type
	MultiFieldArrayD containing each field in DESCRIPTOR::fields_t.

template<typename T , typename DESCRIPTOR , typename OPERATOR >
using	ParametersOfOperatorD
	Deduce ParametersD of OPERATOR w.r.t. T and DESCRIPTOR.

template<typename DYNAMICS >
using	ParametersOfDynamicsD
	Deduce ParametersD of DYNAMICS w.r.t. its value type and descriptor.

template<typename T >
using	Column = cpu::sisd::Column<T>
	Use CPU SISD as default Column.

template<typename T >
using	CyclicColumn = cpu::sisd::CyclicColumn<T>
	Use CPU SISD as default CyclicColumn.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::AdvectionDiffusionBulkTuple>
using	AdvectionDiffusionRLBdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::AdvectionDiffusionBulkTuple>
using	AdvectionDiffusionBGKdynamics
	This approach contains a slight error in the diffusion term.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::AdvectionDiffusionBulkTuple>
using	AdvectionDiffusionTRTdynamics
	This approach contains a slight error in the diffusion term.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::AdvectionDiffusionBulkTuple>
using	AdvectionDiffusionMRTdynamics
	This approach is based on the multi-distribution LBM model.

template<typename T , typename DESCRIPTOR >
using	NoCollideDynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	CUMdynamics
	Implementation partially based on: Geier, Martin, et al.

template<typename T , typename DESCRIPTOR >
using	NoDynamics
	Dynamics for "dead cells" doing nothing.

template<typename T , typename DESCRIPTOR >
using	NoDynamicsWithZero
	Dynamics for "dead cells" doing nothing. Variant with density=0.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	BGKdynamics
	Common BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ConstRhoBGKdynamics
	Pressure-corrected BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ForcedBGKdynamics
	BGK collision step with external force (Guo)

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::ExternalVelocityTuple>
using	MultiComponentForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ForcedKupershtokhBGKdynamics
	BGK collision step with external force (Kupershtokh)

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ForcedShanChenBGKdynamics
	BGK collision step with external force (Shan and Chen)

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	IncBGKdynamics = dynamics::Tuple<T,DESCRIPTOR,MOMENTA,equilibria::Incompressible,collision::BGK>
	Incompressible BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ForcedIncBGKdynamics
	Incompressible BGK collision step with external force.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ExternalTauForcedIncBGKdynamics
	Incompressible BGK collision step with relaxation frequency 1 / TAU_EFF and external force.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	RLBdynamics
	Regularized BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	TRTdynamics
	TRT collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ForcedTRTdynamics
	TRT collision step with external force.

template<typename T , typename DESCRIPTOR >
using	BounceBack
	Bounce Back boundary dynamics.

template<typename T , typename DESCRIPTOR >
using	BounceBackBulkDensity
	Bounce Back boundary dynamics with bulk density.

template<typename T , typename DESCRIPTOR >
using	BounceBackVelocity
	Bounce Back boundary dynamics with Nguyen-Ladd velocity correction.

template<typename T , typename DESCRIPTOR >
using	PartialBounceBack
	Corresponds to macro Robin boundary, micro Fresnel surface Motivated by Hiorth et al.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::PoissonTuple>
using	PoissonDynamics
	Poisson dynamics.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::P1Tuple>
using	P1Dynamics
	P1 dynamics.

template<typename T , typename DESCRIPTOR , typename MOMENTA >
using	ChopardDynamics

template<typename T , typename DESCRIPTOR >
using	EquilibriumBoundaryFirstOrder
	First order equilibrium boundary dynamics.

template<typename T , typename DESCRIPTOR >
using	EquilibriumBoundarySecondOrder
	Second order equilibrium boundary dynamics.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::FreeEnergyBulkTuple>
using	FreeEnergyBGKdynamics

template<typename T , typename DESCRIPTOR >
using	FreeEnergyWallDynamics

template<typename T , typename DESCRIPTOR , int direction, int orientation>
using	FreeEnergyInletOutletDynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	GuoZhaoBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmagorinskyGuoZhaoBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	KBCdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	MRTdynamics
	Original implementation based on: D'Humieres et al., "Multiple-relaxation-time lattice Boltzmann models in three dimensions", Phil: Trans.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ForcedMRTdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PorousBGKdynamics
	Porous BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PorousParticleBGKdynamics
	Porous particle BGK collision for moving particles.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	StaticPorousParticleBGKdynamics
	Porous particle BGK collision for static particles.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmagorinskyPorousParticleBGKdynamics
	BGK collision step for a porosity model.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SubgridParticleBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	DBBParticleBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	KrauseHBGKdynamics
	HBGK collision step for a porosity model enabling drag computation for many particles including the Krause turbulence modell.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmallParticleBGKdymaics
	BGK collision step for a small particles enabling two way coupling.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PSMBGKdynamics
	Partially Saturated Method (PSM), see Krüger, Timm, et al.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PorousForcedBGKdynamics
	BGK collision step for a porosity model.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PorousParticleGuoForcedBGKdynamics
	Guo forced BGK collision for moving porous media (HLBM approach)

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	StaticPorousParticleGuoForcedBGKdynamics
	Guo forced BGK static collision for moving porous media (HLBM approach)

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PorousParticleShanChenForcedBGKdynamics
	ShanChen forced BGK collision for moving porous media (HLBM approach)

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	StaticPorousParticleShanChenForcedBGKdynamics
	ShanChen forced BGK static collision for moving porous media (HLBM approach)

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PorousParticleKupershtokhForcedBGKdynamics
	Kuperstokh forced BGK collision for moving porous media (HLBM approach)

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	StaticPorousParticleKupershtokhForcedBGKdynamics
	Kuperstokh forced BGK static collision for moving porous media (HLBM approach)

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PorousParticlePowerLawBGKdynamics
	BGK collision using Power Law collision frequency.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PorousParticlePowerLawForcedBGKdynamics
	BGK collision using Power Law collision frequency with Guo forcing.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PorousParticlePowerLawHerschelBulkleyBGKdynamics
	BGK collision using Power Law (Herschel Bulkley) collision frequency.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PorousParticlePowerLawHerschelBulkleyForcedBGKdynamics
	BGK collision using Power Law (Herschel Bulkley) collision frequency with Guo forcing.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PowerLawBGKdynamics
	BGK collision using Power Law collision frequency.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PowerLawForcedBGKdynamics
	BGK collision using Power Law collision frequency with Guo forcing.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PowerLawHerschelBulkleyBGKdynamics
	BGK collision using Power Law (Herschel Bulkley) collision frequency.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	PowerLawHerschelBulkleyForcedBGKdynamics
	BGK collision using Power Law (Herschel Bulkley) collision frequency with Guo forcing.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmagorinskyPowerLawBGKdynamics
	Smagorinsky BGK collision using Power Law collision frequency.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmagorinskyPowerLawForcedBGKdynamics
	Smagorinsky BGK collision using Power Law collision frequency and Guo forcing.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmagorinskyPowerLawPorousParticleBGKdynamics
	Smagorinsky BGK collision using Power Law collision frequency for porous particles.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmagorinskyBGKdynamics
	Smagorinsky BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmagorinskyForcedBGKdynamics
	Smagorinsky BGK collision step with Guo forcing.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ExternalTauEffLESBGKdynamics
	LES BGK collision using non-local TAU_EFF per-cell field.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ExternalTauEffLESForcedBGKdynamics
	LES BGK collision with Guo forcing using non-local TAU_EFF per-cell field.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ShearSmagorinskyBGKdynamics
	Shear Smarorinsky BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ShearSmagorinskyForcedBGKdynamics
	Shear Smarorinsky BGK collision step with Guo forcing.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ExternalTauEffLESBGKadvectionDiffusionDynamics
	LES BGK collision for advection diffusion using non-local TAU_EFF per-cell field.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ConStrainSmagorinskyBGKdynamics
	Consistent Strain Smagorinsky BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ConSmagorinskyBGKdynamics
	Consistent Smagorinsky BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	ExternalSmagorinskyBGKdynamics
	Smagorinsky BGK collision step with per-cell Smagorinsky constant.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	WALEBGKdynamics
	WALE LES BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	KrauseBGKdynamics
	Krause BGK collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmagorinskyLinearVelocityForcedBGKdynamics
	ForcedBGK collision step computing OMEGA locally using Smagorinsky LES model.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmagorinskyMRTdynamics
	Smagorinsky MRT collision step.

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	SmagorinskyForcedMRTdynamics
	Smagorinsky MRT collision step with Ladd-Verberg forcing.

template<typename T , typename S >
using	AnalyticalF1D = AnalyticalF<1,T,S>

template<typename T , typename S >
using	AnalyticalF2D = AnalyticalF<2,T,S>

template<typename T , typename S >
using	AnalyticalF3D = AnalyticalF<3,T,S>

template<typename T , typename S >
using	AnalyticalIdentity1D = AnalyticalIdentity<1,T,S>

template<typename T , typename S >
using	AnalyticalIdentity2D = AnalyticalIdentity<2,T,S>

template<typename T , typename S >
using	AnalyticalIdentity3D = AnalyticalIdentity<3,T,S>

template<typename T , typename S >
using	AnalyticalConst1D = AnalyticalConst<1,T,S>

template<typename T , typename S >
using	AnalyticalConst2D = AnalyticalConst<2,T,S>

template<typename T , typename S >
using	AnalyticalConst3D = AnalyticalConst<3,T,S>

template<typename T , typename S >
using	AnalyticalComposed2D = AnalyticalComposed<2,T,S>

template<typename T , typename S >
using	AnalyticalComposed3D = AnalyticalComposed<3,T,S>

template<typename T , typename S >
using	AnalyticalRandom1D = AnalyticalRandomOld<1,T,S>

template<typename T , typename S >
using	AnalyticalRandom2D = AnalyticalRandomOld<2,T,S>

template<typename T , typename S >
using	AnalyticalRandom3D = AnalyticalRandomOld<3,T,S>

template<unsigned D, typename T , typename S >
using	AnalyticCalcPlus = AnalyticCalcF<D,T,S,util::plus>
	addition functor

template<typename T , typename S >
using	AnalyticCalcPlus1D = AnalyticCalcPlus<1,T,S>

template<typename T , typename S >
using	AnalyticCalcPlus2D = AnalyticCalcPlus<2,T,S>

template<typename T , typename S >
using	AnalyticCalcPlus3D = AnalyticCalcPlus<3,T,S>

template<unsigned D, typename T , typename S >
using	AnalyticCalcMinus = AnalyticCalcF<D,T,S,util::minus>
	subtraction functor

template<typename T , typename S >
using	AnalyticCalcMinus1D = AnalyticCalcMinus<1,T,S>

template<typename T , typename S >
using	AnalyticCalcMinus2D = AnalyticCalcMinus<2,T,S>

template<typename T , typename S >
using	AnalyticCalcMinus3D = AnalyticCalcMinus<3,T,S>

template<unsigned D, typename T , typename S >
using	AnalyticCalcMultiplication = AnalyticCalcF<D,T,S,util::multiplies>
	multiplication functor

template<typename T , typename S >
using	AnalyticCalcMultiplication1D = AnalyticCalcMultiplication<1,T,S>

template<typename T , typename S >
using	AnalyticCalcMultiplication2D = AnalyticCalcMultiplication<2,T,S>

template<typename T , typename S >
using	AnalyticCalcMultiplication3D = AnalyticCalcMultiplication<3,T,S>

template<unsigned D, typename T , typename S >
using	AnalyticCalcDivision = AnalyticCalcF<D,T,S,util::divides>
	division functor

template<typename T , typename S >
using	AnalyticCalcDivision1D = AnalyticCalcDivision<1,T,S>

template<typename T , typename S >
using	AnalyticCalcDivision2D = AnalyticCalcDivision<2,T,S>

template<typename T , typename S >
using	AnalyticCalcDivision3D = AnalyticCalcDivision<3,T,S>

template<typename T >
using	BlockCalcPlus2D = BlockCalcF2D<T,util::plus>
	Block level addition functor (T==bool: Union)

template<typename T >
using	BlockCalcMinus2D = BlockCalcF2D<T,util::minus>
	Block level subtraction functor (T==bool: Without)

template<typename T >
using	BlockCalcMultiplication2D = BlockCalcF2D<T,util::multiplies>
	Block level multiplication functor (T==bool: Intersection)

template<typename T >
using	BlockCalcDivision2D = BlockCalcF2D<T,util::divides>
	Block level division functor.

template<typename T >
using	BlockCalcPlus3D = BlockCalcF3D<T,util::plus>
	Block level addition functor (T==bool: Union)

template<typename T >
using	BlockCalcMinus3D = BlockCalcF3D<T,util::minus>
	Block level subtraction functor (T==bool: Without)

template<typename T >
using	BlockCalcMultiplication3D = BlockCalcF3D<T,util::multiplies>
	Block level multiplication functor (T==bool: Intersection)

template<typename T >
using	BlockCalcDivision3D = BlockCalcF3D<T,util::divides>
	Block level division functor.

template<typename T , typename W = T>
using	SuperL1Norm2D = SuperLpNorm2D<T,W,1>
	Functor that returns the L1 norm over omega of the the euklid norm of the input functor.

template<typename T , typename W = T>
using	SuperL2Norm2D = SuperLpNorm2D<T,W,2>
	Functor that returns the L2 norm over omega of the the euklid norm of the input functor.

template<typename T , typename W = T>
using	SuperLinfNorm2D = SuperLpNorm2D<T,W,0>
	Functor that returns the Linf norm over omega of the the euklid norm of the input functor.

template<typename T , typename W = T>
using	SuperL1Norm3D = SuperLpNorm3D<T,W,1>
	Functor that returns the L1 norm over omega of the the euklid norm of the input functor.

template<typename T , typename W = T>
using	SuperL2Norm3D = SuperLpNorm3D<T,W,2>
	Functor that returns the L2 norm over omega of the the euklid norm of the input functor.

template<typename T , typename W = T>
using	SuperLinfNorm3D = SuperLpNorm3D<T,W,0>
	Functor that returns the Linf norm over omega of the the euklid norm of the input functor.

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >
using	SuperLatticeMomentumExchangeForce

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >
using	SuperLatticeStokesDragForce

template<typename T , typename W >
using	SuperCalcPlus2D = SuperCalcF2D<T,W,util::plus>
	Addition functor (W==bool: Union)

template<typename T , typename W >
using	SuperCalcMinus2D = SuperCalcF2D<T,W,util::minus>
	Subtraction functor (W==bool: Without)

template<typename T , typename W >
using	SuperCalcMultiplication2D = SuperCalcF2D<T,W,util::multiplies>
	Multiplication functor (W==bool: Intersection)

template<typename T , typename W >
using	SuperCalcDivision2D = SuperCalcF2D<T,W,util::divides>
	Division functor.

template<typename T , typename W = T>
using	SuperCalcPower2D = SuperCalcF2D<T,W,util::power>
	Power functor.

template<typename T , typename W = T>
using	SuperCalcPlus3D = SuperCalcF3D<T,W,util::plus>
	Addition functor (W==bool: Union)

template<typename T , typename W = T>
using	SuperCalcMinus3D = SuperCalcF3D<T,W,util::minus>
	Subtraction functor (W==bool: Without)

template<typename T , typename W = T>
using	SuperCalcMultiplication3D = SuperCalcF3D<T,W,util::multiplies>
	Multiplication functor (W==bool: Intersection)

template<typename T , typename W = T>
using	SuperCalcDivision3D = SuperCalcF3D<T,W,util::divides>
	Division functor.

template<typename T , typename W = T>
using	SuperCalcPower3D = SuperCalcF3D<T,W,util::power>
	Power functor.

template<typename T , typename W = T>
using	SuperRelativeErrorL1Norm2D = SuperRelativeErrorLpNorm2D<T,W,1>

template<typename T , typename W = T>
using	SuperRelativeErrorL2Norm2D = SuperRelativeErrorLpNorm2D<T,W,2>

template<typename T , typename W = T>
using	SuperRelativeErrorLinfNorm2D = SuperRelativeErrorLpNorm2D<T,W,0>

template<typename T , typename W = T>
using	SuperAbsoluteErrorL1Norm2D = SuperAbsoluteErrorLpNorm2D<T,W,1>

template<typename T , typename W = T>
using	SuperAbsoluteErrorL2Norm2D = SuperAbsoluteErrorLpNorm2D<T,W,2>

template<typename T , typename W = T>
using	SuperAbsoluteErrorLinfNorm2D = SuperAbsoluteErrorLpNorm2D<T,W,0>

template<typename T , typename W = T>
using	SuperRelativeErrorL1Norm3D = SuperRelativeErrorLpNorm3D<T,W,1>

template<typename T , typename W = T>
using	SuperRelativeErrorL2Norm3D = SuperRelativeErrorLpNorm3D<T,W,2>

template<typename T , typename W = T>
using	SuperRelativeErrorLinfNorm3D = SuperRelativeErrorLpNorm3D<T,W,0>

template<typename T , typename W = T>
using	SuperAbsoluteErrorL1Norm3D = SuperAbsoluteErrorLpNorm3D<T,W,1>

template<typename T , typename W = T>
using	SuperAbsoluteErrorL2Norm3D = SuperAbsoluteErrorLpNorm3D<T,W,2>

template<typename T , typename W = T>
using	SuperAbsoluteErrorLinfNorm3D = SuperAbsoluteErrorLpNorm3D<T,W,0>

template<typename T >
using	BlockGeometry2D = BlockGeometry<T,2>

template<typename T >
using	BlockGeometry3D = BlockGeometry<T,3>

template<typename T , typename DESCRIPTOR , bool parallel = true>
using	VTUwriter

template<typename T , typename DESCRIPTOR >
using	VTIwriter

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using	DualPorousBGKDynamics

template<typename T , unsigned D>
using	Cuboid

template<typename T , unsigned D>
using	CuboidGeometry

template<typename T , unsigned D>
using	Communicator

template<typename T , typename DESCRIPTOR >
using	PostProcessor

template<typename T , typename DESCRIPTOR >
using	PostProcessorGenerator

template<typename T , unsigned DIM>
using	SuperGeometryStatistics

template<typename T , unsigned DIM, typename OUT_T = float, typename W = T>
using	SuperVTMwriter

template<typename T , typename DESCRIPTOR >
using	SuperLatticeGeometry

template<typename T , typename DESCRIPTOR >
using	SuperLatticeCuboid

template<typename T , typename DESCRIPTOR >
using	SuperLatticeRank

template<typename T , typename DESCRIPTOR >
using	SuperLatticeF

template<typename T , typename DESCRIPTOR >
using	BlockLatticeF

template<typename T , typename DESCRIPTOR >
using	LatticeCouplingGenerator

template<typename T , unsigned D>
using	BlockGeometryStatistics

template<typename T , unsigned D>
using	BlockF

template<unsigned D, typename T , typename U = T>
using	SuperF

template<typename T , unsigned D>
using	SuperIndicatorF

template<typename T , unsigned D>
using	BlockIndicatorF

template<typename T , unsigned D>
using	BlockIndicatorMaterial

template<typename T , unsigned D>
using	BlockIndicatorBoundaryNeighbor

template<typename T , unsigned D>
using	BlockIndicatorFfromIndicatorF

template<typename T , unsigned D>
using	IndicatorF

template<typename T , unsigned D>
using	IndicatorCuboid

template<typename T , typename S , unsigned D, bool PARTICLE = false>
using	SmoothIndicatorF

template<typename T , unsigned D>
using	SuperIndicatorFfromIndicatorF

template<typename T , unsigned D>
using	SuperIndicatorMaterial

template<typename T , unsigned D>
using	SuperIndicatorBoundaryNeighbor

template<typename T , typename DESCRIPTOR , typename FIELD >
using	SuperField

template<typename T , typename DESCRIPTOR >
using	SuperLatticePhysF

template<typename T , typename DESCRIPTOR >
using	BlockLatticePhysF

template<typename T , typename DESCRIPTOR >
using	SuperLatticeInterpPhysVelocity

template<typename T , typename DESCRIPTOR >
using	BlockLatticeInterpPhysVelocity

Enumerations
enum struct	OperatorScope { PerCell , PerBlock , PerCellWithParameters }
	Block-wide operator application scopes. More...

enum struct	CollisionDispatchStrategy { Dominant , Individual }
	Collision dispatch strategy. More...

enum struct	Platform : std::uint8_t { CPU_SISD , CPU_SIMD , GPU_CUDA }
	OpenLB execution targets. More...

enum struct	ProcessingContext { Evaluation , Simulation }
	OpenLB processing contexts. More...

enum	vtkType { VTI , VTU , VTP }

enum class	BlockDataReductionMode { Analytical , Discrete }
	Mode of reducing block data from given, possibly higher dimensional data. More...

enum class	BlockDataSyncMode { ReduceAndBcast , ReduceOnly , None }
	Mode of synchronizing functor block data between processes. More...

enum class	RoundingMode { None , NearestInteger , Floor , Ceil }
	Mode of how to decide Quality of Grid. More...

Functions
template<typename T , typename DESCRIPTOR >
void	setAdvectionDiffusionConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the AdvectionDiffusionConvectionBoundary function on the superLattice domain This is an Advection Diffusion Boundary therefore mostly--> MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>

template<typename T , typename DESCRIPTOR >
void	setAdvectionDiffusionConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the AdvectionDiffusionConvectionBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setAdvectionDiffusionConvectionBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, bool includeOuterCells=false)
	Add AdvectionDiffusionConvection boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setAdvectionDiffusionTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the AdvectionDiffusionTemperatureBoundary on the superLattice domain This is an advection diffusion boundary -->MixinDynamics = AdvectionDiffusionRLBdynamics Moment-based boundary condition (see ref.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setAdvectionDiffusionTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattic, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the AdvectionDiffusionTemperatureBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setAdvectionDiffusionTemperatureBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF2D< T > &indicator)
	Set AdvectionDiffusionTemperatureBoundary for indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setAdvectionDiffusionTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setAdvectionDiffusionTemperatureBoundary function on the superLattice domain This is an AdvectionDiffusionBoundary therefore mostly --> MixinDynamics = AdvectionDiffusionRLBdynamics.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setAdvectionDiffusionTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setAdvectionDiffusionTemperatureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setAdvectionDiffusionTemperatureBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator)
	Set AdvectionDiffusionTemperatureBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setBounceBackBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&indicator)
	Set bounce back boundary on indicated cells of lattice.

template<typename T , typename DESCRIPTOR >
void	setBounceBackBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int material)
	Set bounce back boundary on material cells of lattice.

template<typename T , typename DESCRIPTOR >
void	setBounceBackVelocityBoundary (SuperGeometry< T, 3 > &superGeometry, int material, T omega, SuperLattice< T, DESCRIPTOR > &sLattice)
	Initialising the setLocalVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setBounceBackVelocityBoundary (FunctorPtr< SuperIndicatorF3D< T > > &&indicator, T omega, SuperLattice< T, DESCRIPTOR > &sLattice)

template<typename T , typename DESCRIPTOR >
void	setBounceBackVelocityBoundary (BlockIndicatorF3D< T > &indicator, T omega, bool includeOuterCells, BlockLattice< T, DESCRIPTOR > &_block)
	Set BounceBackVelocityBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setBoundary (BlockLattice< T, DESCRIPTOR > &block, int iX, int iY, Dynamics< T, DESCRIPTOR > dynamics, PostProcessorGenerator2D< T, DESCRIPTOR > postProcessor)

template<typename T , typename DESCRIPTOR >
void	setBoundary (BlockLattice< T, DESCRIPTOR > &block, int iX, int iY, Dynamics< T, DESCRIPTOR > *dynamics)

template<typename T , typename DESCRIPTOR >
void	addPoints2CommBC (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, int _overlap)
	Adds needed Cells to the Communicator _commBC in SuperLattice.

template<typename T , typename DESCRIPTOR >
void	setBoundary (BlockLattice< T, DESCRIPTOR > &_block, int iX, int iY, int iZ, Dynamics< T, DESCRIPTOR > dynamics, PostProcessorGenerator3D< T, DESCRIPTOR > postProcessor)
	sets boundary on indicated cells. This is a function, which can be used on many boundaries.

template<typename T , typename DESCRIPTOR >
void	setBoundary (BlockLattice< T, DESCRIPTOR > &_block, int iX, int iY, int iZ, Dynamics< T, DESCRIPTOR > *dynamics)

template<typename T , typename DESCRIPTOR >
void	addPoints2CommBC (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator, int _overlap)
	Adds needed Cells to the Communicator _commBC in SuperLattice.

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void	setBouzidiBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary)
	Set Bouzidi boundary on indicated cells of sLattice.

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void	setBouzidiBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int materialOfSolidObstacle, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
	Set Bouzidi boundary on material cells of sLattice.

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void	setBouzidiBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockIndicatorF< T, DESCRIPTOR::d > &boundaryIndicator, BlockIndicatorF< T, DESCRIPTOR::d > &bulkIndicator, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary, bool verbose=false)
	Set Bouzidi boundary on indicated cells of block lattice.

template<typename T , typename DESCRIPTOR >
void	setBouzidiVelocity (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int material, AnalyticalF< DESCRIPTOR::d, T, T > &u, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
	Set Bouzidi velocity boundary on material cells of sLattice.

template<typename T , typename DESCRIPTOR >
void	setBouzidiVelocity (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, AnalyticalF< DESCRIPTOR::d, T, T > &u, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
	Set Bouzidi velocity boundary on indicated cells of sLattice.

template<typename T , typename DESCRIPTOR >
void	setBouzidiVelocity (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, AnalyticalF< DESCRIPTOR::d, T, T > &u)
	Set Bouzidi velocity boundary on indicated cells of sLattice.

template<typename T , typename DESCRIPTOR >
void	setBouzidiVelocity (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF< T, DESCRIPTOR::d > &boundaryIndicator, BlockIndicatorF< T, DESCRIPTOR::d > &bulkIndicator, AnalyticalF< DESCRIPTOR::d, T, T > &u, Cuboid< T, DESCRIPTOR::d > &cuboid)
	Set Bouzidi velocity boundary on indicated cells of block lattice.

template<typename T , typename DESCRIPTOR >
void	setBouzidiAdeDirichlet (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int material, T phi_d, std::vector< int > bulkMaterials=std::vector< int >(1, 1))

template<typename T , typename DESCRIPTOR >
void	setBouzidiAdeDirichlet (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int material, AnalyticalF< DESCRIPTOR::d, T, T > &phi_d, std::vector< int > bulkMaterials=std::vector< int >(1, 1))

template<typename T , typename DESCRIPTOR >
void	setBouzidiAdeDirichlet (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, T phi_d)

template<typename T , typename DESCRIPTOR >
void	setBouzidiAdeDirichlet (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, AnalyticalF< DESCRIPTOR::d, T, T > &phi_d)

template<typename T , typename DESCRIPTOR >
void	setBouzidiAdeDirichlet (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, T phi_d, std::vector< int > bulkMaterials=std::vector< int >(1, 1))

template<typename T , typename DESCRIPTOR >
void	setBouzidiAdeDirichlet (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, AnalyticalF< DESCRIPTOR::d, T, T > &phi_d, std::vector< int > bulkMaterials=std::vector< int >(1, 1))

template<typename T , typename DESCRIPTOR >
void	setBouzidiAdeDirichlet (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF< T, DESCRIPTOR::d > &boundaryIndicator, BlockIndicatorF< T, DESCRIPTOR::d > &bulkIndicator, T phi_d, Cuboid< T, DESCRIPTOR::d > &cuboid)

template<typename T , typename DESCRIPTOR >
void	setBouzidiAdeDirichlet (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF< T, DESCRIPTOR::d > &boundaryIndicator, BlockIndicatorF< T, DESCRIPTOR::d > &bulkIndicator, AnalyticalF< DESCRIPTOR::d, T, T > &phi_d, Cuboid< T, DESCRIPTOR::d > &cuboid)

template<typename T , typename DESCRIPTOR , typename FIELD_A , typename FIELD_B >
void	setExtFieldBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the ExternalFieldBoundary on the superLattice domain This is an AdvectionDiffusionBoundary --> MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>

template<typename T , typename DESCRIPTOR , typename FIELD_A , typename FIELD_B >
void	setExtFieldBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the ExternalFieldBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename FIELD_A , typename FIELD_B >
void	setExtFieldBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator)
	Set externalFieldBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T, DESCRIPTOR>>
void	setFreeEnergyInletBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material, std::string type, int latticeNumber)
	Implementation of a inlet boundary condition for the partner lattices of the binary or ternary free energy model.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setFreeEnergyInletBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, std::string type, int latticeNumber)
	Initialising the Free Energy Inlet Boundary on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setFreeEnergyInletBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, std::string type, int latticeNumber, bool includeOuterCells=false)
	Set FreeEnergyInlet boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setFreeEnergyInletBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material, std::string type, int latticeNumber)
	Initialising the FreeEnergyInletBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setFreeEnergyInletBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator, std::string type, int latticeNumber)
	Initialising the FreeEnergyInletBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setFreeEnergyInletBoundary (BlockLattice< T, DESCRIPTOR > &_block, T omega, BlockIndicatorF3D< T > &indicator, std::string type, int latticeNumber, bool includeOuterCells=false)
	Set FreeEnergyInletBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setFreeEnergyOutletBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material, std::string type, int latticeNumber)
	Implementation of a outlet boundary condition for the partner lattices of the binary or ternary free energy model.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setFreeEnergyOutletBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, std::string type, int latticeNumber)
	Implementation of a outlet boundary condition for the partner lattices of the binary or ternary free energy model.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setFreeEnergyOutletBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, std::string type, int latticeNumber, bool includeOuterCells=false)
	Set FreeEnergyOutlet boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setFreeEnergyOutletBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material, std::string type, int latticeNumber)
	Implementation of a outlet boundary condition for the partner lattices of the binary or the ternary free energy model.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setFreeEnergyOutletBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator, std::string type, int latticeNumber)
	Implementation of a outlet boundary condition for the partner lattices of the binary or the ternary free energy model.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setFreeEnergyOutletBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, T omega, std::string type, int latticeNumber, bool includeOuterCells=false)
	Set FreeEnergyOutletBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setFreeEnergyWallBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 2 > &superGeometry, int material, T alpha, T kappa1, T kappa2, T h1, T h2, int latticeNumber)
	Implementation of a wetting boundary condition for the ternary free energy model, consisting of a BounceBack dynamics and an FreeEnergyWall PostProcessor.

template<typename T , typename DESCRIPTOR >
void	setFreeEnergyWallBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, T alpha, T kappa1, T kappa2, T h1, T h2, int latticeNumber)
	Initialising the Free Energy Wall Boundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setFreeEnergyWallBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 2 > &superGeometry, int material, T alpha, T kappa1, T kappa2, T kappa3, T h1, T h2, T h3, int latticeNumber)
	Implementation of a wetting boundary condition for the ternary free energy model, consisting of a BounceBack dynamics and an FreeEnergyWall PostProcessor.

template<typename T , typename DESCRIPTOR >
void	setFreeEnergyWallBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, T alpha, T kappa1, T kappa2, T kappa3, T h1, T h2, T h3, int latticeNumber)
	Initialising the Free Energy Wall Boundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setFreeEnergyWallBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF2D< T > &indicator, T addend, int latticeNumber, bool includeOuterCells=false)

template<typename T , typename DESCRIPTOR >
void	setFreeEnergyWallBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material, T alpha, T kappa1, T kappa2, T h1, T h2, int latticeNumber)
	Implementation of a wetting boundary condition for the ternary free energy model, consisting of a BounceBack dynamics and an FreeEnergyWall PostProcessor.

template<typename T , typename DESCRIPTOR >
void	setFreeEnergyWallBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator, T alpha, T kappa1, T kappa2, T h1, T h2, int latticeNumber)
	Initialising the Free Energy Wall Boundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setFreeEnergyWallBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material, T alpha, T kappa1, T kappa2, T kappa3, T h1, T h2, T h3, int latticeNumber)
	Implementation of a wetting boundary condition for the ternary free energy model, consisting of a BounceBack dynamics and an FreeEnergyWall PostProcessor.

template<typename T , typename DESCRIPTOR >
void	setFreeEnergyWallBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator, T alpha, T kappa1, T kappa2, T kappa3, T h1, T h2, T h3, int latticeNumber)
	Initialising the Free Energy Wall Boundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setFreeEnergyWallBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, T addend, int latticeNumber, bool includeOuterCells=false)

template<typename T , typename DESCRIPTOR >
void	setInterpolatedConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material, T *uAv)
	Initialising the InterpolatedConvectionBoundary on the superLattice domain This is an interpolated boundary --> MixinDynamics = BGKdynamics Usually T* uAv = NULL;.

template<typename T , typename DESCRIPTOR >
void	setInterpolatedConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, T *uAv)
	Initialising the InterpolatedConvectionBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setInterpolatedConvectionBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, T *uAv, bool includeOuterCells=false)
	Set InterpolatedConvectionBoundary for indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setInterpolatedConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material, T *uAv=NULL)
	Initialising the setInterpolatedConvectionBoundary function on the superLattice domain This is an Interpolated Boundary --> MixinDynamics = BGKdynamics.

template<typename T , typename DESCRIPTOR >
void	setInterpolatedConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator, T *uAv)
	Initialising the setInterpolatedConvectionBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setInterpolatedConvectionBoundary (BlockLattice< T, DESCRIPTOR > &_block, T omega, BlockIndicatorF3D< T > &indicator, T *uAv, bool includeOuterCells=false)
	Add Interpolatedconvection boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setInterpolatedPressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the setInterpolatedPressureBoundary function on the superLattice domain Interpolated Boundaries use the BGKdynamics collision-operator.

template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setInterpolatedPressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the setInterpolatedPressureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setInterpolatedPressureBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, bool includeOuterCells=false)
	Add interpolated pressure boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setInterpolatedPressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setInterpolatedPressureBoundary function on the superLattice domain Interpolated Boundaries use usually the BGKdynamics collision-operator --> MixinDynamics = BGKdynamics<T,DESCRIPTOR>

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setInterpolatedPressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setInterpolatedPressureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setInterpolatedPressureBoundary (BlockLattice< T, DESCRIPTOR > &_block, T omega, BlockIndicatorF3D< T > &indicator, bool includeOuterCells)
	Add interpolated pressure boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setInterpolatedVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the setInterpolatedVelocityBoundary function on the superLattice domain Interpolated Boundaries mostly use the BGKdynamics collision-operator --> MixinDynamics = BGKdynamics<T,DESCRIPTOR>

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setInterpolatedVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the setInterpolatedVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setInterpolatedVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, bool includeOuterCells=false)
	Set interpolatedVelocityBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setInterpolatedVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setInterpolatedVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setInterpolatedVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setInterpolatedVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setInterpolatedVelocityBoundary (BlockLattice< T, DESCRIPTOR > &_block, T omega, BlockIndicatorF3D< T > &indicator, bool includeOuterCells)

template<typename T , typename DESCRIPTOR >
void	setLocalConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material, T *uAv=NULL)
	Initialising the LocalConvectionBoundary on the superLattice domain This is a local boundary --> MixinDynamics = RLBdynamics.

template<typename T , typename DESCRIPTOR >
void	setLocalConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, T *uAv)
	Initialising the LocalConvectionBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setLocalConvectionBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, T *uAv, bool includeOuterCells=false)
	Set LocalConvectionBoundary for indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setLocalConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material, T *uAv=NULL)
	Initialising the setLocalConvectionBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setLocalConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator, T *uAv)
	Initialising the setLocalConvectionBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setLocalConvectionBoundary (BlockLattice< T, DESCRIPTOR > &_block, T omega, BlockIndicatorF3D< T > &indicator, T *uAv, bool includeOuterCells=false)
	Add local convection boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setLocalPressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the setLocalPressureBoundary function on the superLattice domain Local Boundaries use the RLBdynamics collision operator.

template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setLocalPressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the setLocalPressureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setLocalPressureBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, bool includeOuterCells=false)
	Set pressure boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setLocalPressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setLocalPressureBoundary function on the superLattice domain Local Boundaries use the RLBdynamics collision operator.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setLocalPressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setLocalPressureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setLocalPressureBoundary (BlockLattice< T, DESCRIPTOR > &_block, T omega, BlockIndicatorF3D< T > &indicator, bool includeOuterCells)
	Set pressure boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setLocalVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the setLocalVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setLocalVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the setLocalVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setLocalVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, bool includeOuterCells=false)
	Set local velocity boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setLocalVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setLocalVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>
void	setLocalVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setLocalVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setLocalVelocityBoundary (BlockLattice< T, DESCRIPTOR > &_block, T omega, BlockIndicatorF3D< T > &indicator, bool includeOuterCells)
	Set local velocity boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setNewSlipBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material)

template<typename T , typename DESCRIPTOR >
void	setNewSlipBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)

template<typename T , typename DESCRIPTOR >
void	setNewSlipBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, bool includeOuterCells)

template<typename T , typename DESCRIPTOR >
void	setPartialSlipBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T tuner, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the Partial slip boundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setPartialSlipBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T tuner, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the Partial slip boundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setPartialSlipBoundary (BlockLattice< T, DESCRIPTOR > &block, T tuner, BlockIndicatorF2D< T > &indicator, bool includeOuterCells=false)
	Set Partial Slip boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setPartialSlipBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T tuner, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the PartialSlipBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setPartialSlipBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T tuner, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the PartialSlipBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setPartialSlipBoundary (BlockLattice< T, DESCRIPTOR > &block, T tuner, BlockIndicatorF3D< T > &indicator, bool includeOuterCells=false)
	Set Partial Slip Boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setRegularizedHeatFluxBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material, T *heatFlux=nullptr)
	Initialising the RegularizedHeatFluxBoundary on the superLattice domain This is an advection diffusion boundary -->MixinDynamics = AdvectionDiffusionRLBdynamics.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setRegularizedHeatFluxBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, T *heatFlux=nullptr)
	Initialising the RegularizedHeatFluxBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setRegularizedHeatFluxBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, T *heatFlux)
	Set RegularizedHeatFluxBoundary for indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setRegularizedTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the RegularizedTemperatureBoundary on the superLattice domain This is an advection diffusion boundary -->MixinDynamics = AdvectionDiffusionRLBdynamics.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setRegularizedTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the RegularizedTemperatureBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setRegularizedTemperatureBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator)
	Set RegularizedTemperatureBoundary for indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setRobinBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setRobinBoundary function on the superLattice domain This is an AdvectionDiffusionBoundary therefore mostly --> MixinDynamics = AdvectionDiffusionRLBdynamics.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setRobinBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setRobinBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setRobinBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, T omega, bool includeOuterCells=false, bool useOtherStrategy=false)
	Set RobinBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setRtlbmDiffuseConstTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setRtlbmDiffuseConstTemperatureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setRtlbmDiffuseConstTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setRtlbmDiffuseConstTemperatureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setRtlbmDiffuseConstTemperatureBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, T omega, bool includeOuterCells=false)
	Set RtlbmDiffuseConstTemperatureBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setRtlbmDiffuseTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setRtlbmDiffuseTemperatureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setRtlbmDiffuseTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setRtlbmDiffuseTemperatureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setRtlbmDiffuseTemperatureBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, T omega, bool includeOuterCells=false)
	Set RtlbmDiffuseTemperatureBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setRtlbmDirectedTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setRtlbmDirectedTemperatureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setRtlbmDirectedTemperatureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setRtlbmDirectedTemperatureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setRtlbmDirectedTemperatureBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, T omega, bool includeOuterCells=false)
	Set RtlbmDirectedTemperatureBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setSlipBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the SlipBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setSlipBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the SlipBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setSlipBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF2D< T > &indicator, bool includeOuterCells=false)
	set slipBoundary for any indicated cells inside the block domain

template<typename T , typename DESCRIPTOR >
void	setSlipBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setslipBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setSlipBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setslipBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setSlipBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF3D< T > &indicator, bool includeOuterCells=false)
	Set slipBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setSlipBoundaryWithDynamics (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the setSlipBoundaryWithDynamics function on the superLattice domain Interpolated Boundaries use the BGKdynamics collision-operator.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setSlipBoundaryWithDynamics (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the setSlipBoundaryWithDynamics function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setSlipBoundaryWithDynamics (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, bool includeOuterCells=false)
	Set interpolated velocity boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setSlipBoundaryWithDynamics (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setSlipBoundaryWithDynamics function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setSlipBoundaryWithDynamics (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setSlipBoundaryWithDynamics function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setSlipBoundaryWithDynamics (BlockLattice< T, DESCRIPTOR > &_block, T omega, BlockIndicatorF3D< T > &indicator, bool includeOuterCells)

template<typename T , typename DESCRIPTOR >
void	setWallFunctionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material, UnitConverter< T, DESCRIPTOR > const &converter, wallFunctionParam< T > const &wallFunctionParam, IndicatorF3D< T > *geoIndicator=NULL)
	Initialising the WallFunctionBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setWallFunctionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator, UnitConverter< T, DESCRIPTOR > const &converter, wallFunctionParam< T > const &wallFunctionParam, IndicatorF3D< T > *geoIndicator)
	Initialising the WallFunctionBoundary on the superLattice domain.

template<typename T , typename DESCRIPTOR >
void	setWallFunctionBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, UnitConverter< T, DESCRIPTOR > const &converter, wallFunctionParam< T > const &wallFunctionParam, IndicatorF3D< T > *geoIndicator, bool includeOuterCells=false)
	Set WallFunction boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR >
void	setZeroDistributionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material)

template<typename T , typename DESCRIPTOR >
void	setZeroDistributionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)

template<typename T , typename DESCRIPTOR >
void	setZeroDistributionBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator)

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setZeroGradientBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setZeroGradientBoundary function on the superLattice domain This is an AdvectionDiffusionBoundary therefore mostly --> MixinDynamics = AdvectionDiffusionRLBdynamics.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>
void	setZeroGradientBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setZeroGradientBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setZeroGradientBoundary (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator)
	Set ZeroGradientBoundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setZouHePressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the setZouHePressureBoundary function on the superLattice domain ZouHe Boundaries use the BGKdynamics collision operator.

template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setZouHePressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the setZouHePressureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setZouHePressureBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, bool includeOuterCells=false)
	Set pressure boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setZouHePressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setZouHePressureBoundary function on the superLattice domain ZouHe Boundaries use the BGKdynamics collision operator.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setZouHePressureBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setZouHePressureBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void	setZouHePressureBoundary (BlockLattice< T, DESCRIPTOR > &_block, T omega, BlockIndicatorF3D< T > &indicator, bool includeOuterCells)
	Set pressure boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setZouHeVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the setZouHeVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setZouHeVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the setZouHeVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , class MixinDynamics >
void	setZouHeVelocityBoundary (BlockLattice< T, DESCRIPTOR > &block, T omega, BlockIndicatorF2D< T > &indicator, bool includeOuterCells=false)
	Set ZouHe velocity boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setZouHeVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setZouHeVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setZouHeVelocityBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, T omega, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setZouHeVelocityBoundary function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void	setZouHeVelocityBoundary (BlockLattice< T, DESCRIPTOR > &_block, T omega, BlockIndicatorF3D< T > &indicator, bool includeOuterCells)
	Set ZouHe velocity boundary for any indicated cells inside the block domain.

template<typename T >
LoadBalancer< T > *	createLoadBalancer (XMLreader const &xmlReader, CuboidGeometry3D< T > *cGeo=NULL)
	Creator Function for LoadBalancer from XMLreader.

template<typename T >
LoadBalancer< T > *	createLoadBalancer (std::string const &fileName, CuboidGeometry3D< T > *cGeo=NULL)
	Creator Function for LoadBalancer from fileName.

template<typename SUPER >
	SuperCommunicator (SUPER &) -> SuperCommunicator< typename SUPER::value_t, SUPER >

template<typename DYNAMICS >
	DynamicsPromise (meta::id< DYNAMICS >) -> DynamicsPromise< typename DYNAMICS::value_t, typename DYNAMICS::descriptor_t >

template<typename T >
bool	getRangeBlockGeometrySmoothIndicatorIntersection2D (BlockGeometryStructure2D< T > &blockGeometry, SmoothIndicatorF2D< T, T, true > &sIndicator, T invDeltaX, std::vector< int > &start, std::vector< int > &end)

template<typename T , typename DESCRIPTOR >
void	setBlockExternalParticleField (BlockGeometryStructure2D< T > &blockGeometry, AnalyticalF< 2, T, T > &velocity, SmoothIndicatorF2D< T, T, true > &sIndicator, BlockLattice2D< T, DESCRIPTOR > &extendedBlockLattice)

template<typename T , typename DESCRIPTOR >
void	setBlockExternalParticleField (BlockGeometryStructure2D< T > &blockGeometry, AnalyticalF< 2, T, T > &velocity, SmoothIndicatorF2D< T, T, true > &sIndicator, BlockLattice2D< T, DESCRIPTOR > &extendedBlockLattice, Vector< T, 2 > cellMin, Vector< T, 2 > cellMax, Vector< bool, 2 > periodic)

template<typename T , typename DESCRIPTOR >
void	setBlockZetaParticleField (BlockGeometryStructure2D< T > &blockGeometry, AnalyticalF< 2, T, T > &velocity, SmoothIndicatorF2D< T, T, true > &sIndicator, BlockLattice2D< T, DESCRIPTOR > &extendedBlockLattice)

template<typename T >
bool	getRangeBlockGeometrySmoothIndicatorIntersection3D (BlockGeometryStructure3D< T > &blockGeometry, SmoothIndicatorF3D< T, T, true > &sIndicator, T invDeltaX, std::vector< int > &start, std::vector< int > &end)

template<typename T , typename DESCRIPTOR >
void	setBlockExternalParticleField (BlockGeometryStructure3D< T > &blockGeometry, AnalyticalF< 3, T, T > &velocity, SmoothIndicatorF3D< T, T, true > &sIndicator, BlockLattice3D< T, DESCRIPTOR > &extendedBlockLattice)

template<typename T , typename DESCRIPTOR >
void	setBlockExternalParticleField (BlockGeometryStructure3D< T > &blockGeometry, AnalyticalF< 3, T, T > &velocity, SmoothIndicatorF3D< T, T, true > &sIndicator, BlockLattice3D< T, DESCRIPTOR > &extendedBlockLattice, Vector< T, 3 > cellMin, Vector< T, 3 > cellMax, Vector< bool, 3 > periodic)

template<typename PP >
	PostProcessorPromise (meta::id< PP >) -> PostProcessorPromise< typename PP::value_t, typename PP::descriptor_t >

template<typename T , typename DESCRIPTOR , typename DESCRIPTOR_AD >
UnitConverter< T, DESCRIPTOR >	createADfractionalUnitConverter (const UnitConverter< T, DESCRIPTOR > &converter, int fraction, T targetLatticeRelaxationTime)

template<typename T , typename DESCRIPTOR >
UnitConverter< T, DESCRIPTOR >	createFractionalUnitConverter (const UnitConverter< T, DESCRIPTOR > &converter, int fraction, T targetLatticeRelaxationTime)

template<typename T , typename DESCRIPTOR >
T	residualPhysDiffusivity (const UnitConverter< T, DESCRIPTOR > &converterFractional, T physDiffusivity)

void	olbInit (int argc, char **argv, bool multiOutput, bool verbose)

template<>
void	checkPlatform< Platform::GPU_CUDA > ()
	Verifies availability of CUDA device and MPI support.

template<>
void	checkPlatform< Platform::GPU_CUDA > ()
	Verifies availability of CUDA device and MPI support.

template<Platform PLATFORM>
void	checkPlatform ()
	Verifies requirements for using PLATFORM.

template<typename CONCRETIZABLE , typename F >
auto	callUsingConcretePlatform (Platform platform, typename CONCRETIZABLE::base_t *ptr, F f)
	Dispatcher for concrete platform access.

template<typename F >
void	callUsingConcretePlatform (Platform platform, F f)

template<typename CONCRETIZABLE , typename... ARGS>
CONCRETIZABLE::base_t *	constructUsingConcretePlatform (Platform platform, ARGS &&... args)

constexpr bool	isPlatformCPU (Platform platform)
	Returns true if platform is equal to Platform::CPU_*.

template<typename T , typename DESCRIPTOR >
PowerLawUnitConverter< T, DESCRIPTOR > *	createPowerLawUnitConverter (XMLreader const &params)

double	getThetaRefracted (double const &thetaIncident, double const &refractiveRelative)
	Documentation of implemented functions found in 5.2.2 Biomedical Optics, Principles and Imaging; Wang 2007.

double	getFresnelFunction (double const &theta, double const &refractiveRelative)

double	R_phi_diff (double const &theta, double const &refractiveRelative)

double	R_j_diff (double const &theta, double const &refractiveRelative)

double	getRefractionFunction (const double &refractiveRelative)

double	getPartialBBCoefficient (double const &latticeDiffusionCoefficient, double const &relativeRefractiveIndex)

template<typename T , typename DESCRIPTOR >
double	getPartialBBCoefficient (RadiativeUnitConverter< T, DESCRIPTOR > const &converter)

template<typename T , typename DESCRIPTOR >
double	getRefractionFunction (RadiativeUnitConverter< T, DESCRIPTOR > const &converter)

template<typename T , unsigned D, typename IMPL >
constexpr T	norm_squared (const ScalarVector< T, D, IMPL > &a)
	Squared euclidean vector norm.

template<typename T , unsigned D, typename IMPL >
constexpr T	norm (const ScalarVector< T, D, IMPL > &a)
	Euclidean vector norm.

template<typename T , unsigned D, typename IMPL >
bool	closeToZero (const ScalarVector< T, D, IMPL > &a)
	Returns true iff all components are within floating point error distance of 0.

template<typename T , unsigned D, typename IMPL >
constexpr std::vector< T >	toStdVector (const ScalarVector< T, D, IMPL > &a)
	Copies data into a standard vector.

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
constexpr bool	operator< (const ScalarVector< T, D, IMPL > &lhs, const ScalarVector< U, D, IMPL_ > &rhs)
	Returns true if all lhs components are smaller than rhs.

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
constexpr bool	operator> (const ScalarVector< T, D, IMPL > &lhs, const ScalarVector< U, D, IMPL_ > &rhs)
	Returns true if all lhs components are greater than rhs.

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
constexpr bool	operator<= (const ScalarVector< T, D, IMPL > &lhs, const ScalarVector< U, D, IMPL_ > &rhs)
	Returns true if all lhs components are smaller or equal than rhs.

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
constexpr bool	operator>= (const ScalarVector< T, D, IMPL > &lhs, const ScalarVector< U, D, IMPL_ > &rhs)
	Returns true if all lhs components are smaller or equal than rhs.

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
constexpr bool	lex_smaller (const ScalarVector< T, D, IMPL > &lhs, const ScalarVector< U, D, IMPL_ > &rhs)
	Returns true if lhs is lexicographically smaller than rhs.

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
constexpr bool	lex_greater (const ScalarVector< T, D, IMPL > &lhs, const ScalarVector< U, D, IMPL_ > &rhs)
	Returns true if lhs is lexicographically greater than rhs.

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
constexpr bool	lex_smaller_eq (const ScalarVector< T, D, IMPL > &lhs, const ScalarVector< U, D, IMPL_ > &rhs)
	Returns true if lhs is lexicographically smaller or equal to rhs.

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
constexpr bool	lex_greater_eq (const ScalarVector< T, D, IMPL > &lhs, const ScalarVector< U, D, IMPL_ > &rhs)
	Returns true if lhs is lexicographically greater or equal to rhs.

template<typename T , unsigned D, typename IMPL >
std::ostream &	operator<< (std::ostream &os, const ScalarVector< T, D, IMPL > &o)
	Print vector entries to ostream in a human-readable fashion.

template<typename T , typename DESCRIPTOR >
void	setSuperExternalPSMParticleField (SuperGeometry< T, 2 > &sGeometry, int material, AnalyticalF2D< T, T > &velocity, T size, SuperLatticeF2D< T, DESCRIPTOR > &epsilon, SuperLattice< T, DESCRIPTOR > &sLattice)

template<typename COUPLER , typename... MAP>
	SuperLatticeCoupling (COUPLER, MAP &&...) -> SuperLatticeCoupling< COUPLER, typename meta::map< MAP... >::template map_values< descriptors::extract_valued_descriptor_t > >

template<typename COUPLER , typename... MAP>
auto	constructSharedCoupling (COUPLER, MAP &&... map)

template<typename T , typename DESCRIPTOR >
UnitConverter< T, DESCRIPTOR > *	createUnitConverter (XMLreader const &params)
	creator function with data given by a XML file

template<typename T >
std::enable_if_t< std::is_arithmetic< T >::type::value, T >	abs (T x)

template<typename T , typename IMPL , typename IMPL_ >
constexpr T	crossProduct2D (const ScalarVector< T, 2, IMPL > &a, const ScalarVector< T, 2, IMPL_ > &b)

template<typename T , typename IMPL , typename IMPL_ >
constexpr Vector< T, 3 >	crossProduct3D (const ScalarVector< T, 3, IMPL > &a, const ScalarVector< T, 3, IMPL_ > &b) any_platform

template<typename T , unsigned D, typename IMPL , typename IMPL_ >
auto	crossProduct (const ScalarVector< T, D, IMPL > &a, const ScalarVector< T, D, IMPL_ > &b)

template<typename T , unsigned D, typename IMPL >
constexpr Vector< T, D >	normalize (const ScalarVector< T, D, IMPL > &a, T scale=T{1})

template<typename T , unsigned D, typename IMPL >
constexpr Vector< T, D >	abs (const ScalarVector< T, D, IMPL > &a)

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, Vector< T, D > >	operator+ (U a, const ScalarVector< T, D, IMPL > &b) any_platform

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, Vector< T, D > >	operator+ (const ScalarVector< T, D, IMPL > &a, U b) any_platform

template<typename T , unsigned D, typename IMPL , typename IMPL_ >
constexpr Vector< T, D >	operator+ (const ScalarVector< T, D, IMPL > &a, const ScalarVector< T, D, IMPL_ > &b) any_platform

template<typename T , typename W , unsigned D, typename IMPL , typename IMPL_ >
constexpr Vector< decltype(T{}+W{}), D >	operator+ (const ScalarVector< T, D, IMPL > &a, const ScalarVector< W, D, IMPL_ > &b) any_platform

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, Vector< T, D > >	operator- (U a, const ScalarVector< T, D, IMPL > &b) any_platform

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, Vector< T, D > >	operator- (const ScalarVector< T, D, IMPL > &a, U b) any_platform

template<typename T , unsigned D, typename IMPL , typename IMPL_ >
constexpr Vector< T, D >	operator- (const ScalarVector< T, D, IMPL > &a, const ScalarVector< T, D, IMPL_ > &b) any_platform

template<typename T , typename W , unsigned D, typename IMPL , typename IMPL_ >
constexpr Vector< decltype(T{}-W{}), D >	operator- (const ScalarVector< T, D, IMPL > &a, const ScalarVector< W, D, IMPL_ > &b) any_platform

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, Vector< decltype(T{} *U{}), D > >	operator* (U a, const ScalarVector< T, D, IMPL > &b) any_platform

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, Vector< decltype(T{} *U{}), D > >	operator* (const ScalarVector< T, D, IMPL > &a, U b) any_platform

template<typename T , typename U , unsigned D, typename IMPL , typename IMPL_ >
constexpr auto	operator* (const ScalarVector< T, D, IMPL > &a, const ScalarVector< U, D, IMPL_ > &b) any_platform
	Inner product.

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, Vector< T, D > >	operator/ (const ScalarVector< T, D, IMPL > &a, U b) any_platform

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, bool >	operator< (U lhs, const ScalarVector< T, D, IMPL > &rhs) any_platform

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, bool >	operator> (const ScalarVector< T, D, IMPL > &lhs, U rhs) any_platform

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, bool >	operator<= (U lhs, const ScalarVector< T, D, IMPL > &rhs) any_platform

template<typename T , unsigned D, typename U , typename IMPL >
constexpr meta::enable_if_arithmetic_t< U, bool >	operator>= (const ScalarVector< T, D, IMPL > &lhs, U rhs) any_platform

template<typename T , unsigned D, typename IMPL , typename IMPL_ >
constexpr Vector< T, D >	minv (const ScalarVector< T, D, IMPL > &v, const ScalarVector< T, D, IMPL_ > &w)

template<typename T , unsigned D, typename IMPL , typename IMPL_ >
constexpr Vector< T, D >	maxv (const ScalarVector< T, D, IMPL > &v, const ScalarVector< T, D, IMPL_ > &w)

any_platform FreeSurface::Flags	operator& (FreeSurface::Flags lhs, FreeSurface::Flags rhs)

any_platform FreeSurface::Flags	operator\| (FreeSurface::Flags lhs, FreeSurface::Flags rhs)

template<unsigned D, typename T , typename S , typename G >
	AnalyticalConcatenation (AnalyticalF< D, T, S > &, G g, unsigned _=1) -> AnalyticalConcatenation< D, std::remove_pointer_t< decltype(g(std::conditional_t< std::is_invocable_v< G, T >, T, T * >{}))>, T, S, std::is_invocable_v< G, T >, std::is_pointer_v< decltype(g(std::conditional_t< std::is_invocable_v< G, T >, T, T * >{}))> >

template<unsigned D, typename T , typename S , typename U = T>
	AnalyticalConcatenation (AnalyticalF< D, T, S > &, U(*g)(T)) -> AnalyticalConcatenation< D, U, T, S, true, false >

template<unsigned D, typename wrapped_U , typename T , typename S >
	AnalyticalConcatenation (AnalyticalF< D, T, S > &, wrapped_U(T *), unsigned) -> AnalyticalConcatenation< D, std::remove_pointer_t< wrapped_U >, T, S, false, std::is_pointer_v< wrapped_U > >

template<unsigned D, typename wrapped_U , typename T , typename S >
	AnalyticalConcatenation (AnalyticalF< D, T, S > &, wrapped_U(const T *), unsigned) -> AnalyticalConcatenation< D, std::remove_pointer_t< wrapped_U >, T, S, false, std::is_pointer_v< wrapped_U > >

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator+ (std::shared_ptr< AnalyticalF< D, T, S > > lhs, std::shared_ptr< AnalyticalF< D, T, S > > rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator+ (std::shared_ptr< AnalyticalF< D, T, S > > lhs, T rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator+ (T lhs, std::shared_ptr< AnalyticalF< D, T, S > > rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator- (std::shared_ptr< AnalyticalF< D, T, S > > lhs, std::shared_ptr< AnalyticalF< D, T, S > > rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator- (std::shared_ptr< AnalyticalF< D, T, S > > lhs, T rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator- (T lhs, std::shared_ptr< AnalyticalF< D, T, S > > rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator* (std::shared_ptr< AnalyticalF< D, T, S > > lhs, std::shared_ptr< AnalyticalF< D, T, S > > rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator* (std::shared_ptr< AnalyticalF< D, T, S > > lhs, T rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator* (T lhs, std::shared_ptr< AnalyticalF< D, T, S > > rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator/ (std::shared_ptr< AnalyticalF< D, T, S > > lhs, std::shared_ptr< AnalyticalF< D, T, S > > rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator/ (std::shared_ptr< AnalyticalF< D, T, S > > lhs, T rhs)

template<unsigned D, typename T , typename S >
std::shared_ptr< AnalyticalF< D, T, S > >	operator/ (T lhs, std::shared_ptr< AnalyticalF< D, T, S > > rhs)

template<class F >
	AnalyticalDerivativeAD (const F &) -> AnalyticalDerivativeAD< F, typename F::targetType, typename F::sourceType, F::dim >

template<typename S >
IndicatorCuboid2D< S > *	createIndicatorCuboid2D (XMLreader const &params, bool verbose=false)

template<typename S >
IndicatorCircle2D< S > *	createIndicatorCircle2D (XMLreader const &params, bool verbose=false)

template<typename S >
IndicatorTriangle2D< S > *	createIndicatorTriangle2D (XMLreader const &params, bool verbose)

template<typename S >
IndicatorEquiTriangle2D< S > *	createIndicatorEquiTriangle2D (XMLreader const &params, bool verbose)

template<typename S >
std::shared_ptr< IndicatorF3D< S > >	createIndicatorCircle3D (XMLreader const &params, bool verbose=false)

template<typename S >
std::shared_ptr< IndicatorF3D< S > >	createIndicatorSphere3D (XMLreader const &params, bool verbose=false)

template<typename S >
std::shared_ptr< IndicatorF3D< S > >	createIndicatorCylinder3D (XMLreader const &params, bool verbose=false)

template<typename S >
std::shared_ptr< IndicatorF3D< S > >	createIndicatorCone3D (XMLreader const &params, bool verbose=false)

template<typename S >
std::shared_ptr< IndicatorF3D< S > >	createIndicatorCuboid3D (XMLreader const &params, bool verbose=false)

template<typename S >
std::shared_ptr< IndicatorF3D< S > >	createIndicatorUnion3D (XMLreader const &params, bool verbose=false)

template<typename S >
std::shared_ptr< IndicatorF3D< S > >	createIndicatorWithout3D (XMLreader const &params, bool verbose=false)

template<typename S >
std::shared_ptr< IndicatorF3D< S > >	createIndicatorIntersection3D (XMLreader const &params, bool verbose=false)

template<typename S >
std::shared_ptr< IndicatorF3D< S > >	createIndicatorF3D (XMLreader const &params, bool verbose=false)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF2D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF2D< S > >	operator+ (std::shared_ptr< F1< S > > lhs, std::shared_ptr< F2< S > > rhs)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF2D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF2D< S > >	operator- (std::shared_ptr< F1< S > > lhs, std::shared_ptr< F2< S > > rhs)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF2D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF2D< S > >	operator* (std::shared_ptr< F1< S > > lhs, std::shared_ptr< F2< S > > rhs)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity2D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF2D< S > >	operator+ (F1< S > &lhs, std::shared_ptr< F2< S > > rhs)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity2D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF2D< S > >	operator- (F1< S > &lhs, std::shared_ptr< F2< S > > rhs)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity2D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF2D< S > >	operator* (F1< S > &lhs, std::shared_ptr< F2< S > > rhs)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF3D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF3D< S > >	operator+ (std::shared_ptr< F1< S > > lhs, std::shared_ptr< F2< S > > rhs)
	Free function implements lhs+rhs, only for IndicaotrsF3D types through enable_if and is_base_of.

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF3D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF3D< S > >	operator- (std::shared_ptr< F1< S > > lhs, std::shared_ptr< F2< S > > rhs)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF3D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF3D< S > >	operator* (std::shared_ptr< F1< S > > lhs, std::shared_ptr< F2< S > > rhs)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity3D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF3D< S > >	operator+ (F1< S > &lhs, std::shared_ptr< F2< S > > rhs)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity3D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF3D< S > >	operator- (F1< S > &lhs, std::shared_ptr< F2< S > > rhs)

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity3D<S>, F1<S>>::value>::type>
std::shared_ptr< IndicatorF3D< S > >	operator* (F1< S > &lhs, std::shared_ptr< F2< S > > rhs)

template<typename T , typename DESCRIPTOR >
	SuperLatticeDiscreteNormal2D (SuperLattice< T, DESCRIPTOR > &, SuperGeometry< typename SuperLattice< T, DESCRIPTOR >::value_t, 2 > &, FunctorPtr< SuperIndicatorF2D< typename SuperLattice< T, DESCRIPTOR >::value_t > > &&) -> SuperLatticeDiscreteNormal2D< T, DESCRIPTOR >

template<typename T , typename DESCRIPTOR >
	SuperLatticeDiscreteNormalType2D (SuperLattice< T, DESCRIPTOR > &, SuperGeometry< typename SuperLattice< T, DESCRIPTOR >::value_t, 2 > &, FunctorPtr< SuperIndicatorF2D< typename SuperLattice< T, DESCRIPTOR >::value_t > > &&) -> SuperLatticeDiscreteNormalType2D< T, DESCRIPTOR >

template<typename T , typename DESCRIPTOR >
	SuperLatticePhysPressure2D (SuperLattice< T, DESCRIPTOR > &, const UnitConverter< T, DESCRIPTOR > &) -> SuperLatticePhysPressure2D< T, DESCRIPTOR >

template<typename T , typename DESCRIPTOR >
	SuperLatticePhysPressure3D (SuperLattice< T, DESCRIPTOR > &, const UnitConverter< T, DESCRIPTOR > &) -> SuperLatticePhysPressure3D< T, DESCRIPTOR >

template<typename T , typename DESCRIPTOR >
	SuperLatticePhysVelocity2D (SuperLattice< T, DESCRIPTOR > &, const UnitConverter< T, DESCRIPTOR > &) -> SuperLatticePhysVelocity2D< T, DESCRIPTOR >

template<typename T , typename DESCRIPTOR >
	SuperLatticePhysVelocity3D (SuperLattice< T, DESCRIPTOR > &, const UnitConverter< T, DESCRIPTOR > &, bool) -> SuperLatticePhysVelocity3D< T, DESCRIPTOR >

template<typename T >
void	evaluateCuboidGeometryNeighbourhood (CuboidGeometry2D< T > &cuboidGeometry, std::map< int, std::vector< int > > &neighbourhood, int offset=0)
	Evaluate complete neighbourhood and store in std::map.

template<typename S >
std::vector< S >	getDataFromTag (XMLreader const &reader, std::string attrName, int nData)
	Helper Function to retrieve nData-dimensional std::vector of type S from space separated tag.

template<typename T >
CuboidGeometry3D< T > *	createCuboidGeometry (std::string fileName)
	Load CuboidGeometry from XML File.

template<typename T >
void	evaluateCuboidGeometryNeighbourhood (CuboidGeometry3D< T > &cuboidGeometry, std::map< int, std::vector< int > > &neighbourhood, int offset=0)
	Evaluate complete neighbourhood and store in std::map.

bool	checkCuboidNeighbourhoodConsistency (std::map< int, std::vector< int > > &neighbourhood, bool correct=false, bool verbose=false)
	Consistency check for neighbour retrieval.

template<typename T >
void	continueMinimizeByVolume (CuboidGeometry3D< T > &cGeometry, IndicatorF3D< T > &indicatorF, int nC)
	Splits largest cuboid by-volume until there are nC cuboids.

template<typename T >
void	minimizeByVolume (CuboidGeometry3D< T > &cGeometry, IndicatorF3D< T > &indicatorF, int nC)
	Splits into nC cuboids by-volume.

template<typename T >
void	minimizeByWeight (CuboidGeometry3D< T > &cGeometry, IndicatorF3D< T > &indicatorF, int nC)

template<>
std::string	CLIreader::getValueOrFallback< std::string > (const std::string &name, std::string fallback) const

std::string	createFileName (std::string name)
	for .pvd masterFile

std::string	createFileName (std::string name, int iT)
	used for .pvd file per timeStep iT

std::string	createParallelFileName (std::string name, bool withSize=true)
	for parallel io, e.g. adds "_rank0000001" for rank=1, and optional "_size0000016" if withSize==true

std::string	createFileName (std::string name, int iT, int iC)
	every thread writes his cuboids iC per timeStep iT

std::string	createFileName (std::string name, std::string functor, int iT=0)
	to write functors instantaneously, without adding

std::string	createFileName (std::string name, std::string functor, int iT, int iC)
	to write functors instantaneously, without adding

template<class Ch , class Tr >
auto &	operator<< (std::basic_ostream< Ch, Tr > &os, FileName &fileName)

template<typename ARRAYTYPE >
void	writeScalarData (std::ofstream &dataWriterOpened, std::string fullFileName, std::string headLine, ARRAYTYPE &dataVector, int iE, int iE0=0)
	Write functions for scalar and array data.

template<typename ARRAYTYPE >
void	writeScalarData (std::string fullFileName, std::string headLine, ARRAYTYPE &dataVector, int iE, int iE0=0)
	Write scalar data.

template<typename ARRAYTYPE >
void	writeScalarData (std::string fullFileName, std::vector< std::string > &headLineVector, ARRAYTYPE &dataVector, int iT, int iTinit=0)
	Write scalar data (including sanity check)

void	writeArrayData (std::string fullFileName, std::string headLine, std::vector< std::string > &dataVector)
	Write array data.

template<typename ARRAYTYPE >
void	writeArrayData (std::string fullFileName, std::string headLine, std::vector< ARRAYTYPE > &dataVector)
	Write array data.

template<typename ARRAYTYPE >
void	writeArrayData (std::string fullFileName, std::vector< std::string > &headLineVector, std::vector< ARRAYTYPE > &dataVector)
	Write array data (including sanity check)

template<class Ch , class Tr , std::size_t... Is>
void	print_index_sequence (std::basic_ostream< Ch, Tr > &os, const std::index_sequence< Is... > is)
	Print std::index_sequence.

template<class Ch , class Tr , std::size_t... Is>
auto &	operator<< (std::basic_ostream< Ch, Tr > &os, const std::index_sequence< Is... > &is)
	Operator << for std::index_sequence.

template<class Ch , class Tr , typename... args>
auto &	operator<< (std::basic_ostream< Ch, Tr > &os, std::vector< args... > &vec)
	Operator << for std::vector.

template<class Ch , class Tr , class T , std::size_t N>
auto &	operator<< (std::basic_ostream< Ch, Tr > &os, std::array< T, N > &array)
	Operator << for std::array.

template<class Ch , class Tr , typename... args>
auto &	operator<< (std::basic_ostream< Ch, Tr > &os, std::list< args... > &list)
	Operator << for std::list.

template<class Ch , class Tr , typename... args>
auto &	operator<< (std::basic_ostream< Ch, Tr > &os, std::set< args... > &set)
	Operator << for std::set.

template<class Ch , class Tr , typename... args>
auto &	operator<< (std::basic_ostream< Ch, Tr > &os, std::unordered_set< args... > &set)
	Operator << for std::unordered_set.

template<typename O >
std::string	boolToStr (O input)
	Create readable bool string.

void	serializer2ostr (Serializer &serializer, std::ostream &ostr, bool enforceUint=false)
	processes data from a serializer to a given ostr, always in parallel

void	istr2serializer (Serializer &serializer, std::istream &istr, bool enforceUint=false)
	processes an istr to a serializer, always in parallel

void	serializer2buffer (Serializer &serializer, std::uint8_t *buffer)
	processes data from a serializer to a given buffer

void	buffer2serializer (Serializer &serializer, const std::uint8_t *buffer)
	processes a buffer to a serializer

template<>
bool	XMLreader::read< std::size_t > (std::size_t &value, bool verboseOn, bool exitIfMissing) const

template<>
bool	XMLreader::read< std::string > (std::string &entry, bool verboseOn, bool exitIfMissing) const

template<typename T , unsigned D>
std::unordered_set< int >	getLatticeMaterials (const std::vector< SolidBoundary< T, D > > &solidBoundaries)
	Get material numbers of multiple solid boundaries in std::vector.

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdBoundary2D (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 2 > &superGeometry, int material)
	Initialising the setFdBoundary2D function on the superLattice domain Interpolated Boundaries use the BGKdynamics collision-operator.

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdBoundary2D (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
	Initialising the setFdBoundary2D function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdBoundary2D (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF2D< T > &indicator, bool includeOuterCells=false)
	Set interpolated velocity boundary for any indicated cells inside the block domain.

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdBoundary3D (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &superGeometry, int material)
	Initialising the setFdBoundary3D function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdBoundary3D (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&indicator)
	Initialising the setFdBoundary3D function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdBoundary3D (BlockLattice< T, DESCRIPTOR > &_block, BlockIndicatorF3D< T > &indicator, bool includeOuterCells)

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdPostProcessor2D (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int material)
	Initialising the setFdPostProcessor function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdPostProcessor2D (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&indicator)
	Initialising the setFdPostProcessor function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdPostProcessor2D (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF< T, DESCRIPTOR::d > &indicator)

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdPostProcessor3D (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int material)
	Initialising the setFdPostProcessor function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdPostProcessor3D (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&indicator)
	Initialising the setFdPostProcessor function on the superLattice domain.

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>
void	setFdPostProcessor3D (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF< T, DESCRIPTOR::d > &indicator)

template<typename SOLVER >
std::function< void()>	doPostProcess (std::shared_ptr< SOLVER > solver)
	Returns a function that encapsulates the solving process.

template<class SOLVER >
std::shared_ptr< SOLVER >	createLbSolver (XMLreader const &xml)

template<typename PARAMETERS , typename TAG >
std::shared_ptr< PARAMETERS >	createParameters (XMLreader const &xml)

template<class parameters_map >
auto	createParametersTuple (XMLreader const &xml)

double	henyeyGreenstein (double cosTheta, double g)
	Function to compute Henyey Greenstein phase funtion.

template<int q, typename DESCRIPTOR >
std::array< double, q >	testEnergyConservationColumn (const std::array< std::array< double, q >, q > &phi)

template<int q, typename DESCRIPTOR >
std::array< double, q >	testEnergyConservationRow (const std::array< std::array< double, q >, q > &phi)

template<int q>
std::array< double, q >	testAnisotropyConservationColumn (const std::array< std::array< double, q >, q > &phi, const double weights[q], std::array< std::array< double, q >, q > &cosTheta)

std::vector< double >	linespace (double const stepsize, double const a, double const b)
	Computes vector [a, a+stepsize, a+2*stepsize, ..., b].

template<typename DESCRIPTOR >
void	computeAnisotropyMatrix (double const stepsize, double const anisotropyFactor, double solution[(DESCRIPTOR::q-1) *((DESCRIPTOR::q-1)+1)/2], std::array< std::array< double, DESCRIPTOR::q-1 >, DESCRIPTOR::q-1 > &phi, int const breakAfter=-1)

template<typename DESCRIPTOR >
void	computeAnisotropyMatrixKimAndLee (double const anisotropyFactor, std::array< std::array< double, DESCRIPTOR::q >, DESCRIPTOR::q > &phi)

Expr	operator+ (Expr lhs, Expr rhs)

Expr	operator- (Expr lhs, Expr rhs)

Expr	operator* (Expr lhs, Expr rhs)

Expr	operator/ (Expr lhs, Expr rhs)

Expr	operator- (Expr rhs)

template<typename T , bool check = false>
T	getConfinedPermeability (T latticeViscosity, T latticeRelaxationTime, T physDeltaX, T charPhysLength, T physPermeability)

template<typename T , typename DESCRIPTOR , bool check = false>
T	getConfinedPermeability (const UnitConverter< T, DESCRIPTOR > &converter, T physPermeability)

template<typename T >
T	getPhysPermeability (T latticeViscosity, T latticeRelaxationTime, T physDeltaX, T charPhysLength, T confinedPermeability)

template<typename T , typename DESCRIPTOR , bool check = false>
T	getPhysPermeability (const UnitConverter< T, DESCRIPTOR > &converter, T confinedPermeability)

Arithmetic for functors managed by std::shared_ptr
template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator+ (std::shared_ptr< SuperF2D< T, W > > lhs, std::shared_ptr< SuperF2D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator+ (std::shared_ptr< SuperF2D< T, W > > lhs, W rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator+ (W lhs, std::shared_ptr< SuperF2D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator- (std::shared_ptr< SuperF2D< T, W > > lhs, std::shared_ptr< SuperF2D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator- (std::shared_ptr< SuperF2D< T, W > > lhs, W rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator- (W lhs, std::shared_ptr< SuperF2D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator* (std::shared_ptr< SuperF2D< T, W > > lhs, std::shared_ptr< SuperF2D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator* (std::shared_ptr< SuperF2D< T, W > > lhs, W rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator* (W lhs, std::shared_ptr< SuperF2D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator/ (std::shared_ptr< SuperF2D< T, W > > lhs, std::shared_ptr< SuperF2D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator/ (std::shared_ptr< SuperF2D< T, W > > lhs, W rhs)

template<typename T , typename W >
std::shared_ptr< SuperF2D< T, W > >	operator/ (W lhs, std::shared_ptr< SuperF2D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator+ (std::shared_ptr< SuperF3D< T, W > > lhs, std::shared_ptr< SuperF3D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator+ (std::shared_ptr< SuperF3D< T, W > > lhs, W rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator+ (W lhs, std::shared_ptr< SuperF3D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator- (std::shared_ptr< SuperF3D< T, W > > lhs, std::shared_ptr< SuperF3D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator- (std::shared_ptr< SuperF3D< T, W > > lhs, W rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator- (W lhs, std::shared_ptr< SuperF3D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator* (std::shared_ptr< SuperF3D< T, W > > lhs, std::shared_ptr< SuperF3D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator* (std::shared_ptr< SuperF3D< T, W > > lhs, W rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator* (W lhs, std::shared_ptr< SuperF3D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator/ (std::shared_ptr< SuperF3D< T, W > > lhs, std::shared_ptr< SuperF3D< T, W > > rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator/ (std::shared_ptr< SuperF3D< T, W > > lhs, W rhs)

template<typename T , typename W >
std::shared_ptr< SuperF3D< T, W > >	operator/ (W lhs, std::shared_ptr< SuperF3D< T, W > > rhs)

Variables
template<typename T , typename SOLVER >
std::function< T(const std::vector< T > &, unsigned)	getCallable )(std::shared_ptr< SOLVER > solver)
	Returns a function that encapsulates the solving process.

Detailed Description

Top level namespace for all of OpenLB.

Linear damping Force for magnetic dipolemoment in magnetic Field.

to calculate the magnetic force on particles around a cylinder (J.

Drag Force by Schiller and Naumann for low and high particle Re [Schiller, L.;Naumann, Z.; A Drag Coefficient Correlation; VDI Zeitung, 1935, p. 318-320].

All OpenLB code is contained in this namespace.

This class is intended to provide the ability to write particle data.

A super geometry represents a parrallel voxel mesh.

These are functors used for turbulent flows.

A fringe zone is a spatial domain, which is included into the computational domain to aim a transition from turbulent into laminar flow.

The functor dimensions are given by F: S^m -> T^n (S=source, T=target) and are implemented via GenericF(n,m).

Don't get confused by the flipped order of source and target.

It is often applied to improve the use of artificial boundary conditions.

            lambda_max
          _____________
         /             \
        /               \
       /                 \
      /                   \
     /                     \

________/ ________ |x_start | x_ende |--—| |--—| b_rise b_fall

fringe function: lambda(x) = lambda_max*[S((x-x_start)/(b_rise)) - S((x-x_end)/(b_fall)+1)] The fringe function sets the strength of the damping. The maximum strength is lambda_max and the shape of the function is defined by the stepfunction S(x) and the parameters b_rise and b_fall.

lambda_max: maximal damping force x_start: begin of the fringe zone x_end: end of the fringe zone b_rise: rise distance b_fall: fall distance

S is a smooth step function: S(x)=0, for x<=0 S(x)=1/( 1 + util::exp( (1/(x-1)) + (1/x) ) ), for 0<x<1, S(x)=1, for x>=1.

--> G = lambda*(U - u) is the volume force, which is added to the flow equations in order to transfer the actual velocity into the wanted velocity field

u: actual velocity U: wanted velocity - either average profil or poiseuille profile

BibteX listing of the main paper:

@TECHREPORT{lundbladh:99, author = {Anders Lundbladh and Stellan Berlin and Martin Skote and Casper Hildings and Jaisig Choi and John Kim and Dan Henningson}, title = {An Efficient Spectral Method for Simulation of Incompressible Flow Over a Flat Plate}, institution = {not set}, url = {http://www.fluidosol.se/thesismod/paper9.pdf}, year = {1999} }

Some like AMD have an execute member function which writes the data into the external field of a lattice descriptor.

A super geometry consits of a number of block geometries, where the material numbers are stored. It is constructed from a cuboid geometry. All coboids of the cuboid geometry are asigned to block geometries which are extended by an overlap in order to enable efficient parallelisation.

By the class access is provied to the material numbers of the mesh. Methods for renaming materials are provided as well as a statistic class.

This class is not intended to be derived from.

The overall structure is, however, similar to the one of the SuperVTMwriter3D rather than to the SuperParticleSysVtuWriter. This was done to merge it to the SuperVTMwriter3D someday. The following differences do not alllow this a the moment though:

The SuperVTMwriter3D is still dimension sensitiv, the present is not.
The SuperVTMwriter3D assumes a parallelized framework, the present assumes a non-parallelized framework
The Functor type differs. Those can possibly be bases on a common base class or a template argument could be provided
The SuperVTMwriter3D does not take the DESCRIPTOR as argument. The present one does as this is necessary for the underlying datatype. In order to destinguish between particles and the lattice, the descriptor should be included though. As soon as the differences are removed, a generic 2D/3D parallized/nonparallized VTKwriter class can be implemented providing all functionality. WARNING: Due to this, some functionality was not bothered to be implemented ( e.g. compression and binary writeout).

Lindner et al. / Computers and Chemical Engineering 54 (2013) 111-121)

Typedef Documentation

◆ AdvectionDiffusionBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::AdvectionDiffusionBulkTuple>

using olb::AdvectionDiffusionBGKdynamics

Initial value:

 dynamics::Tuple<
  T,DESCRIPTOR,
  MOMENTA,
  equilibria::FirstOrder,
  collision::BGK,
  AdvectionDiffusionExternalVelocityCollision
>

This approach contains a slight error in the diffusion term.

Definition at line 136 of file advectionDiffusionDynamics.h.

◆ AdvectionDiffusionMRTdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::AdvectionDiffusionBulkTuple>

using olb::AdvectionDiffusionMRTdynamics

Initial value:

 dynamics::Tuple<
  T,DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::MRT,
  AdvectionDiffusionExternalVelocityCollision
>

This approach is based on the multi-distribution LBM model.

The coupling is done using the Boussinesq approximation

Definition at line 704 of file advectionDiffusionDynamics.h.

◆ AdvectionDiffusionRLBdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::AdvectionDiffusionBulkTuple>

using olb::AdvectionDiffusionRLBdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::FirstOrder,
  collision::AdvectionDiffusionRLB,
  AdvectionDiffusionExternalVelocityCollision
>

Definition at line 77 of file advectionDiffusionDynamics.h.

◆ AdvectionDiffusionTRTdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::AdvectionDiffusionBulkTuple>

using olb::AdvectionDiffusionTRTdynamics

Initial value:

 dynamics::Tuple<
  T,DESCRIPTOR,
  MOMENTA,
  equilibria::FirstOrder,
  collision::TRT,
  AdvectionDiffusionExternalVelocityCollision
>

This approach contains a slight error in the diffusion term.

Definition at line 148 of file advectionDiffusionDynamics.h.

◆ AdvectionLocalDiffusionBoundariesDynamics

template<typename T , typename DESCRIPTOR , typename DYNAMICS , typename MOMENTA , int... ARGS>

using olb::AdvectionLocalDiffusionBoundariesDynamics

Initial value:

 dynamics::ParameterFromCell<descriptors::OMEGA,
AdvectionDiffusionBoundariesDynamics< T, DESCRIPTOR, DYNAMICS, MOMENTA, ARGS...>
>

Definition at line 105 of file advectionDiffusionBoundaries.h.

◆ AdvectionLocalDiffusionCornerDynamics2D

template<typename T , typename DESCRIPTOR , typename DYNAMICS , typename MOMENTA , int... NORMAL>

using olb::AdvectionLocalDiffusionCornerDynamics2D

Initial value:

 dynamics::ParameterFromCell<descriptors::OMEGA,
 AdvectionDiffusionCornerDynamics2D<T, DESCRIPTOR, DYNAMICS, MOMENTA, NORMAL... >
>

Definition at line 225 of file advectionDiffusionBoundaries.h.

◆ AdvectionLocalDiffusionCornerDynamics3D

template<typename T , typename DESCRIPTOR , typename DYNAMICS , typename MOMENTA , int... NORMAL>

using olb::AdvectionLocalDiffusionCornerDynamics3D

Initial value:

 dynamics::ParameterFromCell<descriptors::OMEGA,
 AdvectionDiffusionCornerDynamics3D<T, DESCRIPTOR, DYNAMICS, MOMENTA, NORMAL... >
>

Definition at line 285 of file advectionDiffusionBoundaries.h.

◆ AdvectionLocalDiffusionEdgesDynamics

template<typename T , typename DESCRIPTOR , typename DYNAMICS , typename MOMENTA , int... ARGS>

using olb::AdvectionLocalDiffusionEdgesDynamics

Initial value:

 dynamics::ParameterFromCell<descriptors::OMEGA,
AdvectionDiffusionEdgesDynamics< T, DESCRIPTOR, DYNAMICS, MOMENTA, ARGS...>
>

Definition at line 165 of file advectionDiffusionBoundaries.h.

◆ AnalyticalComposed2D

template<typename T , typename S >

using olb::AnalyticalComposed2D = AnalyticalComposed<2,T,S>

Definition at line 368 of file analyticalF.h.

◆ AnalyticalComposed3D

template<typename T , typename S >

using olb::AnalyticalComposed3D = AnalyticalComposed<3,T,S>

Definition at line 370 of file analyticalF.h.

◆ AnalyticalConst1D

template<typename T , typename S >

using olb::AnalyticalConst1D = AnalyticalConst<1,T,S>

Definition at line 361 of file analyticalF.h.

◆ AnalyticalConst2D

template<typename T , typename S >

using olb::AnalyticalConst2D = AnalyticalConst<2,T,S>

Definition at line 363 of file analyticalF.h.

◆ AnalyticalConst3D

template<typename T , typename S >

using olb::AnalyticalConst3D = AnalyticalConst<3,T,S>

Definition at line 365 of file analyticalF.h.

◆ AnalyticalF1D

template<typename T , typename S >

using olb::AnalyticalF1D = AnalyticalF<1,T,S>

Definition at line 88 of file analyticalBaseF.h.

◆ AnalyticalF2D

template<typename T , typename S >

using olb::AnalyticalF2D = AnalyticalF<2,T,S>

Definition at line 90 of file analyticalBaseF.h.

◆ AnalyticalF3D

template<typename T , typename S >

using olb::AnalyticalF3D = AnalyticalF<3,T,S>

Definition at line 92 of file analyticalBaseF.h.

◆ AnalyticalIdentity1D

template<typename T , typename S >

using olb::AnalyticalIdentity1D = AnalyticalIdentity<1,T,S>

Definition at line 95 of file analyticalBaseF.h.

◆ AnalyticalIdentity2D

template<typename T , typename S >

using olb::AnalyticalIdentity2D = AnalyticalIdentity<2,T,S>

Definition at line 97 of file analyticalBaseF.h.

◆ AnalyticalIdentity3D

template<typename T , typename S >

using olb::AnalyticalIdentity3D = AnalyticalIdentity<3,T,S>

Definition at line 99 of file analyticalBaseF.h.

◆ AnalyticalRandom1D

template<typename T , typename S >

using olb::AnalyticalRandom1D = AnalyticalRandomOld<1,T,S>

Definition at line 373 of file analyticalF.h.

◆ AnalyticalRandom2D

template<typename T , typename S >

using olb::AnalyticalRandom2D = AnalyticalRandomOld<2,T,S>

Definition at line 375 of file analyticalF.h.

◆ AnalyticalRandom3D

template<typename T , typename S >

using olb::AnalyticalRandom3D = AnalyticalRandomOld<3,T,S>

Definition at line 377 of file analyticalF.h.

◆ AnalyticCalcDivision

template<unsigned D, typename T , typename S >

using olb::AnalyticCalcDivision = AnalyticCalcF<D,T,S,util::divides>

division functor

Definition at line 87 of file analyticCalcF.h.

◆ AnalyticCalcDivision1D

template<typename T , typename S >

using olb::AnalyticCalcDivision1D = AnalyticCalcDivision<1,T,S>

Definition at line 90 of file analyticCalcF.h.

◆ AnalyticCalcDivision2D

template<typename T , typename S >

using olb::AnalyticCalcDivision2D = AnalyticCalcDivision<2,T,S>

Definition at line 92 of file analyticCalcF.h.

◆ AnalyticCalcDivision3D

template<typename T , typename S >

using olb::AnalyticCalcDivision3D = AnalyticCalcDivision<3,T,S>

Definition at line 94 of file analyticCalcF.h.

◆ AnalyticCalcMinus

template<unsigned D, typename T , typename S >

using olb::AnalyticCalcMinus = AnalyticCalcF<D,T,S,util::minus>

subtraction functor

Definition at line 65 of file analyticCalcF.h.

◆ AnalyticCalcMinus1D

template<typename T , typename S >

using olb::AnalyticCalcMinus1D = AnalyticCalcMinus<1,T,S>

Definition at line 68 of file analyticCalcF.h.

◆ AnalyticCalcMinus2D

template<typename T , typename S >

using olb::AnalyticCalcMinus2D = AnalyticCalcMinus<2,T,S>

Definition at line 70 of file analyticCalcF.h.

◆ AnalyticCalcMinus3D

template<typename T , typename S >

using olb::AnalyticCalcMinus3D = AnalyticCalcMinus<3,T,S>

Definition at line 72 of file analyticCalcF.h.

◆ AnalyticCalcMultiplication

template<unsigned D, typename T , typename S >

using olb::AnalyticCalcMultiplication = AnalyticCalcF<D,T,S,util::multiplies>

multiplication functor

Definition at line 76 of file analyticCalcF.h.

◆ AnalyticCalcMultiplication1D

template<typename T , typename S >

using olb::AnalyticCalcMultiplication1D = AnalyticCalcMultiplication<1,T,S>

Definition at line 79 of file analyticCalcF.h.

◆ AnalyticCalcMultiplication2D

template<typename T , typename S >

using olb::AnalyticCalcMultiplication2D = AnalyticCalcMultiplication<2,T,S>

Definition at line 81 of file analyticCalcF.h.

◆ AnalyticCalcMultiplication3D

template<typename T , typename S >

using olb::AnalyticCalcMultiplication3D = AnalyticCalcMultiplication<3,T,S>

Definition at line 83 of file analyticCalcF.h.

◆ AnalyticCalcPlus

template<unsigned D, typename T , typename S >

using olb::AnalyticCalcPlus = AnalyticCalcF<D,T,S,util::plus>

addition functor

Definition at line 54 of file analyticCalcF.h.

◆ AnalyticCalcPlus1D

template<typename T , typename S >

using olb::AnalyticCalcPlus1D = AnalyticCalcPlus<1,T,S>

Definition at line 57 of file analyticCalcF.h.

◆ AnalyticCalcPlus2D

template<typename T , typename S >

using olb::AnalyticCalcPlus2D = AnalyticCalcPlus<2,T,S>

Definition at line 59 of file analyticCalcF.h.

◆ AnalyticCalcPlus3D

template<typename T , typename S >

using olb::AnalyticCalcPlus3D = AnalyticCalcPlus<3,T,S>

Definition at line 61 of file analyticCalcF.h.

◆ BaseType

template<typename T >

using olb::BaseType = typename util::BaseTypeHelper<T>::type

Definition at line 59 of file baseType.h.

◆ BGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::BGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  std::conditional_t<   (DESCRIPTOR::d == 3 && DESCRIPTOR::q == 7)
                     || (DESCRIPTOR::d == 2 && DESCRIPTOR::q == 5),
                        equilibria::FirstOrder,
                        equilibria::SecondOrder>,
  collision::BGK
>

Common BGK collision step.

Definition at line 72 of file dynamics.h.

◆ BlockCalcDivision2D

template<typename T >

using olb::BlockCalcDivision2D = BlockCalcF2D<T,util::divides>

Block level division functor.

Definition at line 92 of file blockCalcF2D.h.

◆ BlockCalcDivision3D

template<typename T >

using olb::BlockCalcDivision3D = BlockCalcF3D<T,util::divides>

Block level division functor.

Definition at line 92 of file blockCalcF3D.h.

◆ BlockCalcMinus2D

template<typename T >

using olb::BlockCalcMinus2D = BlockCalcF2D<T,util::minus>

Block level subtraction functor (T==bool: Without)

Definition at line 84 of file blockCalcF2D.h.

◆ BlockCalcMinus3D

template<typename T >

using olb::BlockCalcMinus3D = BlockCalcF3D<T,util::minus>

Block level subtraction functor (T==bool: Without)

Definition at line 84 of file blockCalcF3D.h.

◆ BlockCalcMultiplication2D

template<typename T >

using olb::BlockCalcMultiplication2D = BlockCalcF2D<T,util::multiplies>

Block level multiplication functor (T==bool: Intersection)

Definition at line 88 of file blockCalcF2D.h.

◆ BlockCalcMultiplication3D

template<typename T >

using olb::BlockCalcMultiplication3D = BlockCalcF3D<T,util::multiplies>

Block level multiplication functor (T==bool: Intersection)

Definition at line 88 of file blockCalcF3D.h.

◆ BlockCalcPlus2D

template<typename T >

using olb::BlockCalcPlus2D = BlockCalcF2D<T,util::plus>

Block level addition functor (T==bool: Union)

Definition at line 80 of file blockCalcF2D.h.

◆ BlockCalcPlus3D

template<typename T >

using olb::BlockCalcPlus3D = BlockCalcF3D<T,util::plus>

Block level addition functor (T==bool: Union)

Definition at line 80 of file blockCalcF3D.h.

◆ BlockF

template<typename T , unsigned D>

using olb::BlockF

Initial value:

 std::conditional_t<
  D == 2,
  BlockF2D<T>,
  BlockF3D<T>
>

Definition at line 188 of file aliases.h.

◆ BlockGeometry2D

template<typename T >

using olb::BlockGeometry2D = BlockGeometry<T,2>

Definition at line 210 of file blockGeometry.h.

◆ BlockGeometry3D

template<typename T >

using olb::BlockGeometry3D = BlockGeometry<T,3>

Definition at line 213 of file blockGeometry.h.

◆ BlockGeometryStatistics

template<typename T , unsigned D>

using olb::BlockGeometryStatistics

Initial value:

 std::conditional_t<
  D == 2,
  BlockGeometryStatistics2D<T>,
  BlockGeometryStatistics3D<T>
>

Definition at line 178 of file aliases.h.

◆ BlockIndicatorBoundaryNeighbor

template<typename T , unsigned D>

using olb::BlockIndicatorBoundaryNeighbor

Initial value:

 std::conditional_t<
  D == 2,
  BlockIndicatorBoundaryNeighbor2D<T>,
  BlockIndicatorBoundaryNeighbor3D<T>
>

Definition at line 238 of file aliases.h.

◆ BlockIndicatorF

template<typename T , unsigned D>

using olb::BlockIndicatorF

Initial value:

 std::conditional_t<
  D == 2,
  BlockIndicatorF2D<T>,
  BlockIndicatorF3D<T>
>

Definition at line 218 of file aliases.h.

◆ BlockIndicatorFfromIndicatorF

template<typename T , unsigned D>

using olb::BlockIndicatorFfromIndicatorF

Initial value:

 std::conditional_t<
  D == 2,
  BlockIndicatorFfromIndicatorF2D<T>,
  BlockIndicatorFfromIndicatorF3D<T>
>

Definition at line 248 of file aliases.h.

◆ BlockIndicatorMaterial

template<typename T , unsigned D>

using olb::BlockIndicatorMaterial

Initial value:

 std::conditional_t<
  D == 2,
  BlockIndicatorMaterial2D<T>,
  BlockIndicatorMaterial3D<T>
>

Definition at line 228 of file aliases.h.

◆ BlockLatticeF

template<typename T , typename DESCRIPTOR >

using olb::BlockLatticeF

Initial value:

 std::conditional_t<
                     DESCRIPTOR::d == 2,
                     BlockLatticeF2D<T,DESCRIPTOR>,
                     BlockLatticeF3D<T,DESCRIPTOR>
                     >

Definition at line 158 of file aliases.h.

◆ BlockLatticeInterpPhysVelocity

template<typename T , typename DESCRIPTOR >

using olb::BlockLatticeInterpPhysVelocity

Initial value:

 std::conditional_t<
  DESCRIPTOR::d == 2,
  BlockLatticeInterpPhysVelocity2D<T,DESCRIPTOR>,
  BlockLatticeInterpPhysVelocity3D<T,DESCRIPTOR>
>

Definition at line 360 of file aliases.h.

◆ BlockLatticePhysF

template<typename T , typename DESCRIPTOR >

using olb::BlockLatticePhysF

Initial value:

 std::conditional_t<
  DESCRIPTOR::d == 2,
  BlockLatticePhysF2D<T,DESCRIPTOR>,
  BlockLatticePhysF3D<T,DESCRIPTOR>
>

Definition at line 339 of file aliases.h.

◆ BlockStructure

template<typename DESCRIPTOR >

using olb::BlockStructure = BlockStructureD<DESCRIPTOR::d>

Definition at line 296 of file blockStructure.h.

◆ BounceBack

template<typename T , typename DESCRIPTOR >

using olb::BounceBack

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::Tuple<
    momenta::FixedDensity,
    momenta::ZeroMomentum,
    momenta::ZeroStress,
    momenta::DefineSeparately
  >,
  equilibria::SecondOrder,
  collision::Revert
>

Bounce Back boundary dynamics.

This is a very popular way to implement no-slip boundary conditions, due to the simplicity and due to the independence of the boundary's orientation.

Definition at line 266 of file dynamics.h.

◆ BounceBackBulkDensity

template<typename T , typename DESCRIPTOR >

using olb::BounceBackBulkDensity

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::Tuple<
    momenta::BulkDensity,
    momenta::ZeroMomentum,
    momenta::ZeroStress,
    momenta::DefineSeparately
  >,
  equilibria::SecondOrder,
  collision::Revert
>

Bounce Back boundary dynamics with bulk density.

Different from BounceBack these dynamics compute the 0th moment from the cell's populations instead of applying a fixed value.

Definition at line 285 of file dynamics.h.

◆ BounceBackVelocity

template<typename T , typename DESCRIPTOR >

using olb::BounceBackVelocity

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::ExternalVelocityTuple,
  equilibria::SecondOrder,
  collision::NguyenLaddCorrection<collision::Revert>
>

Bounce Back boundary dynamics with Nguyen-Ladd velocity correction.

This is a very popular way to implement no-slip boundary conditions, due to the simplicity and due to the independence of the boundary's orientation.

Definition at line 304 of file dynamics.h.

◆ CellDistance

using olb::CellDistance = std::int64_t

Type for in-memory distance of block-local cell indices.

Definition at line 39 of file blockStructure.h.

◆ CellID

using olb::CellID = std::uint32_t

Type for sequential block-local cell indices.

Definition at line 36 of file blockStructure.h.

◆ ChopardDynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA >

using olb::ChopardDynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::Chopard,
  collision::BGK
>

Definition at line 380 of file dynamics.h.

◆ Column

template<typename T >

using olb::Column = cpu::sisd::Column<T>

Use CPU SISD as default Column.

Definition at line 241 of file column.h.

◆ Communicator

template<typename T , unsigned D>

using olb::Communicator

Initial value:

 std::conditional_t<
  D == 2,
  Communicator2D<T>,
  Communicator3D<T>
>

Definition at line 57 of file aliases.h.

◆ ConSmagorinskyBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ConSmagorinskyBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::ConSmagorinskyEffectiveOmega<collision::BGK>
>

Consistent Smagorinsky BGK collision step.

Consistent subgrid scale modelling for lattice Boltzmann methods Orestis Malaspinas and Pierre Sagaut Journal of Fluid Mechanics / Volume / June 2012, pp 514-542 DOI: http://dx.doi.org/10.1017/jfm.2012.155

Definition at line 133 of file smagorinskyBGKdynamics.h.

◆ ConStrainSmagorinskyBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ConStrainSmagorinskyBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::ConStrainSmagorinskyEffectiveOmega<collision::BGK>
>

Consistent Strain Smagorinsky BGK collision step.

Consistent subgrid scale modelling for lattice Boltzmann methods Orestis Malaspinas and Pierre Sagaut Journal of Fluid Mechanics / Volume / June 2012, pp 514-542 DOI: http://dx.doi.org/10.1017/jfm.2012.155

Definition at line 118 of file smagorinskyBGKdynamics.h.

◆ ConstRhoBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ConstRhoBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::ConstRhoBGK
>

Pressure-corrected BGK collision step.

Definition at line 84 of file dynamics.h.

◆ Cuboid

template<typename T , unsigned D>

using olb::Cuboid

Initial value:

 std::conditional_t<
  D == 2,
  Cuboid2D<T>,
  Cuboid3D<T>
>

Definition at line 37 of file aliases.h.

◆ CuboidGeometry

template<typename T , unsigned D>

using olb::CuboidGeometry

Initial value:

 std::conditional_t<
  D == 2,
  CuboidGeometry2D<T>,
  CuboidGeometry3D<T>
>

Definition at line 47 of file aliases.h.

◆ CUMdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::CUMdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::CUM
>

Implementation partially based on: Geier, Martin, et al.

"The cumulant lattice Boltzmann equation in three dimensions: Theory and validation." Computers & Mathematics with Applications 70.4 (2015): 507-547.

Definition at line 38 of file cumulantDynamics.h.

◆ CyclicColumn

template<typename T >

using olb::CyclicColumn = cpu::sisd::CyclicColumn<T>

Use CPU SISD as default CyclicColumn.

Definition at line 245 of file column.h.

◆ DBBParticleBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::DBBParticleBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::DBBParticleBGK
>

Definition at line 506 of file porousBGKdynamics.h.

◆ DualPorousBGKDynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::DualPorousBGKDynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::DualPorousBGK
>

Definition at line 135 of file dualDynamics.h.

◆ EquilibriumBoundaryFirstOrder

template<typename T , typename DESCRIPTOR >

using olb::EquilibriumBoundaryFirstOrder

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::EquilibriumBoundaryTuple,
  equilibria::FirstOrder,
  collision::FixedEquilibrium
>

First order equilibrium boundary dynamics.

Applies the first order equilibrium distribution on every time step using fixed density and velocity moments.

Definition at line 393 of file dynamics.h.

◆ EquilibriumBoundarySecondOrder

template<typename T , typename DESCRIPTOR >

using olb::EquilibriumBoundarySecondOrder

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::EquilibriumBoundaryTuple,
  equilibria::SecondOrder,
  collision::FixedEquilibrium
>

Second order equilibrium boundary dynamics.

Applies the second order equilibrium distribution on every time step using fixed density and velocity moments.

Definition at line 406 of file dynamics.h.

◆ ExternalSmagorinskyBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ExternalSmagorinskyBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::ParameterFromCell<collision::LES::Smagorinsky,
                               collision::SmagorinskyEffectiveOmega<collision::BGK>>
>

Smagorinsky BGK collision step with per-cell Smagorinsky constant.

Definition at line 142 of file smagorinskyBGKdynamics.h.

◆ ExternalTauEffLESBGKadvectionDiffusionDynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ExternalTauEffLESBGKadvectionDiffusionDynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::FirstOrder,
  collision::OmegaFromCellTauEff<collision::BGK>,
  AdvectionDiffusionExternalVelocityCollision
>

LES BGK collision for advection diffusion using non-local TAU_EFF per-cell field.

Definition at line 102 of file smagorinskyBGKdynamics.h.

◆ ExternalTauEffLESBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ExternalTauEffLESBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::OmegaFromCellTauEff<collision::BGK>
>

LES BGK collision using non-local TAU_EFF per-cell field.

Definition at line 58 of file smagorinskyBGKdynamics.h.

◆ ExternalTauEffLESForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ExternalTauEffLESForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::OmegaFromCellTauEff<collision::BGK>,
  forcing::Guo<momenta::Forced>
>

LES BGK collision with Guo forcing using non-local TAU_EFF per-cell field.

Definition at line 67 of file smagorinskyBGKdynamics.h.

◆ ExternalTauForcedIncBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ExternalTauForcedIncBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::Incompressible,
  collision::OmegaFromCellTauEff<collision::BGK>,
  forcing::Guo<momenta::Forced>
>

Incompressible BGK collision step with relaxation frequency 1 / TAU_EFF and external force.

Definition at line 165 of file dynamics.h.

◆ FieldD

template<typename T , typename DESCRIPTOR , typename FIELD >

using olb::FieldD

Initial value:

 Vector<
  typename FIELD::template value_type<T>,
  DESCRIPTOR::template size<FIELD>()
>

Vector storing a single field instance.

Definition at line 43 of file fieldArrayD.h.

◆ ForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::BGK,
  forcing::Guo<momenta::Forced>
>

BGK collision step with external force (Guo)

Guo Z, Zheng C, Shi B (2002) Discrete lattice effects on the forcing term in the lattice Boltzmann method. Phys Rev E 65(4) DOI: 10.1103/PhysRevE.65.046308

Definition at line 98 of file dynamics.h.

◆ ForcedIncBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ForcedIncBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::Incompressible,
  collision::BGK,
  forcing::Guo<momenta::Forced>
>

Incompressible BGK collision step with external force.

Using Guo forcing on incompressible BGK

Definition at line 155 of file dynamics.h.

◆ ForcedKupershtokhBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ForcedKupershtokhBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::BGK,
  forcing::Kupershtokh
>

BGK collision step with external force (Kupershtokh)

Kupershtokh A, Medvedev D, Karpov D (2009) On equations of state in a lattice Boltzmann method. Comput Math Appl 58(5) DOI: 10.1016/j.camwa.2009.02.024

Definition at line 123 of file dynamics.h.

◆ ForcedMRTdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ForcedMRTdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::MRT,
  forcing::LaddVerberg
>

Definition at line 53 of file mrtDynamics.h.

◆ ForcedShanChenBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ForcedShanChenBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::BGK,
  forcing::ShanChen
>

BGK collision step with external force (Shan and Chen)

Shan X, Chen H (1993) Lattice Boltzmann model for simulating flows with multiple phases and components. Phys Rev E. 47 (3) DOI: 10.1103/PhysRevE.47.1815

Definition at line 138 of file dynamics.h.

◆ ForcedTRTdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ForcedTRTdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::TRT,
  forcing::Guo<momenta::Forced>
>

TRT collision step with external force.

Using Guo forcing on incompressible BGK

Definition at line 251 of file dynamics.h.

◆ FreeEnergyBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::FreeEnergyBulkTuple>

using olb::FreeEnergyBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::FreeEnergy,
  collision::FreeEnergy
>

Definition at line 178 of file freeEnergyDynamics.h.

◆ FreeEnergyInletOutletDynamics

template<typename T , typename DESCRIPTOR , int direction, int orientation>

using olb::FreeEnergyInletOutletDynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::Tuple<
    momenta::FreeEnergyInletOutletDensity,
    momenta::FreeEnergyInletOutletMomentum<direction,orientation>,
    momenta::RegularizedBoundaryStress<direction,orientation>,
    momenta::DefineSeparately
  >,
  equilibria::FreeEnergy,
  collision::FreeEnergyInletOutlet<direction,orientation>
>

Definition at line 199 of file freeEnergyDynamics.h.

◆ FreeEnergyWallDynamics

template<typename T , typename DESCRIPTOR >

using olb::FreeEnergyWallDynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::Tuple<
    momenta::BulkDensity,
    momenta::ZeroMomentum,
    momenta::ZeroStress,
    momenta::DefineSeparately
  >,
  equilibria::FreeEnergy,
  collision::Revert
>

Definition at line 186 of file freeEnergyDynamics.h.

◆ GuoZhaoBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::GuoZhaoBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  guoZhao::GuoZhaoSecondOrder,
  collision::BGK,
  guoZhao::GuoZhaoForcing<momenta::GuoZhaoForced>
>

Definition at line 190 of file guoZhaoDynamics.h.

◆ IncBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::IncBGKdynamics = dynamics::Tuple<T,DESCRIPTOR,MOMENTA,equilibria::Incompressible,collision::BGK>

Incompressible BGK collision step.

Definition at line 148 of file dynamics.h.

◆ IndicatorCuboid

template<typename T , unsigned D>

using olb::IndicatorCuboid

Initial value:

 std::conditional_t<
  D == 2,
  IndicatorCuboid2D<T>,
  IndicatorCuboid3D<T>
>

Definition at line 268 of file aliases.h.

◆ IndicatorF

template<typename T , unsigned D>

using olb::IndicatorF

Initial value:

 std::conditional_t<
  D == 2,
  IndicatorF2D<T>,
  IndicatorF3D<T>
>

Definition at line 258 of file aliases.h.

◆ KBCdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::KBCdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::KBC
>

Definition at line 44 of file kbcDynamics.h.

◆ KrauseBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::KrauseBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::KrauseEffectiveOmega<collision::PerPopulationBGK>
>

Krause BGK collision step.

Definition at line 161 of file smagorinskyBGKdynamics.h.

◆ KrauseHBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::KrauseHBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::KrauseH<collision::BGK>
>

HBGK collision step for a porosity model enabling drag computation for many particles including the Krause turbulence modell.

Definition at line 516 of file porousBGKdynamics.h.

◆ LatticeCouplingGenerator

template<typename T , typename DESCRIPTOR >

using olb::LatticeCouplingGenerator

Initial value:

 std::conditional_t<
  DESCRIPTOR::d == 2,
  LatticeCouplingGenerator2D<T,DESCRIPTOR>,
  LatticeCouplingGenerator3D<T,DESCRIPTOR>
>

Definition at line 168 of file aliases.h.

◆ LatticeR

template<unsigned D>

using olb::LatticeR = Vector<std::int32_t,D>

Type for spatial block-local lattice coordinates.

Definition at line 43 of file blockStructure.h.

◆ MRTdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::MRTdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::MRT
>

Original implementation based on: D'Humieres et al., "Multiple-relaxation-time lattice Boltzmann models in three dimensions", Phil: Trans.

R. soc. Lond. A (2002) 360, 437-451 and Yu et al,, "LES of turbulent square jet flow using an MRT lattice Boltzmann model", Computers & Fluids 35 (2006), 957-965

Definition at line 45 of file mrtDynamics.h.

◆ MultiComponentForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::ExternalVelocityTuple>

using olb::MultiComponentForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::BGK,
  forcing::MCGuo<momenta::Identity>
>

Definition at line 108 of file dynamics.h.

◆ MultiFieldArrayForDescriptorD

template<typename T , typename DESCRIPTOR , Platform PLATFORM = Platform::CPU_SISD>

using olb::MultiFieldArrayForDescriptorD = typename MultiFieldArrayForDescriptorHelper<T,DESCRIPTOR,PLATFORM>::type

MultiFieldArrayD containing each field in DESCRIPTOR::fields_t.

Definition at line 636 of file fieldArrayD.h.

◆ NoCollideDynamics

template<typename T , typename DESCRIPTOR >

using olb::NoCollideDynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::BulkTuple,
  equilibria::None,
  collision::None
>

Definition at line 713 of file advectionDiffusionDynamics.h.

◆ NoDynamics

template<typename T , typename DESCRIPTOR >

using olb::NoDynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  
  momenta::Tuple<
    momenta::OneDensity,
    momenta::ZeroMomentum,
    momenta::ZeroStress,
    momenta::DefineSeparately
  >,
  equilibria::None,
  collision::None
>

Dynamics for "dead cells" doing nothing.

Definition at line 48 of file dynamics.h.

◆ NoDynamicsWithZero

template<typename T , typename DESCRIPTOR >

using olb::NoDynamicsWithZero

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::None,
  equilibria::None,
  collision::None
>

Dynamics for "dead cells" doing nothing. Variant with density=0.

Definition at line 63 of file dynamics.h.

◆ P1Dynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::P1Tuple>

using olb::P1Dynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::P1,
  collision::P1
>

P1 dynamics.

Definition at line 334 of file dynamics.h.

◆ ParametersOfDynamicsD

template<typename DYNAMICS >

using olb::ParametersOfDynamicsD

Initial value:

 typename ParametersD<
  typename DYNAMICS::value_t,
  typename DYNAMICS::descriptor_t
>::template include<
  typename DYNAMICS::parameters
>

Deduce ParametersD of DYNAMICS w.r.t. its value type and descriptor.

Definition at line 190 of file fieldParametersD.h.

◆ ParametersOfOperatorD

template<typename T , typename DESCRIPTOR , typename OPERATOR >

using olb::ParametersOfOperatorD

Initial value:

 typename ParametersD<T,DESCRIPTOR>::template include<
  typename OPERATOR::parameters
>

Deduce ParametersD of OPERATOR w.r.t. T and DESCRIPTOR.

Definition at line 184 of file fieldParametersD.h.

◆ PartialBounceBack

template<typename T , typename DESCRIPTOR >

using olb::PartialBounceBack

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::Tuple<momenta::FixedDensity,momenta::ZeroMomentum,momenta::ZeroStress,momenta::DefineSeparately>,
  equilibria::FirstOrder,
  collision::PartialBounceBack
>

Corresponds to macro Robin boundary, micro Fresnel surface Motivated by Hiorth et al.

2008; doi 10.1002/fld.1822

Definition at line 316 of file dynamics.h.

◆ PhysR

template<typename T , unsigned D>

using olb::PhysR = Vector<T,D>

Type for spatial (physical) coordinates.

Definition at line 47 of file blockStructure.h.

◆ PoissonDynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::PoissonTuple>

using olb::PoissonDynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::ZerothOrder,
  collision::Poisson
>

Poisson dynamics.

Definition at line 325 of file dynamics.h.

◆ PorousBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PorousBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::Porous<MOMENTA>,
  equilibria::SecondOrder,
  collision::BGK
>

Porous BGK collision step.

Definition at line 36 of file porousBGKdynamics.h.

◆ PorousForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PorousForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T,DESCRIPTOR,
  momenta::Porous<MOMENTA>,
  equilibria::SecondOrder,
  collision::BGK,
  forcing::Guo<momenta::Forced>
>

BGK collision step for a porosity model.

Definition at line 37 of file porousForcedBGKDynamics.h.

◆ PorousParticleBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PorousParticleBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::PorousParticle<collision::BGK,false>,
  dynamics::ExposePorousParticleMomenta
>

Porous particle BGK collision for moving particles.

Definition at line 468 of file porousBGKdynamics.h.

◆ PorousParticleGuoForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PorousParticleGuoForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::Porous<MOMENTA>,
  equilibria::SecondOrder,
  collision::PorousParticle<collision::BGK,false>,
  forcing::Guo<momenta::Forced>
>

Guo forced BGK collision for moving porous media (HLBM approach)

Definition at line 55 of file porousForcedBGKDynamics.h.

◆ PorousParticleKupershtokhForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PorousParticleKupershtokhForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::BGK,
  forcing::PorousParticleKupershtokh<false>
>

Kuperstokh forced BGK collision for moving porous media (HLBM approach)

Definition at line 173 of file porousForcedBGKDynamics.h.

◆ PorousParticlePowerLawBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PorousParticlePowerLawBGKdynamics

Initial value:

 dynamics::Tuple<
    T, DESCRIPTOR,
    MOMENTA,
    equilibria::SecondOrder,
    powerlaw::OmegaFromCell<collision::PorousParticle<collision::BGK,false>,false>
    >

BGK collision using Power Law collision frequency.

Definition at line 36 of file porousPowerLawBGKdynamics.h.

◆ PorousParticlePowerLawForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PorousParticlePowerLawForcedBGKdynamics

Initial value:

 dynamics::Tuple<
    T, DESCRIPTOR,
    MOMENTA,
    equilibria::SecondOrder,
    powerlaw::OmegaFromCell<collision::BGK,false>,
    forcing::PorousParticleKupershtokh<false>
    >

BGK collision using Power Law collision frequency with Guo forcing.

Definition at line 45 of file porousPowerLawBGKdynamics.h.

◆ PorousParticlePowerLawHerschelBulkleyBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PorousParticlePowerLawHerschelBulkleyBGKdynamics

Initial value:

 dynamics::Tuple<
    T, DESCRIPTOR,
    MOMENTA,
    equilibria::SecondOrder,
    powerlaw::OmegaFromCell<collision::PorousParticle<collision::BGK,false>,true>
    >

BGK collision using Power Law (Herschel Bulkley) collision frequency.

Definition at line 55 of file porousPowerLawBGKdynamics.h.

◆ PorousParticlePowerLawHerschelBulkleyForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PorousParticlePowerLawHerschelBulkleyForcedBGKdynamics

Initial value:

 dynamics::Tuple<
    T, DESCRIPTOR,
    MOMENTA,
    equilibria::SecondOrder,
    powerlaw::OmegaFromCell<collision::BGK,true>,
    forcing::PorousParticleKupershtokh<false>
    >

BGK collision using Power Law (Herschel Bulkley) collision frequency with Guo forcing.

Definition at line 64 of file porousPowerLawBGKdynamics.h.

◆ PorousParticleShanChenForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PorousParticleShanChenForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::Porous<MOMENTA>,
  equilibria::SecondOrder,
  collision::PorousParticle<collision::BGK,false>,
  forcing::ShanChen
>

ShanChen forced BGK collision for moving porous media (HLBM approach)

Definition at line 75 of file porousForcedBGKDynamics.h.

◆ PostProcessor

template<typename T , typename DESCRIPTOR >

using olb::PostProcessor

Initial value:

 std::conditional_t<
  DESCRIPTOR::d == 2,
  PostProcessor2D<T,DESCRIPTOR>,
  PostProcessor3D<T,DESCRIPTOR>
>

Definition at line 67 of file aliases.h.

◆ PostProcessorGenerator

template<typename T , typename DESCRIPTOR >

using olb::PostProcessorGenerator

Initial value:

 std::conditional_t<
  DESCRIPTOR::d == 2,
  PostProcessorGenerator2D<T,DESCRIPTOR>,
  PostProcessorGenerator3D<T,DESCRIPTOR>
>

Definition at line 77 of file aliases.h.

◆ PowerLawBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PowerLawBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  powerlaw::OmegaFromCell<collision::BGK,false>
>

BGK collision using Power Law collision frequency.

Definition at line 168 of file powerLawBGKdynamics.h.

◆ PowerLawForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PowerLawForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  powerlaw::OmegaFromCell<collision::BGK,false>,
  forcing::Guo<momenta::ForcedWithStress>
>

BGK collision using Power Law collision frequency with Guo forcing.

Definition at line 177 of file powerLawBGKdynamics.h.

◆ PowerLawHerschelBulkleyBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PowerLawHerschelBulkleyBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  powerlaw::OmegaFromCell<collision::BGK,true>
>

BGK collision using Power Law (Herschel Bulkley) collision frequency.

Definition at line 187 of file powerLawBGKdynamics.h.

◆ PowerLawHerschelBulkleyForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PowerLawHerschelBulkleyForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  powerlaw::OmegaFromCell<collision::BGK,true>,
  forcing::Guo<momenta::ForcedWithStress>
>

BGK collision using Power Law (Herschel Bulkley) collision frequency with Guo forcing.

Definition at line 196 of file powerLawBGKdynamics.h.

◆ PSMBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::PSMBGKdynamics

Initial value:

 dynamics::Tuple<
  T,DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::PSM<collision::BGK>
>

Partially Saturated Method (PSM), see Krüger, Timm, et al.

The Lattice Boltzmann Method. Springer, 2017. (p.447-451)

Definition at line 535 of file porousBGKdynamics.h.

◆ RLBdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::RLBdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::RLB
>

Regularized BGK collision step.

This model is substantially more stable than plain BGK, and has roughly the same efficiency. However, it cuts out the modes at higher Knudsen numbers and can not be used in the regime of rarefied gases.

Definition at line 180 of file dynamics.h.

◆ ShearSmagorinskyBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ShearSmagorinskyBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::ShearSmagorinskyEffectiveOmega<collision::BGK>
>

Shear Smarorinsky BGK collision step.

Shown good results for wall-bounded flows Leveque et al.: Shear-Improved Smagorinsky Model for Large-Eddy Simulation of Wall-Bounded Turbulent Flows DOI: http://dx.doi.org/10.1017/S0022112006003429

Definition at line 83 of file smagorinskyBGKdynamics.h.

◆ ShearSmagorinskyForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::ShearSmagorinskyForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::ShearSmagorinskyEffectiveOmega<collision::BGK>,
  forcing::Guo<momenta::Forced>
>

Shear Smarorinsky BGK collision step with Guo forcing.

Definition at line 92 of file smagorinskyBGKdynamics.h.

◆ SmagorinskyBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmagorinskyBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::SmagorinskyEffectiveOmega<collision::BGK>
>

Smagorinsky BGK collision step.

Definition at line 39 of file smagorinskyBGKdynamics.h.

◆ SmagorinskyForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmagorinskyForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::SmagorinskyEffectiveOmega<collision::BGK>,
  forcing::Guo<momenta::ForcedWithStress>
>

Smagorinsky BGK collision step with Guo forcing.

Definition at line 48 of file smagorinskyBGKdynamics.h.

◆ SmagorinskyForcedMRTdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmagorinskyForcedMRTdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::SmagorinskyEffectiveOmega<collision::MRT>,
  forcing::LaddVerberg
>

Smagorinsky MRT collision step with Ladd-Verberg forcing.

Definition at line 47 of file smagorinskyMRTdynamics.h.

◆ SmagorinskyGuoZhaoBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmagorinskyGuoZhaoBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  guoZhao::GuoZhaoSecondOrder,
  collision::SmagorinskyEffectiveOmega<collision::BGK>,
  guoZhao::GuoZhaoForcing<momenta::GuoZhaoForcedWithStress>
>

Definition at line 199 of file guoZhaoDynamics.h.

◆ SmagorinskyLinearVelocityForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmagorinskyLinearVelocityForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::SmagorinskyEffectiveOmega<collision::BGK>,
  forcing::LinearVelocity
>

ForcedBGK collision step computing OMEGA locally using Smagorinsky LES model.

Definition at line 170 of file smagorinskyBGKdynamics.h.

◆ SmagorinskyMRTdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmagorinskyMRTdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::SmagorinskyEffectiveOmega<collision::MRT>
>

Smagorinsky MRT collision step.

Definition at line 38 of file smagorinskyMRTdynamics.h.

◆ SmagorinskyPorousParticleBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmagorinskyPorousParticleBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::SmagorinskyEffectiveOmega<collision::PorousParticle<collision::BGK>>
>

BGK collision step for a porosity model.

Definition at line 488 of file porousBGKdynamics.h.

◆ SmagorinskyPowerLawBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmagorinskyPowerLawBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  powerlaw::OmegaFromCell<collision::SmagorinskyEffectiveOmega<collision::BGK>>
>

Smagorinsky BGK collision using Power Law collision frequency.

Definition at line 206 of file powerLawBGKdynamics.h.

◆ SmagorinskyPowerLawForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmagorinskyPowerLawForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  powerlaw::OmegaFromCell<collision::SmagorinskyEffectiveOmega<collision::BGK>>,
  forcing::Guo<momenta::Forced>
>

Smagorinsky BGK collision using Power Law collision frequency and Guo forcing.

Definition at line 215 of file powerLawBGKdynamics.h.

◆ SmagorinskyPowerLawPorousParticleBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmagorinskyPowerLawPorousParticleBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  powerlaw::OmegaFromCell<collision::SmagorinskyEffectiveOmega<collision::PorousParticle<collision::BGK>>>
>

Smagorinsky BGK collision using Power Law collision frequency for porous particles.

Definition at line 225 of file powerLawBGKdynamics.h.

◆ SmallParticleBGKdymaics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SmallParticleBGKdymaics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::SmallParticle<collision::BGK>
>

BGK collision step for a small particles enabling two way coupling.

Definition at line 525 of file porousBGKdynamics.h.

◆ SmoothIndicatorF

template<typename T , typename S , unsigned D, bool PARTICLE = false>

using olb::SmoothIndicatorF

Initial value:

 std::conditional_t<
  D == 2,
  SmoothIndicatorF2D<T,T,PARTICLE>,
  SmoothIndicatorF3D<T,T,PARTICLE>
>

Definition at line 278 of file aliases.h.

◆ StaticPorousParticleBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::StaticPorousParticleBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::PorousParticle<collision::BGK,true>,
  dynamics::ExposePorousParticleMomenta
>

Porous particle BGK collision for static particles.

Definition at line 478 of file porousBGKdynamics.h.

◆ StaticPorousParticleGuoForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::StaticPorousParticleGuoForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::Porous<MOMENTA>,
  equilibria::SecondOrder,
  collision::PorousParticle<collision::BGK,true>,
  forcing::Guo<momenta::Forced>
>

Guo forced BGK static collision for moving porous media (HLBM approach)

Definition at line 65 of file porousForcedBGKDynamics.h.

◆ StaticPorousParticleKupershtokhForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::StaticPorousParticleKupershtokhForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::BGK,
  forcing::PorousParticleKupershtokh<true>
>

Kuperstokh forced BGK static collision for moving porous media (HLBM approach)

Definition at line 183 of file porousForcedBGKDynamics.h.

◆ StaticPorousParticleShanChenForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::StaticPorousParticleShanChenForcedBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  momenta::Porous<MOMENTA>,
  equilibria::SecondOrder,
  collision::PorousParticle<collision::BGK,true>,
  forcing::ShanChen
>

ShanChen forced BGK static collision for moving porous media (HLBM approach)

Definition at line 85 of file porousForcedBGKDynamics.h.

◆ SubgridParticleBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::SubgridParticleBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::SubgridParticle<collision::BGK>
>

Definition at line 497 of file porousBGKdynamics.h.

◆ SuperAbsoluteErrorL1Norm2D

template<typename T , typename W = T>

using olb::SuperAbsoluteErrorL1Norm2D = SuperAbsoluteErrorLpNorm2D<T,W,1>

Definition at line 83 of file superErrorNorm2D.h.

◆ SuperAbsoluteErrorL1Norm3D

template<typename T , typename W = T>

using olb::SuperAbsoluteErrorL1Norm3D = SuperAbsoluteErrorLpNorm3D<T,W,1>

Definition at line 83 of file superErrorNorm3D.h.

◆ SuperAbsoluteErrorL2Norm2D

template<typename T , typename W = T>

using olb::SuperAbsoluteErrorL2Norm2D = SuperAbsoluteErrorLpNorm2D<T,W,2>

Definition at line 86 of file superErrorNorm2D.h.

◆ SuperAbsoluteErrorL2Norm3D

template<typename T , typename W = T>

using olb::SuperAbsoluteErrorL2Norm3D = SuperAbsoluteErrorLpNorm3D<T,W,2>

Definition at line 86 of file superErrorNorm3D.h.

◆ SuperAbsoluteErrorLinfNorm2D

template<typename T , typename W = T>

using olb::SuperAbsoluteErrorLinfNorm2D = SuperAbsoluteErrorLpNorm2D<T,W,0>

Definition at line 89 of file superErrorNorm2D.h.

◆ SuperAbsoluteErrorLinfNorm3D

template<typename T , typename W = T>

using olb::SuperAbsoluteErrorLinfNorm3D = SuperAbsoluteErrorLpNorm3D<T,W,0>

Definition at line 89 of file superErrorNorm3D.h.

◆ SuperCalcDivision2D

template<typename T , typename W >

using olb::SuperCalcDivision2D = SuperCalcF2D<T,W,util::divides>

Division functor.

Definition at line 83 of file superCalcF2D.h.

◆ SuperCalcDivision3D

template<typename T , typename W = T>

using olb::SuperCalcDivision3D = SuperCalcF3D<T,W,util::divides>

Division functor.

Definition at line 86 of file superCalcF3D.h.

◆ SuperCalcMinus2D

template<typename T , typename W >

using olb::SuperCalcMinus2D = SuperCalcF2D<T,W,util::minus>

Subtraction functor (W==bool: Without)

Definition at line 75 of file superCalcF2D.h.

◆ SuperCalcMinus3D

template<typename T , typename W = T>

using olb::SuperCalcMinus3D = SuperCalcF3D<T,W,util::minus>

Subtraction functor (W==bool: Without)

Definition at line 78 of file superCalcF3D.h.

◆ SuperCalcMultiplication2D

template<typename T , typename W >

using olb::SuperCalcMultiplication2D = SuperCalcF2D<T,W,util::multiplies>

Multiplication functor (W==bool: Intersection)

Definition at line 79 of file superCalcF2D.h.

◆ SuperCalcMultiplication3D

template<typename T , typename W = T>

using olb::SuperCalcMultiplication3D = SuperCalcF3D<T,W,util::multiplies>

Multiplication functor (W==bool: Intersection)

Definition at line 82 of file superCalcF3D.h.

◆ SuperCalcPlus2D

template<typename T , typename W >

using olb::SuperCalcPlus2D = SuperCalcF2D<T,W,util::plus>

Addition functor (W==bool: Union)

Definition at line 71 of file superCalcF2D.h.

◆ SuperCalcPlus3D

template<typename T , typename W = T>

using olb::SuperCalcPlus3D = SuperCalcF3D<T,W,util::plus>

Addition functor (W==bool: Union)

Definition at line 74 of file superCalcF3D.h.

◆ SuperCalcPower2D

template<typename T , typename W = T>

using olb::SuperCalcPower2D = SuperCalcF2D<T,W,util::power>

Power functor.

Definition at line 87 of file superCalcF2D.h.

◆ SuperCalcPower3D

template<typename T , typename W = T>

using olb::SuperCalcPower3D = SuperCalcF3D<T,W,util::power>

Power functor.

Definition at line 90 of file superCalcF3D.h.

◆ SuperF

template<unsigned D, typename T , typename U = T>

using olb::SuperF

Initial value:

 std::conditional_t<
  D == 2,
  SuperF2D<T,U>,
  SuperF3D<T,U>
>

Definition at line 198 of file aliases.h.

◆ SuperField

template<typename T , typename DESCRIPTOR , typename FIELD >

using olb::SuperField

Initial value:

 std::conditional_t<
  DESCRIPTOR::d == 2,
  SuperField2D<T,DESCRIPTOR,FIELD>,
  SuperField3D<T,DESCRIPTOR,FIELD>
>

Definition at line 318 of file aliases.h.

◆ SuperGeometryStatistics

template<typename T , unsigned DIM>

using olb::SuperGeometryStatistics

Initial value:

 std::conditional_t<
                     DIM == 2,
                     SuperGeometryStatistics2D<T>,
                     SuperGeometryStatistics3D<T>
                     >

Definition at line 88 of file aliases.h.

◆ SuperIndicatorBoundaryNeighbor

template<typename T , unsigned D>

using olb::SuperIndicatorBoundaryNeighbor

Initial value:

 std::conditional_t<
  D == 2,
  SuperIndicatorBoundaryNeighbor2D<T>,
  SuperIndicatorBoundaryNeighbor3D<T>
>

Definition at line 308 of file aliases.h.

◆ SuperIndicatorF

template<typename T , unsigned D>

using olb::SuperIndicatorF

Initial value:

 std::conditional_t<
  D == 2,
  SuperIndicatorF2D<T>,
  SuperIndicatorF3D<T>
>

Definition at line 208 of file aliases.h.

◆ SuperIndicatorFfromIndicatorF

template<typename T , unsigned D>

using olb::SuperIndicatorFfromIndicatorF

Initial value:

 std::conditional_t<
  D == 2,
  SuperIndicatorFfromIndicatorF2D<T>,
  SuperIndicatorFfromIndicatorF3D<T>
>

Definition at line 288 of file aliases.h.

◆ SuperIndicatorMaterial

template<typename T , unsigned D>

using olb::SuperIndicatorMaterial

Initial value:

 std::conditional_t<
  D == 2,
  SuperIndicatorMaterial2D<T>,
  SuperIndicatorMaterial3D<T>
>

Definition at line 298 of file aliases.h.

◆ SuperL1Norm2D

template<typename T , typename W = T>

using olb::SuperL1Norm2D = SuperLpNorm2D<T,W,1>

Functor that returns the L1 norm over omega of the the euklid norm of the input functor.

Definition at line 94 of file superLpNorm2D.h.

◆ SuperL1Norm3D

template<typename T , typename W = T>

using olb::SuperL1Norm3D = SuperLpNorm3D<T,W,1>

Functor that returns the L1 norm over omega of the the euklid norm of the input functor.

Definition at line 94 of file superLpNorm3D.h.

◆ SuperL2Norm2D

template<typename T , typename W = T>

using olb::SuperL2Norm2D = SuperLpNorm2D<T,W,2>

Functor that returns the L2 norm over omega of the the euklid norm of the input functor.

Definition at line 98 of file superLpNorm2D.h.

◆ SuperL2Norm3D

template<typename T , typename W = T>

using olb::SuperL2Norm3D = SuperLpNorm3D<T,W,2>

Functor that returns the L2 norm over omega of the the euklid norm of the input functor.

Definition at line 98 of file superLpNorm3D.h.

◆ SuperLatticeCuboid

template<typename T , typename DESCRIPTOR >

using olb::SuperLatticeCuboid

Initial value:

 std::conditional_t<
                     DESCRIPTOR::d == 2,
                     SuperLatticeCuboid2D<T,DESCRIPTOR>,
                     SuperLatticeCuboid3D<T,DESCRIPTOR>
                     >

Definition at line 128 of file aliases.h.

◆ SuperLatticeF

template<typename T , typename DESCRIPTOR >

using olb::SuperLatticeF

Initial value:

 std::conditional_t<
                     DESCRIPTOR::d == 2,
                     SuperLatticeF2D<T,DESCRIPTOR>,
                     SuperLatticeF3D<T,DESCRIPTOR>
                     >

Definition at line 148 of file aliases.h.

◆ SuperLatticeGeometry

template<typename T , typename DESCRIPTOR >

using olb::SuperLatticeGeometry

Initial value:

 std::conditional_t<
                     DESCRIPTOR::d == 2,
                     SuperLatticeGeometry2D<T,DESCRIPTOR>,
                     SuperLatticeGeometry3D<T,DESCRIPTOR>
                     >

Definition at line 118 of file aliases.h.

◆ SuperLatticeInterpPhysVelocity

template<typename T , typename DESCRIPTOR >

using olb::SuperLatticeInterpPhysVelocity

Initial value:

 std::conditional_t<
  DESCRIPTOR::d == 2,
  SuperLatticeInterpPhysVelocity2D<T,DESCRIPTOR>,
  SuperLatticeInterpPhysVelocity3D<T,DESCRIPTOR>
>

Definition at line 349 of file aliases.h.

◆ SuperLatticeMomentumExchangeForce

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

using olb::SuperLatticeMomentumExchangeForce

Initial value:

 
  SuperLatticeParticleForce<T,DESCRIPTOR,PARTICLETYPE,
    BlockLatticeMomentumExchangeForce<T,DESCRIPTOR,PARTICLETYPE>>

Definition at line 108 of file latticeMomentumExchangeForce.h.

◆ SuperLatticePhysF

template<typename T , typename DESCRIPTOR >

using olb::SuperLatticePhysF

Initial value:

 std::conditional_t<
  DESCRIPTOR::d == 2,
  SuperLatticePhysF2D<T,DESCRIPTOR>,
  SuperLatticePhysF3D<T,DESCRIPTOR>
>

Definition at line 329 of file aliases.h.

◆ SuperLatticeRank

template<typename T , typename DESCRIPTOR >

using olb::SuperLatticeRank

Initial value:

 std::conditional_t<
                     DESCRIPTOR::d == 2,
                     SuperLatticeRank2D<T,DESCRIPTOR>,
                     SuperLatticeRank3D<T,DESCRIPTOR>
                     >

Definition at line 138 of file aliases.h.

◆ SuperLatticeStokesDragForce

template<typename T , typename DESCRIPTOR , typename PARTICLETYPE >

using olb::SuperLatticeStokesDragForce

Initial value:

 
  SuperLatticeParticleForce<T,DESCRIPTOR,PARTICLETYPE,
    BlockLatticeStokesDragForce<T,DESCRIPTOR,PARTICLETYPE>>

Definition at line 115 of file latticeMomentumExchangeForce.h.

◆ SuperLinfNorm2D

template<typename T , typename W = T>

using olb::SuperLinfNorm2D = SuperLpNorm2D<T,W,0>

Functor that returns the Linf norm over omega of the the euklid norm of the input functor.

Definition at line 102 of file superLpNorm2D.h.

◆ SuperLinfNorm3D

template<typename T , typename W = T>

using olb::SuperLinfNorm3D = SuperLpNorm3D<T,W,0>

Functor that returns the Linf norm over omega of the the euklid norm of the input functor.

Definition at line 102 of file superLpNorm3D.h.

◆ SuperRelativeErrorL1Norm2D

template<typename T , typename W = T>

using olb::SuperRelativeErrorL1Norm2D = SuperRelativeErrorLpNorm2D<T,W,1>

Definition at line 53 of file superErrorNorm2D.h.

◆ SuperRelativeErrorL1Norm3D

template<typename T , typename W = T>

using olb::SuperRelativeErrorL1Norm3D = SuperRelativeErrorLpNorm3D<T,W,1>

Definition at line 53 of file superErrorNorm3D.h.

◆ SuperRelativeErrorL2Norm2D

template<typename T , typename W = T>

using olb::SuperRelativeErrorL2Norm2D = SuperRelativeErrorLpNorm2D<T,W,2>

Definition at line 56 of file superErrorNorm2D.h.

◆ SuperRelativeErrorL2Norm3D

template<typename T , typename W = T>

using olb::SuperRelativeErrorL2Norm3D = SuperRelativeErrorLpNorm3D<T,W,2>

Definition at line 56 of file superErrorNorm3D.h.

◆ SuperRelativeErrorLinfNorm2D

template<typename T , typename W = T>

using olb::SuperRelativeErrorLinfNorm2D = SuperRelativeErrorLpNorm2D<T,W,0>

Definition at line 59 of file superErrorNorm2D.h.

◆ SuperRelativeErrorLinfNorm3D

template<typename T , typename W = T>

using olb::SuperRelativeErrorLinfNorm3D = SuperRelativeErrorLpNorm3D<T,W,0>

Definition at line 59 of file superErrorNorm3D.h.

◆ SuperVTMwriter

template<typename T , unsigned DIM, typename OUT_T = float, typename W = T>

using olb::SuperVTMwriter

Initial value:

 std::conditional_t<
                     DIM == 2,
                     SuperVTMwriter2D<T,OUT_T,W>,
                     SuperVTMwriter3D<T,OUT_T,W>
                     >

Definition at line 108 of file aliases.h.

◆ TRTdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::TRTdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::TRT
>

TRT collision step.

Definition at line 239 of file dynamics.h.

◆ VTIwriter

template<typename T , typename DESCRIPTOR >

using olb::VTIwriter

Initial value:

 VTKwriter<
  T,
  SuperF3D<T,T>,
  VTI
>

Definition at line 157 of file vtkWriter.h.

◆ VTUwriter

template<typename T , typename DESCRIPTOR , bool parallel = true>

using olb::VTUwriter

Initial value:

 VTKwriter<
  T,
  typename std::conditional_t<
    parallel,
    SuperContainerF<T,DESCRIPTOR,DynamicFieldGroupsD<T,typename DESCRIPTOR::fields_t>,T>,
    ContainerF<T,DESCRIPTOR,DynamicFieldGroupsD<T,typename DESCRIPTOR::fields_t>,T>
  >,
  VTU
>

Definition at line 145 of file vtkWriter.h.

◆ WALEBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>

using olb::WALEBGKdynamics

Initial value:

 dynamics::Tuple<
  T, DESCRIPTOR,
  MOMENTA,
  equilibria::SecondOrder,
  collision::WaleEffectiveOmega<collision::BGK>
>

WALE LES BGK collision step.

Definition at line 152 of file smagorinskyBGKdynamics.h.

Enumeration Type Documentation

◆ BlockDataReductionMode

enum class olb::BlockDataReductionMode

strong

Mode of reducing block data from given, possibly higher dimensional data.

Required for optimizing block reduction functors such as BlockReduction3D2D if hyperplane is axis-aligned i.e. trivially discretizable.

Enumerator
Analytical	Interpolate block data at exact physical locations.
Discrete	Read block data from discrete lattice locations.

Definition at line 35 of file blockDataReductionMode.h.

                                  {
  Analytical,
  Discrete
};

◆ BlockDataSyncMode

enum class olb::BlockDataSyncMode

strong

Mode of synchronizing functor block data between processes.

Required for optimizing functor operations to various usage patterns.

i.e. the convention is for the full domain to be available on every rank but this is not ideal in most usage scenarios of reduction functors.

e.g. the primary user of BlockReduction3D2D, BlockGifWriter, only requires full data to be available on the rank where its io is performed (rank 0).

SuperLatticeFlux3D only requires rank-local data to be available. Any further synchronization would potentially impact performance in this critical area.

Enumerator
ReduceAndBcast	default behavior, full block data available on all ranks after update
ReduceOnly	optimize for usage in e.g. BlockGifWriter, full data only available on main rank
None	optimize for usage in e.g. SuperLatticeFlux3D, only rank-local data available

Definition at line 43 of file blockDataSyncMode.h.

                             {
  ReduceAndBcast,
  ReduceOnly,
  None
};

◆ CollisionDispatchStrategy

enum struct olb::CollisionDispatchStrategy

strong

Collision dispatch strategy.

Enumerator
Dominant	Apply dominant dynamics using mask and fallback to virtual dispatch for others.
Individual	Apply all dynamics individually (async for Platform::GPU_CUDA)

Definition at line 88 of file operator.h.

                                      {
  Dominant,
  Individual
};

◆ OperatorScope

enum struct olb::OperatorScope

strong

Block-wide operator application scopes.

Declares how the actual OPERATOR::apply template wants to be called.

Enumerator
PerCell	Per-cell application, i.e. OPERATOR::apply is passed a CELL concept implementation.
PerBlock	Per-block application, i.e. OPERATOR::apply is passed a ConcreteBlockLattice.
PerCellWithParameters	Per-cell application with parameters, i.e. OPERATOR::apply is passed a CELL concept implementation and parameters.

Definition at line 54 of file operator.h.

                          {
  PerCell,
  PerBlock,
  PerCellWithParameters,
};

◆ Platform

enum struct olb::Platform : std::uint8_t

strong

OpenLB execution targets.

Enumerator
CPU_SISD
CPU_SIMD	Basic scalar CPU.
GPU_CUDA	Vector CPU (AVX2 / AVX-512 collision)

Definition at line 36 of file platform.h.

                     : std::uint8_t {
  CPU_SISD, 
  CPU_SIMD, 
  GPU_CUDA, 
};

◆ ProcessingContext

enum struct olb::ProcessingContext

strong

OpenLB processing contexts.

Currently of no relevance for CPU_SISD and CPU_SIMD target platforms

Used to control synchronization between mirrored device and host data for non-host processed block lattices.

Preliminary for first GPU release.

Enumerator

Evaluation

Simulation

Data available on host for e.g. functor evaluation.

Data available on device for evolving the simulation

Definition at line 55 of file platform.h.

                              {
  Evaluation, 
  Simulation  
};

◆ RoundingMode

enum class olb::RoundingMode

strong

Mode of how to decide Quality of Grid.

Enumerator
None	No rounding.
NearestInteger	Rounds to nearest Integer.
Floor	Rounds up.
Ceil	Rounds down.

Definition at line 30 of file roundingMode.h.

                        {
  None,
  NearestInteger,
  Floor,
  Ceil,
};

◆ vtkType

enum olb::vtkType

Enumerator
VTI
VTU
VTP

Definition at line 52 of file vtkWriter.h.

52{ VTI, VTU, VTP };

olb::VTP

@ VTP

Definition vtkWriter.h:52

Function Documentation

◆ abs() [1/2]

template<typename T , unsigned D, typename IMPL >

constexpr Vector< T, D > olb::abs ( const ScalarVector< T, D, IMPL > & a )

constexpr

Definition at line 254 of file vector.h.

{
  using namespace util;
  return Vector<T,D>([&a](unsigned iDim) -> T {
    return abs(a[iDim]);
  });
}

References abs().

Here is the call graph for this function:

◆ abs() [2/2]

template<typename T >

std::enable_if_t< std::is_arithmetic< T >::type::value, T > olb::abs ( T x )

Definition at line 396 of file util.h.

{
  return util::fabs(x);
}

References olb::util::fabs().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addPoints2CommBC() [1/2]

template<typename T , typename DESCRIPTOR >

void olb::addPoints2CommBC	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator,
		int	_overlap )

Adds needed Cells to the Communicator _commBC in SuperLattice.

Definition at line 60 of file setBoundary2D.h.

{
  /*  local boundaries: _overlap = 0;
   *  interp boundaries: _overlap = 1;
   *  bouzidi boundaries: _overlap = 1;
   *  extField boundaries: _overlap = 1;
   *  advectionDiffusion boundaries: _overlap = 1;
   */
 
  if (_overlap == 0) {
    return;
  }
 
  auto& communicator = sLattice.getCommunicator(stage::PostStream());
  communicator.template requestField<descriptors::POPULATION>();
 
  SuperGeometry<T,2>& superGeometry = indicator->getSuperGeometry();
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    const int nX = superGeometry.getBlockGeometry(iCloc).getNx();
    const int nY = superGeometry.getBlockGeometry(iCloc).getNy();
 
    for (int iX = -_overlap; iX < nX+_overlap; ++iX) {
      for (int iY = -_overlap; iY < nY+_overlap; ++iY) {
        if (iX < 0 || iX > nX - 1 ||
            iY < 0 || iY > nY - 1 ) { // if within overlap
          if (superGeometry.getBlockGeometry(iCloc).getMaterial(iX,iY) != 0) {
            bool found = false;
            for (int iXo = -_overlap; iXo <= _overlap && !found; ++iXo) {
              for (int iYo = -_overlap; iYo <= _overlap && !found; ++iYo) {
                const int nextX = iXo + iX;
                const int nextY = iYo + iY;
                if (indicator->getBlockIndicatorF(iCloc)(nextX, nextY)) {
                  communicator.requestCell({iCloc, iX, iY});
                  found = true;
                }
              }
            }
          }
        }
      }
    }
  }
 
  communicator.exchangeRequests();
}

References olb::SuperGeometry< T, D >::getBlockGeometry(), olb::SuperLattice< T, DESCRIPTOR >::getCommunicator(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ addPoints2CommBC() [2/2]

template<typename T , typename DESCRIPTOR >

void olb::addPoints2CommBC	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator,
		int	_overlap )

Adds needed Cells to the Communicator _commBC in SuperLattice.

Definition at line 57 of file setBoundary3D.h.

{
  /*  local boundaries: _overlap = 0;
   *  interp boundaries: _overlap = 1;
   *  bouzidi boundaries: _overlap = 1;
   *  extField boundaries: _overlap = 1;
   *  advectionDiffusion boundaries: _overlap = 1;
   */
 
  if (_overlap == 0) {
    return;
  }
 
  auto& communicator = sLattice.getCommunicator(stage::PostStream());
  communicator.template requestField<descriptors::POPULATION>();
 
  SuperGeometry<T,3>& superGeometry = indicator->getSuperGeometry();
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    const int nX = superGeometry.getBlockGeometry(iCloc).getNx();
    const int nY = superGeometry.getBlockGeometry(iCloc).getNy();
    const int nZ = superGeometry.getBlockGeometry(iCloc).getNz();
 
    for (int iX = -_overlap; iX < nX+_overlap; ++iX) {
      for (int iY = -_overlap; iY < nY+_overlap; ++iY) {
        for (int iZ = -_overlap; iZ < nZ+_overlap; ++iZ) {
          if (iX < 0 || iX > nX - 1 ||
              iY < 0 || iY > nY - 1 ||
              iZ < 0 || iZ > nZ - 1 ) { // if within overlap
            if (superGeometry.getBlockGeometry(iCloc).getMaterial(iX,iY,iZ) != 0) {
              bool found = false;
              for (int iXo = -_overlap; iXo <= _overlap && !found; ++iXo) {
                for (int iYo = -_overlap; iYo <= _overlap && !found; ++iYo) {
                  for (int iZo = -_overlap; iZo <= _overlap && !found; ++iZo) {
                    const int nextX = iXo + iX;
                    const int nextY = iYo + iY;
                    const int nextZ = iZo + iZ;
                    if (indicator->getBlockIndicatorF(iCloc)(nextX, nextY, nextZ)
                        && nextX >= -_overlap && nextX < nX+_overlap
                        && nextY >= -_overlap && nextY < nY+_overlap
                        && nextZ >= -_overlap && nextZ < nZ+_overlap) {
                      communicator.requestCell({iCloc, iX, iY, iZ});
                      found = true;
                    }
                  }
                }
              }
            }
          }
        }
      }
    }
  }
 
  communicator.exchangeRequests();
}

References olb::SuperGeometry< T, D >::getBlockGeometry(), olb::SuperLattice< T, DESCRIPTOR >::getCommunicator(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ AnalyticalConcatenation() [1/4]

template<unsigned D, typename T , typename S , typename G >

olb::AnalyticalConcatenation	(	AnalyticalF< D, T, S > &	,
		G	g,
		unsigned	_ = 1 ) -> AnalyticalConcatenation< D, std::remove_pointer_t< decltype(g(std::conditional_t< std::is_invocable_v< G, T >, T, T * >{}))>, T, S, std::is_invocable_v< G, T >, std::is_pointer_v< decltype(g(std::conditional_t< std::is_invocable_v< G, T >, T, T * >{}))> >

◆ AnalyticalConcatenation() [2/4]

template<unsigned D, typename T , typename S , typename U = T>

olb::AnalyticalConcatenation	(	AnalyticalF< D, T, S > &	,
		U(*)(T)	g ) -> AnalyticalConcatenation< D, U, T, S, true, false >

◆ AnalyticalConcatenation() [3/4]

template<unsigned D, typename wrapped_U , typename T , typename S >

olb::AnalyticalConcatenation	(	AnalyticalF< D, T, S > &	,
		wrapped_U(const T *)	,
		unsigned	) -> AnalyticalConcatenation< D, std::remove_pointer_t< wrapped_U >, T, S, false, std::is_pointer_v< wrapped_U > >

◆ AnalyticalConcatenation() [4/4]

template<unsigned D, typename wrapped_U , typename T , typename S >

olb::AnalyticalConcatenation	(	AnalyticalF< D, T, S > &	,
		wrapped_U(T *)	,
		unsigned	) -> AnalyticalConcatenation< D, std::remove_pointer_t< wrapped_U >, T, S, false, std::is_pointer_v< wrapped_U > >

◆ AnalyticalDerivativeAD()

template<class F >

olb::AnalyticalDerivativeAD ( const F & ) -> AnalyticalDerivativeAD< F, typename F::targetType, typename F::sourceType, F::dim >

◆ boolToStr()

template<typename O >

std::string olb::boolToStr ( O input )

Create readable bool string.

motivated by inconsistencies during ostream operator <<

Definition at line 122 of file printUtils.h.

                              {
  //If scalar
  if constexpr (std::is_arithmetic<O>::value) {
    if (input){
      return "true";
    } else {
      return "false";
    }
  //If e.g. Vector
  } else {
    std::stringstream stream;
    stream << "[";
    for(unsigned iDim=0; iDim<O::d; ++iDim){
      stream << (iDim==0 ? "" : ",");
      if (input[iDim]){
        stream << "true";
      } else {
        stream << "false";
      }
    }
    stream << "]";
    return stream.str();
  }
}

◆ buffer2serializer()

void olb::buffer2serializer	(	Serializer &	serializer,
		const std::uint8_t *	buffer )

processes a buffer to a serializer

Definition at line 108 of file serializerIO.hh.

{
  serializer.resetCounter();
  std::size_t blockSize;
  bool* dataBuffer = nullptr;
  while (dataBuffer = serializer.getNextBlock(blockSize, true), dataBuffer != nullptr) {
    std::memcpy(dataBuffer, buffer, blockSize);
    buffer += blockSize;
  }
  serializer.resetCounter();
}

References olb::Serializer::getNextBlock(), and olb::Serializer::resetCounter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ callUsingConcretePlatform() [1/2]

template<typename F >

void olb::callUsingConcretePlatform	(	Platform	platform,
		F	f )

inline

Definition at line 109 of file platform.h.

{
  switch (platform) {
#ifdef PLATFORM_CPU_SISD
  case Platform::CPU_SISD:
    f(meta::value<Platform::CPU_SISD>{});
    break;
#endif
#ifdef PLATFORM_CPU_SIMD
  case Platform::CPU_SIMD:
    f(meta::value<Platform::CPU_SIMD>{});
    break;
#endif
#ifdef PLATFORM_GPU_CUDA
  case Platform::GPU_CUDA:
    f(meta::value<Platform::GPU_CUDA>{});
    break;
#endif
  default:
    throw std::invalid_argument("Invalid PLATFORM");
  }
}

References CPU_SIMD, CPU_SISD, and GPU_CUDA.

◆ callUsingConcretePlatform() [2/2]

template<typename CONCRETIZABLE , typename F >

auto olb::callUsingConcretePlatform	(	Platform	platform,
		typename CONCRETIZABLE::base_t *	ptr,
		F	f )

inline

Dispatcher for concrete platform access.

See e.g. ConcretizableBlockLattice usage in BlockLattice::getField

Definition at line 88 of file platform.h.

{
  switch (platform) {
#ifdef PLATFORM_CPU_SISD
  case Platform::CPU_SISD:
    return f(static_cast<typename CONCRETIZABLE::template type<Platform::CPU_SISD>*>(ptr));
#endif
#ifdef PLATFORM_CPU_SIMD
  case Platform::CPU_SIMD:
    return f(static_cast<typename CONCRETIZABLE::template type<Platform::CPU_SIMD>*>(ptr));
#endif
#ifdef PLATFORM_GPU_CUDA
  case Platform::GPU_CUDA:
    return f(static_cast<typename CONCRETIZABLE::template type<Platform::GPU_CUDA>*>(ptr));
#endif
  default:
    throw std::invalid_argument("Invalid PLATFORM");
  }
}

References CPU_SIMD, CPU_SISD, and GPU_CUDA.

Here is the caller graph for this function:

◆ checkCuboidNeighbourhoodConsistency()

bool olb::checkCuboidNeighbourhoodConsistency	(	std::map< int, std::vector< int > > &	neighbourhood,
		bool	correct = false,
		bool	verbose = false )

Consistency check for neighbour retrieval.

workaround for issue #319

Definition at line 312 of file cuboidGeometry3D.h.

{
  bool consistent = true;
  for ( auto cuboidNeighbourPair : neighbourhood){
    //Retrieve iC and neighbours
    int iC = cuboidNeighbourPair.first;
    std::vector<int>& neighbours = cuboidNeighbourPair.second;
    //Loop over neighbours
    for (int iCN : neighbours){
      //Retreive neighbour's neighbours
      std::vector<int>& neighboursNeighbours = neighbourhood[iCN];
      bool iCfound = false;
      //Loop over neighbour's neighbours
      for (int iCNN : neighboursNeighbours ){
        if (iCNN == iC){
          iCfound=true;
          break;
        }
      }
      if (!iCfound){
        //Set consistency boolean to false
        consistent = false;
        //Output, if desired
        if (verbose){
          std::cout << "iC " << iC << " not found in list of neighbour iC "
                             << iCN << std::endl;
        }
        //Correct, if desired
        if (correct){
          neighbourhood[iCN].push_back(iC);
        }
      }
    }
  }
  //Return whether consistent
  return consistent;
}

Here is the caller graph for this function:

◆ checkPlatform()

template<Platform PLATFORM>

void olb::checkPlatform ( )

Verifies requirements for using PLATFORM.

◆ checkPlatform< Platform::GPU_CUDA >() [1/2]

template<>

void olb::checkPlatform< Platform::GPU_CUDA > ( )

Verifies availability of CUDA device and MPI support.

Definition at line 46 of file communicator.hh.

{
  OstreamManager clout(std::cout, "GPU_CUDA");
 
  int nDevices{};
  cudaGetDeviceCount(&nDevices);
 
  clout.setMultiOutput(true);
  if (nDevices < 1) {
    clout << "No CUDA device found" << std::endl;
  } else if (nDevices > 1) {
    clout << "Found " << nDevices << " CUDA devices but only one can be used per MPI process." << std::endl;
  }
#ifdef OLB_DEBUG
  for (int deviceI=0; deviceI < nDevices; ++deviceI) {
    cudaDeviceProp deviceProp;
    cudaGetDeviceProperties(&deviceProp, deviceI);
    clout << deviceProp.name << " visible" << std::endl;
  }
#endif
  clout.setMultiOutput(false);
 
#ifdef PARALLEL_MODE_MPI
#if defined(MPIX_CUDA_AWARE_SUPPORT) && MPIX_CUDA_AWARE_SUPPORT
  if (!MPIX_Query_cuda_support()) {
    clout << "The used MPI Library is not CUDA-aware. Multi-GPU execution will fail." << std::endl;
  }
#endif
#if defined(MPIX_CUDA_AWARE_SUPPORT) && !MPIX_CUDA_AWARE_SUPPORT
  clout << "The used MPI Library is not CUDA-aware. Multi-GPU execution will fail." << std::endl;
#endif
#if !defined(MPIX_CUDA_AWARE_SUPPORT)
  clout << "Unable to check for CUDA-aware MPI support. Multi-GPU execution may fail." << std::endl;
#endif
#endif // PARALLEL_MODE_MPI
}

References olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ checkPlatform< Platform::GPU_CUDA >() [2/2]

template<>

void olb::checkPlatform< Platform::GPU_CUDA > ( )

Verifies availability of CUDA device and MPI support.

Definition at line 46 of file communicator.hh.

{
  OstreamManager clout(std::cout, "GPU_CUDA");
 
  int nDevices{};
  cudaGetDeviceCount(&nDevices);
 
  clout.setMultiOutput(true);
  if (nDevices < 1) {
    clout << "No CUDA device found" << std::endl;
  } else if (nDevices > 1) {
    clout << "Found " << nDevices << " CUDA devices but only one can be used per MPI process." << std::endl;
  }
#ifdef OLB_DEBUG
  for (int deviceI=0; deviceI < nDevices; ++deviceI) {
    cudaDeviceProp deviceProp;
    cudaGetDeviceProperties(&deviceProp, deviceI);
    clout << deviceProp.name << " visible" << std::endl;
  }
#endif
  clout.setMultiOutput(false);
 
#ifdef PARALLEL_MODE_MPI
#if defined(MPIX_CUDA_AWARE_SUPPORT) && MPIX_CUDA_AWARE_SUPPORT
  if (!MPIX_Query_cuda_support()) {
    clout << "The used MPI Library is not CUDA-aware. Multi-GPU execution will fail." << std::endl;
  }
#endif
#if defined(MPIX_CUDA_AWARE_SUPPORT) && !MPIX_CUDA_AWARE_SUPPORT
  clout << "The used MPI Library is not CUDA-aware. Multi-GPU execution will fail." << std::endl;
#endif
#if !defined(MPIX_CUDA_AWARE_SUPPORT)
  clout << "Unable to check for CUDA-aware MPI support. Multi-GPU execution may fail." << std::endl;
#endif
#endif // PARALLEL_MODE_MPI
}

References olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ CLIreader::getValueOrFallback< std::string >()

template<>

std::string olb::CLIreader::getValueOrFallback< std::string >	(	const std::string &	name,
		std::string	fallback ) const

Definition at line 77 of file cliReader.h.

                                                   {
  if (contains(name)) {
    return operator[](name);
  } else {
    return fallback;
  }
}

◆ closeToZero()

template<typename T , unsigned D, typename IMPL >

bool olb::closeToZero ( const ScalarVector< T, D, IMPL > & a )

Returns true iff all components are within floating point error distance of 0.

Definition at line 75 of file scalarVector.h.

{
  const T eps = std::numeric_limits<T>::epsilon();
  for (unsigned iDim=0; iDim < D; ++iDim) {
    if (util::fabs(a[iDim]) > eps) {
      return false;
    }
  }
  return true;
}

References olb::util::fabs().

Here is the call graph for this function:

◆ computeAnisotropyMatrix()

template<typename DESCRIPTOR >

void olb::computeAnisotropyMatrix	(	double const	stepsize,
		double const	anisotropyFactor,
		double	solution[(DESCRIPTOR::q-1) *((DESCRIPTOR::q-1)+1)/2],
		std::array< std::array< double, DESCRIPTOR::q-1 >, DESCRIPTOR::q-1 > &	phi,
		int const	breakAfter = -1 )

Template Parameters

DESCRIPTOR	a lattice stencil
q	number of lattice stencils MINUS one, 0th direction not needed

Parameters

stepsize	choose precision
anisotropyFactor	also known as g
solution	for debugging
phi	is anisotropy matrix(sym), element [i][j] probability of scattering from i into j (direction)
breakAfter	to limit endless iteration for testing

Definition at line 132 of file anisoDiscr.h.

{
  using namespace descriptors;
  if ( !DESCRIPTOR::template provides<descriptors::tag::RTLBM>() ) {
    std::cout << "Warning: Compute anisotropy matrix for wrong latice stencil!" << std::endl;
    std::cout << "Weight for direction 0 is required to be 0." << std::endl;
    return;
  }
 
  OstreamManager clout( std::cout, "AnisotropyMatrix" );
  clout << "Call AnistorpiyMatrix()" << std::endl;
#ifdef FEATURE_OPENBLAS
  clout << "Compute anisotropy matrix ..." << std::endl;
  typedef DESCRIPTOR L;
  int const q = L::q-1;
  int const mm = 2*q;
  int const nn = (q+1)*q/2;
 
  // qxq matrix 0th row and 0th column are empty
  std::array<std::array<double,q>,q> angleProb;
  double dotProduct;
  double normI;
  double normJ;
  for (int iPop=0; iPop<q; iPop++) {
    for (int jPop=0; jPop<q; jPop++) {
      // shift by 1 due to notation in DESCRIPTOR/DESCRIPTOR
      // exclude 0th direction
      dotProduct = c<L>(iPop+1)*c<L>(jPop+1);
      normI = util::sqrt( c<L>(iPop+1)*c<L>(iPop+1) );
      normJ = util::sqrt( c<L>(jPop+1)*c<L>(jPop+1) );
      angleProb[iPop][jPop] = dotProduct / (normI*normJ);
    }
  }
 
  for (int i=0; i<q; i++) {
    for (int j=0; j<q; j++) {
      phi[i][j]=1.0;
    }
  }
 
  for ( int i = 0; i < nn; i++ ) {
    solution[i] = 0;
  };
 
  int iter;
  double U[mm][nn];
  double U_array[nn*mm];
  std::vector<double> anisoIterVector = linespace( stepsize, 0, anisotropyFactor );
 
  // additional condition only for unit testing
  size_t index = 0;
  for ( ; index < anisoIterVector.size() && index != (std::size_t)(breakAfter); index++) {
    // wipe matrices and vectors
    for (int m = 0; m < mm; m++) {
      for (int n = 0; n < nn; n++) {
        U[m][n] = 0;
      }
    }
 
    // compute matrix U, iter handels symmetry
    iter = 0;
    for (int m=0; m<q; m++) {
      for (int n=m; n<q; n++) {
        U[m][iter]   = t<double,L>(m+1)*phi[n][m];
        U[n][iter]   = t<double,L>(n+1)*phi[m][n];
        U[m+q][iter] = t<double,L>(m+1)*phi[n][m]*angleProb[n][m];
        U[n+q][iter] = t<double,L>(n+1)*phi[m][n]*angleProb[m][n];
        iter++;
      }
    }
 
    double sum1;
    double sum2;
    // compute vector b
    for (int n=0; n<q; n++) {
      // get sum
      sum1 = 0;
      sum2 = 0;
      for (int k=0; k<q; k++) {
        sum1 += t<double,L>(k+1)*phi[k][n];
        sum2 += t<double,L>(k+1)*phi[k][n]*angleProb[k][n];
      }
      solution[n] = 1 - sum1;
      solution[q+n] = anisoIterVector[index] - sum2;
    }
 
    // transform 2d array to 1d array, column major
    for ( int n = 0; n < nn; ++n) {
      for ( int m = 0; m < mm; ++m ) {
        U_array[n*mm +m] = U[m][n];
      }
    }
 
    //util::print(b, nn, "b");
 
    // solve Ax = QRx = R'Q'x = b
    // equiv x = Q*R'\x
    LAPACKE_dgels( LAPACK_COL_MAJOR, 'N', mm,
                   nn, 1, U_array,
                   mm, solution, nn);
    //util::print(b, nn, "b after");
 
    iter = 0;
    for (int m=0; m<q; m++) {
      for (int n=m; n<q; n++) {
        phi[n][m] = phi[n][m]*(1+solution[iter]);
        phi[m][n] = phi[n][m];
        iter++;
      }
    }
    //util::print( testEnergyConservationColumn<q>(phi,L::t), "colum sum elementwise" );
    //util::print( testEnergyConservationRow<q>(phi,L::t), "row sum elementwise" );
    //util::print( testEnergyConservationSec<q>(phi,L::t,angleProb), "second Moment" );
  }
  clout << "Terminate after " << index << " iterations" << std::endl;
#endif
}

References linespace(), and olb::util::sqrt().

Here is the call graph for this function:

◆ computeAnisotropyMatrixKimAndLee()

template<typename DESCRIPTOR >

void olb::computeAnisotropyMatrixKimAndLee	(	double const	anisotropyFactor,
		std::array< std::array< double, DESCRIPTOR::q >, DESCRIPTOR::q > &	phi )

Definition at line 254 of file anisoDiscr.h.

{
  OstreamManager clout( std::cout, "AnisotropyMatrix_KimAndLee" );
  clout << "Compute anisotropy matrix ..." << std::endl;
  typedef DESCRIPTOR L;
  int const q = L::q;
 
  // qxq matrix 0th row and 0th column are empty
  std::array<std::array<double,q>, q> cosTheta;
  double dotProduct;
  double normI;
  double normJ;
  for (int iPop=0; iPop<q; iPop++) {
    for (int jPop=0; jPop<q; jPop++) {
      dotProduct = descriptors::c<L>(iPop) * descriptors::c<L>(jPop);
      normI = util::sqrt( util::normSqr<int,3>(descriptors::c<L>(iPop)) );
      normJ = util::sqrt( util::normSqr<int,3>(descriptors::c<L>(jPop)) );
      cosTheta[iPop][jPop] = dotProduct /(normI*normJ);
      if ( util::normSqr<int,3>(descriptors::c<L>(iPop)) == 0 || util::normSqr<int,3>(descriptors::c<L>(jPop)) == 0) {
        cosTheta[iPop][jPop] = 0.0;
      }
    }
  }
 
  std::array<std::array<double,q>, q> phaseFunction;
  for (int m=0; m<q; m++) {
    for (int n=0; n<q; n++) {
      phaseFunction[m][n] = henyeyGreenstein(cosTheta[m][n], anisotropyFactor);
    }
  }
 
  for (int m=0; m<q; m++) {
    for (int n=0; n<q; n++) {
      dotProduct = 0;
      for (int i = 0; i < q; ++i) {
        dotProduct += phaseFunction[m][i]*descriptors::t<double,L>(i);
      }
      phi[m][n] = phaseFunction[m][n] / dotProduct;
    }
  }
  //util::print( testEnergyConservationColumn<q>(phi,L::t), "colum sum elementwise" );
  //util::print( testEnergyConservationRow<q>(phi,L::t), "row sum elementwise" );
  //util::print( testAnisotropyConservationColumn<q>(phi,L::t,cosTheta), "anisotropyConservation Moment" );
}

References henyeyGreenstein(), and olb::util::sqrt().

Here is the call graph for this function:

◆ constructSharedCoupling()

template<typename COUPLER , typename... MAP>

auto olb::constructSharedCoupling	(	COUPLER	,
		MAP &&...	map )

Definition at line 343 of file superLatticeCoupling.h.

                                                    {
  return std::make_shared<SuperLatticeCoupling<
    COUPLER,
    typename meta::map<MAP...>::template map_values<descriptors::extract_valued_descriptor_t>
  >>(COUPLER{}, std::forward<decltype(map)>(map)...);
}

◆ constructUsingConcretePlatform()

template<typename CONCRETIZABLE , typename... ARGS>

CONCRETIZABLE::base_t * olb::constructUsingConcretePlatform	(	Platform	platform,
		ARGS &&...	args )

Definition at line 133 of file platform.h.

{
  switch (platform) {
#ifdef PLATFORM_CPU_SISD
  case Platform::CPU_SISD:
    return new typename CONCRETIZABLE::template type<Platform::CPU_SISD>(std::forward<decltype(args)>(args)...);
#endif
#ifdef PLATFORM_CPU_SIMD
  case Platform::CPU_SIMD:
    return new typename CONCRETIZABLE::template type<Platform::CPU_SIMD>(std::forward<decltype(args)>(args)...);
#endif
#ifdef PLATFORM_GPU_CUDA
  case Platform::GPU_CUDA:
    return new typename CONCRETIZABLE::template type<Platform::GPU_CUDA>(std::forward<decltype(args)>(args)...);
#endif
  default:
    throw std::invalid_argument("Invalid PLATFORM");
  }
}

References CPU_SIMD, CPU_SISD, and GPU_CUDA.

Here is the caller graph for this function:

◆ continueMinimizeByVolume()

template<typename T >

void olb::continueMinimizeByVolume	(	CuboidGeometry3D< T > &	cGeometry,
		IndicatorF3D< T > &	indicatorF,
		int	nC )

Splits largest cuboid by-volume until there are nC cuboids.

Definition at line 36 of file cuboidGeometryMinimizer.h.

{
  cGeometry.shrink(indicatorF);
 
  while (cGeometry.getNc() < nC) {
    // Search for the largest child cuboid
    T iCVolume[cGeometry.getNc()];
    int maxiC = 0;
    for (int iC = 0; iC < cGeometry.getNc(); iC++) {
      iCVolume[iC] = cGeometry.get(iC).getLatticeVolume();
      if ( iCVolume[iC] > iCVolume[maxiC] ) {
        maxiC = iC;
      }
    }
 
    // looking for largest extend, because halfing the cuboid by its largest extend will result in the smallest surface and therfore in the least comminication cells
    auto& largest = cGeometry.get(maxiC);
    if (largest.getNx() >= largest.getNy() && largest.getNx() >= largest.getNz()) {
      // clout << "Cut in x direction!" << std::endl;
      largest.divide(2,1,1, cGeometry.cuboids());
    }
    else if (largest.getNy() >= largest.getNx() && largest.getNy() >= largest.getNz()) {
      // clout << "Cut in y direction!" << std::endl;
      largest.divide(1,2,1, cGeometry.cuboids());
    }
    else {
      // clout << "Cut in z direction!" << std::endl;
      largest.divide(1,1,2, cGeometry.cuboids());
    }
    cGeometry.remove(maxiC);
    // shrink the two new cuboids
    cGeometry.shrink(cGeometry.cuboids().size()-2, indicatorF);
    cGeometry.shrink(cGeometry.cuboids().size()-1, indicatorF);
  }
}

References olb::CuboidGeometry3D< T >::cuboids(), olb::CuboidGeometry3D< T >::get(), olb::CuboidGeometry3D< T >::getNc(), olb::CuboidGeometry3D< T >::remove(), and olb::CuboidGeometry3D< T >::shrink().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ createADfractionalUnitConverter()

template<typename T , typename DESCRIPTOR , typename DESCRIPTOR_AD >

UnitConverter< T, DESCRIPTOR > olb::createADfractionalUnitConverter	(	const UnitConverter< T, DESCRIPTOR > &	converter,
		int	fraction,
		T	targetLatticeRelaxationTime )

Definition at line 36 of file fractionalUnitConverter.h.

{
  if (fraction <= 0) {
    throw std::out_of_range("fracton must be positive.");
  }
 
  T conversionViscosityOrDiffusivity = converter.getPhysDeltaX() * converter.getPhysDeltaX() / (converter.getPhysDeltaT() * fraction);
  T physViscosiyOrDiffusivity = (targetLatticeRelaxationTime - 0.5) * conversionViscosityOrDiffusivity / descriptors::invCs2<T,DESCRIPTOR_AD>();
 
  return UnitConverter<T,DESCRIPTOR> (
           converter.getPhysDeltaX() / fraction,
           converter.getPhysDeltaT() / fraction,
           converter.getCharPhysLength(),
           converter.getCharPhysVelocity(),
           physViscosiyOrDiffusivity,
           converter.getPhysDensity(),
           converter.getCharPhysPressure()
         );
}

References olb::UnitConverter< T, DESCRIPTOR >::getCharPhysLength(), olb::UnitConverter< T, DESCRIPTOR >::getCharPhysPressure(), olb::UnitConverter< T, DESCRIPTOR >::getCharPhysVelocity(), olb::UnitConverter< T, DESCRIPTOR >::getPhysDeltaT(), olb::UnitConverter< T, DESCRIPTOR >::getPhysDeltaX(), and olb::UnitConverter< T, DESCRIPTOR >::getPhysDensity().

Here is the call graph for this function:

◆ createCuboidGeometry()

template<typename T >

CuboidGeometry3D< T > * olb::createCuboidGeometry ( std::string fileName )

Load CuboidGeometry from XML File.

Definition at line 266 of file cuboidGeometry3D.h.

{
  OstreamManager clout("saveCuboidGeometry3D");
  XMLreader reader(fileName);
 
  std::vector<T> origin = getDataFromTag<T>(reader["CuboidGeometry"], "origin", 3);
  std::vector<int> extent = getDataFromTag<int>(reader["CuboidGeometry"], "extent", 3);
  T deltaR = getDataFromTag<T>(reader["CuboidGeometry"], "deltaR", 1)[0];
  size_t weight = getDataFromTag<size_t>(reader["CuboidGeometry"], "weight", 1)[0];
 
  CuboidGeometry3D<T>* cGeo = new CuboidGeometry3D<T> (origin, deltaR, extent);
  cGeo->getMotherCuboid().setWeight(weight);
  cGeo->clearCuboids();
 
  for ( XMLreader* cub: reader["CuboidGeometry"] ) {
    origin = getDataFromTag<T>(*cub, "origin", 3);
    extent = getDataFromTag<int>(*cub, "extent", 3);
    deltaR = getDataFromTag<T>(*cub, "deltaR", 1)[0];
    weight = getDataFromTag<int>(*cub, "weight", 1)[0];
 
    cGeo->add( Cuboid3D<T>(origin, deltaR, extent) );
    cGeo->get(cGeo->getNc() - 1).setWeight(weight);
  }
 
  return cGeo;
}

References olb::CuboidGeometry3D< T >::add(), olb::CuboidGeometry3D< T >::clearCuboids(), olb::CuboidGeometry3D< T >::get(), olb::CuboidGeometry3D< T >::getMotherCuboid(), and olb::CuboidGeometry3D< T >::getNc().

Here is the call graph for this function:

◆ createFileName() [1/5]

std::string olb::createFileName ( std::string name )

for .pvd masterFile

Definition at line 34 of file fileName.hh.

{
  std::stringstream fNameStream;
  fNameStream << name;
  return fNameStream.str();
}

Here is the caller graph for this function:

◆ createFileName() [2/5]

std::string olb::createFileName	(	std::string	name,
		int	iT )

used for .pvd file per timeStep iT

Definition at line 42 of file fileName.hh.

{
  std::stringstream fNameStream;
  fNameStream << name  << "_"
              << "iT" << std::setw(7) << std::setfill('0') << iT ;
  return fNameStream.str();
}

◆ createFileName() [3/5]

std::string olb::createFileName	(	std::string	name,
		int	iT,
		int	iC )

every thread writes his cuboids iC per timeStep iT

Definition at line 67 of file fileName.hh.

{
  std::stringstream fNameStream;
  fNameStream << name  << "_"
              << "iT" << std::setw(7) << std::setfill('0') << iT
              << "iC" << std::setw(5) << std::setfill('0') << iC ;
  return fNameStream.str();
}

◆ createFileName() [4/5]

std::string olb::createFileName	(	std::string	name,
		std::string	functor,
		int	iT,
		int	iC )

to write functors instantaneously, without adding

Definition at line 85 of file fileName.hh.

{
  std::stringstream fNameStream;
  fNameStream << name <<"_"<< functor << "iT" << std::setw(7) << std::setfill('0') << iT
              << "iC" << std::setw(5) << std::setfill('0') << iC ;
  return fNameStream.str();
}

◆ createFileName() [5/5]

std::string olb::createFileName	(	std::string	name,
		std::string	functor,
		int	iT = 0 )

to write functors instantaneously, without adding

Definition at line 77 of file fileName.hh.

{
  std::stringstream fNameStream;
  fNameStream << name <<"_"<< functor << "iT" << std::setw(7) << std::setfill('0') << iT;
  return fNameStream.str();
}

◆ createFractionalUnitConverter()

template<typename T , typename DESCRIPTOR >

UnitConverter< T, DESCRIPTOR > olb::createFractionalUnitConverter	(	const UnitConverter< T, DESCRIPTOR > &	converter,
		int	fraction,
		T	targetLatticeRelaxationTime )

Definition at line 59 of file fractionalUnitConverter.h.

{
  return createADfractionalUnitConverter<T,DESCRIPTOR,DESCRIPTOR> (
           converter, fraction, targetLatticeRelaxationTime );
}

◆ createIndicatorCircle2D()

template<typename S >

IndicatorCircle2D< S > * olb::createIndicatorCircle2D	(	XMLreader const &	params,
		bool	verbose = false )

Definition at line 255 of file indicatorF2D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorCircle2D");
  params.setWarningsOn(verbose);
 
  Vector<S,2> center;
  S radius = 1;
 
  std::stringstream xmlCenter( params.getAttribute("center") );
  xmlCenter >> center[0] >> center[1];
  std::stringstream xmlRadius( params.getAttribute("radius") );
  xmlRadius >> radius;
 
  return new IndicatorCircle2D<S>(center, radius);
}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

◆ createIndicatorCircle3D()

template<typename S >

std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorCircle3D	(	XMLreader const &	params,
		bool	verbose = false )

Definition at line 795 of file indicatorF3D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorCircle3D");
 
  Vector<S,3> center;
  Vector<S,3> normal;
  S radius = 1;
 
  //  params.setWarningsOn(false);
  params.setWarningsOn(true);
 
  std::stringstream xmlCenter1( params.getAttribute("center") );
  xmlCenter1 >> center[0] >> center[1] >> center[2];
  std::stringstream xmlCenter2( params.getAttribute("normal") );
  xmlCenter2 >> normal[0] >> normal[1] >> normal[2];
  std::stringstream xmlRadius( params.getAttribute("radius") );
  xmlRadius >> radius;
 
  return std::make_shared<IndicatorCircle3D<S>>(center, normal, radius);
}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

◆ createIndicatorCone3D()

template<typename S >

std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorCone3D	(	XMLreader const &	params,
		bool	verbose = false )

Definition at line 864 of file indicatorF3D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorCone3D");
 
  Vector<S,3> center1;
  Vector<S,3> center2(S(1), S(1), S(1));
  S radius1 = S(0);
  S radius2 = S(1);
 
  //  params.setWarningsOn(false);
  params.setWarningsOn(true);
 
  std::stringstream xmlCenter1( params.getAttribute("center1") );
  xmlCenter1 >> center1[0] >> center1[1] >> center1[2];
  std::stringstream xmlCenter2( params.getAttribute("center2") );
  xmlCenter2 >> center2[0] >> center2[1] >> center2[2];
  std::stringstream xmlRadius1( params.getAttribute("radius1") );
  xmlRadius1 >> radius1;
  std::stringstream xmlRadius2( params.getAttribute("radius2") );
  xmlRadius2 >> radius2;
 
  return std::make_shared<IndicatorCone3D<S>>(center1, center2, radius1, radius2);
}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

◆ createIndicatorCuboid2D()

template<typename S >

IndicatorCuboid2D< S > * olb::createIndicatorCuboid2D	(	XMLreader const &	params,
		bool	verbose = false )

Definition at line 135 of file indicatorF2D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorCuboid2D");
  params.setWarningsOn(verbose);
 
  Vector<S,2> center;
  S xLength;
  S yLength;
 
  std::stringstream xmlCenter( params.getAttribute("center") );
  xmlCenter >> center[0] >> center[1];
  std::stringstream xmlRadius( params.getAttribute("length") );
  xmlRadius >> xLength >> yLength;
 
  return new IndicatorCuboid2D<S>(xLength, yLength, center);
}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

◆ createIndicatorCuboid3D()

template<typename S >

std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorCuboid3D	(	XMLreader const &	params,
		bool	verbose = false )

Definition at line 889 of file indicatorF3D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorCuboid3D");
 
  Vector<S,3> origin;
  Vector<S,3> extend(S(1),S(1),S(1));
 
  //  params.setWarningsOn(false);
  params.setWarningsOn(true);
 
  std::stringstream xmlOrigin( params.getAttribute("origin") );
  xmlOrigin >> origin[0] >> origin[1] >> origin[2];
  std::stringstream xmlExtend( params.getAttribute("extend") );
  xmlExtend >> extend[0] >> extend[1] >> extend[2];
 
  return std::make_shared<IndicatorCuboid3D<S>>(extend, origin);
}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

◆ createIndicatorCylinder3D()

template<typename S >

std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorCylinder3D	(	XMLreader const &	params,
		bool	verbose = false )

for debugging purpose

Definition at line 837 of file indicatorF3D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorCylinder3D");
 
  Vector<S,3> center1;
  Vector<S,3> center2(S(1),S(1),S(1));
  S radius = 1;
 
  //  params.setWarningsOn(false);
  //  params.setWarningsOn(true);
 
  std::stringstream xmlCenter1( (params).getAttribute("center1") );
  xmlCenter1 >> center1[0] >> center1[1] >> center1[2];
  std::stringstream xmlCenter2( (params).getAttribute("center2") );
  xmlCenter2 >> center2[0] >> center2[1] >> center2[2];
  std::stringstream xmlRadius( (params).getAttribute("radius") );
  xmlRadius >> radius;
 
//  print(center1, "center1: ");
//  print(center2, "center2: ");
//  print(radius, "radius: ");
 
  return std::make_shared<IndicatorCylinder3D<S>>(center1, center2, radius);
}

◆ createIndicatorEquiTriangle2D()

template<typename S >

IndicatorEquiTriangle2D< S > * olb::createIndicatorEquiTriangle2D	(	XMLreader const &	params,
		bool	verbose )

Definition at line 396 of file indicatorF2D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorEquiTriangle2D");
  params.setWarningsOn(verbose);
 
  Vector<S,2> center;
  S radius = 1;
 
  std::stringstream xmlCenter( params.getAttribute("center") );
  xmlCenter>> center[0] >> center[1];
  std::stringstream xmlRadius( params.getAttribute("radius") );
  xmlRadius >> radius;
 
  return new IndicatorEquiTriangle2D<S>(center, radius);
}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

◆ createIndicatorF3D()

template<typename S >

std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorF3D	(	XMLreader const &	params,
		bool	verbose = false )

Definition at line 957 of file indicatorF3D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorF3D");
 
  //  clout << "XML element: "<< params.getName() << std::endl;
  //  params.print(2);
 
  std::string actualName = params.getName();
  if ( actualName == "IndicatorCircle3D" ) {
    return createIndicatorCircle3D<S>(params);
  }
  else if ( actualName == "IndicatorSphere3D" ) {
    return createIndicatorSphere3D<S>(params);
  }
  else if ( actualName == "IndicatorCylinder3D" ) {
    return createIndicatorCylinder3D<S>(params);
  }
  else if ( actualName == "IndicatorCone3D" ) {
    return createIndicatorCone3D<S>(params);
  }
  else if ( actualName == "IndicatorCuboid3D" ) {
    return createIndicatorCuboid3D<S>(params);
  }
  else if ( actualName == "IndicatorUnion3D" ) {
    return createIndicatorUnion3D<S>(params);
  }
  else if ( actualName == "IndicatorWithout3D" ) {
    return createIndicatorWithout3D<S>(params);
  }
  else if ( actualName == "IndicatorIntersection3D" ) {
    return createIndicatorIntersection3D<S>(params);
  }
  else {
    auto firstChild = params.begin(); // get iterator of childTree
    return createIndicatorF3D<S>( **firstChild );
  }
}

References olb::XMLreader::begin(), and olb::XMLreader::getName().

Here is the call graph for this function:

◆ createIndicatorIntersection3D()

template<typename S >

std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorIntersection3D	(	XMLreader const &	params,
		bool	verbose = false )

Definition at line 941 of file indicatorF3D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorIntersection3D");
 
  //  clout << "xml position: " << params.getName() << std::endl;
  //  params.print(2);
 
  std::shared_ptr<IndicatorF3D<S>> output = createIndicatorF3D<S>(**params.begin());
  for (auto it = params.begin()+1; it != params.end(); ++it) {
    output = output * createIndicatorF3D<S>(**it);
  }
  return output;
}

References olb::XMLreader::begin(), and olb::XMLreader::end().

Here is the call graph for this function:

◆ createIndicatorSphere3D()

template<typename S >

std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorSphere3D	(	XMLreader const &	params,
		bool	verbose = false )

Definition at line 817 of file indicatorF3D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorSphere3D");
 
  Vector<S,3> center;
  S radius = 1;
 
  //  params.setWarningsOn(false);
  params.setWarningsOn(true);
 
  std::stringstream xmlCenter1( params.getAttribute("center") );
  xmlCenter1 >> center[0] >> center[1] >> center[2];
  std::stringstream xmlRadius( params.getAttribute("radius") );
  xmlRadius >> radius;
 
  return std::make_shared<IndicatorSphere3D<S>>(center, radius);
}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

◆ createIndicatorTriangle2D()

template<typename S >

IndicatorTriangle2D< S > * olb::createIndicatorTriangle2D	(	XMLreader const &	params,
		bool	verbose )

Definition at line 317 of file indicatorF2D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorTriangle2D");
  params.setWarningsOn(verbose);
 
  Vector<S,2> a;
  Vector<S,2> b;
  Vector<S,2> c;
 
  std::stringstream xmla( params.getAttribute("a") );
  xmla>> a[0] >> a[1];
  std::stringstream xmlb( params.getAttribute("b") );
  xmlb >> b[0] >> b[1];
  std::stringstream xmlc( params.getAttribute("c") );
  xmlc >> c[0] >> c[1];
 
  return new IndicatorTriangle2D<S>(a, b, c);
}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

◆ createIndicatorUnion3D()

template<typename S >

std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorUnion3D	(	XMLreader const &	params,
		bool	verbose = false )

Definition at line 909 of file indicatorF3D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorUnion3D");
 
  //  clout << "xml position: " << params.getName() << std::endl;
  //  params.print(2);
 
  std::shared_ptr<IndicatorF3D<S>> output = createIndicatorF3D<S>(**params.begin());
  for (auto it = params.begin()+1; it != params.end(); ++it) {
    output = output + createIndicatorF3D<S>(**it);
  }
  return output;
}

References olb::XMLreader::begin(), and olb::XMLreader::end().

Here is the call graph for this function:

◆ createIndicatorWithout3D()

template<typename S >

std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorWithout3D	(	XMLreader const &	params,
		bool	verbose = false )

Definition at line 925 of file indicatorF3D.hh.

{
  OstreamManager clout(std::cout,"createIndicatorWithout3D");
 
  //  clout << "xml position: " << params.getName() << std::endl;
  //  params.print(2);
 
  std::shared_ptr<IndicatorF3D<S>> output = createIndicatorF3D<S>(**params.begin());
  for (auto it = params.begin()+1; it != params.end(); ++it) {
    output = output - createIndicatorF3D<S>(**it);
  }
  return output;
}

References olb::XMLreader::begin(), and olb::XMLreader::end().

Here is the call graph for this function:

◆ createLbSolver()

template<class SOLVER >

std::shared_ptr< SOLVER > olb::createLbSolver ( XMLreader const & xml )

Definition at line 338 of file lbSolver.h.

{
  using parameters_map = typename SOLVER::BaseSolver::Parameters_t;
  auto paramsTuple = createParametersTuple<parameters_map>(xml);
  return std::make_shared<SOLVER>(paramsTuple);
}

◆ createLoadBalancer() [1/2]

template<typename T >

LoadBalancer< T > * olb::createLoadBalancer	(	std::string const &	fileName,
		CuboidGeometry3D< T > *	cGeo = NULL )

Creator Function for LoadBalancer from fileName.

Definition at line 215 of file loadBalancer.h.

{
  std::string fname = singleton::directories().getLogOutDir() + fileName + ".xml";
  XMLreader lbReader(fname);
  return createLoadBalancer(lbReader["LoadBalancer"], cGeo);
}

References createLoadBalancer(), olb::singleton::directories(), and olb::singleton::Directories::getLogOutDir().

Here is the call graph for this function:

◆ createLoadBalancer() [2/2]

template<typename T >

LoadBalancer< T > * olb::createLoadBalancer	(	XMLreader const &	xmlReader,
		CuboidGeometry3D< T > *	cGeo = NULL )

Creator Function for LoadBalancer from XMLreader.

LoadBalancer Data may be either in an extra file (given by the "file" attribute of the xmlReader)
LoadBalancer Mode is determined by the "mode" attribute of lbXml.

Definition at line 142 of file loadBalancer.h.

{
  OstreamManager clout(std::cout, "createLoadBalancer");
  std::string defaultMode = "Block";
 
  LoadBalancer<T>* lb; // The LoadBalancer to be returned
 
  // Read file attribute to decide if a new XML reader has to be created
  XMLreader const* lbXml;
  std::string fileAttr = xmlReader.getAttribute("file");
  bool newFile = ( fileAttr != "Attribute not found." );
  if ( newFile ) {
    lbXml = new XMLreader(fileAttr);
  }
  else {
    lbXml = &xmlReader;
  }
 
  bool verbose = false;
  (*lbXml).setWarningsOn(false);
 
  std::string mode = lbXml->getAttribute("mode");
  if ( mode == "Attribute not found.") {
    clout << "Warning: Cannot read parameter from Xml-file: Mode. Set default: mode = " << defaultMode << std::endl;
    mode = defaultMode;
  }
 
  // Heuristic Mode
  if ( mode == "Heuristic" ) {
    // only read ratioFullEmpty - Heuristic LB will constructed from cuboidGeometry deterministicly
    double ratioFullEmpty;
    if (!(*lbXml)["RatioFullEmpty"].read<double>(ratioFullEmpty, verbose)) {
      lb = new HeuristicLoadBalancer<T>(*cGeo);
    }
    else {
      lb = new HeuristicLoadBalancer<T>(*cGeo, ratioFullEmpty);
    }
  }
 
  // Base Mode
  else if ( mode == "Base" ) {
    //LoadBalancer<T>* loadBalancer = new LoadBalancer<T>();
    //loadBalancer->load(fileName);
    clout << "LOADING BASE LB NOT IMPLEMENTED YET!" << std::endl;
    (*lbXml).setWarningsOn(true);
    //return loadBalancer;
    lb = NULL;
  }
 
  // Block Mode
  else if ( mode == "Block" ) {
    int size = 1;
    if (!(*lbXml)["Size"].read<int>(size, verbose)) {
      clout << "Warning: Cannot read parameter from Xml-file: Size. Set default: size = 1"
            << std::endl;
    }
    lb = new LoadBalancer<T>(size);
  }
 
 
  (*lbXml).setWarningsOn(true);
 
  // Delete XMLreader if it was created for the LB file
  if ( newFile ) {
    delete lbXml;
  }
 
  return lb;
}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ createParallelFileName()

std::string olb::createParallelFileName	(	std::string	name,
		bool	withSize = true )

for parallel io, e.g. adds "_rank0000001" for rank=1, and optional "_size0000016" if withSize==true

for pararalle io, e.g. adds "_rank0000001" for rank=1

Definition at line 51 of file fileName.hh.

{
  std::stringstream fNameStream;
 
  std::stringstream fNameStreamTmp;
  fNameStreamTmp << singleton::mpi().getSize();
  std::size_t stringLength = fNameStream.str().length();
 
  fNameStream << name  << "_rank" << std::setw(stringLength) << std::setfill('0') << singleton::mpi().getRank();
  if (withSize) {
    fNameStream << "_size" << std::setw(stringLength) << std::setfill('0') << singleton::mpi().getSize();
  }
  return fNameStream.str();
}

References olb::singleton::MpiManager::getRank(), olb::singleton::MpiManager::getSize(), and olb::singleton::mpi().

Here is the call graph for this function:

◆ createParameters()

template<typename PARAMETERS , typename TAG >

std::shared_ptr< PARAMETERS > olb::createParameters ( XMLreader const & xml )

Definition at line 360 of file solverParameters.h.

{
  auto result = std::make_shared<PARAMETERS>();
  parameters::Reader<PARAMETERS, TAG>(result).read(xml);
  result->initialize();
  return result;
}

References olb::parameters::Reader< PARAMETERS, TAG >::read().

Here is the call graph for this function:

◆ createParametersTuple()

template<class parameters_map >

auto olb::createParametersTuple ( XMLreader const & xml )

Definition at line 369 of file solverParameters.h.

{
  utilities::TypeIndexedSharedPtrTuple<parameters_map> paramsTuple;
  meta::tuple_for_each(paramsTuple.tuple, [&xml](auto& element, auto index) {
    using parameter_type = typename std::remove_reference_t<decltype(element)>::element_type;
    using tag = typename parameters_map::keys_t::template get<index()>;
    element = createParameters<parameter_type,tag>(xml);
  });
  return paramsTuple;
}

References olb::utilities::TypeIndexedTuple< MAP >::tuple, and olb::meta::tuple_for_each().

Here is the call graph for this function:

◆ createPowerLawUnitConverter()

template<typename T , typename DESCRIPTOR >

PowerLawUnitConverter< T, DESCRIPTOR > * olb::createPowerLawUnitConverter ( XMLreader const & params )

Definition at line 94 of file powerLawUnitConverter.hh.

{
  OstreamManager clout(std::cout,"createUnitConverter");
  params.setWarningsOn(false);
 
  T physDeltaX;
  T physDeltaT;
 
  T charPhysLength;
  T charPhysVelocity;
  T physViscosity;
  T physConsistencyCoeff;
  T powerLawIndex;
  T physDensity;
  T charPhysPressure = 0;
 
  int resolution;
  T latticeRelaxationTime;
  T charLatticeVelocity;
 
  int counter = 0; // counting the number of Discretization parameters and returning a warning if more than 2 are provided
 
 
  // params[parameter].read(value) sets the value or returns false if the parameter can not be found
  params["Application"]["PhysParameters"]["CharPhysLength"].read(charPhysLength);
  params["Application"]["PhysParameters"]["CharPhysVelocity"].read(charPhysVelocity);
  params["Application"]["PhysParameters"]["PhysConsistencyCoeff"].read(physConsistencyCoeff);
  params["Application"]["PhysParameters"]["powerLawIndex"].read(powerLawIndex);
  params["Application"]["PhysParameters"]["PhysDensity"].read(physDensity);
  params["Application"]["PhysParameters"]["CharPhysPressure"].read(charPhysPressure);
 
  physViscosity = physConsistencyCoeff * util::pow(charPhysVelocity / (2*charPhysLength), powerLawIndex-1);
 
  std::vector<std::string> discretizationParam = {"PhysDeltaX", "Resolution",
    "CharLatticeVelocity", "PhysDeltaT", "LatticeRelaxationTime"};
 
  for(int i = 0; i<discretizationParam.size(); i++){
    std::string test;
    if(params["Application"]["Discretization"][discretizationParam[i]].read(test,false)){
      counter++;
    }
  }
  if(counter>2){
    clout << "WARNING: More than 2 discretization parameters provided" << std::endl;
  }
 
  if (!params["Application"]["Discretization"]["PhysDeltaX"].read(physDeltaX,false)) {
    if (!params["Application"]["Discretization"]["Resolution"].read<int>(resolution,false)) {
      if (!params["Application"]["Discretization"]["CharLatticeVelocity"].read(charLatticeVelocity,false)) {
        // NOT found physDeltaX, resolution or charLatticeVelocity
        clout << "Error: Have not found PhysDeltaX, Resolution or CharLatticeVelocity in XML file."
              << std::endl;
        exit (1);
      }
      else {
        // found charLatticeVelocity
        if (params["Application"]["Discretization"]["PhysDeltaT"].read(physDeltaT,false)) {
          physDeltaX = charPhysVelocity / charLatticeVelocity * physDeltaT;
        }
        else if (params["Application"]["Discretization"]["LatticeRelaxationTime"].read(latticeRelaxationTime,false)) {
          physDeltaX = physViscosity * charLatticeVelocity / charPhysVelocity * descriptors::invCs2<T,DESCRIPTOR>() / (latticeRelaxationTime - 0.5);
        }
      }
    }
    else {
      // found resolution
      physDeltaX = charPhysLength / resolution;
    }
  }
  // found physDeltaX
  if (!params["Application"]["Discretization"]["PhysDeltaT"].read(physDeltaT,false)) {
    if (!params["Application"]["Discretization"]["LatticeRelaxationTime"].read(latticeRelaxationTime,false)) {
      if (!params["Application"]["Discretization"]["CharLatticeVelocity"].read(charLatticeVelocity,false)) {
        // NOT found physDeltaT, latticeRelaxationTime and charLatticeVelocity
        clout << "Error: Have not found PhysDeltaT, LatticeRelaxationTime or CharLatticeVelocity in XML file."
              << std::endl;
        exit (1);
      }
      else {
        // found charLatticeVelocity
        physDeltaT = charLatticeVelocity / charPhysVelocity * physDeltaX;
      }
    }
    else {
      // found latticeRelaxationTime
      physDeltaT = (latticeRelaxationTime - 0.5) / descriptors::invCs2<T,DESCRIPTOR>() * physDeltaX * physDeltaX / physViscosity;
    }
  }
 
  return new PowerLawUnitConverter<T, DESCRIPTOR>(physDeltaX, physDeltaT, charPhysLength, charPhysVelocity, physConsistencyCoeff, powerLawIndex, physDensity, charPhysPressure);
}

References olb::util::pow(), olb::XMLreader::read(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

◆ createUnitConverter()

template<typename T , typename DESCRIPTOR >

UnitConverter< T, DESCRIPTOR > * olb::createUnitConverter ( XMLreader const & params )

creator function with data given by a XML file

Definition at line 95 of file unitConverter.hh.

{
  OstreamManager clout(std::cout,"createUnitConverter");
  params.setWarningsOn(false);
 
  T physDeltaX{};
  T physDeltaT{};
 
  T charPhysLength{};
  T charPhysVelocity{};
  T physViscosity{};
  T physDensity{};
  T charPhysPressure = 0;
 
  int resolution{};
  T latticeRelaxationTime{};
  T charLatticeVelocity{};
 
  int counter = 0; // counting the number of Discretization parameters and returning a warning if more than 2 are provided
 
  // params[parameter].read(value) sets the value or returns false if the parameter can not be found
  params["Application"]["PhysParameters"]["CharPhysLength"].read(charPhysLength);
  params["Application"]["PhysParameters"]["CharPhysVelocity"].read(charPhysVelocity);
  params["Application"]["PhysParameters"]["PhysViscosity"].read(physViscosity);
  params["Application"]["PhysParameters"]["PhysDensity"].read(physDensity);
  params["Application"]["PhysParameters"]["CharPhysPressure"].read(charPhysPressure);
 
  std::vector<std::string> discretizationParam = {"PhysDeltaX", "Resolution",
    "CharLatticeVelocity", "PhysDeltaT", "LatticeRelaxationTime"};
 
  for(int i = 0; i<discretizationParam.size(); i++){
    std::string test;
    if(params["Application"]["Discretization"][discretizationParam[i]].read(test,false)){
      counter++;
    }
  }
  if(counter>2){
    clout << "WARNING: More than 2 discretization parameters provided" << std::endl;
  }
 
  if (!params["Application"]["Discretization"]["PhysDeltaX"].read(physDeltaX,false)) {
    if (!params["Application"]["Discretization"]["Resolution"].read<int>(resolution,false)) {
      if (!params["Application"]["Discretization"]["CharLatticeVelocity"].read(charLatticeVelocity,false)) {
        // NOT found physDeltaX, resolution or charLatticeVelocity
        clout << "Error: Have not found PhysDeltaX, Resolution or CharLatticeVelocity in XML file."
              << std::endl;
        exit (1);
      }
      else {
        // found charLatticeVelocity
        if (params["Application"]["Discretization"]["PhysDeltaT"].read(physDeltaT,false)) {
          physDeltaX = charPhysVelocity / charLatticeVelocity * physDeltaT;
        }
        else if (params["Application"]["Discretization"]["LatticeRelaxationTime"].read(latticeRelaxationTime,false)) {
          physDeltaX = physViscosity * charLatticeVelocity / charPhysVelocity * descriptors::invCs2<T,DESCRIPTOR>() / (latticeRelaxationTime - 0.5);
        }
        else {
          clout << "Error: Only found CharLatticeVelocity, missing PhysDeltaT or LatticeRelaxationTime"
                << std::endl;
          exit (1);
        }
      }
    }
    else {
      // found resolution
      physDeltaX = charPhysLength / resolution;
 
      if (params["Application"]["Discretization"]["CharLatticeVelocity"].read(charLatticeVelocity,false)) {
        latticeRelaxationTime = physViscosity * charLatticeVelocity * descriptors::invCs2<T,DESCRIPTOR>() * resolution + 0.5;
      }
      else {
        if (!params["Application"]["Discretization"]["LatticeRelaxationTime"].read(latticeRelaxationTime,false)) {
          clout << "Error: Have not found LatticeRelaxationTime and was not able to derive it using CharLatticeVelocity"
                << std::endl;
          exit (1);
        }
      }
    }
  }
  // found physDeltaX
  if (!params["Application"]["Discretization"]["PhysDeltaT"].read(physDeltaT,false)) {
    if (!params["Application"]["Discretization"]["LatticeRelaxationTime"].read(latticeRelaxationTime,false)) {
      if (!params["Application"]["Discretization"]["CharLatticeVelocity"].read(charLatticeVelocity,false)) {
        // NOT found physDeltaT, latticeRelaxationTime and charLatticeVelocity
        clout << "Error: Have not found PhysDeltaT, LatticeRelaxationTime or CharLatticeVelocity in XML file."
              << std::endl;
        exit (1);
      }
      else {
        // found charLatticeVelocity
        physDeltaT = charLatticeVelocity / charPhysVelocity * physDeltaX;
      }
    }
    else {
      // found latticeRelaxationTime
      physDeltaT = (latticeRelaxationTime - 0.5) / descriptors::invCs2<T,DESCRIPTOR>() * physDeltaX * physDeltaX / physViscosity;
    }
  }
 
  return new UnitConverter<T, DESCRIPTOR>(physDeltaX, physDeltaT, charPhysLength, charPhysVelocity, physViscosity, physDensity, charPhysPressure);
}

References olb::XMLreader::read(), and olb::XMLreader::setWarningsOn().

Here is the call graph for this function:

◆ crossProduct()

template<typename T , unsigned D, typename IMPL , typename IMPL_ >

auto olb::crossProduct	(	const ScalarVector< T, D, IMPL > &	a,
		const ScalarVector< T, D, IMPL_ > &	b )

Definition at line 235 of file vector.h.

                                                                                    {
  static_assert((D==2 || D==3), "ERROR: Unknown dimension!");
  if constexpr (D==2){
    return crossProduct2D(a,b);
  } else {
    return crossProduct3D(a,b);
  }
}

References crossProduct2D(), and crossProduct3D().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ crossProduct2D()

template<typename T , typename IMPL , typename IMPL_ >

constexpr T olb::crossProduct2D	(	const ScalarVector< T, 2, IMPL > &	a,
		const ScalarVector< T, 2, IMPL_ > &	b )

constexpr

Definition at line 217 of file vector.h.

{
  return (a[0]*b[1] - a[1]*b[0]);
}

Here is the caller graph for this function:

◆ crossProduct3D()

template<typename T , typename IMPL , typename IMPL_ >

constexpr Vector< T, 3 > olb::crossProduct3D	(	const ScalarVector< T, 3, IMPL > &	a,
		const ScalarVector< T, 3, IMPL_ > &	b )

constexpr

Definition at line 224 of file vector.h.

{
  return Vector<T,3>(
           a[1]*b[2] - a[2]*b[1],
           a[2]*b[0] - a[0]*b[2],
           a[0]*b[1] - a[1]*b[0]
         );
}

Here is the caller graph for this function:

◆ doPostProcess()

template<typename SOLVER >

std::function< void()> olb::doPostProcess ( std::shared_ptr< SOLVER > solver )

Returns a function that encapsulates the solving process.

Definition at line 328 of file lbSolver.h.

                                                                {
  return [=]() {
    solver->postProcess();
  };
}

◆ DynamicsPromise()

template<typename DYNAMICS >

olb::DynamicsPromise ( meta::id< DYNAMICS > ) -> DynamicsPromise< typename DYNAMICS::value_t, typename DYNAMICS::descriptor_t >

Here is the caller graph for this function:

◆ evaluateCuboidGeometryNeighbourhood() [1/2]

template<typename T >

void olb::evaluateCuboidGeometryNeighbourhood	(	CuboidGeometry2D< T > &	cuboidGeometry,
		std::map< int, std::vector< int > > &	neighbourhood,
		int	offset = 0 )

Evaluate complete neighbourhood and store in std::map.

Definition at line 166 of file cuboidGeometry2D.h.

{
  for (int iC=0; iC<cuboidGeometry.getNc(); ++iC){
    //Retrieve neighbours of iC
    std::vector<int> neighbours;
    cuboidGeometry.getNeighbourhood(iC, neighbours, offset);
    neighbourhood[iC]=neighbours;
  }
}

References olb::CuboidGeometry2D< T >::getNc(), and olb::CuboidGeometry2D< T >::getNeighbourhood().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ evaluateCuboidGeometryNeighbourhood() [2/2]

template<typename T >

void olb::evaluateCuboidGeometryNeighbourhood	(	CuboidGeometry3D< T > &	cuboidGeometry,
		std::map< int, std::vector< int > > &	neighbourhood,
		int	offset = 0 )

Evaluate complete neighbourhood and store in std::map.

Definition at line 295 of file cuboidGeometry3D.h.

{
  for (int iC=0; iC<cuboidGeometry.getNc(); ++iC){
    //Retrieve neighbours of iC
    std::vector<int> neighbours;
    cuboidGeometry.getNeighbourhood(iC, neighbours, offset);
    neighbourhood[iC]=neighbours;
  }
}

References olb::CuboidGeometry3D< T >::getNc(), and olb::CuboidGeometry3D< T >::getNeighbourhood().

Here is the call graph for this function:

◆ getConfinedPermeability() [1/2]

template<typename T , typename DESCRIPTOR , bool check = false>

T olb::getConfinedPermeability	(	const UnitConverter< T, DESCRIPTOR > &	converter,
		T	physPermeability )

Definition at line 51 of file permeability.h.

                                                                                             {
  return getConfinedPermeability<T,check>(
    converter.getLatticeViscosity(), converter.getLatticeRelaxationTime(),
    converter.getPhysDeltaX(), converter.getCharPhysLength(),
    physPermeability );
}

References olb::UnitConverter< T, DESCRIPTOR >::getCharPhysLength(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeRelaxationTime(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeViscosity(), and olb::UnitConverter< T, DESCRIPTOR >::getPhysDeltaX().

Here is the call graph for this function:

◆ getConfinedPermeability() [2/2]

template<typename T , bool check = false>

T olb::getConfinedPermeability	(	T	latticeViscosity,
		T	latticeRelaxationTime,
		T	physDeltaX,
		T	charPhysLength,
		T	physPermeability )

Definition at line 32 of file permeability.h.

{
  T minPermeabiliy = physDeltaX * physDeltaX * latticeViscosity * latticeRelaxationTime;
  if constexpr (check){
    if ( physPermeability >= minPermeabiliy ){
      throw std::invalid_argument( "Error: Min permeability exceeded!" );
      return 1.0;
    } else {
      return 1. - minPermeabiliy / physPermeability;
    }
  } else {
    return 1. - minPermeabiliy / physPermeability;
  }
 
  __builtin_unreachable();
}

◆ getDataFromTag()

template<typename S >

std::vector< S > olb::getDataFromTag	(	XMLreader const &	reader,
		std::string	attrName,
		int	nData )

Helper Function to retrieve nData-dimensional std::vector of type S from space separated tag.

Definition at line 253 of file cuboidGeometry3D.h.

{
  std::vector<S> values(nData, S());
  std::stringstream extstr(reader.getAttribute(attrName));
  for (auto& valueI: values) {
    extstr >> valueI;
  }
  return values;
}

References olb::XMLreader::getAttribute().

Here is the call graph for this function:

◆ getFresnelFunction()

double olb::getFresnelFunction	(	double const &	theta,
		double const &	refractiveRelative )

Definition at line 244 of file radiativeUnitConverter.h.

{
  double thetaRefracted = getThetaRefracted(theta, refractiveRelative);
  double rf_1 = 0.5 * util::pow((refractiveRelative * util::cos(thetaRefracted) - util::cos(theta)) /
                                (refractiveRelative * util::cos(thetaRefracted) + util::cos(theta)), 2.);
  double rf_2 = 0.5 * util::pow((refractiveRelative * util::cos(theta) - util::cos(thetaRefracted)) /
                                (refractiveRelative * util::cos(theta) + util::cos(thetaRefracted)), 2.);
  return rf_1 + rf_2;   // eq.(5.115)
};

References olb::util::cos(), getThetaRefracted(), and olb::util::pow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getLatticeMaterials()

template<typename T , unsigned D>

std::unordered_set< int > olb::getLatticeMaterials ( const std::vector< SolidBoundary< T, D > > & solidBoundaries )

Get material numbers of multiple solid boundaries in std::vector.

can be used to e.g. limit setBoundaryField() by material number

Definition at line 64 of file wall.h.

{
  std::unordered_set<int> materials;
  for (const SolidBoundary<T,D>& solidBoundary : solidBoundaries ){
    materials.insert( solidBoundary.getLatticeMaterial() );
  }
  return materials;
}

Here is the caller graph for this function:

◆ getPartialBBCoefficient() [1/2]

double olb::getPartialBBCoefficient	(	double const &	latticeDiffusionCoefficient,
		double const &	relativeRefractiveIndex )

Definition at line 278 of file radiativeUnitConverter.h.

{
  double C_R = getRefractionFunction( relativeRefractiveIndex );
  return 2 - 2/(4*latticeDiffusionCoefficient*C_R +1);
};

References getRefractionFunction().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getPartialBBCoefficient() [2/2]

template<typename T , typename DESCRIPTOR >

double olb::getPartialBBCoefficient ( RadiativeUnitConverter< T, DESCRIPTOR > const & converter )

Definition at line 55 of file radiativeUnitConverter.h.

{
  return getPartialBBCoefficient( converter.getLatticeDiffusion(), converter.getRefractiveRelative() );
};

References olb::RadiativeUnitConverter< T, DESCRIPTOR >::getLatticeDiffusion(), getPartialBBCoefficient(), and olb::RadiativeUnitConverter< T, DESCRIPTOR >::getRefractiveRelative().

Here is the call graph for this function:

◆ getPhysPermeability() [1/2]

template<typename T , typename DESCRIPTOR , bool check = false>

T olb::getPhysPermeability	(	const UnitConverter< T, DESCRIPTOR > &	converter,
		T	confinedPermeability )

Definition at line 67 of file permeability.h.

                                                                                             {
  return getPhysPermeability<T>(
    converter.getLatticeViscosity(), converter.getLatticeRelaxationTime(),
    converter.getPhysDeltaX(), converter.getCharPhysLength(),
    confinedPermeability );
}

References olb::UnitConverter< T, DESCRIPTOR >::getCharPhysLength(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeRelaxationTime(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeViscosity(), and olb::UnitConverter< T, DESCRIPTOR >::getPhysDeltaX().

Here is the call graph for this function:

◆ getPhysPermeability() [2/2]

template<typename T >

T olb::getPhysPermeability	(	T	latticeViscosity,
		T	latticeRelaxationTime,
		T	physDeltaX,
		T	charPhysLength,
		T	confinedPermeability )

Definition at line 59 of file permeability.h.

{
  T minPermeabiliy = physDeltaX * physDeltaX * latticeViscosity * latticeRelaxationTime;
  return minPermeabiliy / (1. - confinedPermeability);
}

◆ getRangeBlockGeometrySmoothIndicatorIntersection2D()

template<typename T >

bool olb::getRangeBlockGeometrySmoothIndicatorIntersection2D	(	BlockGeometryStructure2D< T > &	blockGeometry,
		SmoothIndicatorF2D< T, T, true > &	sIndicator,
		T	invDeltaX,
		std::vector< int > &	start,
		std::vector< int > &	end )

◆ getRangeBlockGeometrySmoothIndicatorIntersection3D()

template<typename T >

bool olb::getRangeBlockGeometrySmoothIndicatorIntersection3D	(	BlockGeometryStructure3D< T > &	blockGeometry,
		SmoothIndicatorF3D< T, T, true > &	sIndicator,
		T	invDeltaX,
		std::vector< int > &	start,
		std::vector< int > &	end )

◆ getRefractionFunction() [1/2]

double olb::getRefractionFunction ( const double & refractiveRelative )

Definition at line 264 of file radiativeUnitConverter.h.

{
  int N = 10000.0;
  double h = (M_PI / 2.) /double(N);
  double R_phi = 0.0;
  double R_j = 0.0;
  for (int i = 0; i < N; i++) {
    R_phi += h*(R_phi_diff(0.5*h + h*i,refractiveRelative));
    R_j   += h*(R_j_diff  (0.5*h + h*i,refractiveRelative));
  }
  double R_eff = (R_phi + R_j) / (2 - R_phi + R_j);     // eq.(5.112)
  return (1 + R_eff) / (1 - R_eff);                     // eq.(5.111)    C_R = (1 + R_eff) / (1 - R_eff);
};

References M_PI, R_j_diff(), and R_phi_diff().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ getRefractionFunction() [2/2]

template<typename T , typename DESCRIPTOR >

double olb::getRefractionFunction ( RadiativeUnitConverter< T, DESCRIPTOR > const & converter )

Definition at line 62 of file radiativeUnitConverter.h.

{
  return getRefractionFunction(converter.getRefractiveRelative());
};

References getRefractionFunction(), and olb::RadiativeUnitConverter< T, DESCRIPTOR >::getRefractiveRelative().

Here is the call graph for this function:

◆ getThetaRefracted()

double olb::getThetaRefracted	(	double const &	thetaIncident,
		double const &	refractiveRelative )

Documentation of implemented functions found in 5.2.2 Biomedical Optics, Principles and Imaging; Wang 2007.

Definition at line 235 of file radiativeUnitConverter.h.

{
  double thetaRefracted = M_PI/2.;
  if ( refractiveRelative * util::sin(thetaIncident) < 1 ) {
    thetaRefracted = util::asin( refractiveRelative * util::sin(thetaIncident));  // eq.(5.118)
  }
  return thetaRefracted;
};

References olb::util::asin(), M_PI, and olb::util::sin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ henyeyGreenstein()

double olb::henyeyGreenstein	(	double	cosTheta,
		double	g )

Function to compute Henyey Greenstein phase funtion.

Parameters

cosTheta	util::cos(theta) of scattering event with net direction theta
g	anisotropy factor

Definition at line 55 of file anisoDiscr.h.

{
  return (1-g*g) / util::pow(1+g*g-2*g*cosTheta,1.5);
}

References olb::util::pow().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ isPlatformCPU()

constexpr bool olb::isPlatformCPU ( Platform platform )

constexpr

Returns true if platform is equal to Platform::CPU_*.

Definition at line 154 of file platform.h.

                                                {
  switch (platform) {
#ifdef PLATFORM_CPU_SISD
  case Platform::CPU_SISD:
    return true;
#endif
#ifdef PLATFORM_CPU_SIMD
  case Platform::CPU_SIMD:
    return true;
#endif
#ifdef PLATFORM_GPU_CUDA
  case Platform::GPU_CUDA:
    return false;
#endif
  default:
    throw std::invalid_argument("Invalid PLATFORM");
  }
}

References CPU_SIMD, CPU_SISD, and GPU_CUDA.

Here is the caller graph for this function:

◆ istr2serializer()

void olb::istr2serializer	(	Serializer &	serializer,
		std::istream &	istr,
		bool	enforceUint = false )

processes an istr to a serializer, always in parallel

Definition at line 66 of file serializerIO.hh.

{
  //std::size_t binarySize = serializer.getSize();
  serializer.resetCounter();
 
  // read binary size from first integer of stream
  std::size_t binarySize;
  if (enforceUint) {
    unsigned int uintBinarySize;
    Base64Decoder<unsigned int> sizeDecoder(istr, 1);
    sizeDecoder.decode(&uintBinarySize, 1);
    binarySize = uintBinarySize;
  }
  else {
    Base64Decoder<std::size_t> sizeDecoder(istr, 1);
    sizeDecoder.decode(&binarySize, 1);
  }
  //OLB_PRECONDITION(binarySize == serializer.getSize());
 
 
  Base64Decoder<bool> dataDecoder(istr, binarySize);
 
  std::size_t blockSize;
  bool* dataBuffer = nullptr;
  while (dataBuffer = serializer.getNextBlock(blockSize, true), dataBuffer != nullptr) {
    dataDecoder.decode(dataBuffer, blockSize);
  }
  serializer.resetCounter();
}

References olb::Base64Decoder< T >::decode(), olb::Serializer::getNextBlock(), and olb::Serializer::resetCounter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ lex_greater()

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >

constexpr bool olb::lex_greater	(	const ScalarVector< T, D, IMPL > &	lhs,
		const ScalarVector< U, D, IMPL_ > &	rhs )

inlineconstexpr

Returns true if lhs is lexicographically greater than rhs.

Definition at line 146 of file scalarVector.h.

{
  for (unsigned iDim=0; iDim < D; ++iDim) {
    if (lhs[iDim] > rhs[iDim]) return true;
    if (lhs[iDim] < rhs[iDim]) return false;
  }
  return false;
}

◆ lex_greater_eq()

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >

constexpr bool olb::lex_greater_eq	(	const ScalarVector< T, D, IMPL > &	lhs,
		const ScalarVector< U, D, IMPL_ > &	rhs )

inlineconstexpr

Returns true if lhs is lexicographically greater or equal to rhs.

Definition at line 168 of file scalarVector.h.

{
  for (unsigned iDim=0; iDim < D; ++iDim) {
    if (lhs[iDim] > rhs[iDim]) return true;
    if (lhs[iDim] < rhs[iDim]) return false;
  }
  return true;
}

◆ lex_smaller()

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >

constexpr bool olb::lex_smaller	(	const ScalarVector< T, D, IMPL > &	lhs,
		const ScalarVector< U, D, IMPL_ > &	rhs )

inlineconstexpr

Returns true if lhs is lexicographically smaller than rhs.

Definition at line 135 of file scalarVector.h.

{
  for (unsigned iDim=0; iDim < D; ++iDim) {
    if (lhs[iDim] < rhs[iDim]) return true;
    if (lhs[iDim] > rhs[iDim]) return false;
  }
  return false;
}

◆ lex_smaller_eq()

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >

constexpr bool olb::lex_smaller_eq	(	const ScalarVector< T, D, IMPL > &	lhs,
		const ScalarVector< U, D, IMPL_ > &	rhs )

inlineconstexpr

Returns true if lhs is lexicographically smaller or equal to rhs.

Definition at line 157 of file scalarVector.h.

{
  for (unsigned iDim=0; iDim < D; ++iDim) {
    if (lhs[iDim] < rhs[iDim]) return true;
    if (lhs[iDim] > rhs[iDim]) return false;
  }
  return true;
}

◆ linespace()

std::vector< double > olb::linespace	(	double const	stepsize,
		double const	a,
		double const	b )

Computes vector [a, a+stepsize, a+2*stepsize, ..., b].

Parameters

stepsize
a
b

Definition at line 109 of file anisoDiscr.h.

{
  std::vector<double> linspace{}; // initalize to empty
  if ( util::nearZero( a-b ) ) {
    return linspace;
  }
  int const h = (int) ( (b-a) / stepsize);
  for (int n = 0; n <= h; n++) {
    linspace.push_back( a +double(n)/h * b );
  }
  return linspace;
}

References olb::util::nearZero().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ maxv()

template<typename T , unsigned D, typename IMPL , typename IMPL_ >

constexpr Vector< T, D > olb::maxv	(	const ScalarVector< T, D, IMPL > &	v,
		const ScalarVector< T, D, IMPL_ > &	w )

constexpr

Definition at line 400 of file vector.h.

{
  return Vector<T,D>([&v,&w](unsigned iDim) -> T {
    return util::max(v[iDim], w[iDim]);
  });
}

References olb::util::max().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minimizeByVolume()

template<typename T >

void olb::minimizeByVolume	(	CuboidGeometry3D< T > &	cGeometry,
		IndicatorF3D< T > &	indicatorF,
		int	nC )

Splits into nC cuboids by-volume.

Definition at line 74 of file cuboidGeometryMinimizer.h.

{
  // Search for the largest multiplier not dividable by two
  int initalNc = nC;
  while ( initalNc % 2 == 0 ) {
    initalNc /= 2;
  }
 
  // Split evenly in initalNc many cuboids and shrink all
  cGeometry.split(0, initalNc);
  cGeometry.shrink(indicatorF);
 
  continueMinimizeByVolume(cGeometry, indicatorF, nC);
}

References continueMinimizeByVolume(), olb::CuboidGeometry3D< T >::shrink(), and olb::CuboidGeometry3D< T >::split().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minimizeByWeight()

template<typename T >

void olb::minimizeByWeight	(	CuboidGeometry3D< T > &	cGeometry,
		IndicatorF3D< T > &	indicatorF,
		int	nC )

Definition at line 90 of file cuboidGeometryMinimizer.h.

{
  cGeometry.setWeights(indicatorF);
 
  // conduct a prime factorisation for the number of cuboids nC
  std::vector<int> factors;
  int initalNc = nC;
  // iterate over the prime numbes from 0 to 100 (may have to be extended)
  for (int i : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71}) {
    while (initalNc % i == 0) {
      initalNc /= i;
      factors.push_back(i);
    }
  }
 
  // recursively split the current cuboids by each prime factor
  for (int i = factors.size() - 1; i >= 0; i--) {
    int currentNc = cGeometry.cuboids().size();
    for (int iC = 0; iC < currentNc; iC++) {
      // clout << "split cuboid number #" << iC << " in " << factors[i] << " parts" << std::endl;
      cGeometry.splitByWeight(iC, factors[i], indicatorF);
      cGeometry.shrink(indicatorF);
    }
    for (int iC = 0; iC < currentNc; iC++) {
      // clout << "delet cuboid number #" << iC << std::endl;
      cGeometry.remove(0);
    }
  }
}

References olb::CuboidGeometry3D< T >::cuboids(), olb::CuboidGeometry3D< T >::remove(), olb::CuboidGeometry3D< T >::setWeights(), olb::CuboidGeometry3D< T >::shrink(), and olb::CuboidGeometry3D< T >::splitByWeight().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ minv()

template<typename T , unsigned D, typename IMPL , typename IMPL_ >

constexpr Vector< T, D > olb::minv	(	const ScalarVector< T, D, IMPL > &	v,
		const ScalarVector< T, D, IMPL_ > &	w )

constexpr

Definition at line 391 of file vector.h.

{
  return Vector<T,D>([&v,&w](unsigned iDim) -> T {
    return util::min(v[iDim], w[iDim]);
  });
}

References olb::util::min().

Here is the call graph for this function:

◆ norm()

template<typename T , unsigned D, typename IMPL >

constexpr T olb::norm ( const ScalarVector< T, D, IMPL > & a )

inlineconstexpr

Euclidean vector norm.

Definition at line 66 of file scalarVector.h.

{
  using namespace util;
  T sqNorm = norm_squared(a);
  return sqrt(sqNorm);
}

References norm_squared().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ norm_squared()

template<typename T , unsigned D, typename IMPL >

constexpr T olb::norm_squared ( const ScalarVector< T, D, IMPL > & a )

inlineconstexpr

Squared euclidean vector norm.

Definition at line 55 of file scalarVector.h.

{
  T sqNorm{};
  for (unsigned iDim=0; iDim < D; ++iDim) {
    sqNorm += a[iDim] * a[iDim];
  }
  return sqNorm;
}

Here is the caller graph for this function:

◆ normalize()

template<typename T , unsigned D, typename IMPL >

constexpr Vector< T, D > olb::normalize	(	const ScalarVector< T, D, IMPL > &	a,
		T	scale = T{1} )

constexpr

Definition at line 245 of file vector.h.

                                                                            {1})
{
  T invScale (scale / norm(a));
  return Vector<T,D>([invScale,&a](unsigned iDim) -> T {
    return a[iDim] * invScale;
  });
}

Here is the caller graph for this function:

◆ olbInit()

void olb::olbInit	(	int *	argc,
		char ***	argv,
		bool	multiOutput,
		bool	verbose )

Verify requirements for using all enabled platforms

Definition at line 45 of file olbInit.cpp.

{
  // create an OstreamManager object in order to enable multi output
  olb::OstreamManager clout(std::cout, "olbInit");
  clout.setMultiOutput(multiOutput);
  singleton::mpi().init(argc, argv, verbose);
 
#ifdef PARALLEL_MODE_OMP
  singleton::omp().init(verbose);
#endif
 
  int nThreads = 1;
  if (const char* envOlbNumThreads = std::getenv("OLB_NUM_THREADS")) {
    nThreads = std::stoi(envOlbNumThreads);
  }
  singleton::pool().init(nThreads, verbose);
 
  #ifdef PLATFORM_GPU_CUDA
  checkPlatform<Platform::GPU_CUDA>();
  #endif
}

References checkPlatform< Platform::GPU_CUDA >(), olb::ompManager::init(), olb::singleton::MpiManager::init(), olb::ThreadPool::init(), olb::singleton::mpi(), olb::singleton::omp(), olb::singleton::pool(), and olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

◆ operator&()

any_platform FreeSurface::Flags olb::operator&	(	FreeSurface::Flags	lhs,
		FreeSurface::Flags	rhs )

inline

Definition at line 141 of file freeSurfaceHelpers.h.

                                                                                           {
  return static_cast<FreeSurface::Flags>(static_cast<std::uint8_t>(lhs) & static_cast<std::uint8_t>(rhs));
}

◆ operator*() [1/17]

template<typename T , typename U , unsigned D, typename IMPL , typename IMPL_ >

constexpr auto olb::operator*	(	const ScalarVector< T, D, IMPL > &	a,
		const ScalarVector< U, D, IMPL_ > &	b )

constexpr

Inner product.

Definition at line 345 of file vector.h.

{
  decltype(T{}*U{}) scalarProduct{};
  for (unsigned iDim=0; iDim < D; ++iDim) {
    scalarProduct += a[iDim] * b[iDim];
  }
  return scalarProduct;
}

◆ operator*() [2/17]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, Vector< decltype(T{} U{}), D > > olb::operator	(	const ScalarVector< T, D, IMPL > &	a,
		U	b )

constexpr

Definition at line 337 of file vector.h.

{
  Vector<decltype(T{}*U{}),D> result(a);
  return result *= b;
}

◆ operator*() [3/17]

Expr olb::operator*	(	Expr	lhs,
		Expr	rhs )

Definition at line 166 of file expr.h.

                                   {
  return Expr(lhs, Expr::Op::Mul, rhs);
}

References olb::Expr::Mul.

◆ operator*() [4/17]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity2D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF2D< S > > olb::operator*	(	F1< S > &	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 240 of file indicCalc2D.hh.

{
  return lhs._f * rhs;
}

◆ operator*() [5/17]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity3D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF3D< S > > olb::operator*	(	F1< S > &	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 144 of file indicComb3D.hh.

{
  return lhs._f * rhs;
}

◆ operator*() [6/17]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator*	(	std::shared_ptr< AnalyticalF< D, T, S > >	lhs,
		std::shared_ptr< AnalyticalF< D, T, S > >	rhs )

Definition at line 121 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcMultiplication<D,T,S>(std::move(lhs), std::move(rhs)));
}

◆ operator*() [7/17]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator*	(	std::shared_ptr< AnalyticalF< D, T, S > >	lhs,
		T	rhs )

Definition at line 128 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcMultiplication<D,T,S>(std::move(lhs), rhs));
}

◆ operator*() [8/17]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF2D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF2D< S > > olb::operator*	(	std::shared_ptr< F1< S > >	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 218 of file indicCalc2D.hh.

{
  return std::make_shared<IndicMultiplication2D<S>>(lhs, rhs);
}

◆ operator*() [9/17]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF3D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF3D< S > > olb::operator*	(	std::shared_ptr< F1< S > >	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 122 of file indicComb3D.hh.

{
  return std::make_shared<IndicMultiplication3D<S>>(lhs, rhs);
}

◆ operator*() [10/17]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator*	(	std::shared_ptr< SuperF2D< T, W > >	lhs,
		std::shared_ptr< SuperF2D< T, W > >	rhs )

Definition at line 180 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcMultiplication2D<T,W>(std::move(lhs), std::move(rhs)));
}

◆ operator*() [11/17]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator*	(	std::shared_ptr< SuperF2D< T, W > >	lhs,
		W	rhs )

Definition at line 187 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcMultiplication2D<T,W>(std::move(lhs), rhs));
}

◆ operator*() [12/17]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator*	(	std::shared_ptr< SuperF3D< T, W > >	lhs,
		std::shared_ptr< SuperF3D< T, W > >	rhs )

Definition at line 180 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcMultiplication3D<T,W>(std::move(lhs), std::move(rhs)));
}

◆ operator*() [13/17]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator*	(	std::shared_ptr< SuperF3D< T, W > >	lhs,
		W	rhs )

Definition at line 187 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcMultiplication3D<T,W>(std::move(lhs), rhs));
}

◆ operator*() [14/17]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator*	(	T	lhs,
		std::shared_ptr< AnalyticalF< D, T, S > >	rhs )

Definition at line 135 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcMultiplication<D,T,S>(lhs, std::move(rhs)));
}

◆ operator*() [15/17]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, Vector< decltype(T{} U{}), D > > olb::operator	(	U	a,
		const ScalarVector< T, D, IMPL > &	b )

constexpr

Definition at line 329 of file vector.h.

{
  Vector<decltype(T{}*U{}),D> result(b);
  return result *= a;
}

◆ operator*() [16/17]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator*	(	W	lhs,
		std::shared_ptr< SuperF2D< T, W > >	rhs )

Definition at line 194 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcMultiplication2D<T,W>(lhs, std::move(rhs)));
}

◆ operator*() [17/17]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator*	(	W	lhs,
		std::shared_ptr< SuperF3D< T, W > >	rhs )

Definition at line 194 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcMultiplication3D<T,W>(lhs, std::move(rhs)));
}

◆ operator+() [1/18]

template<typename T , unsigned D, typename IMPL , typename IMPL_ >

constexpr Vector< T, D > olb::operator+	(	const ScalarVector< T, D, IMPL > &	a,
		const ScalarVector< T, D, IMPL_ > &	b )

constexpr

Definition at line 278 of file vector.h.

{
  return Vector<T,D>(a) += b;
}

◆ operator+() [2/18]

template<typename T , typename W , unsigned D, typename IMPL , typename IMPL_ >

constexpr Vector< decltype(T{}+W{}), D > olb::operator+	(	const ScalarVector< T, D, IMPL > &	a,
		const ScalarVector< W, D, IMPL_ > &	b )

constexpr

Definition at line 285 of file vector.h.

                           {}+W{}),D> operator+ (
  const ScalarVector<T,D,IMPL>& a, const ScalarVector<W,D,IMPL_>& b) any_platform
{
  Vector<decltype(T{}+W{}),D> result;
  for (unsigned iDim=0; iDim < D; ++iDim) {
    result[iDim] = a[iDim] + b[iDim];
  }
  return result;
}

◆ operator+() [3/18]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator+	(	const ScalarVector< T, D, IMPL > &	a,
		U	b )

constexpr

Definition at line 272 of file vector.h.

{
  return Vector<T,D>(a) += b;
}

◆ operator+() [4/18]

Expr olb::operator+	(	Expr	lhs,
		Expr	rhs )

Definition at line 158 of file expr.h.

                                   {
  return Expr(lhs, Expr::Op::Add, rhs);
}

References olb::Expr::Add.

◆ operator+() [5/18]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity2D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF2D< S > > olb::operator+	(	F1< S > &	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 226 of file indicCalc2D.hh.

{
  return lhs._f + rhs;
}

◆ operator+() [6/18]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity3D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF3D< S > > olb::operator+	(	F1< S > &	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 130 of file indicComb3D.hh.

{
  return lhs._f + rhs;
}

◆ operator+() [7/18]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator+	(	std::shared_ptr< AnalyticalF< D, T, S > >	lhs,
		std::shared_ptr< AnalyticalF< D, T, S > >	rhs )

Definition at line 79 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcPlus<D,T,S>(std::move(lhs), std::move(rhs)));
}

◆ operator+() [8/18]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator+	(	std::shared_ptr< AnalyticalF< D, T, S > >	lhs,
		T	rhs )

Definition at line 86 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcPlus<D,T,S>(std::move(lhs), rhs));
}

◆ operator+() [9/18]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF2D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF2D< S > > olb::operator+	(	std::shared_ptr< F1< S > >	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 204 of file indicCalc2D.hh.

{
  return std::make_shared<IndicPlus2D<S>>(lhs, rhs);
}

◆ operator+() [10/18]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF3D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF3D< S > > olb::operator+	(	std::shared_ptr< F1< S > >	lhs,
		std::shared_ptr< F2< S > >	rhs )

Free function implements lhs+rhs, only for IndicaotrsF3D types through enable_if and is_base_of.

Template Parameters

S	usual type for source dimension of the functor
F1	lhs has to be derived from IndicatorF3D, otherwise function is disabled
F2	rhs

Definition at line 108 of file indicComb3D.hh.

{
  return std::make_shared<IndicPlus3D<S>>(lhs, rhs);
}

◆ operator+() [11/18]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator+	(	std::shared_ptr< SuperF2D< T, W > >	lhs,
		std::shared_ptr< SuperF2D< T, W > >	rhs )

Definition at line 138 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcPlus2D<T,W>(std::move(lhs), std::move(rhs)));
}

◆ operator+() [12/18]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator+	(	std::shared_ptr< SuperF2D< T, W > >	lhs,
		W	rhs )

Definition at line 145 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcPlus2D<T,W>(std::move(lhs), rhs));
}

◆ operator+() [13/18]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator+	(	std::shared_ptr< SuperF3D< T, W > >	lhs,
		std::shared_ptr< SuperF3D< T, W > >	rhs )

Definition at line 138 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcPlus3D<T,W>(std::move(lhs), std::move(rhs)));
}

◆ operator+() [14/18]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator+	(	std::shared_ptr< SuperF3D< T, W > >	lhs,
		W	rhs )

Definition at line 145 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcPlus3D<T,W>(std::move(lhs), rhs));
}

◆ operator+() [15/18]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator+	(	T	lhs,
		std::shared_ptr< AnalyticalF< D, T, S > >	rhs )

Definition at line 93 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcPlus<D,T,S>(lhs, std::move(rhs)));
}

◆ operator+() [16/18]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator+	(	U	a,
		const ScalarVector< T, D, IMPL > &	b )

constexpr

Definition at line 265 of file vector.h.

{
  return Vector<T,D>(b) += a;
}

◆ operator+() [17/18]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator+	(	W	lhs,
		std::shared_ptr< SuperF2D< T, W > >	rhs )

Definition at line 152 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcPlus2D<T,W>(lhs, std::move(rhs)));
}

◆ operator+() [18/18]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator+	(	W	lhs,
		std::shared_ptr< SuperF3D< T, W > >	rhs )

Definition at line 152 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcPlus3D<T,W>(lhs, std::move(rhs)));
}

◆ operator-() [1/19]

template<typename T , unsigned D, typename IMPL , typename IMPL_ >

constexpr Vector< T, D > olb::operator-	(	const ScalarVector< T, D, IMPL > &	a,
		const ScalarVector< T, D, IMPL_ > &	b )

constexpr

Definition at line 310 of file vector.h.

{
  return Vector<T,D>(a) -= b;
}

◆ operator-() [2/19]

template<typename T , typename W , unsigned D, typename IMPL , typename IMPL_ >

constexpr Vector< decltype(T{}-W{}), D > olb::operator-	(	const ScalarVector< T, D, IMPL > &	a,
		const ScalarVector< W, D, IMPL_ > &	b )

constexpr

Definition at line 317 of file vector.h.

                           {}-W{}),D> operator- (
  const ScalarVector<T,D,IMPL>& a, const ScalarVector<W,D,IMPL_>& b) any_platform
{
  Vector<decltype(T{}-W{}),D> result;
  for (unsigned iDim=0; iDim < D; ++iDim) {
    result[iDim] = a[iDim] - b[iDim];
  }
  return result;
}

◆ operator-() [3/19]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator-	(	const ScalarVector< T, D, IMPL > &	a,
		U	b )

constexpr

Definition at line 304 of file vector.h.

{
  return Vector<T,D>(a) -= b;
}

◆ operator-() [4/19]

Expr olb::operator-	(	Expr	lhs,
		Expr	rhs )

Definition at line 162 of file expr.h.

                                   {
  return Expr(lhs, Expr::Op::Sub, rhs);
}

References olb::Expr::Sub.

◆ operator-() [5/19]

Expr olb::operator- ( Expr rhs )

Definition at line 174 of file expr.h.

                         {
  return Expr(-1.) * rhs;
}

◆ operator-() [6/19]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity2D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF2D< S > > olb::operator-	(	F1< S > &	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 233 of file indicCalc2D.hh.

{
  return lhs._f - rhs;
}

◆ operator-() [7/19]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorIdentity3D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF3D< S > > olb::operator-	(	F1< S > &	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 137 of file indicComb3D.hh.

{
  return lhs._f - rhs;
}

◆ operator-() [8/19]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator-	(	std::shared_ptr< AnalyticalF< D, T, S > >	lhs,
		std::shared_ptr< AnalyticalF< D, T, S > >	rhs )

Definition at line 100 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcMinus<D,T,S>(std::move(lhs), std::move(rhs)));
}

◆ operator-() [9/19]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator-	(	std::shared_ptr< AnalyticalF< D, T, S > >	lhs,
		T	rhs )

Definition at line 107 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcMinus<D,T,S>(std::move(lhs), rhs));
}

◆ operator-() [10/19]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF2D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF2D< S > > olb::operator-	(	std::shared_ptr< F1< S > >	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 211 of file indicCalc2D.hh.

{
  return std::make_shared<IndicMinus2D<S>>(lhs, rhs);
}

◆ operator-() [11/19]

template<typename S , template< typename U > class F1, template< typename V > class F2, typename = typename std::enable_if<std::is_base_of<IndicatorF3D<S>, F1<S>>::value>::type>

std::shared_ptr< IndicatorF3D< S > > olb::operator-	(	std::shared_ptr< F1< S > >	lhs,
		std::shared_ptr< F2< S > >	rhs )

Definition at line 115 of file indicComb3D.hh.

{
  return std::make_shared<IndicMinus3D<S>>(rhs, lhs);
}

◆ operator-() [12/19]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator-	(	std::shared_ptr< SuperF2D< T, W > >	lhs,
		std::shared_ptr< SuperF2D< T, W > >	rhs )

Definition at line 159 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcMinus2D<T,W>(std::move(lhs), std::move(rhs)));
}

◆ operator-() [13/19]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator-	(	std::shared_ptr< SuperF2D< T, W > >	lhs,
		W	rhs )

Definition at line 166 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcMinus2D<T,W>(std::move(lhs), rhs));
}

◆ operator-() [14/19]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator-	(	std::shared_ptr< SuperF3D< T, W > >	lhs,
		std::shared_ptr< SuperF3D< T, W > >	rhs )

Definition at line 159 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcMinus3D<T,W>(std::move(lhs), std::move(rhs)));
}

◆ operator-() [15/19]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator-	(	std::shared_ptr< SuperF3D< T, W > >	lhs,
		W	rhs )

Definition at line 166 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcMinus3D<T,W>(std::move(lhs), rhs));
}

◆ operator-() [16/19]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator-	(	T	lhs,
		std::shared_ptr< AnalyticalF< D, T, S > >	rhs )

Definition at line 114 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcMinus<D,T,S>(lhs, std::move(rhs)));
}

◆ operator-() [17/19]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator-	(	U	a,
		const ScalarVector< T, D, IMPL > &	b )

constexpr

Definition at line 297 of file vector.h.

{
  return Vector<T,D>(a) - b;
}

◆ operator-() [18/19]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator-	(	W	lhs,
		std::shared_ptr< SuperF2D< T, W > >	rhs )

Definition at line 173 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcMinus2D<T,W>(lhs, std::move(rhs)));
}

◆ operator-() [19/19]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator-	(	W	lhs,
		std::shared_ptr< SuperF3D< T, W > >	rhs )

Definition at line 173 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcMinus3D<T,W>(lhs, std::move(rhs)));
}

◆ operator/() [1/11]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator/	(	const ScalarVector< T, D, IMPL > &	a,
		U	b )

constexpr

Definition at line 357 of file vector.h.

{
  return Vector<T,D>(a) /= b;
}

◆ operator/() [2/11]

Expr olb::operator/	(	Expr	lhs,
		Expr	rhs )

Definition at line 170 of file expr.h.

                                   {
  return Expr(lhs, Expr::Op::Div, rhs);
}

References olb::Expr::Div.

◆ operator/() [3/11]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator/	(	std::shared_ptr< AnalyticalF< D, T, S > >	lhs,
		std::shared_ptr< AnalyticalF< D, T, S > >	rhs )

Definition at line 142 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcDivision<D,T,S>(std::move(lhs), std::move(rhs)));
}

◆ operator/() [4/11]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator/	(	std::shared_ptr< AnalyticalF< D, T, S > >	lhs,
		T	rhs )

Definition at line 149 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcDivision<D,T,S>(std::move(lhs), rhs));
}

◆ operator/() [5/11]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator/	(	std::shared_ptr< SuperF2D< T, W > >	lhs,
		std::shared_ptr< SuperF2D< T, W > >	rhs )

Definition at line 201 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcDivision2D<T,W>(std::move(lhs), std::move(rhs)));
}

◆ operator/() [6/11]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator/	(	std::shared_ptr< SuperF2D< T, W > >	lhs,
		W	rhs )

Definition at line 208 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcDivision2D<T,W>(std::move(lhs), rhs));
}

◆ operator/() [7/11]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator/	(	std::shared_ptr< SuperF3D< T, W > >	lhs,
		std::shared_ptr< SuperF3D< T, W > >	rhs )

Definition at line 201 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcDivision3D<T,W>(std::move(lhs), std::move(rhs)));
}

◆ operator/() [8/11]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator/	(	std::shared_ptr< SuperF3D< T, W > >	lhs,
		W	rhs )

Definition at line 208 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcDivision3D<T,W>(std::move(lhs), rhs));
}

◆ operator/() [9/11]

template<unsigned D, typename T , typename S >

std::shared_ptr< AnalyticalF< D, T, S > > olb::operator/	(	T	lhs,
		std::shared_ptr< AnalyticalF< D, T, S > >	rhs )

Definition at line 156 of file analyticCalcF.hh.

{
  return std::shared_ptr<AnalyticalF<D,T,S>>(
           new AnalyticCalcDivision<D,T,S>(lhs, std::move(rhs)));
}

◆ operator/() [10/11]

template<typename T , typename W >

std::shared_ptr< SuperF2D< T, W > > olb::operator/	(	W	lhs,
		std::shared_ptr< SuperF2D< T, W > >	rhs )

Definition at line 215 of file superCalcF2D.hh.

{
  return std::shared_ptr<SuperF2D<T,W>>(
           new SuperCalcDivision2D<T,W>(lhs, std::move(rhs)));
}

◆ operator/() [11/11]

template<typename T , typename W >

std::shared_ptr< SuperF3D< T, W > > olb::operator/	(	W	lhs,
		std::shared_ptr< SuperF3D< T, W > >	rhs )

Definition at line 215 of file superCalcF3D.hh.

{
  return std::shared_ptr<SuperF3D<T,W>>(
           new SuperCalcDivision3D<T,W>(lhs, std::move(rhs)));
}

◆ operator<() [1/2]

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >

constexpr bool olb::operator<	(	const ScalarVector< T, D, IMPL > &	lhs,
		const ScalarVector< U, D, IMPL_ > &	rhs )

inlineconstexpr

Returns true if all lhs components are smaller than rhs.

Definition at line 99 of file scalarVector.h.

{
  bool smaller = true;
  for (unsigned iDim=0; iDim < D; ++iDim) {
    smaller &= (lhs[iDim] < rhs[iDim]);
  }
  return smaller;
}

◆ operator<() [2/2]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, bool > olb::operator<	(	U	lhs,
		const ScalarVector< T, D, IMPL > &	rhs )

constexpr

Definition at line 363 of file vector.h.

{
  return Vector<U,D>(lhs) < rhs;
}

◆ operator<<() [1/8]

template<class Ch , class Tr , std::size_t... Is>

auto & olb::operator<<	(	std::basic_ostream< Ch, Tr > &	os,
		const std::index_sequence< Is... > &	is )

Operator << for std::index_sequence.

Definition at line 49 of file printUtils.h.

{
  os << "<";
  print_index_sequence(os, is);
  return os << ">";
}

References print_index_sequence().

Here is the call graph for this function:

◆ operator<<() [2/8]

template<class Ch , class Tr >

auto & olb::operator<<	(	std::basic_ostream< Ch, Tr > &	os,
		FileName &	fileName )

Definition at line 68 of file plainWriter.h.

{
  return os << fileName.str();
}

◆ operator<<() [3/8]

template<class Ch , class Tr , class T , std::size_t N>

auto & olb::operator<<	(	std::basic_ostream< Ch, Tr > &	os,
		std::array< T, N > &	array )

Operator << for std::array.

Definition at line 71 of file printUtils.h.

{
  os << "|[";
  for(auto it = array.begin(); it != array.end(); ++it){
    os << (it==array.begin()? "" : ",") << *it;
  }
  return os << "]|";
}

◆ operator<<() [4/8]

template<class Ch , class Tr , typename... args>

auto & olb::operator<<	(	std::basic_ostream< Ch, Tr > &	os,
		std::list< args... > &	list )

Operator << for std::list.

Definition at line 83 of file printUtils.h.

{
  os << "|[";
  for(auto it = list.begin(); it != list.end(); ++it){
    os << (it==list.begin()? "" : ",") << *it;
  }
  return os << "]|";
}

◆ operator<<() [5/8]

template<class Ch , class Tr , typename... args>

auto & olb::operator<<	(	std::basic_ostream< Ch, Tr > &	os,
		std::set< args... > &	set )

Operator << for std::set.

Definition at line 95 of file printUtils.h.

{
  os << "|[";
  for(auto it = set.begin(); it != set.end(); ++it){
    os << (it==set.begin()? "" : ",") << *it;
  }
  return os << "]|";
}

◆ operator<<() [6/8]

template<class Ch , class Tr , typename... args>

auto & olb::operator<<	(	std::basic_ostream< Ch, Tr > &	os,
		std::unordered_set< args... > &	set )

Operator << for std::unordered_set.

Definition at line 107 of file printUtils.h.

{
  os << "|[";
  for(auto it = set.begin(); it != set.end(); ++it){
    os << (it==set.begin()? "" : ",") << *it;
  }
  return os << "]|";
}

◆ operator<<() [7/8]

template<class Ch , class Tr , typename... args>

auto & olb::operator<<	(	std::basic_ostream< Ch, Tr > &	os,
		std::vector< args... > &	vec )

Operator << for std::vector.

Definition at line 59 of file printUtils.h.

{
  os << "|[";
  for(auto it = vec.begin(); it != vec.end(); ++it){
    os << (it==vec.begin()? "" : ",") << *it;
  }
  return os << "]|";
}

◆ operator<<() [8/8]

template<typename T , unsigned D, typename IMPL >

std::ostream & olb::operator<<	(	std::ostream &	os,
		const ScalarVector< T, D, IMPL > &	o )

inline

Print vector entries to ostream in a human-readable fashion.

Definition at line 179 of file scalarVector.h.

{
  if (D > 0) {
    os << "[";
    for (unsigned iDim=0; iDim < D-1; ++iDim) {
      os << o[iDim] << " ";
    }
    os << o[D-1]<<"]";
  }
  else {
    os << "[empty]";
  }
  return os;
}

◆ operator<=() [1/2]

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >

constexpr bool olb::operator<=	(	const ScalarVector< T, D, IMPL > &	lhs,
		const ScalarVector< U, D, IMPL_ > &	rhs )

inlineconstexpr

Returns true if all lhs components are smaller or equal than rhs.

Definition at line 117 of file scalarVector.h.

{
  bool smallerEq = true;
  for (unsigned iDim=0; iDim < D; ++iDim) {
    smallerEq &= (lhs[iDim] <= rhs[iDim]);
  }
  return smallerEq;
}

◆ operator<=() [2/2]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, bool > olb::operator<=	(	U	lhs,
		const ScalarVector< T, D, IMPL > &	rhs )

constexpr

Definition at line 377 of file vector.h.

{
  return Vector<U,D>(lhs) <= rhs;
}

◆ operator>() [1/2]

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >

constexpr bool olb::operator>	(	const ScalarVector< T, D, IMPL > &	lhs,
		const ScalarVector< U, D, IMPL_ > &	rhs )

inlineconstexpr

Returns true if all lhs components are greater than rhs.

Definition at line 110 of file scalarVector.h.

{
  return rhs < lhs;
}

◆ operator>() [2/2]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, bool > olb::operator>	(	const ScalarVector< T, D, IMPL > &	lhs,
		U	rhs )

constexpr

Definition at line 371 of file vector.h.

{
  return lhs > Vector<U,D>(rhs);
}

◆ operator>=() [1/2]

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >

constexpr bool olb::operator>=	(	const ScalarVector< T, D, IMPL > &	lhs,
		const ScalarVector< U, D, IMPL_ > &	rhs )

inlineconstexpr

Returns true if all lhs components are smaller or equal than rhs.

Definition at line 128 of file scalarVector.h.

{
  return rhs <= lhs;
}

◆ operator>=() [2/2]

template<typename T , unsigned D, typename U , typename IMPL >

constexpr meta::enable_if_arithmetic_t< U, bool > olb::operator>=	(	const ScalarVector< T, D, IMPL > &	lhs,
		U	rhs )

constexpr

Definition at line 385 of file vector.h.

{
  return lhs >= Vector<U,D>(rhs);
}

◆ operator|()

any_platform FreeSurface::Flags olb::operator\|	(	FreeSurface::Flags	lhs,
		FreeSurface::Flags	rhs )

inline

Definition at line 145 of file freeSurfaceHelpers.h.

                                                                                           {
  return static_cast<FreeSurface::Flags>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
}

◆ PostProcessorPromise()

template<typename PP >

olb::PostProcessorPromise ( meta::id< PP > ) -> PostProcessorPromise< typename PP::value_t, typename PP::descriptor_t >

◆ print_index_sequence()

template<class Ch , class Tr , std::size_t... Is>

void olb::print_index_sequence	(	std::basic_ostream< Ch, Tr > &	os,
		const std::index_sequence< Is... >	is )

Print std::index_sequence.

Definition at line 36 of file printUtils.h.

{
  std::size_t i=0;
  ((os << (i++==0? "" : ",") << Is), ...);
}

Here is the caller graph for this function:

◆ R_j_diff()

double olb::R_j_diff	(	double const &	theta,
		double const &	refractiveRelative )

Definition at line 259 of file radiativeUnitConverter.h.

{
  return 3. * util::sin(theta) * util::pow(util::cos(theta),2.) * getFresnelFunction(theta,refractiveRelative);
};

References olb::util::cos(), getFresnelFunction(), olb::util::pow(), and olb::util::sin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ R_phi_diff()

double olb::R_phi_diff	(	double const &	theta,
		double const &	refractiveRelative )

Definition at line 254 of file radiativeUnitConverter.h.

{
  return 2. * util::sin(theta) * util::cos(theta) * getFresnelFunction(theta,refractiveRelative);
};

References olb::util::cos(), getFresnelFunction(), and olb::util::sin().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ residualPhysDiffusivity()

template<typename T , typename DESCRIPTOR >

T olb::residualPhysDiffusivity	(	const UnitConverter< T, DESCRIPTOR > &	converterFractional,
		T	physDiffusivity )

Definition at line 68 of file fractionalUnitConverter.h.

{
  return physDiffusivity - converterFractional.getPhysViscosity();
}

References olb::UnitConverter< T, DESCRIPTOR >::getPhysViscosity().

Here is the call graph for this function:

◆ serializer2buffer()

void olb::serializer2buffer	(	Serializer &	serializer,
		std::uint8_t *	buffer )

processes data from a serializer to a given buffer

Definition at line 96 of file serializerIO.hh.

{
  serializer.resetCounter();
  std::size_t blockSize;
  const bool* dataBuffer = nullptr;
  while (dataBuffer = serializer.getNextBlock(blockSize, false), dataBuffer != nullptr) {
    std::memcpy(buffer, dataBuffer, blockSize);
    buffer += blockSize;
  }
  serializer.resetCounter();
}

References olb::Serializer::getNextBlock(), and olb::Serializer::resetCounter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ serializer2ostr()

void olb::serializer2ostr	(	Serializer &	serializer,
		std::ostream &	ostr,
		bool	enforceUint = false )

processes data from a serializer to a given ostr, always in parallel

Definition at line 40 of file serializerIO.hh.

{
  serializer.resetCounter();
  // write binary size into first integer of stream
  std::size_t binarySize = serializer.getSize();
  if (enforceUint) {
    Base64Encoder<unsigned int> sizeEncoder(ostr, 1);
    OLB_PRECONDITION(binarySize <= std::numeric_limits<unsigned int>::max());
    unsigned int uintBinarySize = (unsigned int)binarySize;
    sizeEncoder.encode(&uintBinarySize, 1);
  }
  else {
    Base64Encoder<std::size_t> sizeEncoder(ostr, 1);
    sizeEncoder.encode(&binarySize, 1);
  }
 
  Base64Encoder<bool> dataEncoder (ostr, binarySize);
 
  std::size_t blockSize;
  const bool* dataBuffer = nullptr;
  while (dataBuffer = serializer.getNextBlock(blockSize, false), dataBuffer != nullptr) {
    dataEncoder.encode(dataBuffer, blockSize);
  }
  serializer.resetCounter();
}

References olb::Base64Encoder< T >::encode(), olb::Serializer::getNextBlock(), olb::Serializer::getSize(), OLB_PRECONDITION, and olb::Serializer::resetCounter().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setAdvectionDiffusionConvectionBoundary() [1/3]

template<typename T , typename DESCRIPTOR >

void olb::setAdvectionDiffusionConvectionBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells = false )

Add AdvectionDiffusionConvection boundary for any indicated cells inside the block domain.

set AdvectionDiffusionConvection boundary for any indicated cells inside the block domain

Definition at line 63 of file setAdvectionDiffusionConvectionBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setAdvectionDiffusionConvectionBoundary");
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {
        auto postProcessor = std::unique_ptr<PostProcessorGenerator3D<T, DESCRIPTOR>>{
      new ConvectionBoundaryProcessorGenerator3D<T, DESCRIPTOR>(iX, iX, iY, iY, iZ, iZ, -discreteNormal[1], -discreteNormal[2], -discreteNormal[3]) };
    if (postProcessor) {
          _block.addPostProcessor(*postProcessor);
        }
      }
      else {
        clout << "Warning: Could not setAdvectionDiffusionConvectionBoundary (" << iX << ", " << iY << ", " << iZ << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] << ", " << discreteNormal[3] << "), set to bounceBack" << std::endl;
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setAdvectionDiffusionConvectionBoundary() [2/3]

template<typename T , typename DESCRIPTOR >

void olb::setAdvectionDiffusionConvectionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the AdvectionDiffusionConvectionBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setAdvectionDiffusionConvectionBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setAdvectionDiffusionConvectionBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setAdvectionDiffusionConvectionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc), indicator->getBlockIndicatorF(iCloc),
        includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setAdvectionDiffusionConvectionBoundary() [3/3]

template<typename T , typename DESCRIPTOR >

void olb::setAdvectionDiffusionConvectionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the AdvectionDiffusionConvectionBoundary function on the superLattice domain This is an Advection Diffusion Boundary therefore mostly--> MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>

Initialising the AdvectionDiffusionConvectionBoundary function on the superLattice domain.

Definition at line 36 of file setAdvectionDiffusionConvectionBoundary3D.hh.

{
  setAdvectionDiffusionConvectionBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setAdvectionDiffusionTemperatureBoundary() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setAdvectionDiffusionTemperatureBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator )

Set AdvectionDiffusionTemperatureBoundary for any indicated cells inside the block domain.

Definition at line 54 of file setAdvectionDiffusionTemperatureBoundary3D.hh.

{
  using namespace boundaryhelper;
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
 
      if(discreteNormal[0] == 2 || discreteNormal[0] == 4) { // internal corner or internal edge -> probably curved boundary
        throw std::runtime_error("No valid discrete normal found. This BC is not suited for curved walls.");
      }
 
      if (discreteNormal[0] == 0) { // flat //set momenta, dynamics and postProcessors for indicated cells
        _block.defineDynamics({iX, iY, iZ}, DirectionOrientationMixinDynamicsForPlainMomenta<T,DESCRIPTOR,
            AdvectionDiffusionBoundariesDynamics,MixinDynamics,momenta::EquilibriumBoundaryTuple>::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      else if (discreteNormal[0] == 1) {    // corner //set momenta, dynamics and postProcessors on indicated boundery corner cells
        _block.defineDynamics({iX, iY, iZ}, NormalMixinDynamicsForPlainMomenta<T,DESCRIPTOR,
          AdvectionDiffusionCornerDynamics3D,MixinDynamics,momenta::EquilibriumBoundaryTuple
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      else if (discreteNormal[0] == 3) {    // edge //set momenta, dynamics and postProcessors on indicated boundary edge cells
        _block.defineDynamics({iX, iY, iZ}, NormalSpecialMixinDynamicsForPlainMomenta<T,DESCRIPTOR,
          AdvectionDiffusionEdgesDynamics,MixinDynamics,momenta::EquilibriumBoundaryTuple
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::defineDynamics(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setAdvectionDiffusionTemperatureBoundary() [2/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setAdvectionDiffusionTemperatureBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF2D< T > &	indicator )

Set AdvectionDiffusionTemperatureBoundary for indicated cells inside the block domain.

set AdvectionDiffusionTemperature boundary on indicated cells inside the block domains

Definition at line 53 of file setAdvectionDiffusionTemperatureBoundary2D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = 1;
  std::vector<int> discreteNormal(3,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX,iY);
 
      if (discreteNormal[0] == 0) {
        block.defineDynamics({iX,iY}, DirectionOrientationMixinDynamicsForPlainMomenta<T,DESCRIPTOR,
          AdvectionDiffusionBoundariesDynamics,MixinDynamics,momenta::EquilibriumBoundaryTuple
        >::construct(Vector<int,2>(discreteNormal.data() + 1)));
      }
      else if (discreteNormal[0] == 1) {
        block.defineDynamics({iX,iY}, NormalMixinDynamicsForPlainMomenta<T,DESCRIPTOR,
          AdvectionDiffusionCornerDynamics2D,MixinDynamics,momenta::EquilibriumBoundaryTuple
        >::construct(Vector<int,2>(discreteNormal.data() + 1)));
      }
      else { // discreteNormal[2] == 2 -> internal corner, probably a curved wall
        throw std::runtime_error("No valid discrete normal found. This BC is not suited for curved walls.");
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::defineDynamics(), and olb::BlockIndicatorF2D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setAdvectionDiffusionTemperatureBoundary() [3/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setAdvectionDiffusionTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattic,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the AdvectionDiffusionTemperatureBoundary on the superLattice domain.

Definition at line 42 of file setAdvectionDiffusionTemperatureBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setAdvectionDiffusionTemperatureBoundary");
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setAdvectionDiffusionTemperatureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc),
        indicator->getBlockIndicatorF(iCloc));
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setAdvectionDiffusionTemperatureBoundary() [4/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setAdvectionDiffusionTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setAdvectionDiffusionTemperatureBoundary function on the superLattice domain.

Definition at line 42 of file setAdvectionDiffusionTemperatureBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setAdvectionDiffusionTemperatureBoundary");
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); iCloc++) {
    setAdvectionDiffusionTemperatureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc),
        indicator->getBlockIndicatorF(iCloc));
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setAdvectionDiffusionTemperatureBoundary() [5/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setAdvectionDiffusionTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the AdvectionDiffusionTemperatureBoundary on the superLattice domain This is an advection diffusion boundary -->MixinDynamics = AdvectionDiffusionRLBdynamics Moment-based boundary condition (see ref.

Initialising the AdvectionDiffusionTemperatureBoundary on the superLattice domain.

doi:10.1504/PCFD.2016.077296) if a single population is missing, otherwise non-equilibrium bounce-back is used (see ref. doi:10.1007/978-3-319-44649-3)

Definition at line 35 of file setAdvectionDiffusionTemperatureBoundary2D.hh.

{
  setAdvectionDiffusionTemperatureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setAdvectionDiffusionTemperatureBoundary() [6/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setAdvectionDiffusionTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setAdvectionDiffusionTemperatureBoundary function on the superLattice domain This is an AdvectionDiffusionBoundary therefore mostly --> MixinDynamics = AdvectionDiffusionRLBdynamics.

Initialising the setAdvectionDiffusionTemperatureBoundary function on the superLattice domain.

Definition at line 35 of file setAdvectionDiffusionTemperatureBoundary3D.hh.

{
  setAdvectionDiffusionTemperatureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setBlockExternalParticleField() [1/4]

template<typename T , typename DESCRIPTOR >

void olb::setBlockExternalParticleField	(	BlockGeometryStructure2D< T > &	blockGeometry,
		AnalyticalF< 2, T, T > &	velocity,
		SmoothIndicatorF2D< T, T, true > &	sIndicator,
		BlockLattice2D< T, DESCRIPTOR > &	extendedBlockLattice )

◆ setBlockExternalParticleField() [2/4]

template<typename T , typename DESCRIPTOR >

void olb::setBlockExternalParticleField	(	BlockGeometryStructure2D< T > &	blockGeometry,
		AnalyticalF< 2, T, T > &	velocity,
		SmoothIndicatorF2D< T, T, true > &	sIndicator,
		BlockLattice2D< T, DESCRIPTOR > &	extendedBlockLattice,
		Vector< T, 2 >	cellMin,
		Vector< T, 2 >	cellMax,
		Vector< bool, 2 >	periodic )

◆ setBlockExternalParticleField() [3/4]

template<typename T , typename DESCRIPTOR >

void olb::setBlockExternalParticleField	(	BlockGeometryStructure3D< T > &	blockGeometry,
		AnalyticalF< 3, T, T > &	velocity,
		SmoothIndicatorF3D< T, T, true > &	sIndicator,
		BlockLattice3D< T, DESCRIPTOR > &	extendedBlockLattice )

◆ setBlockExternalParticleField() [4/4]

template<typename T , typename DESCRIPTOR >

void olb::setBlockExternalParticleField	(	BlockGeometryStructure3D< T > &	blockGeometry,
		AnalyticalF< 3, T, T > &	velocity,
		SmoothIndicatorF3D< T, T, true > &	sIndicator,
		BlockLattice3D< T, DESCRIPTOR > &	extendedBlockLattice,
		Vector< T, 3 >	cellMin,
		Vector< T, 3 >	cellMax,
		Vector< bool, 3 >	periodic )

◆ setBlockZetaParticleField()

template<typename T , typename DESCRIPTOR >

void olb::setBlockZetaParticleField	(	BlockGeometryStructure2D< T > &	blockGeometry,
		AnalyticalF< 2, T, T > &	velocity,
		SmoothIndicatorF2D< T, T, true > &	sIndicator,
		BlockLattice2D< T, DESCRIPTOR > &	extendedBlockLattice )

◆ setBounceBackBoundary() [1/2]

template<typename T , typename DESCRIPTOR >

void olb::setBounceBackBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	indicator )

Set bounce back boundary on indicated cells of lattice.

Definition at line 31 of file setBounceBackBoundary.h.

{
  sLattice.template defineDynamics<BounceBack>(
    std::forward<decltype(indicator)>(indicator));
}

Here is the caller graph for this function:

◆ setBounceBackBoundary() [2/2]

template<typename T , typename DESCRIPTOR >

void olb::setBounceBackBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, DESCRIPTOR::d > &	superGeometry,
		int	material )

Set bounce back boundary on material cells of lattice.

Definition at line 40 of file setBounceBackBoundary.h.

{
  setBounceBackBoundary(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBounceBackBoundary().

Here is the call graph for this function:

◆ setBounceBackVelocityBoundary() [1/3]

template<typename T , typename DESCRIPTOR >

void olb::setBounceBackVelocityBoundary	(	BlockIndicatorF3D< T > &	indicator,
		T	omega,
		bool	includeOuterCells,
		BlockLattice< T, DESCRIPTOR > &	_block )

Set BounceBackVelocityBoundary for any indicated cells inside the block domain.

Definition at line 57 of file setBounceBackVelocityBoundary3D.hh.

{
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  T default_rho = 1.0;
  T default_u[] = {0.0, 0.0, 0.0};
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      PostProcessorGenerator3D<T,DESCRIPTOR>* postProcessor = nullptr;
      dynamics = new BounceBackVelocity<T,DESCRIPTOR>(default_rho, default_u);
 
      setBoundary(_block, iX,iY,iZ, dynamics, postProcessor);
    }
  });
}

References olb::BlockIndicatorF3D< T >::getBlockGeometry(), and setBoundary().

Here is the call graph for this function:

◆ setBounceBackVelocityBoundary() [2/3]

template<typename T , typename DESCRIPTOR >

void olb::setBounceBackVelocityBoundary	(	FunctorPtr< SuperIndicatorF3D< T > > &&	indicator,
		T	omega,
		SuperLattice< T, DESCRIPTOR > &	sLattice )

Definition at line 40 of file setBounceBackVelocityBoundary3D.hh.

{
  OstreamManager clout(std::cout, "BounceBackVelocityBoundary");
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  clout << sLattice.getLoadBalancer().size() <<"sLattice.getLoadBalancer.size()" << std::endl;
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setBounceBackVelocityBoundary<T,DESCRIPTOR>(indicator->getBlockIndicatorF(iC),omega,includeOuterCells,sLattice.getBlock(iC));
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setBounceBackVelocityBoundary() [3/3]

template<typename T , typename DESCRIPTOR >

void olb::setBounceBackVelocityBoundary	(	SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		T	omega,
		SuperLattice< T, DESCRIPTOR > &	sLattice )

Initialising the setLocalVelocityBoundary function on the superLattice domain.

Definition at line 34 of file setBounceBackVelocityBoundary3D.hh.

{
  setBounceBackVelocityBoundary<T,DESCRIPTOR>(superGeometry.getMaterialIndicator(material),omega,sLattice);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setBoundary() [1/4]

template<typename T , typename DESCRIPTOR >

void olb::setBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		int	iX,
		int	iY,
		int	iZ,
		Dynamics< T, DESCRIPTOR > *	dynamics )

Definition at line 45 of file setBoundary3D.h.

{
  if (dynamics) {
    _block.defineDynamics({iX, iY, iZ}, dynamics);
    auto cell = _block.get(iX,iY,iZ);
    dynamics->initialize(cell);
  }
}

References olb::BlockLattice< T, DESCRIPTOR >::defineDynamics(), olb::BlockLattice< T, DESCRIPTOR >::get(), and olb::Dynamics< T, DESCRIPTOR >::initialize().

Here is the call graph for this function:

◆ setBoundary() [2/4]

template<typename T , typename DESCRIPTOR >

void olb::setBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		int	iX,
		int	iY,
		int	iZ,
		Dynamics< T, DESCRIPTOR > *	dynamics,
		PostProcessorGenerator3D< T, DESCRIPTOR > *	postProcessor )

sets boundary on indicated cells. This is a function, which can be used on many boundaries.

Definition at line 31 of file setBoundary3D.h.

{
  if (dynamics) {
    _block.defineDynamics({iX, iY, iZ}, dynamics);
    auto cell = _block.get(iX,iY,iZ);
    dynamics->initialize(cell);
  }
  if (postProcessor && !_block.isPadding({iX,iY,iZ})) {
    _block.addPostProcessor(*postProcessor);
  }
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockLattice< T, DESCRIPTOR >::defineDynamics(), olb::BlockLattice< T, DESCRIPTOR >::get(), olb::Dynamics< T, DESCRIPTOR >::initialize(), and olb::BlockStructureD< D >::isPadding().

Here is the call graph for this function:

◆ setBoundary() [3/4]

template<typename T , typename DESCRIPTOR >

void olb::setBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		int	iX,
		int	iY,
		Dynamics< T, DESCRIPTOR > *	dynamics )

Definition at line 48 of file setBoundary2D.h.

{
  if (dynamics) {
    block.defineDynamics({iX, iY}, dynamics);
    auto cell = block.get(iX,iY);
    dynamics->initialize(cell);
  }
}

References olb::BlockLattice< T, DESCRIPTOR >::defineDynamics(), olb::BlockLattice< T, DESCRIPTOR >::get(), and olb::Dynamics< T, DESCRIPTOR >::initialize().

Here is the call graph for this function:

◆ setBoundary() [4/4]

template<typename T , typename DESCRIPTOR >

void olb::setBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		int	iX,
		int	iY,
		Dynamics< T, DESCRIPTOR > *	dynamics,
		PostProcessorGenerator2D< T, DESCRIPTOR > *	postProcessor )

Definition at line 33 of file setBoundary2D.h.

{
  if (dynamics) {
    block.defineDynamics({iX, iY}, dynamics);
    auto cell = block.get(iX,iY);
    dynamics->initialize(cell);
  }
  if (postProcessor && !block.isPadding({iX,iY})) {
    block.addPostProcessor(*postProcessor);
  }
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockLattice< T, DESCRIPTOR >::defineDynamics(), olb::BlockLattice< T, DESCRIPTOR >::get(), olb::Dynamics< T, DESCRIPTOR >::initialize(), and olb::BlockStructureD< D >::isPadding().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setBouzidiAdeDirichlet() [1/8]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiAdeDirichlet	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF< T, DESCRIPTOR::d > &	boundaryIndicator,
		BlockIndicatorF< T, DESCRIPTOR::d > &	bulkIndicator,
		AnalyticalF< DESCRIPTOR::d, T, T > &	phi_d,
		Cuboid< T, DESCRIPTOR::d > &	cuboid )

Definition at line 547 of file setBouzidiBoundary.h.

{
  block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
    if (boundaryIndicator(solidLatticeR)) {
      for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
        Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
        if (block.isInside(boundaryLatticeR)) {
          const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
          auto x_b = block.get(boundaryLatticeR);
          const auto opp_bouzidi_dist = x_b.template getFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite);
 
          // check if distance from the fluid cell to the solid cell is a valid bouzidi distance
          if (opp_bouzidi_dist >= 0) {
            T boundaryPhysR[DESCRIPTOR::d] { };
            T phi_at_cell[1] { };
            cuboid.getPhysR(boundaryPhysR, boundaryLatticeR);
 
            phi_d(phi_at_cell, boundaryPhysR);
 
            // set computed velocity into the bouzidi velocity field
            block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_ADE_DIRICHLET>(iPop_opposite, phi_at_cell[0]);
          }
        }
      }
    }
  });
}

References olb::BlockStructureD< D >::forSpatialLocations(), olb::BlockLattice< T, DESCRIPTOR >::get(), and olb::BlockStructureD< D >::isInside().

Here is the call graph for this function:

◆ setBouzidiAdeDirichlet() [2/8]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiAdeDirichlet	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF< T, DESCRIPTOR::d > &	boundaryIndicator,
		BlockIndicatorF< T, DESCRIPTOR::d > &	bulkIndicator,
		T	phi_d,
		Cuboid< T, DESCRIPTOR::d > &	cuboid )

Definition at line 520 of file setBouzidiBoundary.h.

{
  block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
    if (boundaryIndicator(solidLatticeR)) {
      for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
        Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
        if (block.isInside(boundaryLatticeR)) {
          const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
          auto x_b = block.get(boundaryLatticeR);
          const auto opp_bouzidi_dist = x_b.template getFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite);
 
          // check if distance from the fluid cell to the solid cell is a valid bouzidi distance
          if (opp_bouzidi_dist >= 0) {
            // set computed velocity into the bouzidi velocity field
            block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_ADE_DIRICHLET>(iPop_opposite, phi_d);
          }
        }
      }
    }
  });
}

References olb::BlockStructureD< D >::forSpatialLocations(), olb::BlockLattice< T, DESCRIPTOR >::get(), and olb::BlockStructureD< D >::isInside().

Here is the call graph for this function:

◆ setBouzidiAdeDirichlet() [3/8]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiAdeDirichlet	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	boundaryIndicator,
		AnalyticalF< DESCRIPTOR::d, T, T > &	phi_d,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Definition at line 509 of file setBouzidiBoundary.h.

{
  setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
                               boundaryIndicator->getSuperGeometry().getMaterialIndicator(std::move(bulkMaterials)),
                               phi_d);
}

◆ setBouzidiAdeDirichlet() [4/8]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiAdeDirichlet	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	boundaryIndicator,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	bulkIndicator,
		AnalyticalF< DESCRIPTOR::d, T, T > &	phi_d )

Definition at line 480 of file setBouzidiBoundary.h.

{
  auto& load = sLattice.getLoadBalancer();
  auto& cuboidGeometry = boundaryIndicator->getSuperGeometry().getCuboidGeometry();
  for (int iCloc = 0; iCloc < load.size(); ++iCloc) {
    auto& cuboid = cuboidGeometry.get(load.glob(iCloc));
    setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
                                     boundaryIndicator->getBlockIndicatorF(iCloc),
                                     bulkIndicator->getBlockIndicatorF(iCloc),
                                     phi_d,
                                     cuboid);
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setBouzidiAdeDirichlet() [5/8]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiAdeDirichlet	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	boundaryIndicator,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	bulkIndicator,
		T	phi_d )

Definition at line 462 of file setBouzidiBoundary.h.

{
  auto& load = sLattice.getLoadBalancer();
  auto& cuboidGeometry = boundaryIndicator->getSuperGeometry().getCuboidGeometry();
  for (int iCloc = 0; iCloc < load.size(); ++iCloc) {
    auto& cuboid = cuboidGeometry.get(load.glob(iCloc));
    setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
                                     boundaryIndicator->getBlockIndicatorF(iCloc),
                                     bulkIndicator->getBlockIndicatorF(iCloc),
                                     phi_d,
                                     cuboid);
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setBouzidiAdeDirichlet() [6/8]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiAdeDirichlet	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	boundaryIndicator,
		T	phi_d,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Definition at line 498 of file setBouzidiBoundary.h.

{
  setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
                               boundaryIndicator->getSuperGeometry().getMaterialIndicator(std::move(bulkMaterials)),
                               phi_d);
}

◆ setBouzidiAdeDirichlet() [7/8]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiAdeDirichlet	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, DESCRIPTOR::d > &	superGeometry,
		int	material,
		AnalyticalF< DESCRIPTOR::d, T, T > &	phi_d,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Definition at line 453 of file setBouzidiBoundary.h.

{
  setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material), phi_d, bulkMaterials);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setBouzidiAdeDirichlet() [8/8]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiAdeDirichlet	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, DESCRIPTOR::d > &	superGeometry,
		int	material,
		T	phi_d,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Definition at line 444 of file setBouzidiBoundary.h.

{
  setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material), phi_d, bulkMaterials);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setBouzidiBoundary() [1/3]

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>

void olb::setBouzidiBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockGeometry< T, DESCRIPTOR::d > &	blockGeometry,
		BlockIndicatorF< T, DESCRIPTOR::d > &	boundaryIndicator,
		BlockIndicatorF< T, DESCRIPTOR::d > &	bulkIndicator,
		IndicatorF< T, DESCRIPTOR::d > &	indicatorAnalyticalBoundary,
		bool	verbose = false )

Set Bouzidi boundary on indicated cells of block lattice.

Definition at line 250 of file setBouzidiBoundary.h.

{
  OstreamManager clout(std::cout, "BouzidiBoundarySetter");
  clout.setMultiOutput(true);
 
  const T deltaR = blockGeometry.getDeltaR();
  // for each solid cell: all of its fluid neighbors need population updates
  block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
    // Check if cell is solid cell
    if (boundaryIndicator(solidLatticeR)) {
      for (int iPop=1; iPop < DESCRIPTOR::q; ++iPop) {
        Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
        const auto c = descriptors::c<DESCRIPTOR>(iPop);
        const auto iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
 
        if (blockGeometry.isInside(boundaryLatticeR)) {
          T boundaryPhysR[DESCRIPTOR::d] { };
          blockGeometry.getPhysR(boundaryPhysR,boundaryLatticeR);
          // check if neighbor is fluid cell
          if (bulkIndicator(boundaryLatticeR)) {
            T dist = -1;    // distance to boundary
            T qIpop = -1;   // normed distance (Bouzidi distance) to boundary
            const T norm = deltaR * util::norm<DESCRIPTOR::d>(descriptors::c<DESCRIPTOR>(iPop));
            auto direction = -deltaR * c; // vector pointing from the boundary cell to the solid cell
 
            // Check if distance calculation was performed correctly
            if (indicatorAnalyticalBoundary.distance(dist, boundaryPhysR, direction, blockGeometry.getIcGlob())) {
              qIpop = dist / norm;
 
              // if distance function returned a dist. not suitable for Bouzidi -> fall-back
              if ((qIpop < 0) || (qIpop > 1)) {
                if(verbose) {
                  clout << "Error, non suitable dist. at lattice: (" << boundaryLatticeR << "), physical: (" << blockGeometry.getPhysR(boundaryLatticeR) << "), direction " << iPop << ". Fall-back to bounce-back." << std::endl;
                }
 
                // fall-back: half-way bounce back
                qIpop = 0.5;
              }
            }
            // if distance function couldn't compute any distance -> fall-back
            else {
              if(verbose) {
                clout << "Error, no boundary found at lattice:(" << boundaryLatticeR << "), physical: (" << blockGeometry.getPhysR(boundaryLatticeR) << "), direction: " << iPop << ".Fall-back to bounce-back." << std::endl;
              }
 
              // fall-back: half-way bounce back
              qIpop = 0.5;
            }
 
            // double check
            if (qIpop >= 0) {
              // Bouzidi require the fluid side neighbor of the boundary cell also to be fluid
              if (bulkIndicator(boundaryLatticeR + descriptors::c<DESCRIPTOR>(iPop))) {
                // Standard case, c.f. Bouzidi paper, setting Bouzidi-distance
                block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, qIpop);
              }
              else {
                // If no fluid cell found: fall-back to bounce-back
                block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, T{0.5});
              }
              // Initialize velocity coefficients if necessary
              if constexpr (std::is_same_v<OPERATOR, BouzidiVelocityPostProcessor>) {
                block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_VELOCITY>(iPop_opposite, 0);
              }
              // Initialize ade dirichlet coefficients if necessary
              if constexpr (std::is_same_v<OPERATOR, BouzidiAdeDirichletPostProcessor>) {
                block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_ADE_DIRICHLET>(iPop_opposite, 0);
              }
              // Setting up the post processor, if this cell does not have one yet.
              if (!block.isPadding(boundaryLatticeR)) {
                block.addPostProcessor(typeid(stage::PostStream),
                                      boundaryLatticeR,
                                      meta::id<OPERATOR>{});
              }
            }
          }
          // if neigbour cell is not fluid
          else {
            // check if neighbor cell is not solid
            if (blockGeometry.getMaterial(boundaryLatticeR) != 0) {
              // fall-back to half-way bounce-back
              block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, T{0.5});
              // Initialize velocity coefficients if necessary
              if constexpr (std::is_same_v<OPERATOR, BouzidiVelocityPostProcessor>) {
                block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_VELOCITY>(iPop_opposite, 0);
              }
              // Initialize velocity coefficients if necessary
              if constexpr (std::is_same_v<OPERATOR, BouzidiAdeDirichletPostProcessor>) {
                block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_ADE_DIRICHLET>(iPop_opposite, 0);
              }
              if (!block.isPadding(boundaryLatticeR)) {
                block.addPostProcessor(typeid(stage::PostStream),
                                      boundaryLatticeR,
                                      meta::id<OPERATOR>{});
              }
            }
          }
        }
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockStructureD< D >::forSpatialLocations(), olb::BlockLattice< T, DESCRIPTOR >::get(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getIcGlob(), olb::BlockGeometry< T, D >::getMaterial(), olb::BlockGeometry< T, D >::getPhysR(), olb::BlockStructureD< D >::isInside(), olb::BlockStructureD< D >::isPadding(), norm(), and olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

◆ setBouzidiBoundary() [2/3]

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>

void olb::setBouzidiBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	boundaryIndicator,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	bulkIndicator,
		IndicatorF< T, DESCRIPTOR::d > &	indicatorAnalyticalBoundary )

Set Bouzidi boundary on indicated cells of sLattice.

Definition at line 213 of file setBouzidiBoundary.h.

{
  int _overlap = 1;
  OstreamManager clout(std::cout, "BouzidiBoundarySetter");
  auto& load = sLattice.getLoadBalancer();
  for (int iC=0; iC < load.size(); ++iC) {
    setBouzidiBoundary<T,DESCRIPTOR,OPERATOR>(sLattice.getBlock(iC),
                          (bulkIndicator->getBlockIndicatorF(iC)).getBlockGeometry(),
                          boundaryIndicator->getBlockIndicatorF(iC),
                          bulkIndicator->getBlockIndicatorF(iC),
                          indicatorAnalyticalBoundary);
  }
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator), _overlap);
  clout.setMultiOutput(false);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and olb::OstreamManager::setMultiOutput().

Here is the call graph for this function:

◆ setBouzidiBoundary() [3/3]

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>

void olb::setBouzidiBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, DESCRIPTOR::d > &	superGeometry,
		int	materialOfSolidObstacle,
		IndicatorF< T, DESCRIPTOR::d > &	indicatorAnalyticalBoundary,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Set Bouzidi boundary on material cells of sLattice.

Definition at line 234 of file setBouzidiBoundary.h.

{
  //Getting the indicators by material numbers and calling the superLattice method via the indicators:
  setBouzidiBoundary<T,DESCRIPTOR,OPERATOR>(sLattice,
                      FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(materialOfSolidObstacle)),
                      FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(std::move(bulkMaterials))),
                      indicatorAnalyticalBoundary);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setBouzidiVelocity() [1/4]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiVelocity	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF< T, DESCRIPTOR::d > &	boundaryIndicator,
		BlockIndicatorF< T, DESCRIPTOR::d > &	bulkIndicator,
		AnalyticalF< DESCRIPTOR::d, T, T > &	u,
		Cuboid< T, DESCRIPTOR::d > &	cuboid )

Set Bouzidi velocity boundary on indicated cells of block lattice.

Definition at line 401 of file setBouzidiBoundary.h.

{
  const T deltaR = cuboid.getDeltaR();
  block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
    if (boundaryIndicator(solidLatticeR)) {
      for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
        Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
        if (block.isInside(boundaryLatticeR)) {
          const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
          auto x_b = block.get(boundaryLatticeR);
          const auto opp_bouzidi_dist = x_b.template getFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite);
 
          // check if distance from the fluid cell to the solid cell is a valid bouzidi distance
          if (opp_bouzidi_dist >= 0) {
            T wallVelocity[DESCRIPTOR::d] = { };
            T physicalIntersection[DESCRIPTOR::d] = { };
            T boundaryPhysR[DESCRIPTOR::d] { };
            cuboid.getPhysR(boundaryPhysR, boundaryLatticeR);
 
            // calculating the intersection of the boundary with the missing link in physical coordinates
            for ( int i = 0; i< DESCRIPTOR::d; ++i) {
              physicalIntersection[i] = boundaryPhysR[i] + opp_bouzidi_dist * deltaR * descriptors::c<DESCRIPTOR>(iPop_opposite,i);
            }
 
            //Calculating the velocity at the wall intersection
            u(wallVelocity, physicalIntersection);
            const auto c = descriptors::c<DESCRIPTOR>(iPop_opposite);
            T vel_coeff = c * Vector<T,DESCRIPTOR::d>(wallVelocity);
 
            // set computed velocity into the bouzidi velocity field
            block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_VELOCITY>(iPop_opposite, vel_coeff);
          }
        }
      }
    }
  });
}

References olb::BlockStructureD< D >::forSpatialLocations(), olb::BlockLattice< T, DESCRIPTOR >::get(), and olb::BlockStructureD< D >::isInside().

Here is the call graph for this function:

◆ setBouzidiVelocity() [2/4]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiVelocity	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	boundaryIndicator,
		AnalyticalF< DESCRIPTOR::d, T, T > &	u,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Set Bouzidi velocity boundary on indicated cells of sLattice.

Definition at line 370 of file setBouzidiBoundary.h.

{
  setBouzidiVelocity<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
                               boundaryIndicator->getSuperGeometry().getMaterialIndicator(std::move(bulkMaterials)),
                               u);
}

◆ setBouzidiVelocity() [3/4]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiVelocity	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	boundaryIndicator,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	bulkIndicator,
		AnalyticalF< DESCRIPTOR::d, T, T > &	u )

Set Bouzidi velocity boundary on indicated cells of sLattice.

Definition at line 382 of file setBouzidiBoundary.h.

{
  auto& load = sLattice.getLoadBalancer();
  auto& cuboidGeometry = boundaryIndicator->getSuperGeometry().getCuboidGeometry();
  for (int iCloc = 0; iCloc < load.size(); ++iCloc) {
    auto& cuboid = cuboidGeometry.get(load.glob(iCloc));
    setBouzidiVelocity<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
                                     boundaryIndicator->getBlockIndicatorF(iCloc),
                                     bulkIndicator->getBlockIndicatorF(iCloc),
                                     u,
                                     cuboid);
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setBouzidiVelocity() [4/4]

template<typename T , typename DESCRIPTOR >

void olb::setBouzidiVelocity	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, DESCRIPTOR::d > &	superGeometry,
		int	material,
		AnalyticalF< DESCRIPTOR::d, T, T > &	u,
		std::vector< int >	bulkMaterials = std::vector<int>(1,1) )

Set Bouzidi velocity boundary on material cells of sLattice.

Definition at line 360 of file setBouzidiBoundary.h.

{
  setBouzidiVelocity<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material), u, bulkMaterials);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setExtFieldBoundary() [1/3]

template<typename T , typename DESCRIPTOR , typename FIELD_A , typename FIELD_B >

void olb::setExtFieldBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator )

Set externalFieldBoundary for any indicated cells inside the block domain.

Definition at line 59 of file setExtFieldBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setExtFieldBoundary");
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = 1;
  std::vector<int> discreteNormal(4, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {
        auto postProcessor = std::unique_ptr<PostProcessorGenerator3D<T, DESCRIPTOR>>{
        new ExtFieldBoundaryProcessorGenerator3D<T,DESCRIPTOR,FIELD_A,FIELD_B>(iX, iX, iY, iY, iZ, iZ, -discreteNormal[1], -discreteNormal[2], -discreteNormal[3]) };
        if (postProcessor) {
          _block.addPostProcessor(*postProcessor);
        }
      }
      else {
        clout << "Warning: Could not setExternalFieldBoundary (" << iX << ", " << iY << ", " << iZ << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] << "," << discreteNormal[3] << ")" << std::endl;
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setExtFieldBoundary() [2/3]

template<typename T , typename DESCRIPTOR , typename FIELD_A , typename FIELD_B >

void olb::setExtFieldBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the ExternalFieldBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setExtFieldBoundary3D.hh.

{
  int _overlap = 1;
  OstreamManager clout(std::cout, "setExtFieldBoundary");
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setExtFieldBoundary<T,DESCRIPTOR,FIELD_A,FIELD_B>(
      sLattice.getBlock(iCloc),
      indicator->getBlockIndicatorF(iCloc));
  }
  addPoints2CommBC(sLattice,std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setExtFieldBoundary() [3/3]

template<typename T , typename DESCRIPTOR , typename FIELD_A , typename FIELD_B >

void olb::setExtFieldBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the ExternalFieldBoundary on the superLattice domain This is an AdvectionDiffusionBoundary --> MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>

Initialising the ExternalFieldBoundary on the superLattice domain.

Definition at line 35 of file setExtFieldBoundary3D.hh.

{
  setExtFieldBoundary<T,DESCRIPTOR,FIELD_A,FIELD_B>(sLattice,
      superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFdBoundary2D() [1/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdBoundary2D	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF2D< T > &	indicator,
		bool	includeOuterCells = false )

Set interpolated velocity boundary for any indicated cells inside the block domain.

Set Interpolated velocity boundary for any indicated cells inside the block domain.

Definition at line 65 of file setFdBoundary2D.hh.

{
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
      block.get(iX, iY).template setField<descriptors::NORMAL_X>(-discreteNormal[1]);
      block.get(iX, iY).template setField<descriptors::NORMAL_Y>(-discreteNormal[2]);
    }
  });
  block.addPostProcessor ( typeid(stage::PostStream), indicator,
                           meta::id<FdBoundaryPostProcessor2D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>>{} );
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockLattice< T, DESCRIPTOR >::get(), and olb::BlockIndicatorF2D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setFdBoundary2D() [2/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdBoundary2D	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the setFdBoundary2D function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setFdBoundary2D.hh.

{
  bool includeOuterCells = false;
  int _overlap = indicator->getSuperGeometry().getOverlap();
  OstreamManager clout(std::cout, "setOnBCInterpolatedBoundary");
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setFdBoundary2D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>(sLattice.getBlock(iCloc),
        indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary2D.h/hh
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
 
 
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFdBoundary2D() [3/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdBoundary2D	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the setFdBoundary2D function on the superLattice domain Interpolated Boundaries use the BGKdynamics collision-operator.

Initialising the setFdBoundary2D function on the superLattice domain.

Definition at line 35 of file setFdBoundary2D.hh.

{
  setFdBoundary2D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFdBoundary3D() [1/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdBoundary3D	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells )

Definition at line 65 of file setFdBoundary3D.hh.

{
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      std::vector<int> discreteNormal(4,0);
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY, iZ);
      block.get(iX, iY, iZ).template setField<descriptors::NORMAL_X>(-discreteNormal[1]);
      block.get(iX, iY, iZ).template setField<descriptors::NORMAL_Y>(-discreteNormal[2]);
      block.get(iX, iY, iZ).template setField<descriptors::NORMAL_Z>(-discreteNormal[3]);
    }
  });
  block.addPostProcessor ( typeid(stage::PostStream), indicator,
                           meta::id<FdBoundaryPostProcessor3D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>> {} );
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockStructureD< D >::forSpatialLocations(), olb::BlockLattice< T, DESCRIPTOR >::get(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), and olb::BlockGeometry< T, D >::getStatistics().

Here is the call graph for this function:

◆ setFdBoundary3D() [2/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdBoundary3D	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setFdBoundary3D function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setFdBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setFdBoundary3D");
  int _overlap = indicator->getSuperGeometry().getOverlap();
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setFdBoundary3D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>(sLattice.getBlock(iC), indicator->getBlockIndicatorF(iC),includeOuterCells);
    //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary3D.h/hh
    addPoints2CommBC(sLattice,std::forward<decltype(indicator)>(indicator), _overlap);
  }
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFdBoundary3D() [3/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename SCHEME_BOUND , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdBoundary3D	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setFdBoundary3D function on the superLattice domain.

Definition at line 35 of file setFdBoundary3D.hh.

{
  setFdBoundary3D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFdPostProcessor2D() [1/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdPostProcessor2D	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF< T, DESCRIPTOR::d > &	indicator )

Definition at line 50 of file setFdPostProcessor2D.hh.

{
  block.addPostProcessor(typeid(stage::PostStream), indicator, meta::id<FdPostProcessor2D<T,DESCRIPTOR,MODEL,PARAMETERS,FIELD,SOURCE>>{});
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor().

Here is the call graph for this function:

◆ setFdPostProcessor2D() [2/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdPostProcessor2D	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	indicator )

Initialising the setFdPostProcessor function on the superLattice domain.

Definition at line 41 of file setFdPostProcessor2D.hh.

{
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setFdPostProcessor2D<T,DESCRIPTOR,MODEL,PARAMETERS,FIELD,SOURCE>(sLattice.getBlock(iC), indicator->getBlockIndicatorF(iC));
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFdPostProcessor2D() [3/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdPostProcessor2D	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, DESCRIPTOR::d > &	superGeometry,
		int	material )

Initialising the setFdPostProcessor function on the superLattice domain.

Definition at line 34 of file setFdPostProcessor2D.hh.

{
  setFdPostProcessor2D<T,DESCRIPTOR,MODEL,PARAMETERS,FIELD,SOURCE>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFdPostProcessor3D() [1/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdPostProcessor3D	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF< T, DESCRIPTOR::d > &	indicator )

Definition at line 50 of file setFdPostProcessor3D.hh.

{
  block.addPostProcessor(typeid(stage::PostStream), indicator, meta::id<FdPostProcessor3D<T,DESCRIPTOR,MODEL,PARAMETERS,FIELD,SOURCE>>{});
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor().

Here is the call graph for this function:

◆ setFdPostProcessor3D() [2/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdPostProcessor3D	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&	indicator )

Initialising the setFdPostProcessor function on the superLattice domain.

Definition at line 41 of file setFdPostProcessor3D.hh.

{
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setFdPostProcessor3D<T,DESCRIPTOR,MODEL,PARAMETERS,FIELD,SOURCE>(sLattice.getBlock(iC), indicator->getBlockIndicatorF(iC));
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFdPostProcessor3D() [3/3]

template<typename T , typename DESCRIPTOR , typename MODEL , typename PARAMETERS , typename FIELD = descriptors::AD_FIELD, typename SOURCE = void>

void olb::setFdPostProcessor3D	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, DESCRIPTOR::d > &	superGeometry,
		int	material )

Initialising the setFdPostProcessor function on the superLattice domain.

Definition at line 34 of file setFdPostProcessor3D.hh.

{
  setFdPostProcessor3D<T,DESCRIPTOR,MODEL,PARAMETERS,FIELD,SOURCE>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFreeEnergyInletBoundary() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setFreeEnergyInletBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		T	omega,
		BlockIndicatorF3D< T > &	indicator,
		std::string	type,
		int	latticeNumber,
		bool	includeOuterCells = false )

Set FreeEnergyInletBoundary for any indicated cells inside the block domain.

Definition at line 62 of file setFreeEnergyInletBoundary3D.hh.

{
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  OstreamManager clout(std::cout, "setFreeEnergyInletBoundary");
  bool _output = false;
  std::vector<int> discreteNormal(4, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ, true);
 
      if (discreteNormal[0] == 0) {
        Dynamics<T, DESCRIPTOR>* dynamics = nullptr;
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          if (latticeNumber == 1) {//set PressureBoundary momenta and dynamics on indicated cells
            if (type == "density") {
              dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics,momenta::RegularizedPressureBoundaryTuple<0,-1>>>();
            }
            else {  //set VelocityBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
                momenta::BasicDirichletVelocityBoundaryTuple<0,-1>
              >>();
            }
          }
          else {
            dynamics = _block.template getDynamics<FreeEnergyInletOutletDynamics<T,DESCRIPTOR,0,-1>>();
          }
        }
 
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          if (latticeNumber == 1) {
            if (type == "density") {//set PressureBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics,momenta::RegularizedPressureBoundaryTuple<0,1>>>();
            }
            else {  //set VelocityBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
                momenta::BasicDirichletVelocityBoundaryTuple<0,1>
              >>();
            }
          }
          else {
            dynamics = _block.template getDynamics<FreeEnergyInletOutletDynamics<T,DESCRIPTOR,0,1>>();
          }
        }
 
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          if (latticeNumber == 1) {
            if (type == "density") {//set PressureBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics,momenta::RegularizedPressureBoundaryTuple<1,-1>>>();
            }
            else {  //set VelocityBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
                momenta::BasicDirichletVelocityBoundaryTuple<1,-1>
              >>();
            }
          }
          else {
            dynamics = _block.template getDynamics<FreeEnergyInletOutletDynamics<T,DESCRIPTOR,1,-1>>();
          }
        }
 
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          if (latticeNumber == 1) {
            if (type == "density") {//set PressureBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics,momenta::RegularizedPressureBoundaryTuple<1,1>>>();
            }
            else {  //set VelocityBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
                momenta::BasicDirichletVelocityBoundaryTuple<1,1>
              >>();
            }
          }
          else {
            dynamics = _block.template getDynamics<FreeEnergyInletOutletDynamics<T,DESCRIPTOR,1,1>>();
          }
        }
 
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          if (latticeNumber == 1) {
            if (type == "density") {//set PressureBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics,momenta::RegularizedPressureBoundaryTuple<2,-1>>>();
            }
            else {  //set VelocityBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
                momenta::BasicDirichletVelocityBoundaryTuple<2,-1>
              >>();
            }
          }
          else {
            dynamics = _block.template getDynamics<FreeEnergyInletOutletDynamics<T,DESCRIPTOR,2,-1>>();
          }
        }
 
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          if (latticeNumber == 1) {
            if (type == "density") {//set PressureBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics,momenta::RegularizedPressureBoundaryTuple<2,1>>>();
            }
            else {  //set VelocityBoundary momenta and dynamics on indicated cells
              dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
                momenta::BasicDirichletVelocityBoundaryTuple<2,1>
              >>();
            }
          }
          else {
            dynamics = _block.template getDynamics<FreeEnergyInletOutletDynamics<T,DESCRIPTOR,2,1>>();
          }
        }
        dynamics->getParameters(_block).template set<descriptors::OMEGA>(omega);
        if (latticeNumber != 1) {
          _block.defineDynamics({iX, iY, iZ}, dynamics);
          auto cell = _block.get(iX,iY,iZ);
          dynamics->initialize(cell);
        }
      }
 
      if (latticeNumber == 1){
              _block.addPostProcessor(
        typeid(stage::PostStream), {iX, iY, iZ},
        olb::boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR, FreeEnergyChemPotBoundaryProcessor3DA>(
          Vector<int,3>(discreteNormal.data() + 1)));
      } else {
              _block.addPostProcessor(
        typeid(stage::PostStream), {iX, iY, iZ},
        olb::boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR, FreeEnergyChemPotBoundaryProcessor3DB>(
          Vector<int,3>(discreteNormal.data() + 1)));
      }
 
      if (_output) {
        clout << "setFreeEnergyInletBoundary<" << "," << ">("  << iX << ", "<< iY << ", " << iZ << ")" << std::endl;
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockLattice< T, DESCRIPTOR >::defineDynamics(), olb::BlockLattice< T, DESCRIPTOR >::get(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and olb::Dynamics< T, DESCRIPTOR >::initialize().

Here is the call graph for this function:

◆ setFreeEnergyInletBoundary() [2/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setFreeEnergyInletBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		std::string	type,
		int	latticeNumber,
		bool	includeOuterCells = false )

Set FreeEnergyInlet boundary for any indicated cells inside the block domain.

Set Free Energy Inlet boundary for any indicated cells inside the block domain.

Definition at line 61 of file setFreeEnergyInletBoundary2D.hh.

{
  bool _output = false;
  OstreamManager clout(std::cout, "setFreeEnergyInletBoundary");
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX,iY);
      if (discreteNormal[0] == 0) {
        Dynamics<T, DESCRIPTOR>* dynamics = nullptr;
        if (discreteNormal[1] == -1) {
 
          if (latticeNumber == 1) {
            //set momenta and dynamics for a pressure boundary on indicated cells
            if (type == "density") {
              dynamics = block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics, momenta::RegularizedPressureBoundaryTuple<0,-1>>>();
            }
            else {
              //set momenta and dynamics for a velocity boundary on indicated cells
              dynamics = block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics, momenta::RegularizedVelocityBoundaryTuple<0,-1>>>();
            }
            block.defineDynamics({iX, iY}, dynamics);
          }
          else {
            dynamics = block.template getDynamics<FreeEnergyInletOutletDynamics<T,DESCRIPTOR,0,-1>>();
            block.defineDynamics({iX, iY}, dynamics);
          }
        }
 
        else if (discreteNormal[1] == 1) {
          if (latticeNumber == 1) {
            if (type == "density") {
              //set momenta and dynamics for a pressure boundary on indicated cells
              dynamics = block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics, momenta::RegularizedPressureBoundaryTuple<0,1>>>();
            }
            else {
              //set momenta and dynamics for a velocity boundary on indicated cells
              dynamics = block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics, momenta::RegularizedVelocityBoundaryTuple< 0,1>>>();
            }
            block.defineDynamics({iX, iY}, dynamics);
          }
          else {
            dynamics = block.template getDynamics<FreeEnergyInletOutletDynamics<T,DESCRIPTOR,0,1>>();
            block.defineDynamics({iX, iY}, dynamics);
          }
        }
 
        else if (discreteNormal[2] == -1) {
          if (latticeNumber == 1) {
            if (type == "density") {
              //set momenta and dynamics for a pressure boundary on indicated cells
              dynamics = block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics, momenta::RegularizedPressureBoundaryTuple< 1,-1>>>();
            }
            else {
              //set momenta and dynamics for a velocity boundary on indicated cells
              dynamics = block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
                MixinDynamics, momenta::RegularizedVelocityBoundaryTuple< 1,-1>>>();
            }
            block.defineDynamics({iX, iY}, dynamics);
          }
          else {
            dynamics = block.template getDynamics<FreeEnergyInletOutletDynamics<T,DESCRIPTOR,1,-1>>();
            block.defineDynamics({iX, iY}, dynamics);
          }
        }
 
        else if (discreteNormal[2] == 1) {
          if (latticeNumber == 1) {
            if (type == "density") {
              //set momenta and dynamics for a pressure boundary on indicated cells
              dynamics = block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR, MixinDynamics,
                momenta::RegularizedPressureBoundaryTuple< 1,1>>>();
            }
            else {
              //set momenta and dynamics for a velocity boundary on indicated cells
              dynamics = block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR, MixinDynamics,
                momenta::RegularizedVelocityBoundaryTuple< 1,1>>>();
            }
            block.defineDynamics({iX, iY}, dynamics);
          }
          else {
            dynamics = block.template getDynamics<FreeEnergyInletOutletDynamics<T,DESCRIPTOR,1,1>>();
            block.defineDynamics({iX, iY}, dynamics);
          }
        }
 
        if (latticeNumber != 1) {
          block.defineDynamics({iX, iY}, dynamics);
        }
 
        if ( latticeNumber == 1){
                block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY},
          olb::boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR, FreeEnergyChemPotBoundaryProcessor2DA>(
            Vector<int,2>(discreteNormal.data() + 1)));
        } else {
                block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY},
          olb::boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR, FreeEnergyChemPotBoundaryProcessor2DB>(
            Vector<int,2>(discreteNormal.data() + 1)));
        }
 
        dynamics->getParameters(block).template set<descriptors::OMEGA>(omega);
        //sets the boundary on any indicated cell
        //located in setLocalVelocityBoundary2D.h/hh
        setBoundary(block, iX,iY, dynamics);
 
        if (_output) {
          clout << "setFreeEnergyInletBoundary<" << "," << ">("  << iX << ", "<< iY << ")" << std::endl;
        }
 
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockLattice< T, DESCRIPTOR >::defineDynamics(), olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setFreeEnergyInletBoundary() [3/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setFreeEnergyInletBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator,
		std::string	type,
		int	latticeNumber )

Initialising the Free Energy Inlet Boundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setFreeEnergyInletBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setFreeEnergyInletBoundary");
  bool includeOuterCells = false;
  int _overlap = 1;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setFreeEnergyInletBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice.getBlock(iCloc), omega,
        indicator->getBlockIndicatorF(iCloc), type, latticeNumber, includeOuterCells);
  }
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFreeEnergyInletBoundary() [4/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setFreeEnergyInletBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator,
		std::string	type,
		int	latticeNumber )

Initialising the FreeEnergyInletBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setFreeEnergyInletBoundary3D.hh.

{
  bool includeOuterCells = false;
  int _overlap = 1;
  OstreamManager clout(std::cout, "setFreeEnergyInletBoundary");
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setFreeEnergyInletBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc),omega,
        indicator->getBlockIndicatorF(iCloc), type, latticeNumber, includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFreeEnergyInletBoundary() [5/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T, DESCRIPTOR>>

void olb::setFreeEnergyInletBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material,
		std::string	type,
		int	latticeNumber )

Implementation of a inlet boundary condition for the partner lattices of the binary or ternary free energy model.

Initialising the Free Energy Inlet Boundary on the superLattice domain.

FreeEnergyInletBoundary is local boundary Condition --> MixinDynamics = RLBdynamics Initialising the Free Energy Inlet Boundary on the superLattice domain

Definition at line 35 of file setFreeEnergyInletBoundary2D.hh.

{
  setFreeEnergyInletBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material), type, latticeNumber);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFreeEnergyInletBoundary() [6/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setFreeEnergyInletBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		std::string	type,
		int	latticeNumber )

Initialising the FreeEnergyInletBoundary on the superLattice domain.

Definition at line 35 of file setFreeEnergyInletBoundary3D.hh.

{
  setFreeEnergyInletBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material), type, latticeNumber);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFreeEnergyOutletBoundary() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setFreeEnergyOutletBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		T	omega,
		std::string	type,
		int	latticeNumber,
		bool	includeOuterCells = false )

Set FreeEnergyOutletBoundary for any indicated cells inside the block domain.

Definition at line 68 of file setFreeEnergyOutletBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setFreeEnergyOutletBoundary");
  bool _output = false;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  //setFreeEnergyInletBoundary on indicated cells inside the blockLattice domain
  setFreeEnergyInletBoundary<T,DESCRIPTOR,MixinDynamics>(_block, omega, indicator, type, latticeNumber,includeOuterCells);
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ, true);
      if (discreteNormal[0] == 0) {//set postProcessor on indicated cells
        _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            olb::boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR, FreeEnergyConvectiveProcessor3D>(
              Vector<int,3>(discreteNormal.data() + 1)));
        if (_output) {
          clout << "setFreeEnergyOutletBoundary<" << "," << ">("  << iX << ", "<< iY << ", " << iZ << ")" << std::endl;
        }
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setFreeEnergyOutletBoundary() [2/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setFreeEnergyOutletBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		std::string	type,
		int	latticeNumber,
		bool	includeOuterCells = false )

Set FreeEnergyOutlet boundary for any indicated cells inside the block domain.

Definition at line 65 of file setFreeEnergyOutletBoundary2D.hh.

{
  bool _output = false;
  OstreamManager clout(std::cout, "setFreeEnergyOutletBoundary");
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  //setFreeEnergyInletBoundary on the block domain
  setFreeEnergyInletBoundary<T,DESCRIPTOR,MixinDynamics>(block, omega,
      indicator, type, latticeNumber, includeOuterCells);
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX,iY);
      if (discreteNormal[0] == 0) {
        block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY},
            olb::boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR, FreeEnergyConvectiveProcessor2D>(
              Vector<int,2>(discreteNormal.data() + 1)));
 
        if (_output) {
          clout << "setFreeEnergyOutletBoundary<" << "," << ">("  << iX << ", "<< iY << ")" << std::endl;
        }
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF2D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setFreeEnergyOutletBoundary() [3/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setFreeEnergyOutletBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator,
		std::string	type,
		int	latticeNumber )

Implementation of a outlet boundary condition for the partner lattices of the binary or ternary free energy model.

Initialising the Free Energy Outlet Boundary on the superLattice domain

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 45 of file setFreeEnergyOutletBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setFreeEnergyOutletBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setFreeEnergyOutletBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc), omega,
        indicator->getBlockIndicatorF(iCloc), type, latticeNumber, includeOuterCells);
  }
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFreeEnergyOutletBoundary() [4/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setFreeEnergyOutletBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator,
		std::string	type,
		int	latticeNumber )

Implementation of a outlet boundary condition for the partner lattices of the binary or the ternary free energy model.

Initialising the FreeEnergyOutletBoundary on the superLattice domain

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 47 of file setFreeEnergyOutletBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setFreeEnergyOutletBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setFreeEnergyOutletBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc),
        indicator->getBlockIndicatorF(iCloc),  omega, type, latticeNumber, includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFreeEnergyOutletBoundary() [5/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setFreeEnergyOutletBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material,
		std::string	type,
		int	latticeNumber )

Implementation of a outlet boundary condition for the partner lattices of the binary or ternary free energy model.

Initialising the Free Energy Outlet Boundary on the superLattice domain

Definition at line 36 of file setFreeEnergyOutletBoundary2D.hh.

{
  setFreeEnergyOutletBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material), type, latticeNumber);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFreeEnergyOutletBoundary() [6/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setFreeEnergyOutletBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		std::string	type,
		int	latticeNumber )

Implementation of a outlet boundary condition for the partner lattices of the binary or the ternary free energy model.

Initialising the FreeEnergyOutletBoundary on the superLattice domain

Definition at line 38 of file setFreeEnergyOutletBoundary3D.hh.

{
  setFreeEnergyOutletBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material), type, latticeNumber);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFreeEnergyWallBoundary() [1/10]

template<typename T , typename DESCRIPTOR >

void olb::setFreeEnergyWallBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		T	addend,
		int	latticeNumber,
		bool	includeOuterCells = false )

Definition at line 142 of file setFreeEnergyWallBoundary3D.hh.

{
  using namespace boundaryhelper;
  OstreamManager clout(std::cout, "setFreeEnergyWallBoundary");
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ, true);
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {
        if (latticeNumber == 1) {
          _block.template defineDynamics<BounceBackBulkDensity>({iX,iY,iZ});
        }
        else {
          _block.template defineDynamics<FreeEnergyWallDynamics>({iX,iY,iZ});
        }
 
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            olb::boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR,FreeEnergyWallProcessor3D>(
              Vector<int,3>(discreteNormal.data() + 1)));
          _block.get(iX, iY, iZ).template setField<olb::descriptors::ADDEND>(addend);
 
 
          if(latticeNumber == 1){
            _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            promisePostProcessorForNormal<T,DESCRIPTOR,FreeEnergyChemPotBoundaryProcessor3DA>(
              Vector<int,3>(discreteNormal.data() + 1)));
          } else {
            _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            promisePostProcessorForNormal<T,DESCRIPTOR,FreeEnergyChemPotBoundaryProcessor3DB>(
              Vector<int,3>(discreteNormal.data() + 1)));
          }
 
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockLattice< T, DESCRIPTOR >::get(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setFreeEnergyWallBoundary() [2/10]

template<typename T , typename DESCRIPTOR >

void olb::setFreeEnergyWallBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF2D< T > &	indicator,
		T	addend,
		int	latticeNumber,
		bool	includeOuterCells = false )

Definition at line 138 of file setFreeEnergyWallBoundary2D.hh.

{
  using namespace boundaryhelper;
  OstreamManager clout(std::cout, "setFreeEnergyWallBoundary");
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX,iY);
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0) {
        if (latticeNumber == 1) {
          block.template defineDynamics<BounceBackBulkDensity>({iX,iY});
        }
        else {
          block.template defineDynamics<FreeEnergyWallDynamics>({iX,iY});
        }
 
          block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY},
            promisePostProcessorForNormal<T,DESCRIPTOR,FreeEnergyWallProcessor2D>(
              Vector<int,2>(discreteNormal.data() + 1)));
          block.get(iX, iY).template setField<olb::descriptors::ADDEND>(addend);
 
          if(latticeNumber == 1){
            block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY},
            promisePostProcessorForNormal<T,DESCRIPTOR, FreeEnergyChemPotBoundaryProcessor2DA>(
              Vector<int,2>(discreteNormal.data() + 1)));
          } else {
            block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY},
            promisePostProcessorForNormal<T,DESCRIPTOR, FreeEnergyChemPotBoundaryProcessor2DB>(
              Vector<int,2>(discreteNormal.data() + 1)));
          }
 
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockLattice< T, DESCRIPTOR >::get(), and olb::BlockIndicatorF2D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setFreeEnergyWallBoundary() [3/10]

template<typename T , typename DESCRIPTOR >

void olb::setFreeEnergyWallBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator,
		T	alpha,
		T	kappa1,
		T	kappa2,
		T	h1,
		T	h2,
		int	latticeNumber )

Initialising the Free Energy Wall Boundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 52 of file setFreeEnergyWallBoundary2D.hh.

{
  int _overlap = 1;
  OstreamManager clout(std::cout, "setFreeEnergyWallBoundary");
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  T addend = 0;
  if (latticeNumber==1) {
    addend = 1./(alpha*alpha) * ( (h1/kappa1) + (h2/kappa2) );
  }
  else if (latticeNumber==2) {
    addend = 1./(alpha*alpha) * ( (h1/kappa1) + (-h2/kappa2) );
  }
  else if (latticeNumber==3) {
    addend = 1./(alpha*alpha) * ( (h1/kappa1) + (h2/kappa2) );
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setFreeEnergyWallBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
                                            indicator->getBlockIndicatorF(iCloc), addend, latticeNumber, includeOuterCells);
  }
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFreeEnergyWallBoundary() [4/10]

template<typename T , typename DESCRIPTOR >

void olb::setFreeEnergyWallBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator,
		T	alpha,
		T	kappa1,
		T	kappa2,
		T	kappa3,
		T	h1,
		T	h2,
		T	h3,
		int	latticeNumber )

Initialising the Free Energy Wall Boundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 105 of file setFreeEnergyWallBoundary2D.hh.

{
 
  int _overlap = indicator->getSuperGeometry().getOverlap();
  OstreamManager clout(std::cout, "setFreeEnergyWallBoundary");
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  T addend = 0;
  if (latticeNumber==1) {
    addend = 1./(alpha*alpha) * ( (h1/kappa1) + (h2/kappa2) + (h3/kappa3) );
  }
  else if (latticeNumber==2) {
    addend = 1./(alpha*alpha) * ( (h1/kappa1) + (-h2/kappa2) );
  }
  else if (latticeNumber==3) {
    addend = 1./(alpha*alpha) * ( (h3/kappa3) );
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setFreeEnergyWallBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
                                            indicator->getBlockIndicatorF(iCloc), addend, latticeNumber, includeOuterCells);
  }
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFreeEnergyWallBoundary() [5/10]

template<typename T , typename DESCRIPTOR >

void olb::setFreeEnergyWallBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator,
		T	alpha,
		T	kappa1,
		T	kappa2,
		T	h1,
		T	h2,
		int	latticeNumber )

Initialising the Free Energy Wall Boundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 52 of file setFreeEnergyWallBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setFreeEnergyWallBoundary");
  bool includeOuterCells = false;
  int _overlap = 1;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  T addend = 0;
  if (latticeNumber==1) {
    addend = 1./(alpha*alpha) * ( (h1/kappa1) + (h2/kappa2) );
  }
  else if (latticeNumber==2) {
    addend = 1./(alpha*alpha) * ( (h1/kappa1) + (-h2/kappa2) );
  }
  else if (latticeNumber==3) {
    addend = 1./(alpha*alpha) * ( (h1/kappa1) + (h2/kappa2) );
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setFreeEnergyWallBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
                                            indicator->getBlockIndicatorF(iCloc), addend, latticeNumber, includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFreeEnergyWallBoundary() [6/10]

template<typename T , typename DESCRIPTOR >

void olb::setFreeEnergyWallBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator,
		T	alpha,
		T	kappa1,
		T	kappa2,
		T	kappa3,
		T	h1,
		T	h2,
		T	h3,
		int	latticeNumber )

Initialising the Free Energy Wall Boundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 108 of file setFreeEnergyWallBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setFreeEnergyWallBoundary");
  bool includeOuterCells = false;
  int _overlap = indicator->getSuperGeometry().getOverlap();
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  T addend = 0;
  if (latticeNumber==1) {
    addend = 1./(alpha*alpha) * ( (h1/kappa1) + (h2/kappa2) + (h3/kappa3) );
  }
  else if (latticeNumber==2) {
    addend = 1./(alpha*alpha) * ( (h1/kappa1) + (-h2/kappa2) );
  }
  else if (latticeNumber==3) {
    addend = 1./(alpha*alpha) * ( (h3/kappa3) );
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setFreeEnergyWallBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
                                            indicator->getBlockIndicatorF(iCloc), addend, latticeNumber, includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setFreeEnergyWallBoundary() [7/10]

template<typename T , typename DESCRIPTOR >

void olb::setFreeEnergyWallBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material,
		T	alpha,
		T	kappa1,
		T	kappa2,
		T	h1,
		T	h2,
		int	latticeNumber )

Implementation of a wetting boundary condition for the ternary free energy model, consisting of a BounceBack dynamics and an FreeEnergyWall PostProcessor.

Parameters

[in]	alpha_	- Parameter related to the interface width. [lattice units]
[in]	kappa1_	- Parameter related to surface tension. [lattice units]
[in]	kappa2_	- Parameter related to surface tension. [lattice units]
[in]	h1_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	h2_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	latticeNumber	- determines the number of the free energy lattice to set the boundary accordingly Initialising the Free Energy Wall Boundary on the superLattice domain
[in]	alpha_	- Parameter related to the interface width. [lattice units]
[in]	kappa1_	- Parameter related to surface tension. [lattice units]
[in]	kappa2_	- Parameter related to surface tension. [lattice units]
[in]	h1_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	h2_	- Parameter related to resulting contact angle of the boundary. [lattice units] Initialising the Free Energy Wall Boundary on the superLattice domain

Definition at line 43 of file setFreeEnergyWallBoundary2D.hh.

{
  setFreeEnergyWallBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material),
                                          alpha, kappa1, kappa2, h1, h2, latticeNumber);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFreeEnergyWallBoundary() [8/10]

template<typename T , typename DESCRIPTOR >

void olb::setFreeEnergyWallBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material,
		T	alpha,
		T	kappa1,
		T	kappa2,
		T	kappa3,
		T	h1,
		T	h2,
		T	h3,
		int	latticeNumber )

Implementation of a wetting boundary condition for the ternary free energy model, consisting of a BounceBack dynamics and an FreeEnergyWall PostProcessor.

Parameters

[in]	alpha_	- Parameter related to the interface width. [lattice units]
[in]	kappa1_	- Parameter related to surface tension. [lattice units]
[in]	kappa2_	- Parameter related to surface tension. [lattice units]
[in]	kappa3_	- Parameter related to surface tension. [lattice units]
[in]	h1_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	h2_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	h3_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	latticeNumber	- determines the number of the free energy lattice to set the boundary accordingly Initialising the Free Energy Wall Boundary on the superLattice domain
[in]	alpha_	- Parameter related to the interface width. [lattice units]
[in]	kappa1_	- Parameter related to surface tension. [lattice units]
[in]	kappa2_	- Parameter related to surface tension. [lattice units]
[in]	kappa3_	- Parameter related to surface tension. [lattice units]
[in]	h1_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	h2_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	h3_	- Parameter related to resulting contact angle of the boundary. [lattice units] Initialising the Free Energy Wall Boundary on the superLattice domain

Definition at line 96 of file setFreeEnergyWallBoundary2D.hh.

{
  setFreeEnergyWallBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material),
                                          alpha, kappa1, kappa2, kappa3, h1, h2, h3, latticeNumber);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFreeEnergyWallBoundary() [9/10]

template<typename T , typename DESCRIPTOR >

void olb::setFreeEnergyWallBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		T	alpha,
		T	kappa1,
		T	kappa2,
		T	h1,
		T	h2,
		int	latticeNumber )

Implementation of a wetting boundary condition for the ternary free energy model, consisting of a BounceBack dynamics and an FreeEnergyWall PostProcessor.

Parameters

[in]	alpha_	- Parameter related to the interface width. [lattice units]
[in]	kappa1_	- Parameter related to surface tension. [lattice units]
[in]	kappa2_	- Parameter related to surface tension. [lattice units]
[in]	h1_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	h2_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	latticeNumber	- determines the number of the free energy lattice to set the boundary accordingly Initialising the Free Energy Wall Boundary on the superLattice domain

Definition at line 42 of file setFreeEnergyWallBoundary3D.hh.

{
  setFreeEnergyWallBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material),
                                          alpha, kappa1, kappa2, h1, h2, latticeNumber);
 
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setFreeEnergyWallBoundary() [10/10]

template<typename T , typename DESCRIPTOR >

void olb::setFreeEnergyWallBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		T	alpha,
		T	kappa1,
		T	kappa2,
		T	kappa3,
		T	h1,
		T	h2,
		T	h3,
		int	latticeNumber )

Implementation of a wetting boundary condition for the ternary free energy model, consisting of a BounceBack dynamics and an FreeEnergyWall PostProcessor.

Parameters

[in]	alpha_	- Parameter related to the interface width. [lattice units]
[in]	kappa1_	- Parameter related to surface tension. [lattice units]
[in]	kappa2_	- Parameter related to surface tension. [lattice units]
[in]	kappa3_	- Parameter related to surface tension. [lattice units]
[in]	h1_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	h2_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	h3_	- Parameter related to resulting contact angle of the boundary. [lattice units]
[in]	latticeNumber	- determines the number of the free energy lattice to set the boundary accordingly Initialising the Free Energy Wall Boundary on the superLattice domain

Definition at line 98 of file setFreeEnergyWallBoundary3D.hh.

{
  setFreeEnergyWallBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material),
                                          alpha, kappa1, kappa2, kappa3, h1, h2, h3, latticeNumber);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setInterpolatedConvectionBoundary() [1/6]

template<typename T , typename DESCRIPTOR >

void olb::setInterpolatedConvectionBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		T	omega,
		BlockIndicatorF3D< T > &	indicator,
		T *	uAv,
		bool	includeOuterCells = false )

Add Interpolatedconvection boundary for any indicated cells inside the block domain.

set InterpolatedConvection boundary for any indicated cells inside the block domain

Definition at line 62 of file setInterpolatedConvectionBoundary3D.hh.

{
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[0] == 0) {
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<StraightConvectionBoundaryProcessor3D<DESCRIPTOR,0,-1>>());
          _block.template getField<typename StraightConvectionBoundaryProcessor3D<DESCRIPTOR,0,-1>::PREV_CELL>();
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<StraightConvectionBoundaryProcessor3D<DESCRIPTOR,0,1>>());
          _block.template getField<typename StraightConvectionBoundaryProcessor3D<DESCRIPTOR,0,1>::PREV_CELL>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<StraightConvectionBoundaryProcessor3D<DESCRIPTOR,1,-1>>());
          _block.template getField<typename StraightConvectionBoundaryProcessor3D<DESCRIPTOR,1,-1>::PREV_CELL>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<StraightConvectionBoundaryProcessor3D<DESCRIPTOR,1,1>>());
          _block.template getField<typename StraightConvectionBoundaryProcessor3D<DESCRIPTOR,1,1>::PREV_CELL>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<StraightConvectionBoundaryProcessor3D<DESCRIPTOR,2,-1>>());
          _block.template getField<typename StraightConvectionBoundaryProcessor3D<DESCRIPTOR,2,-1>::PREV_CELL>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<StraightConvectionBoundaryProcessor3D<DESCRIPTOR,2,1>>());
          _block.template getField<typename StraightConvectionBoundaryProcessor3D<DESCRIPTOR,2,1>::PREV_CELL>();
        }
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setInterpolatedConvectionBoundary() [2/6]

template<typename T , typename DESCRIPTOR >

void olb::setInterpolatedConvectionBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		T *	uAv,
		bool	includeOuterCells = false )

Set InterpolatedConvectionBoundary for indicated cells inside the block domain.

Definition at line 60 of file setInterpolatedConvectionBoundary2D.hh.

{
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  OstreamManager clout(std::cout, "setInterpolatedConvectionBoundary");
  bool _output = false;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      PostProcessorGenerator2D<T, DESCRIPTOR>* postProcessor = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
      if (discreteNormal[0] == 0) {
        if (discreteNormal[1] == -1) {
          if (_output) {
            clout << "setInterpolatedConvectionBoundary<" << 0 << ","<< -1 << ">("  << iX << ", "<< iY << ", " << omega << " )" << std::endl;
          }
          postProcessor = new StraightConvectionBoundaryProcessorGenerator2D
          < T,DESCRIPTOR,0,-1 >  (iX, iX, iY, iY, uAv);
        }
        else if (discreteNormal[1] == 1) {
          if (_output) {
            clout << "setInterpolatedConvectionBoundary<" << 0 << "," << 1 << ">("  << iX << ", "<< iY << ", " << omega << " )" << std::endl;
          }
          postProcessor = new StraightConvectionBoundaryProcessorGenerator2D
          < T,DESCRIPTOR,0,1 >  (iX, iX, iY, iY, uAv);
        }
        else if (discreteNormal[2] == -1) {
          if (_output) {
            clout << "setInterpolatedConvectionBoundary<" << 1 << "," << -1 << ">("  << iX << ", "<< iY << ", " << omega << " )" << std::endl;
          }
          postProcessor = new StraightConvectionBoundaryProcessorGenerator2D
          < T,DESCRIPTOR,1,-1 >  (iX, iX, iY, iY, uAv);
        }
        else if (discreteNormal[2] == 1) {
          if (_output) {
            clout << "setInterpolatedConvectionBoundary<" << 1 << "," << 1 << ">("  << iX << ", "<< iY << ", " << omega << " )" << std::endl;
          }
          postProcessor = new StraightConvectionBoundaryProcessorGenerator2D
          < T,DESCRIPTOR,1,1 >  (iX, iX, iY, iY, uAv);
        }
        if (postProcessor) {
          block.addPostProcessor(*postProcessor);
        }
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF2D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setInterpolatedConvectionBoundary() [3/6]

template<typename T , typename DESCRIPTOR >

void olb::setInterpolatedConvectionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator,
		T *	uAv )

Initialising the InterpolatedConvectionBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 41 of file setInterpolatedConvectionBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setInterpolatedConvectionBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setInterpolatedConvectionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc), omega,
        indicator->getBlockIndicatorF(iCloc), uAv, includeOuterCells);
  }
  addPoints2CommBC<T, DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setInterpolatedConvectionBoundary() [4/6]

template<typename T , typename DESCRIPTOR >

void olb::setInterpolatedConvectionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator,
		T *	uAv )

Initialising the setInterpolatedConvectionBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 40 of file setInterpolatedConvectionBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setInterpolatedConvectionBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setInterpolatedConvectionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),omega, indicator->getBlockIndicatorF(iCloc),
        uAv, includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setInterpolatedConvectionBoundary() [5/6]

template<typename T , typename DESCRIPTOR >

void olb::setInterpolatedConvectionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material,
		T *	uAv )

Initialising the InterpolatedConvectionBoundary on the superLattice domain This is an interpolated boundary --> MixinDynamics = BGKdynamics Usually T* uAv = NULL;.

Initialising the InterpolatedConvectionBoundary on the superLattice domain.

Definition at line 35 of file setInterpolatedConvectionBoundary2D.hh.

{
  setInterpolatedConvectionBoundary<T,DESCRIPTOR>(sLattice, omega, superGeometry.getMaterialIndicator(material), uAv);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setInterpolatedConvectionBoundary() [6/6]

template<typename T , typename DESCRIPTOR >

void olb::setInterpolatedConvectionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		T *	uAv = NULL )

Initialising the setInterpolatedConvectionBoundary function on the superLattice domain This is an Interpolated Boundary --> MixinDynamics = BGKdynamics.

Initialising the setInterpolatedConvectionBoundary function on the superLattice domain.

Definition at line 32 of file setInterpolatedConvectionBoundary3D.hh.

{
  setInterpolatedConvectionBoundary<T,DESCRIPTOR>(sLattice, omega, superGeometry.getMaterialIndicator(material), uAv);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setInterpolatedPressureBoundary() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setInterpolatedPressureBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		T	omega,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells )

Add interpolated pressure boundary for any indicated cells inside the block domain.

Definition at line 66 of file setInterpolatedPressureBoundary3D.hh.

{
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
 
      if (discreteNormal[0] == 0) {
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletPressureBoundaryTuple<0,-1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,0,-1>>());
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletPressureBoundaryTuple<0,1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,0,1>>());
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletPressureBoundaryTuple<1,-1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,1,-1>>());
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletPressureBoundaryTuple<1,1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,1,1>>());
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletPressureBoundaryTuple<2,-1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,2,-1>>());
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletPressureBoundaryTuple<2,1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,2,1>>());
        }
        else{
          std::cout << "Discrete Normal is not valid for interpolated pressure boundary!" << std::endl;
          singleton::exit(1);
        }
      }
      else {
        // When this error occurs, check your geometry for stray cells or try slightly variating your resolution
        std::cout << "Discrete Normal is not valid for interpolated pressure boundary!" << std::endl;
        singleton::exit(1);
      }
      if (dynamics) {
        dynamics->getParameters(_block).template set<descriptors::OMEGA>(omega);
      }
      setBoundary(_block, iX, iY, iZ, dynamics);
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::singleton::exit(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setInterpolatedPressureBoundary() [2/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::setInterpolatedPressureBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		bool	includeOuterCells = false )

Add interpolated pressure boundary for any indicated cells inside the block domain.

Set interpolated pressure boundary for any indicated cells inside the block domain.

Definition at line 62 of file setInterpolatedPressureBoundary2D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      Dynamics<T, DESCRIPTOR>* dynamics = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
      if (discreteNormal[0] == 0) {
        dynamics = block.getDynamics(MixinDynamicsExchangeDirectionOrientationMomenta<T,DESCRIPTOR,
          MixinDynamics,momenta::BasicDirichletPressureBoundaryTuple
        >::construct(Vector<int,2>(discreteNormal.data() + 1)));
        block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY},
          promisePostProcessorForDirectionOrientation<T,DESCRIPTOR,StraightFdBoundaryProcessor2D>(
            Vector<int,2>(discreteNormal.data() + 1)));
        setBoundary(block,iX,iY, dynamics);
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), and setBoundary().

Here is the call graph for this function:

◆ setInterpolatedPressureBoundary() [3/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::setInterpolatedPressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the setInterpolatedPressureBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setInterpolatedPressureBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setLocalPressureBoundary2D");
  bool includeOuterCells = false;
  int _overlap = 1;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setInterpolatedPressureBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice.getBlock(iCloc),omega,
        indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setInterpolatedPressureBoundary() [4/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setInterpolatedPressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setInterpolatedPressureBoundary function on the superLattice domain.

Definition at line 44 of file setInterpolatedPressureBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setInterpolatedPressureBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  //clout << sLattice.getLoadBalancer().size() <<"sLattice.getLoadBalancer.size()" << std::endl;
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setInterpolatedPressureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iC), omega, indicator->getBlockIndicatorF(iC),
        includeOuterCells);
  }
  //defined in setLocalVelocityBoundary
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
 
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setInterpolatedPressureBoundary() [5/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setInterpolatedPressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the setInterpolatedPressureBoundary function on the superLattice domain Interpolated Boundaries use the BGKdynamics collision-operator.

Initialising the setInterpolatedPressureBoundary function on the superLattice domain.

Definition at line 35 of file setInterpolatedPressureBoundary2D.hh.

{
  setInterpolatedPressureBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice,omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setInterpolatedPressureBoundary() [6/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setInterpolatedPressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setInterpolatedPressureBoundary function on the superLattice domain Interpolated Boundaries use usually the BGKdynamics collision-operator --> MixinDynamics = BGKdynamics<T,DESCRIPTOR>

Initialising the setInterpolatedPressureBoundary function on the superLattice domain.

Definition at line 36 of file setInterpolatedPressureBoundary3D.hh.

{
  setInterpolatedPressureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setInterpolatedVelocityBoundary() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setInterpolatedVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		T	omega,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells )

Definition at line 62 of file setInterpolatedVelocityBoundary3D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[0] == 0) {
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {//set momenta, dynamics and postProcessors on indicated velocityBoundaryCells
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<0,-1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,0,-1>>());
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<0,1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,0,1>>());
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<1,-1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,1,-1>>());
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<1,1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,1,1>>());
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<2,-1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,2,-1>>());
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<2,1>
          >>();
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY, iZ},
            meta::id<PlaneFdBoundaryProcessor3D<T,DESCRIPTOR,2,1>>());
        }
      }
 
      else if (discreteNormal[0] == 1) {//set momenta,dynamics and postProcessors on indicated velocityBoundary External Corner cells
        //ExternalVelocityCorner
        dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
        _block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY, iZ},
          promisePostProcessorForNormal<T,DESCRIPTOR,OuterVelocityCornerProcessor3D>(
            Vector<int,3>(discreteNormal.data() + 1)));
      }
 
      else if (discreteNormal[0] == 2) {//
        //Internalvelocitycorner
        dynamics = _block.getDynamics(PlainMixinDynamicsForNormalMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::InnerCornerVelocityTuple3D
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      //ExternalVelocityEdge
      else if (discreteNormal[0] == 3) {//set momenta,dynamics and postProcessors on indicated velocityBoundary External Edge cells
        dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
        _block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY, iZ},
          promisePostProcessorForNormalSpecial<T,DESCRIPTOR,OuterVelocityEdgeProcessor3D>(
            Vector<int,3>(discreteNormal.data() + 1)));
      }
      //InternalVelocityEdge
      else if (discreteNormal[0] == 4) {//set momenta,dynamics and postProcessors on indicated velocityBoundary Inner Edge cells
            dynamics = _block.getDynamics(PlainMixinDynamicsForNormalSpecialMomenta<T,DESCRIPTOR,
              CombinedRLBdynamics,MixinDynamics,momenta::InnerEdgeVelocityTuple3D
            >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
 
      if (dynamics) {
        dynamics->getParameters(_block).template set<descriptors::OMEGA>(omega);
      }
      setBoundary(_block, iX,iY,iZ, dynamics);
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setInterpolatedVelocityBoundary() [2/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::setInterpolatedVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		bool	includeOuterCells = false )

Set interpolatedVelocityBoundary for any indicated cells inside the block domain.

Set Interpolated velocity boundary for any indicated cells inside the block domain.

Definition at line 63 of file setInterpolatedVelocityBoundary2D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      Dynamics<T, DESCRIPTOR>* dynamics = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
      if (discreteNormal[0] == 0) {
        dynamics = block.getDynamics(MixinDynamicsExchangeDirectionOrientationMomenta<T,DESCRIPTOR,
          MixinDynamics,momenta::BasicDirichletVelocityBoundaryTuple
        >::construct(Vector<int,2>(discreteNormal.data() + 1)));
        block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY},
          promisePostProcessorForDirectionOrientation<T,DESCRIPTOR,StraightFdBoundaryProcessor2D>(
            Vector<int,2>(discreteNormal.data() + 1)));
      }
      else if (discreteNormal[0] == 1) {
        dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
        block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY},
          promisePostProcessorForNormal<T,DESCRIPTOR,OuterVelocityCornerProcessor2D>(
            Vector<int,2>(discreteNormal.data() + 1)));
      }
      else if (discreteNormal[0] == 2) {
        dynamics = block.getDynamics(PlainMixinDynamicsForNormalMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::InnerCornerVelocityTuple2D
        >::construct(Vector<int,2>(discreteNormal.data() + 1)));
      }
      if (dynamics) {
        dynamics->getParameters(block).template set<descriptors::OMEGA>(omega);
      }
      setBoundary(block, iX, iY, dynamics);
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setInterpolatedVelocityBoundary() [3/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setInterpolatedVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the setInterpolatedVelocityBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 41 of file setInterpolatedVelocityBoundary2D.hh.

{
  bool includeOuterCells = false;
  int _overlap = 1;
  OstreamManager clout(std::cout, "setInterpolatedVelocityBoundary");
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setInterpolatedVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc), omega,
        indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary2D.h/hh
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setInterpolatedVelocityBoundary() [4/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setInterpolatedVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setInterpolatedVelocityBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setInterpolatedVelocityBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setInterpolatedVelocityBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setInterpolatedVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iC),omega, indicator->getBlockIndicatorF(iC),includeOuterCells);
  }
  //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary3D.h/hh
  addPoints2CommBC(sLattice,std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setInterpolatedVelocityBoundary() [5/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setInterpolatedVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the setInterpolatedVelocityBoundary function on the superLattice domain Interpolated Boundaries mostly use the BGKdynamics collision-operator --> MixinDynamics = BGKdynamics<T,DESCRIPTOR>

Initialising the setInterpolatedVelocityBoundary function on the superLattice domain.

Definition at line 34 of file setInterpolatedVelocityBoundary2D.hh.

{
  setInterpolatedVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setInterpolatedVelocityBoundary() [6/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setInterpolatedVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setInterpolatedVelocityBoundary function on the superLattice domain.

Definition at line 35 of file setInterpolatedVelocityBoundary3D.hh.

{
  setInterpolatedVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setLocalConvectionBoundary() [1/6]

template<typename T , typename DESCRIPTOR >

void olb::setLocalConvectionBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		T	omega,
		BlockIndicatorF3D< T > &	indicator,
		T *	uAv,
		bool	includeOuterCells = false )

Add local convection boundary for any indicated cells inside the block domain.

Add convection boundary for any indicated cells inside the block domain.

Definition at line 63 of file setLocalConvectionBoundary3D.hh.

{
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      PostProcessorGenerator3D<T,DESCRIPTOR>* postProcessor = nullptr;
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
 
      if (discreteNormal[0] == 0) {//set postProcessors for indicated boundary cells
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          postProcessor = nullptr;
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          postProcessor = nullptr;
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          postProcessor = nullptr;
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          postProcessor = nullptr;
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          postProcessor = nullptr;
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          postProcessor = nullptr;
        }
        if (postProcessor) {
          _block.addPostProcessor(*postProcessor);
        }
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setLocalConvectionBoundary() [2/6]

template<typename T , typename DESCRIPTOR >

void olb::setLocalConvectionBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		T *	uAv,
		bool	includeOuterCells = false )

Set LocalConvectionBoundary for indicated cells inside the block domain.

Definition at line 60 of file setLocalConvectionBoundary2D.hh.

{
  OstreamManager clout (std::cout, "setLocalConvectionBoundary");
  bool _output = false;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      PostProcessorGenerator2D<T, DESCRIPTOR>* postProcessor = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
      if (discreteNormal[0] == 0) {//set postProcessors on indicated LocalConvectionBoundary cells
        if (discreteNormal[1] == -1) {
          if (_output) {
            clout << "setLocalConvectionBoundary<" << 0 << ","<< -1 << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << ", " << omega << " )" << std::endl;
          }
          postProcessor = nullptr;
        }
        else if (discreteNormal[1] == 1) {
          if (_output) {
            clout << "setLocalConvectionBoundary<" << 0 << ","<< 1 << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << ", " << omega << " )" << std::endl;
          }
          postProcessor = nullptr;
        }
        else if (discreteNormal[2] == -1) {
          if (_output) {
            clout << "setLocalConvectionBoundary<" << 1 << ","<< -1 << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << ", " << omega << " )" << std::endl;
          }
          postProcessor = nullptr;
        }
        else if (discreteNormal[2] == 1) {
          if (_output) {
            clout << "setLocalConvectionBoundary<" << 1 << ","<< 1 << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << ", " << omega << " )" << std::endl;
          }
          postProcessor = nullptr;
        }
        if (postProcessor) {
          block.addPostProcessor(*postProcessor);
        }
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF2D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setLocalConvectionBoundary() [3/6]

template<typename T , typename DESCRIPTOR >

void olb::setLocalConvectionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator,
		T *	uAv )

Initialising the LocalConvectionBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 41 of file setLocalConvectionBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setLocalConvectionBoundary");
  int _overlap = 0;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setLocalConvectionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc), omega,
        indicator->getBlockIndicatorF(iCloc), uAv, includeOuterCells);
  }
  addPoints2CommBC<T, DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setLocalConvectionBoundary() [4/6]

template<typename T , typename DESCRIPTOR >

void olb::setLocalConvectionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator,
		T *	uAv )

Initialising the setLocalConvectionBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setLocalConvectionBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setLocalConvectionBoundary");
  int _overlap = 0;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setLocalConvectionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),omega, indicator->getBlockIndicatorF(iCloc),
        uAv, includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setLocalConvectionBoundary() [5/6]

template<typename T , typename DESCRIPTOR >

void olb::setLocalConvectionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material,
		T *	uAv = NULL )

Initialising the LocalConvectionBoundary on the superLattice domain This is a local boundary --> MixinDynamics = RLBdynamics.

Initialising the LocalConvectionBoundary on the superLattice domain.

Definition at line 35 of file setLocalConvectionBoundary2D.hh.

{
  setLocalConvectionBoundary<T,DESCRIPTOR>(sLattice, omega, superGeometry.getMaterialIndicator(material), uAv);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setLocalConvectionBoundary() [6/6]

template<typename T , typename DESCRIPTOR >

void olb::setLocalConvectionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		T *	uAv = NULL )

Initialising the setLocalConvectionBoundary function on the superLattice domain.

Definition at line 35 of file setLocalConvectionBoundary3D.hh.

{
  setLocalConvectionBoundary<T,DESCRIPTOR>(sLattice, omega, superGeometry.getMaterialIndicator(material), uAv);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setLocalPressureBoundary() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setLocalPressureBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		T	omega,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells )

Set pressure boundary for any indicated cells inside the block domain.

Definition at line 62 of file setLocalPressureBoundary3D.hh.

{
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
 
      if (discreteNormal[0] == 0) {//set momenta, dynamics and postProcessors on indicated cells
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
            MixinDynamics,momenta::RegularizedPressureBoundaryTuple< 0,-1>>>();
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
            MixinDynamics,momenta::RegularizedPressureBoundaryTuple< 0,1>>>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
            MixinDynamics,momenta::RegularizedPressureBoundaryTuple< 1,-1>>>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
            MixinDynamics,momenta::RegularizedPressureBoundaryTuple< 1,1>>>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
            MixinDynamics,momenta::RegularizedPressureBoundaryTuple< 2,-1>>>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR,
            MixinDynamics,momenta::RegularizedPressureBoundaryTuple< 2,1>>>();
        }
      }
      if (dynamics) {
        dynamics->getParameters(_block).template set<descriptors::OMEGA>(omega);
      }
      setBoundary(_block, iX,iY,iZ, dynamics);
    }
  });
}

References olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setLocalPressureBoundary() [2/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::setLocalPressureBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		bool	includeOuterCells = false )

Set pressure boundary for any indicated cells inside the block domain.

Definition at line 62 of file setLocalPressureBoundary2D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      Dynamics<T, DESCRIPTOR>* dynamics = nullptr;
      PostProcessorGenerator2D<T, DESCRIPTOR>* postProcessor = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
      if (discreteNormal[0] == 0) {
        dynamics = block.getDynamics(PlainMixinDynamicsForDirectionOrientationMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::RegularizedPressureBoundaryTuple
        >::construct(Vector<int,2>(discreteNormal.data() + 1)));
 
        dynamics->getParameters(block).template set<descriptors::OMEGA>(omega);
        setBoundary(block, iX,iY, dynamics, postProcessor);
      }
    }
  });
}

References olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setLocalPressureBoundary() [3/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::setLocalPressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the setLocalPressureBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setLocalPressureBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setLocalPressureBoundary2D");
  bool includeOuterCells = false;
  int _overlap = 0;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setLocalPressureBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice.getBlock(iCloc),omega,
        indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setLocalPressureBoundary() [4/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setLocalPressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setLocalPressureBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setLocalPressureBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setLocalPressureBoundary");
  int _overlap = 0;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  //clout << sLattice.getLoadBalancer().size() <<"sLattice.getLoadBalancer.size()" << std::endl;
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setLocalPressureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iC), omega, indicator->getBlockIndicatorF(iC),includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setLocalPressureBoundary() [5/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setLocalPressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the setLocalPressureBoundary function on the superLattice domain Local Boundaries use the RLBdynamics collision operator.

Initialising the setLocalPressureBoundary function on the superLattice domain.

Definition at line 36 of file setLocalPressureBoundary2D.hh.

{
  setLocalPressureBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setLocalPressureBoundary() [6/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setLocalPressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setLocalPressureBoundary function on the superLattice domain Local Boundaries use the RLBdynamics collision operator.

Initialising the setLocalPressureBoundary function on the superLattice domain.

Definition at line 35 of file setLocalPressureBoundary3D.hh.

{
  setLocalPressureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega,superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setLocalVelocityBoundary() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setLocalVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		T	omega,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells )

Set local velocity boundary for any indicated cells inside the block domain.

Definition at line 64 of file setLocalVelocityBoundary3D.hh.

{
  using namespace boundaryhelper;
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[0] == 0) {
        //setVelocityBoundary
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::RegularizedVelocityBoundaryTuple<0,-1>
          >>();
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::RegularizedVelocityBoundaryTuple<0,1>
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::RegularizedVelocityBoundaryTuple<1,-1>
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::RegularizedVelocityBoundaryTuple<1,1>
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::RegularizedVelocityBoundaryTuple<2,-1>
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          dynamics = _block.template getDynamics<CombinedRLBdynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::RegularizedVelocityBoundaryTuple<2,1>
          >>();
        }
      }
      //ExternalVelocityCorner
      else if (discreteNormal[0] == 1) {
        dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
        _block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY, iZ},
          promisePostProcessorForNormal<T,DESCRIPTOR,OuterVelocityCornerProcessor3D>(
            Vector<int,3>(discreteNormal.data() + 1)));
      }
      //InternalVelocityCorner
      else if (discreteNormal[0] == 2) {
        dynamics = _block.getDynamics(PlainMixinDynamicsForNormalMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::InnerCornerVelocityTuple3D
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      //ExternalVelocityEdge
      else if (discreteNormal[0] == 3) {
        dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
        _block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY, iZ},
          promisePostProcessorForNormalSpecial<T,DESCRIPTOR,OuterVelocityEdgeProcessor3D>(
            Vector<int,3>(discreteNormal.data() + 1)));
      }
      //InternalVelocityEdge
      else if (discreteNormal[0] == 4) {
        dynamics = _block.getDynamics(PlainMixinDynamicsForNormalSpecialMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::InnerEdgeVelocityTuple3D
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      if (dynamics) {
        dynamics->getParameters(_block).template set<descriptors::OMEGA>(omega);
      }
      setBoundary(_block, iX,iY,iZ, dynamics);
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setLocalVelocityBoundary() [2/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::setLocalVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		bool	includeOuterCells = false )

Set local velocity boundary for any indicated cells inside the block domain.

Definition at line 62 of file setLocalVelocityBoundary2D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      Dynamics<T, DESCRIPTOR>* dynamics = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
      if (discreteNormal[0] == 0) {
        dynamics = block.getDynamics(PlainMixinDynamicsForDirectionOrientationMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::RegularizedVelocityBoundaryTuple
        >::construct(Vector<int,2>(discreteNormal.data() + 1)));
      }
      else if (discreteNormal[0] == 1) {
        dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
        block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY},
          promisePostProcessorForNormal<T,DESCRIPTOR,OuterVelocityCornerProcessor2D>(
            Vector<int,2>(discreteNormal.data() + 1)));
      }
      //sets momenta, dynamics and postProcessors on local InnerVelocityCornerBoundary Cells
      else if (discreteNormal[0] == 2) {
        dynamics = block.getDynamics(PlainMixinDynamicsForNormalMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::InnerCornerVelocityTuple2D
        >::construct(Vector<int,2>(discreteNormal.data() + 1)));
      }
      if (dynamics) {
        dynamics->getParameters(block).template set<descriptors::OMEGA>(omega);
      }
      setBoundary(block, iX,iY, dynamics);
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setLocalVelocityBoundary() [3/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setLocalVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the setLocalVelocityBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setLocalVelocityBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setLocalVelocityBoundary2D");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setLocalVelocityBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice.getBlock(iCloc), omega,
        indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setLocalVelocityBoundary() [4/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setLocalVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setLocalVelocityBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setLocalVelocityBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setLocalVelocityBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
 
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setLocalVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iC), omega, indicator->getBlockIndicatorF(iC),includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setLocalVelocityBoundary() [5/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setLocalVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the setLocalVelocityBoundary function on the superLattice domain.

Definition at line 36 of file setLocalVelocityBoundary2D.hh.

{
  setLocalVelocityBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setLocalVelocityBoundary() [6/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = RLBdynamics<T,DESCRIPTOR>>

void olb::setLocalVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setLocalVelocityBoundary function on the superLattice domain.

Definition at line 36 of file setLocalVelocityBoundary3D.hh.

{
  setLocalVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setNewSlipBoundary() [1/3]

template<typename T , typename DESCRIPTOR >

void olb::setNewSlipBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells )

Definition at line 106 of file setNewSlipBoundary3D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
 
      if(util::fabs(discreteNormal[1])+util::fabs(discreteNormal[2])+util::fabs(discreteNormal[3]) == T{1.}){
        _block.addPostProcessor(
            typeid(stage::PostCollide), {iX,iY,iZ},
            promisePostProcessorForNormal<T, DESCRIPTOR, SlipBoundaryPostProcessor3D>(
              Vector<int,3>(discreteNormal.data()+1)
            )
          );
        dynamics = _block.template getDynamics<NoCollideDynamics<T,DESCRIPTOR>>();
      } else {
        dynamics = _block.template getDynamics<BounceBack<T,DESCRIPTOR>>();
      }
      setBoundary(_block, iX, iY, iZ, dynamics);
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::util::fabs(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), and setBoundary().

Here is the call graph for this function:

◆ setNewSlipBoundary() [2/3]

template<typename T , typename DESCRIPTOR >

void olb::setNewSlipBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Definition at line 89 of file setNewSlipBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setInterpolatedVelocityBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setNewSlipBoundary<T,DESCRIPTOR>(sLattice.getBlock(iC), indicator->getBlockIndicatorF(iC),includeOuterCells);
  }
  addPoints2CommBC(sLattice,std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setNewSlipBoundary() [3/3]

template<typename T , typename DESCRIPTOR >

void olb::setNewSlipBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Definition at line 83 of file setNewSlipBoundary3D.hh.

{
  setNewSlipBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setPartialSlipBoundary() [1/6]

template<typename T , typename DESCRIPTOR >

void olb::setPartialSlipBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	tuner,
		BlockIndicatorF2D< T > &	indicator,
		bool	includeOuterCells = false )

Set Partial Slip boundary for any indicated cells inside the block domain.

Definition at line 65 of file setPartialSlipBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setPartialSlipBoundary");
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      if (tuner < 0. || tuner > 1.) {
        clout << "Warning: Could not setPartialSlipBoundary (" << iX << ", " << iY << "), tuner must be between 0.1 and instead is=" << tuner <<", set to bounceBack" << std::endl;
        block.template defineDynamics<BounceBack>({iX, iY});
      }
      else {
        discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
        if (discreteNormal[1]!=0 || discreteNormal[2]!=0) {
          //set partial slip boundary on indicated cells
          bool _output = false;
          if (_output) {
            clout << "setPartialSlipBoundary<" << discreteNormal[1] << ","<< discreteNormal[2] << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << " )" << std::endl;
          }
          PostProcessorGenerator2D<T, DESCRIPTOR>* postProcessor = new PartialSlipBoundaryProcessorGenerator2D<T, DESCRIPTOR>(tuner, iX, iX, iY, iY, discreteNormal[1], discreteNormal[2]);
          if (postProcessor) {
            block.addPostProcessor(*postProcessor);
          }
        }
        else {
          clout << "Warning: Could not setPartialSlipBoundary (" << iX << ", " << iY << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] <<"), set to bounceBack" << std::endl;
          block.template defineDynamics<BounceBack>({iX, iY});
        }
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockIndicatorF2D< T >::getBlockGeometry(), and olb::BlockGeometry< T, D >::getStatistics().

Here is the call graph for this function:

◆ setPartialSlipBoundary() [2/6]

template<typename T , typename DESCRIPTOR >

void olb::setPartialSlipBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	tuner,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells = false )

Set Partial Slip Boundary for any indicated cells inside the block domain.

Set Partial Slip boundary for any indicated cells inside the block domain.

Definition at line 64 of file setPartialSlipBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setPartialSlipBoundary");
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      if (tuner < 0. || tuner > 1.) {
        clout << "Warning: Could not setPartialSlipBoundary (" << iX << ", " << iY << ", " << iZ << "), tuner must be between 0.1 and instead is=" << tuner <<", set to bounceBack" << std::endl;
        block.template defineDynamics<BounceBack>({iX, iY, iZ});
      }
      else {
        discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
        if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {//set PostProcessor on indicated cells
          OstreamManager clout(std::cout, "setPartialslipBoundary");
          bool _output = false;
          if (_output) {
            clout << "setPartialSlipBoundary<" << discreteNormal[1] << ","<< discreteNormal[2] << ","<< discreteNormal[3] << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << ", " << iZ << ", " << iZ << " )" << std::endl;
          }
          PostProcessorGenerator3D<T, DESCRIPTOR>* postProcessor = new PartialSlipBoundaryProcessorGenerator3D<T, DESCRIPTOR>(tuner, iX, iX, iY, iY, iZ, iZ, discreteNormal[1], discreteNormal[2], discreteNormal[3]);
          if (postProcessor) {
            block.addPostProcessor(*postProcessor);
          }
        }
        else {//define Dynamics on indicated cells
          clout << "Warning: Could not setPartialSlipBoundary (" << iX << ", " << iY << ", " << iZ << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] <<","<< discreteNormal[3] <<"), set to bounceBack" << std::endl;
          block.template defineDynamics<BounceBack>({iX, iY, iZ});
        }
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setPartialSlipBoundary() [3/6]

template<typename T , typename DESCRIPTOR >

void olb::setPartialSlipBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	tuner,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the Partial slip boundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 44 of file setPartialSlipBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setPartialSlipBoundary");
  bool includeOuterCells = false;
  int _overlap = 1;
 
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setPartialSlipBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
                                         tuner, indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary2D.h/hh
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setPartialSlipBoundary() [4/6]

template<typename T , typename DESCRIPTOR >

void olb::setPartialSlipBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	tuner,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the PartialSlipBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setPartialSlipBoundary3D.hh.

{
  bool includeOuterCells = false;
  int _overlap = 1;
  OstreamManager clout(std::cout, "setPartialslipBoundary");
 
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setPartialSlipBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
                                         tuner, indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setPartialSlipBoundary() [5/6]

template<typename T , typename DESCRIPTOR >

void olb::setPartialSlipBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	tuner,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the Partial slip boundary on the superLattice domain.

Definition at line 37 of file setPartialSlipBoundary2D.hh.

{
  setPartialSlipBoundary<T,DESCRIPTOR>(sLattice, tuner, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setPartialSlipBoundary() [6/6]

template<typename T , typename DESCRIPTOR >

void olb::setPartialSlipBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	tuner,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the PartialSlipBoundary function on the superLattice domain.

Definition at line 36 of file setPartialSlipBoundary3D.hh.

{
  setPartialSlipBoundary<T,DESCRIPTOR>(sLattice, tuner, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setRegularizedHeatFluxBoundary() [1/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setRegularizedHeatFluxBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		T *	heatFlux )

Set RegularizedHeatFluxBoundary for indicated cells inside the block domain.

Definition at line 57 of file setRegularizedHeatFluxBoundary2D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  OstreamManager clout(std::cout, "setRegularizedHeatFluxBoundary");
  /*
   *x0,x1,y0,y1 Range of cells to be traversed
   **/
  int x0 = 0;
  int y0 = 0;
  int x1 = blockGeometryStructure.getNx()-1;
  int y1 = blockGeometryStructure.getNy()-1;
  std::vector<int> discreteNormal(3,0);
  for (int iX = x0; iX <= x1; ++iX) {
    for (int iY = y0; iY <= y1; ++iY) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      auto cell = block.get(iX,iY);
      if (indicator(iX, iY)) {
        discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX,iY);
        if (discreteNormal[0] == 0) {//set momenta, dynamics and postProcessor on indicated RegularizedHeatFluxBoundary cells
          dynamics = block.getDynamics(PlainMixinDynamicsForDirectionOrientationMomenta<T,DESCRIPTOR,
            CombinedAdvectionDiffusionRLBdynamics,
            MixinDynamics,momenta::RegularizedHeatFluxBoundaryTuple
          >::construct(Vector<int,2>(discreteNormal.data() + 1)));
          setBoundary(block, iX,iY, dynamics);
          cell.defineU(heatFlux);
        }
        else if (discreteNormal[0] == 1) {//set momenta, dynamics and postProcessor on indicated RegularizedHeatFluxBoundary corner cells
          dynamics = block.getDynamics(NormalMixinDynamicsForPlainMomenta<T,DESCRIPTOR,
            AdvectionDiffusionCornerDynamics2D,
            MixinDynamics,momenta::EquilibriumBoundaryTuple
          >::construct(Vector<int,2>(discreteNormal.data() + 1)));
          setBoundary(block, iX,iY, dynamics);
        }
        if (dynamics) {
          dynamics->getParameters(block).template set<descriptors::OMEGA>(omega);
        }
      }
    }
  }
}

References olb::BlockLattice< T, DESCRIPTOR >::get(), olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), olb::BlockGeometry< T, D >::getStatistics(), and setBoundary().

Here is the call graph for this function:

◆ setRegularizedHeatFluxBoundary() [2/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setRegularizedHeatFluxBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator,
		T *	heatFlux = nullptr )

Initialising the RegularizedHeatFluxBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setRegularizedHeatFluxBoundary2D.hh.

{
  int _overlap = 1;
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setRegularizedHeatFluxBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc), omega,
        indicator->getBlockIndicatorF(iCloc), heatFlux);
  }
  addPoints2CommBC<T, DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setRegularizedHeatFluxBoundary() [3/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setRegularizedHeatFluxBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material,
		T *	heatFlux = nullptr )

Initialising the RegularizedHeatFluxBoundary on the superLattice domain This is an advection diffusion boundary -->MixinDynamics = AdvectionDiffusionRLBdynamics.

Initialising the RegularizedHeatFluxBoundary on the superLattice domain.

Definition at line 35 of file setRegularizedHeatFluxBoundary2D.hh.

{
  setRegularizedHeatFluxBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material), heatFlux);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setRegularizedTemperatureBoundary() [1/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setRegularizedTemperatureBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator )

Set RegularizedTemperatureBoundary for indicated cells inside the block domain.

Definition at line 57 of file setRegularizedTemperatureBoundary2D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  /*
   *x0,x1,y0,y1 Range of cells to be traversed
   **/
  int x0 = 0;
  int y0 = 0;
  int x1 = blockGeometryStructure.getNx()-1;
  int y1 = blockGeometryStructure.getNy()-1;
  std::vector<int> discreteNormal(3,0);
  for (int iX = x0; iX <= x1; ++iX) {
    for (int iY = y0; iY <= y1; ++iY) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      PostProcessorGenerator2D<T,DESCRIPTOR>* postProcessor = nullptr;
      if (indicator(iX, iY)) {
        discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX,iY);
        if (discreteNormal[0] == 0) {   
          dynamics = block.getDynamics(PlainMixinDynamicsForDirectionOrientationMomenta<T,DESCRIPTOR,
            CombinedAdvectionDiffusionRLBdynamics,
            MixinDynamics,momenta::RegularizedTemperatureBoundaryTuple
          >::construct(Vector<int,2>(discreteNormal.data() + 1)));
          dynamics->getParameters(block).template set<descriptors::OMEGA>(omega);
          setBoundary(block, iX,iY, dynamics, postProcessor);
        }
        else if (discreteNormal[0] == 1) {
          dynamics = block.getDynamics(NormalMixinDynamicsForPlainMomenta<T,DESCRIPTOR,
            AdvectionDiffusionCornerDynamics2D,
            MixinDynamics,momenta::EquilibriumBoundaryTuple
          >::construct(Vector<int,2>(discreteNormal.data() + 1)));
          dynamics->getParameters(block).template set<descriptors::OMEGA>(omega);
          setBoundary(block, iX,iY, dynamics, postProcessor);
        }
      }
    }
  }
}

References olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::BlockStructureD< D >::getNx(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), olb::BlockGeometry< T, D >::getStatistics(), and setBoundary().

Here is the call graph for this function:

◆ setRegularizedTemperatureBoundary() [2/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setRegularizedTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the RegularizedTemperatureBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setRegularizedTemperatureBoundary2D.hh.

{
  int _overlap = 1;
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setRegularizedTemperatureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc),omega,
        indicator->getBlockIndicatorF(iCloc));
  }
  addPoints2CommBC<T, DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setRegularizedTemperatureBoundary() [3/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setRegularizedTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the RegularizedTemperatureBoundary on the superLattice domain This is an advection diffusion boundary -->MixinDynamics = AdvectionDiffusionRLBdynamics.

Initialising the RegularizedTemperatureBoundary on the superLattice domain.

Definition at line 34 of file setRegularizedTemperatureBoundary2D.hh.

{
  setRegularizedTemperatureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setRobinBoundary() [1/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setRobinBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		T	omega,
		bool	includeOuterCells = false,
		bool	useOtherStrategy = false )

Set RobinBoundary for any indicated cells inside the block domain.

Definition at line 63 of file setRobinBoundary3D.hh.

{
  using namespace boundaryhelper;
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
 
      if(discreteNormal[0] == 0){ //flat
        if(!useOtherStrategy){
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX,iY,iZ},
            promisePostProcessorForNormal<T, DESCRIPTOR, robinBoundaryLatticePostProcessor3D>(
              Vector <int,3> (discreteNormal.data()+1)
            )
          );
        } else{
          _block.addPostProcessor(
            typeid(stage::PostStream), {iX,iY,iZ},
            promisePostProcessorForNormal<T, DESCRIPTOR, robinBoundaryLatticePostProcessor3Dother>(
              Vector <int,3> (discreteNormal.data()+1)
            )
          );
        }
        dynamics = _block.template getDynamics<AdvectionDiffusionBGKdynamics<T,DESCRIPTOR>>();
      }
      setBoundary(_block, iX, iY, iZ, dynamics);
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), and setBoundary().

Here is the call graph for this function:

◆ setRobinBoundary() [2/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setRobinBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setRobinBoundary function on the superLattice domain.

Definition at line 46 of file setRobinBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setRobinBoundary");
  bool includeOuterCells = false;
  bool useOtherStrategy = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); iCloc++) {
    setRobinBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc), indicator->getBlockIndicatorF(iCloc), omega, includeOuterCells, useOtherStrategy);
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setRobinBoundary() [3/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setRobinBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setRobinBoundary function on the superLattice domain This is an AdvectionDiffusionBoundary therefore mostly --> MixinDynamics = AdvectionDiffusionRLBdynamics.

Initialising the setRobinBoundary function on the superLattice domain.

Definition at line 39 of file setRobinBoundary3D.hh.

{
  setRobinBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setRtlbmDiffuseConstTemperatureBoundary() [1/3]

template<typename T , typename DESCRIPTOR >

void olb::setRtlbmDiffuseConstTemperatureBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		T	omega,
		bool	includeOuterCells = false )

Set RtlbmDiffuseConstTemperatureBoundary for any indicated cells inside the block domain.

Definition at line 62 of file setRtlbmDiffuseConstTemperatureBoundary3D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      PostProcessorGenerator3D<T,DESCRIPTOR>* postProcessor = nullptr;
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[0] == 0) { // flat //set momenta, dynamics and postProcessors for indicated cells
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseConstBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,0,-1
          >>();
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseConstBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,0,1
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseConstBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,1,-1
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseConstBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,1,1
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseConstBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,2,-1
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseConstBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,2,1
          >>();
        }
      }
      else if (discreteNormal[0] == 1) { // corner //set momenta, dynamics and postProcessors on indicated boundery corner cells
        dynamics = _block.getDynamics(NormalDynamicsForPlainMomenta<T,DESCRIPTOR,
          RtlbmDiffuseConstCornerBoundaryDynamics,
          momenta::EquilibriumBoundaryTuple
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      else if (discreteNormal[0] == 3) {    // edge //set momenta, dynamics and postProcessors on indicated boundary edge cells
        dynamics = _block.getDynamics(NormalSpecialDynamicsForPlainMomenta<T,DESCRIPTOR,
          RtlbmDiffuseConstEdgeBoundaryDynamics,
          momenta::EquilibriumBoundaryTuple
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      dynamics->getParameters(_block).template set<descriptors::OMEGA>(omega);
      setBoundary(_block, iX,iY,iZ, dynamics, postProcessor);
    }
  });
}

References olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setRtlbmDiffuseConstTemperatureBoundary() [2/3]

template<typename T , typename DESCRIPTOR >

void olb::setRtlbmDiffuseConstTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setRtlbmDiffuseConstTemperatureBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setRtlbmDiffuseConstTemperatureBoundary3D.hh.

{
  int _overlap = 1;
  OstreamManager clout(std::cout, "setRtlbmDiffuseConstTemperatureBoundary");
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); iCloc++) {
    setRtlbmDiffuseConstTemperatureBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
        indicator->getBlockIndicatorF(iCloc), omega, includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setRtlbmDiffuseConstTemperatureBoundary() [3/3]

template<typename T , typename DESCRIPTOR >

void olb::setRtlbmDiffuseConstTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setRtlbmDiffuseConstTemperatureBoundary function on the superLattice domain.

Definition at line 35 of file setRtlbmDiffuseConstTemperatureBoundary3D.hh.

{
  setRtlbmDiffuseConstTemperatureBoundary<T,DESCRIPTOR>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setRtlbmDiffuseTemperatureBoundary() [1/3]

template<typename T , typename DESCRIPTOR >

void olb::setRtlbmDiffuseTemperatureBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		T	omega,
		bool	includeOuterCells = false )

Set RtlbmDiffuseTemperatureBoundary for any indicated cells inside the block domain.

Definition at line 62 of file setRtlbmDiffuseTemperatureBoundary3D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      PostProcessorGenerator3D<T,DESCRIPTOR>* postProcessor = nullptr;
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[0] == 0) { // flat //set momenta, dynamics and postProcessors for indicated cells
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,0,-1
          >>();
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,0,1
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,1,-1
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,1,1
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,2,-1
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          dynamics = _block.template getDynamics<RtlbmDiffuseBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,2,1
          >>();
        }
        setBoundary(_block, iX,iY,iZ, dynamics, postProcessor);
      }
      else if (discreteNormal[0] == 1) {    // corner //set momenta, dynamics and postProcessors on indicated boundery corner cells
        dynamics = _block.getDynamics(NormalDynamicsForPlainMomenta<T,DESCRIPTOR,
          RtlbmDiffuseCornerBoundaryDynamics,
          momenta::EquilibriumBoundaryTuple
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
        setBoundary(_block, iX,iY,iZ, dynamics, postProcessor);
      }
      else if (discreteNormal[0] == 3) {    // edge //set momenta, dynamics and postProcessors on indicated boundary edge cells
        dynamics = _block.getDynamics(NormalSpecialDynamicsForPlainMomenta<T,DESCRIPTOR,
          RtlbmDiffuseEdgeBoundaryDynamics,
          momenta::EquilibriumBoundaryTuple
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
        setBoundary(_block, iX,iY,iZ, dynamics, postProcessor);
      }
      dynamics->getParameters(_block).template set<descriptors::OMEGA>(omega);
    }
  });
}

References olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setRtlbmDiffuseTemperatureBoundary() [2/3]

template<typename T , typename DESCRIPTOR >

void olb::setRtlbmDiffuseTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setRtlbmDiffuseTemperatureBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setRtlbmDiffuseTemperatureBoundary3D.hh.

{
  int _overlap = 0;
  OstreamManager clout(std::cout, "setRtlbmDiffuseTemperatureBoundary");
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); iCloc++) {
    setRtlbmDiffuseTemperatureBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
        indicator->getBlockIndicatorF(iCloc), omega, includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setRtlbmDiffuseTemperatureBoundary() [3/3]

template<typename T , typename DESCRIPTOR >

void olb::setRtlbmDiffuseTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setRtlbmDiffuseTemperatureBoundary function on the superLattice domain.

Definition at line 35 of file setRtlbmDiffuseTemperatureBoundary3D.hh.

{
  setRtlbmDiffuseTemperatureBoundary<T,DESCRIPTOR>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setRtlbmDirectedTemperatureBoundary() [1/3]

template<typename T , typename DESCRIPTOR >

void olb::setRtlbmDirectedTemperatureBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		T	omega,
		bool	includeOuterCells = false )

Set RtlbmDirectedTemperatureBoundary for any indicated cells inside the block domain.

Definition at line 62 of file setRtlbmDirectedTemperatureBoundary3D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      PostProcessorGenerator3D<T,DESCRIPTOR>* postProcessor = nullptr;
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[0] == 0) { // flat //set momenta, dynamics and postProcessors for indicated cells
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          dynamics = _block.template getDynamics<RtlbmDirectedBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,0,-1
          >>();
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          dynamics = _block.template getDynamics<RtlbmDirectedBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,0,1
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          dynamics = _block.template getDynamics<RtlbmDirectedBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,1,-1
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          dynamics = _block.template getDynamics<RtlbmDirectedBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,1,1
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          dynamics = _block.template getDynamics<RtlbmDirectedBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,2,-1
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          dynamics = _block.template getDynamics<RtlbmDirectedBoundaryDynamics<T,DESCRIPTOR,
            momenta::EquilibriumBoundaryTuple,2,1
          >>();
        }
      }
      else if (discreteNormal[0] == 1) {    // corner //set momenta, dynamics and postProcessors on indicated boundery corner cells
        dynamics = _block.getDynamics(NormalDynamicsForPlainMomenta<T,DESCRIPTOR,
          RtlbmDirectedCornerBoundaryDynamics,momenta::EquilibriumBoundaryTuple
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      else if (discreteNormal[0] == 3) {    // edge //set momenta, dynamics and postProcessors on indicated boundary edge cells
        dynamics = _block.getDynamics(NormalSpecialDynamicsForPlainMomenta<T,DESCRIPTOR,
          RtlbmDirectedEdgeBoundaryDynamics,momenta::EquilibriumBoundaryTuple
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
    dynamics->getParameters(_block).template set<descriptors::OMEGA>(omega);
    setBoundary(_block, iX,iY,iZ, dynamics, postProcessor);
    }
  });
}

References olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setRtlbmDirectedTemperatureBoundary() [2/3]

template<typename T , typename DESCRIPTOR >

void olb::setRtlbmDirectedTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setRtlbmDirectedTemperatureBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setRtlbmDirectedTemperatureBoundary3D.hh.

{
  int _overlap = 1;
  OstreamManager clout(std::cout, "setRtlbmDirectedTemperatureBoundary");
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); iCloc++) {
    setRtlbmDirectedTemperatureBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
        indicator->getBlockIndicatorF(iCloc), omega, includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setRtlbmDirectedTemperatureBoundary() [3/3]

template<typename T , typename DESCRIPTOR >

void olb::setRtlbmDirectedTemperatureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setRtlbmDirectedTemperatureBoundary function on the superLattice domain.

Definition at line 35 of file setRtlbmDirectedTemperatureBoundary3D.hh.

{
  setRtlbmDirectedTemperatureBoundary<T,DESCRIPTOR>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setSlipBoundary() [1/6]

template<typename T , typename DESCRIPTOR >

void olb::setSlipBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF2D< T > &	indicator,
		bool	includeOuterCells = false )

set slipBoundary for any indicated cells inside the block domain

Set slip boundary on blockLattice domain.

Definition at line 115 of file setSlipBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setSlipBoundary");
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0) {
        //set slip boundary on indicated cells
        bool _output = false;
        if (_output) {
          clout << "setSlipBoundary<" << discreteNormal[1] << ","<< discreteNormal[2] << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << " )" << std::endl;
        }
        block.addPostProcessor(
            typeid(stage::PostStream), {iX,iY},
            boundaryhelper::promisePostProcessorForNormal<T, DESCRIPTOR, FullSlipBoundaryPostProcessor2D>(
              Vector <int,2> (discreteNormal.data()+1)
            )
          );
      }
      else {
        clout << "Warning: Could not addSlipBoundary (" << iX << ", " << iY << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] <<"), set to bounceBack" << std::endl;
        block.template defineDynamics<BounceBack>({iX, iY});
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF2D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setSlipBoundary() [2/6]

template<typename T , typename DESCRIPTOR >

void olb::setSlipBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells = false )

Set slipBoundary for any indicated cells inside the block domain.

Set slip boundary for any indicated cells inside the block domain.

Definition at line 118 of file setSlipBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setslipBoundary");
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {//set postProcessors for indicated cells
        OstreamManager clout(std::cout, "setslipBoundary");
        bool _output = false;
        if (_output) {
          clout << "setSlipBoundary<" << discreteNormal[1] << ","<< discreteNormal[2] << ","<< discreteNormal[3] << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << ", " << iZ << ", " << iZ << " )" << std::endl;
        }
        block.addPostProcessor(
            typeid(stage::PostStream), {iX,iY,iZ},
            boundaryhelper::promisePostProcessorForNormal<T, DESCRIPTOR, FullSlipBoundaryPostProcessor3D>(
              Vector <int,3> (discreteNormal.data()+1)
            )
          );
      }
      else {//define dynamics for indicated cells
        clout << "Warning: Could not setSlipBoundary (" << iX << ", " << iY << ", " << iZ << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] <<","<< discreteNormal[3] <<"), set to bounceBack" << std::endl;
        block.template defineDynamics<BounceBack>({iX, iY, iZ});
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setSlipBoundary() [3/6]

template<typename T , typename DESCRIPTOR >

void olb::setSlipBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the SlipBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 95 of file setSlipBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setSlipBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setSlipBoundary<T, DESCRIPTOR>(sLattice.getBlock(iCloc),
                                   indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  //defined inside setLocalVelocityBoundary2D.h/hh
  addPoints2CommBC<T, DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setSlipBoundary() [4/6]

template<typename T , typename DESCRIPTOR >

void olb::setSlipBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setslipBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 100 of file setSlipBoundary3D.hh.

{
  bool includeOuterCells = false;
  int _overlap = 1;
  OstreamManager clout(std::cout, "setslipBoundary");
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setSlipBoundary(sLattice.getBlock(iCloc), indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setSlipBoundary().

Here is the call graph for this function:

◆ setSlipBoundary() [5/6]

template<typename T , typename DESCRIPTOR >

void olb::setSlipBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the SlipBoundary on the superLattice domain.

Definition at line 88 of file setSlipBoundary2D.hh.

{
  setSlipBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ setSlipBoundary() [6/6]

template<typename T , typename DESCRIPTOR >

void olb::setSlipBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setslipBoundary function on the superLattice domain.

Definition at line 93 of file setSlipBoundary3D.hh.

{
  setSlipBoundary<T, DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setSlipBoundaryWithDynamics() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setSlipBoundaryWithDynamics	(	BlockLattice< T, DESCRIPTOR > &	_block,
		T	omega,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells )

Definition at line 62 of file setSlipBoundaryWithDynamics3D.hh.

{
  using namespace boundaryhelper;
  OstreamManager clout(std::cout, "setslipBoundaryWithDynamics");
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY, iZ);
      // Setting postProcessor as in setSlipBoundary3D
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {//set postProcessors for indicated cells
        bool _output = false;
        if (_output) {
          clout << "setSlipBoundary<" << discreteNormal[1] << ","<< discreteNormal[2] << ","<< discreteNormal[3] << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << ", " << iZ << ", " << iZ << " )" << std::endl;
        }
        PostProcessorGenerator3D<T, DESCRIPTOR>* postProcessor = new SlipBoundaryProcessorGenerator3D<T, DESCRIPTOR>(iX, iX, iY, iY, iZ, iZ, discreteNormal[1], discreteNormal[2], discreteNormal[3]);
        if (postProcessor) {
          block.addPostProcessor(*postProcessor);
        }
      }
      else {//define dynamics for indicated cells
        clout << "Warning: Could not setSlipBoundary (" << iX << ", " << iY << ", " << iZ << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] <<","<< discreteNormal[3] <<"), set to bounceBack" << std::endl;
        block.template defineDynamics<BounceBack>({iX, iY, iZ});
      }
      // Setting dynamics and momenta as in interpolatedVelocityBoundary3D
      if (discreteNormal[0] == 0) {
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {//set momenta, dynamics and postProcessors on indicated velocityBoundaryCells
          dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<0,-1>
          >>();
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<0,1>
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<1,-1>
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<1,1>
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<2,-1>
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::BasicDirichletVelocityBoundaryTuple<2,1>
          >>();
        }
      }
      else if (discreteNormal[0] == 1) {//set momenta,dynamics and postProcessors on indicated velocityBoundary External Corner cells
        dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
      }
      else if (discreteNormal[0] == 2) {//Internalvelocitycorner
        dynamics = block.getDynamics(PlainMixinDynamicsForNormalMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::InnerCornerVelocityTuple3D
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      //ExternalVelocityEdge
      else if (discreteNormal[0] == 3) {//set momenta,dynamics and postProcessors on indicated velocityBoundary External Edge cells
        dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
      }
      //InternalVelocityEdge
      else if (discreteNormal[0] == 4) {//set momenta,dynamics and postProcessors on indicated velocityBoundary Inner Edge cells
            dynamics = block.getDynamics(PlainMixinDynamicsForNormalSpecialMomenta<T,DESCRIPTOR,
              CombinedRLBdynamics,MixinDynamics,momenta::InnerEdgeVelocityTuple3D
            >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      dynamics->getParameters(block).template set<descriptors::OMEGA>(omega);
      setBoundary(block, iX,iY,iZ, dynamics);
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setSlipBoundaryWithDynamics() [2/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setSlipBoundaryWithDynamics	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		bool	includeOuterCells = false )

Set interpolated velocity boundary for any indicated cells inside the block domain.

Set Interpolated velocity boundary for any indicated cells inside the block domain.

sets momenta, dynamics and post processor on velocity boundary cells

sets momenta, dynamics and post processors on externalVelocityCorner Boundary cells

sets momenta, dynamics and post processors on internalVelocityCorner Boundary cells

sets momenta, dynamics and post processor on velocity boundary cells

sets momenta, dynamics and post processors on externalVelocityCorner Boundary cells

sets momenta, dynamics and post processors on internalVelocityCorner Boundary cells

Definition at line 61 of file setSlipBoundaryWithDynamics2D.hh.

{
  using namespace boundaryhelper;
  OstreamManager clout(std::cout, "setSlipBoundaryWithDynamics");
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      Dynamics<T, DESCRIPTOR>* dynamics = nullptr;
      PostProcessorGenerator2D<T, DESCRIPTOR>* postProcessor = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
      if (discreteNormal[0] == 0) {
        dynamics = block.getDynamics(MixinDynamicsExchangeDirectionOrientationMomenta<T,DESCRIPTOR,
            MixinDynamics,momenta::BasicDirichletVelocityBoundaryTuple
          >::construct(Vector<int,2>(discreteNormal.data()+1)));
        postProcessor = new SlipBoundaryProcessorGenerator2D<T, DESCRIPTOR>(iX, iX, iY, iY, discreteNormal[1], discreteNormal[2]);
      }
      else if (discreteNormal[0] == 1) {
        dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
        postProcessor = new SlipBoundaryProcessorGenerator2D<T, DESCRIPTOR>(iX, iX, iY, iY, discreteNormal[1], discreteNormal[2]);
      }
      else if (discreteNormal[0] == 2) {
        dynamics = block.getDynamics(PlainMixinDynamicsForNormalMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::InnerCornerVelocityTuple2D
        >::construct(Vector<int,2>(discreteNormal.data()+1)));
        postProcessor = nullptr;
      }
      dynamics->getParameters(block).template set<descriptors::OMEGA>(omega);
      setBoundary(block, iX,iY, dynamics, postProcessor);
    }
  });
}

References olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setSlipBoundaryWithDynamics() [3/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setSlipBoundaryWithDynamics	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the setSlipBoundaryWithDynamics function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 41 of file setSlipBoundaryWithDynamics2D.hh.

{
  bool includeOuterCells = false;
  int _overlap = indicator->getSuperGeometry().getOverlap();
  OstreamManager clout(std::cout, "setOnBCInterpolatedBoundary");
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setSlipBoundaryWithDynamics<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc), omega,
        indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary2D.h/hh
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setSlipBoundaryWithDynamics() [4/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setSlipBoundaryWithDynamics	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setSlipBoundaryWithDynamics function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setSlipBoundaryWithDynamics3D.hh.

{
  OstreamManager clout(std::cout, "setSlipBoundaryWithDynamics");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setSlipBoundaryWithDynamics<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iC),omega, indicator->getBlockIndicatorF(iC),includeOuterCells);
  }
  //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary3D.h/hh
  addPoints2CommBC(sLattice,std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setSlipBoundaryWithDynamics() [5/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setSlipBoundaryWithDynamics	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the setSlipBoundaryWithDynamics function on the superLattice domain Interpolated Boundaries use the BGKdynamics collision-operator.

Initialising the setSlipBoundaryWithDynamics function on the superLattice domain.

Definition at line 34 of file setSlipBoundaryWithDynamics2D.hh.

{
  setSlipBoundaryWithDynamics<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setSlipBoundaryWithDynamics() [6/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setSlipBoundaryWithDynamics	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setSlipBoundaryWithDynamics function on the superLattice domain.

Definition at line 35 of file setSlipBoundaryWithDynamics3D.hh.

{
  setSlipBoundaryWithDynamics<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setSuperExternalPSMParticleField()

template<typename T , typename DESCRIPTOR >

void olb::setSuperExternalPSMParticleField	(	SuperGeometry< T, 2 > &	sGeometry,
		int	material,
		AnalyticalF2D< T, T > &	velocity,
		T	size,
		SuperLatticeF2D< T, DESCRIPTOR > &	epsilon,
		SuperLattice< T, DESCRIPTOR > &	sLattice )

Definition at line 50 of file superLattice2D.hh.

{
  FunctorPtr<SuperIndicatorF2D<T>>&& indicator = sGeometry.getMaterialIndicator(material);
  const int overlap = indicator->getSuperGeometry().getOverlap();
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    int globIC = sLattice.getLoadBalancer().glob(iC);
    BlockIndicatorF2D<T>& blockIndicator = indicator->getBlockIndicatorF(iC);
    setBlockExternalPSMParticleField( sGeometry.getBlockGeometry(iC), velocity, size, epsilon,
    sLattice.getBlock(iC), blockIndicator, globIC, overlap);
  }
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperGeometry< T, D >::getBlockGeometry(), olb::SuperStructure< T, D >::getLoadBalancer(), and olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setWallFunctionBoundary() [1/3]

template<typename T , typename DESCRIPTOR >

void olb::setWallFunctionBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		wallFunctionParam< T > const &	wallFunctionParam,
		IndicatorF3D< T > *	geoIndicator,
		bool	includeOuterCells = false )

Set WallFunction boundary for any indicated cells inside the block domain.

Definition at line 71 of file setWallFunctionBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setWallFunctionBoundary");
  bool _output = false;
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      std::vector<int> missingIndices;
      for (int x = -1 ; x < 2; ++x) {
        for (int y = -1 ; y < 2; ++y) {
          for (int z = -1 ; z < 2; ++z) {
            if (blockGeometryStructure.getMaterial(iX + x, iY + y, iZ + z) == 0) {
              for (int iPop = 0; iPop < DESCRIPTOR::q; ++iPop) {
                if (descriptors::c<DESCRIPTOR>(iPop,0) == x &&
                    descriptors::c<DESCRIPTOR>(iPop,1) == y &&
                    descriptors::c<DESCRIPTOR>(iPop,2) == z) {
                  missingIndices.push_back(descriptors::opposite<DESCRIPTOR>(iPop));
                }
              }
            }
          }
        }
      }
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {
        discreteNormal.erase(discreteNormal.begin());
        //OLB_PRECONDITION(x0==x1 || y0==y1 || z0==z1);
        if (_output) {
          clout << "setWallFunctionBoundary<" << discreteNormal[0] << ","<< discreteNormal[1] << ","<< discreteNormal[2] << ">("  << iX << ", "<< iX << ", " << iY << ", " << iY << ", " << iZ << ", " << iZ << " )" << std::endl;
        }
        auto postProcessor = std::unique_ptr<PostProcessorGenerator3D<T, DESCRIPTOR>>{ new WallFunctionBoundaryProcessorGenerator3D<T, DESCRIPTOR>(iX, iX, iY, iY, iZ, iZ, indicator.getBlockGeometry(), discreteNormal, missingIndices,
            converter, wallFunctionParam, geoIndicator) };
        if (postProcessor) {
          _block.addPostProcessor(*postProcessor);
        }
      }
      else {
        clout << "Warning: Could not setWallFunctionBoundary (" << iX << ", " << iY << ", " << iZ << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] <<","<< discreteNormal[3] <<"), set to bounceBack" << std::endl;
        _block.template defineDynamics<BounceBack>({iX, iY, iZ});
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setWallFunctionBoundary() [2/3]

template<typename T , typename DESCRIPTOR >

void olb::setWallFunctionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		wallFunctionParam< T > const &	wallFunctionParam,
		IndicatorF3D< T > *	geoIndicator )

Initialising the WallFunctionBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 46 of file setWallFunctionBoundary3D.hh.

{
  int _overlap = 1;
  bool includeOuterCells = false;
  OstreamManager clout(std::cout, "setWallFunctionBoundary");
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setWallFunctionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
        indicator->getBlockIndicatorF(iCloc),
        converter, wallFunctionParam, geoIndicator, includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
 
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setWallFunctionBoundary() [3/3]

template<typename T , typename DESCRIPTOR >

void olb::setWallFunctionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material,
		UnitConverter< T, DESCRIPTOR > const &	converter,
		wallFunctionParam< T > const &	wallFunctionParam,
		IndicatorF3D< T > *	geoIndicator = NULL )

Initialising the WallFunctionBoundary on the superLattice domain.

Definition at line 35 of file setWallFunctionBoundary3D.hh.

{
  setWallFunctionBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material),
                                        converter, wallFunctionParam, geoIndicator);
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setZeroDistributionBoundary() [1/3]

template<typename T , typename DESCRIPTOR >

void olb::setZeroDistributionBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator )

Definition at line 65 of file setZeroDistributionBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setZeroDistributionBoundary");
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = 1;
  std::vector<int> discreteNormal(4, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {
        auto postProcessor = std::unique_ptr<PostProcessorGenerator3D<T, DESCRIPTOR>>{
        new ZeroDistributionBoundaryProcessorGenerator3D<T, DESCRIPTOR>(iX, iX, iY, iY, iZ, iZ, -discreteNormal[1], -discreteNormal[2], -discreteNormal[3]) };
        if (postProcessor) {
          _block.addPostProcessor(*postProcessor);
        }
      }
      else {
        clout << "Warning: Could not setZeroDistributionBoundary (" << iX << ", " << iY << ", " << iZ << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] << "," << discreteNormal[3] << ")" << std::endl;
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setZeroDistributionBoundary() [2/3]

template<typename T , typename DESCRIPTOR >

void olb::setZeroDistributionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 50 of file setZeroDistributionBoundary3D.hh.

{
  int _overlap = 1;
  OstreamManager clout(std::cout, "setZeroDistributionBoundary");
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    //sets ZeroDistributionBoundary on the block level
    setZeroDistributionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
        indicator->getBlockIndicatorF(iCloc));
  }
  addPoints2CommBC(sLattice,std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setZeroDistributionBoundary() [3/3]

template<typename T , typename DESCRIPTOR >

void olb::setZeroDistributionBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Definition at line 41 of file setZeroDistributionBoundary3D.hh.

{
  setZeroDistributionBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setZeroGradientBoundary() [1/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setZeroGradientBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		BlockIndicatorF3D< T > &	indicator )

Set ZeroGradientBoundary for any indicated cells inside the block domain.

Definition at line 57 of file setZeroGradientBoundary3D.hh.

{
  using namespace boundaryhelper;
  const auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {
        for(int iPop = 0; iPop < DESCRIPTOR::q; iPop++){
          auto c = descriptors::c<DESCRIPTOR>(iPop);
          T k = c[0]*(-discreteNormal[1]) + c[1]*(-discreteNormal[2]) + c[2]*(-discreteNormal[3]);
          if(k > T{0.} && blockGeometryStructure.getMaterial(iX+c[0], iY+c[1], iZ+c[2]) == 1 ){
            _block.get(iX+c[0], iY+c[1], iZ+c[2]).template getFieldPointer<descriptors::NEIGHBOR>()[0] = T{1.};
          }
          if(k > T{0.} && blockGeometryStructure.getMaterial(iX+2*c[0], iY+2*c[1], iZ+2*c[2]) == 1 ){
            _block.get(iX+2*c[0], iY+2*c[1], iZ+2*c[2]).template getFieldPointer<descriptors::NEIGHBOR>()[0] = T{1.};
          }
        }
        _block.addPostProcessor(
            typeid(stage::PostCollide), {iX,iY,iZ},
            meta::id<zeroGradientLatticePostProcessor3D<T, DESCRIPTOR>>{}
            );
        _block.template defineDynamics<NoCollideDynamics>({iX, iY, iZ});
      } else {
        _block.template defineDynamics<BounceBack>({iX, iY, iZ});
      }
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockLattice< T, DESCRIPTOR >::get(), and olb::BlockIndicatorF3D< T >::getBlockGeometry().

Here is the call graph for this function:

◆ setZeroGradientBoundary() [2/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setZeroGradientBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setZeroGradientBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setZeroGradientBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setZeroGradientBoundary");
 
  int _overlap = 1;
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); iCloc++) {
    setZeroGradientBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc), indicator->getBlockIndicatorF(iCloc));
  }
  addPoints2CommBC(sLattice,std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setZeroGradientBoundary() [3/3]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = AdvectionDiffusionRLBdynamics<T,DESCRIPTOR>>

void olb::setZeroGradientBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setZeroGradientBoundary function on the superLattice domain This is an AdvectionDiffusionBoundary therefore mostly --> MixinDynamics = AdvectionDiffusionRLBdynamics.

Initialising the setZeroGradientBoundary function on the superLattice domain.

Definition at line 35 of file setZeroGradientBoundary3D.hh.

{
  setZeroGradientBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setZouHePressureBoundary() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >

void olb::setZouHePressureBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		T	omega,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells )

Set pressure boundary for any indicated cells inside the block domain.

Definition at line 62 of file setZouHePressureBoundary3D.hh.

{
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
 
      if (discreteNormal[0] == 0) {
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletPressureBoundaryTuple< 0,-1>, 0, -1
          >>();
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletPressureBoundaryTuple< 0,1>, 0, 1
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletPressureBoundaryTuple< 1,-1>, 1, -1
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletPressureBoundaryTuple< 1,1>, 1, 1
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletPressureBoundaryTuple< 2,-1>, 2, -1
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletPressureBoundaryTuple< 2,1>, 2, 1
          >>();
        }
      }
      dynamics->getParameters(_block).template set<descriptors::OMEGA>(omega);
      setBoundary(_block, iX,iY,iZ, dynamics);
    }
  });
}

References olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setZouHePressureBoundary() [2/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::setZouHePressureBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		bool	includeOuterCells = false )

Set pressure boundary for any indicated cells inside the block domain.

set momenta,dynamics and post processors on cells

Definition at line 63 of file setZouHePressureBoundary2D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(3, 0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
        && indicator(iX, iY)) {
      Dynamics<T, DESCRIPTOR>* dynamics = nullptr;
      PostProcessorGenerator2D<T, DESCRIPTOR>* postProcessor = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
      if (discreteNormal[0] == 0) {
        dynamics = block.getDynamics(DirectionOrientationMixinDynamicsForDirectionOrientationMomenta<T,DESCRIPTOR,
          ZouHeDynamics,MixinDynamics,momenta::BasicDirichletPressureBoundaryTuple
        >::construct(Vector<int,2>(discreteNormal.data() + 1)));
        dynamics->getParameters(block).template set<descriptors::OMEGA>(omega);
        setBoundary(block, iX,iY, dynamics, postProcessor);
      }
    }
  });
}

References olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setZouHePressureBoundary() [3/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::setZouHePressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the setZouHePressureBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setZouHePressureBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setZouHePressureBoundary2D");
  bool includeOuterCells = false;
  int _overlap = 1;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setZouHePressureBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice.getBlock(iCloc),omega,
        indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setZouHePressureBoundary() [4/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setZouHePressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setZouHePressureBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setZouHePressureBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setZouHePressureBoundary");
  int _overlap = 0;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  //clout << sLattice.getLoadBalancer().size() <<"sLattice.getLoadBalancer.size()" << std::endl;
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setZouHePressureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iC), omega, indicator->getBlockIndicatorF(iC),includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setZouHePressureBoundary() [5/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setZouHePressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the setZouHePressureBoundary function on the superLattice domain ZouHe Boundaries use the BGKdynamics collision operator.

Initialising the setZouHePressureBoundary function on the superLattice domain.

Definition at line 36 of file setZouHePressureBoundary2D.hh.

{
  setZouHePressureBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setZouHePressureBoundary() [6/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setZouHePressureBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setZouHePressureBoundary function on the superLattice domain ZouHe Boundaries use the BGKdynamics collision operator.

Initialising the setZouHePressureBoundary function on the superLattice domain.

Definition at line 35 of file setZouHePressureBoundary3D.hh.

{
  setZouHePressureBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega,superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setZouHeVelocityBoundary() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setZouHeVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	_block,
		T	omega,
		BlockIndicatorF3D< T > &	indicator,
		bool	includeOuterCells )

Set ZouHe velocity boundary for any indicated cells inside the block domain.

Definition at line 63 of file setZouHeVelocityBoundary3D.hh.

{
  using namespace boundaryhelper;
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  std::vector<int> discreteNormal(4,0);
  blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
    if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
        && indicator(iX, iY, iZ)) {
      Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
      discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY, iZ);
      if (discreteNormal[0] == 0) {
        //setVelocityBoundary
        if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletVelocityBoundaryTuple<0,-1>, 0,-1
          >>();
        }
        else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletVelocityBoundaryTuple<0,1>, 0,1
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletVelocityBoundaryTuple<1,-1>, 1,-1
          >>();
        }
        else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletVelocityBoundaryTuple<1,1>, 1,1
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletVelocityBoundaryTuple<2,-1>, 2,-1
          >>();
        }
        else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
          dynamics = _block.template getDynamics<ZouHeDynamics<T,DESCRIPTOR, MixinDynamics,
            momenta::BasicDirichletVelocityBoundaryTuple<2,1>, 2,1
          >>();
        }
      }
      //ExternalVelocityCorner
      else if (discreteNormal[0] == 1) {
        dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
        _block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY, iZ},
          promisePostProcessorForNormal<T,DESCRIPTOR,OuterVelocityCornerProcessor3D>(
            Vector<int,3>(discreteNormal.data() + 1)));
      }
      //InternalVelocityCorner
      else if (discreteNormal[0] == 2) {
        dynamics = _block.getDynamics(PlainMixinDynamicsForNormalMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::InnerCornerVelocityTuple3D
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      //ExternalVelocityEdge
      else if (discreteNormal[0] == 3) {
        dynamics = _block.template getDynamics<typename MixinDynamics::template exchange_momenta<
          momenta::FixedVelocityBoundaryTuple
        >>();
        _block.addPostProcessor(
          typeid(stage::PostStream), {iX, iY, iZ},
          promisePostProcessorForNormalSpecial<T,DESCRIPTOR,OuterVelocityEdgeProcessor3D>(
            Vector<int,3>(discreteNormal.data() + 1)));
      }
      //InternalVelocityEdge
      else if (discreteNormal[0] == 4) {
        dynamics = _block.getDynamics(PlainMixinDynamicsForNormalSpecialMomenta<T,DESCRIPTOR,
          CombinedRLBdynamics,MixinDynamics,momenta::InnerEdgeVelocityTuple3D
        >::construct(Vector<int,3>(discreteNormal.data() + 1)));
      }
      dynamics->getParameters(_block).template set<descriptors::OMEGA>(omega);
      setBoundary(_block, iX,iY,iZ, dynamics);
    }
  });
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::Dynamics< T, DESCRIPTOR >::getParameters(), and setBoundary().

Here is the call graph for this function:

◆ setZouHeVelocityBoundary() [2/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics >

void olb::setZouHeVelocityBoundary	(	BlockLattice< T, DESCRIPTOR > &	block,
		T	omega,
		BlockIndicatorF2D< T > &	indicator,
		bool	includeOuterCells = false )

Set ZouHe velocity boundary for any indicated cells inside the block domain.

Definition at line 62 of file setZouHeVelocityBoundary2D.hh.

{
  using namespace boundaryhelper;
  OstreamManager clout(std::cout, "setZouHeVelocityBoundary2D");
  auto& blockGeometryStructure = indicator.getBlockGeometry();
  const int margin = includeOuterCells ? 0 : 1;
  /*
   *x0,x1,y0,y1 Range of cells to be traversed
   **/
  int x0 = margin;
  int y0 = margin;
  int x1 = blockGeometryStructure.getNx()-1 -margin;
  int y1 = blockGeometryStructure.getNy()-1 -margin;
  std::vector<int> discreteNormal(3, 0);
  for (int iX = x0; iX <= x1; ++iX) {
    for (int iY = y0; iY <= y1; ++iY) {
      Dynamics<T, DESCRIPTOR>* dynamics = nullptr;
      if (indicator(iX, iY)) {
        discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
        if (discreteNormal[0] == 0) {
          //set the momenta,dynamics and post processor on the indicated ZouHe velocity boundary cells
          dynamics = block.getDynamics(DirectionOrientationMixinDynamicsForDirectionOrientationMomenta<T,DESCRIPTOR,
            ZouHeDynamics,MixinDynamics,momenta::BasicDirichletVelocityBoundaryTuple
          >::construct(Vector<int,2>(discreteNormal.data() + 1)));
        }
        else if (discreteNormal[0] == 1) {
          //sets the momenta, dynamics and post processors on indicated ZouHeVelocityCornerBoundary cells
          dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
            momenta::FixedVelocityBoundaryTuple
          >>();
          block.addPostProcessor(
            typeid(stage::PostStream), {iX, iY},
            promisePostProcessorForNormal<T,DESCRIPTOR,OuterVelocityCornerProcessor2D>(
              Vector<int,2>(discreteNormal.data() + 1)));
        }
        //sets momenta, dynamics and postProcessors on ZouHe InnerVelocityCornerBoundary Cells
        else if (discreteNormal[0] == 2) {
          dynamics = block.getDynamics(PlainMixinDynamicsForNormalMomenta<T,DESCRIPTOR,
            CombinedRLBdynamics,MixinDynamics,momenta::InnerCornerVelocityTuple2D
          >::construct(Vector<int,2>(discreteNormal.data() + 1)));
        }
        //sets the boundary on any indicated cell
        setBoundary(block, iX,iY, dynamics);
      }
    }
  }
}

References olb::BlockLattice< T, DESCRIPTOR >::addPostProcessor(), olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::BlockLattice< T, DESCRIPTOR >::getDynamics(), olb::BlockStructureD< D >::getNx(), olb::BlockGeometry< T, D >::getStatistics(), and setBoundary().

Here is the call graph for this function:

◆ setZouHeVelocityBoundary() [3/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setZouHeVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF2D< T > > &&	indicator )

Initialising the setZouHeVelocityBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 41 of file setZouHeVelocityBoundary2D.hh.

{
  OstreamManager clout(std::cout, "setZouHeVelocityBoundary2D");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
  for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
    setZouHeVelocityBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice.getBlock(iCloc), omega,
        indicator->getBlockIndicatorF(iCloc), includeOuterCells);
  }
  addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setZouHeVelocityBoundary() [4/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setZouHeVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		FunctorPtr< SuperIndicatorF3D< T > > &&	indicator )

Initialising the setZouHeVelocityBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setZouHeVelocityBoundary3D.hh.

{
  OstreamManager clout(std::cout, "setZouHeVelocityBoundary");
  int _overlap = 1;
  bool includeOuterCells = false;
  if (indicator->getSuperGeometry().getOverlap() == 1) {
    includeOuterCells = true;
    clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
  }
 
  for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
    setZouHeVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iC), omega, indicator->getBlockIndicatorF(iC),includeOuterCells);
  }
  addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), and olb::SuperStructure< T, D >::getLoadBalancer().

Here is the call graph for this function:

◆ setZouHeVelocityBoundary() [5/6]

template<typename T , typename DESCRIPTOR , class MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setZouHeVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 2 > &	superGeometry,
		int	material )

Initialising the setZouHeVelocityBoundary function on the superLattice domain.

Definition at line 35 of file setZouHeVelocityBoundary2D.hh.

{
  setZouHeVelocityBoundary<T,DESCRIPTOR, MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ setZouHeVelocityBoundary() [6/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>

void olb::setZouHeVelocityBoundary	(	SuperLattice< T, DESCRIPTOR > &	sLattice,
		T	omega,
		SuperGeometry< T, 3 > &	superGeometry,
		int	material )

Initialising the setZouHeVelocityBoundary function on the superLattice domain.

Definition at line 36 of file setZouHeVelocityBoundary3D.hh.

{
  setZouHeVelocityBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, omega, superGeometry.getMaterialIndicator(material));
}

References olb::SuperGeometry< T, D >::getMaterialIndicator().

Here is the call graph for this function:

◆ SuperCommunicator()

template<typename SUPER >

olb::SuperCommunicator ( SUPER & ) -> SuperCommunicator< typename SUPER::value_t, SUPER >

◆ SuperLatticeCoupling()

template<typename COUPLER , typename... MAP>

olb::SuperLatticeCoupling	(	COUPLER	,
		MAP &&	... ) -> SuperLatticeCoupling< COUPLER, typename meta::map< MAP... >::template map_values< descriptors::extract_valued_descriptor_t > >

◆ SuperLatticeDiscreteNormal2D()

template<typename T , typename DESCRIPTOR >

olb::SuperLatticeDiscreteNormal2D	(	SuperLattice< T, DESCRIPTOR > &	,
		SuperGeometry< typename SuperLattice< T, DESCRIPTOR >::value_t, 2 > &	,
		FunctorPtr< SuperIndicatorF2D< typename SuperLattice< T, DESCRIPTOR >::value_t > > &&	) -> SuperLatticeDiscreteNormal2D< T, DESCRIPTOR >

◆ SuperLatticeDiscreteNormalType2D()

template<typename T , typename DESCRIPTOR >

olb::SuperLatticeDiscreteNormalType2D	(	SuperLattice< T, DESCRIPTOR > &	,
		SuperGeometry< typename SuperLattice< T, DESCRIPTOR >::value_t, 2 > &	,
		FunctorPtr< SuperIndicatorF2D< typename SuperLattice< T, DESCRIPTOR >::value_t > > &&	) -> SuperLatticeDiscreteNormalType2D< T, DESCRIPTOR >

◆ SuperLatticePhysPressure2D()

template<typename T , typename DESCRIPTOR >

olb::SuperLatticePhysPressure2D	(	SuperLattice< T, DESCRIPTOR > &	,
		const UnitConverter< T, DESCRIPTOR > &	) -> SuperLatticePhysPressure2D< T, DESCRIPTOR >

◆ SuperLatticePhysPressure3D()

template<typename T , typename DESCRIPTOR >

olb::SuperLatticePhysPressure3D	(	SuperLattice< T, DESCRIPTOR > &	,
		const UnitConverter< T, DESCRIPTOR > &	) -> SuperLatticePhysPressure3D< T, DESCRIPTOR >

◆ SuperLatticePhysVelocity2D()

template<typename T , typename DESCRIPTOR >

olb::SuperLatticePhysVelocity2D	(	SuperLattice< T, DESCRIPTOR > &	,
		const UnitConverter< T, DESCRIPTOR > &	) -> SuperLatticePhysVelocity2D< T, DESCRIPTOR >

◆ SuperLatticePhysVelocity3D()

template<typename T , typename DESCRIPTOR >

olb::SuperLatticePhysVelocity3D	(	SuperLattice< T, DESCRIPTOR > &	,
		const UnitConverter< T, DESCRIPTOR > &	,
		bool	) -> SuperLatticePhysVelocity3D< T, DESCRIPTOR >

◆ testAnisotropyConservationColumn()

template<int q>

std::array< double, q > olb::testAnisotropyConservationColumn	(	const std::array< std::array< double, q >, q > &	phi,
		const double	weights[q],
		std::array< std::array< double, q >, q > &	cosTheta )

Definition at line 90 of file anisoDiscr.h.

{
  std::array<double,q> discIntegral;
  for ( int iVec = 0; iVec < q; iVec++ ) {
    discIntegral[iVec] = 0;
    for ( int iSum = 0; iSum < q; iSum++ ) {
      discIntegral[iVec] += weights[iSum] * cosTheta[iVec][iSum]* phi[iVec][iSum];
    }
  }
  return discIntegral;
}

◆ testEnergyConservationColumn()

template<int q, typename DESCRIPTOR >

std::array< double, q > olb::testEnergyConservationColumn ( const std::array< std::array< double, q >, q > & phi )

Definition at line 62 of file anisoDiscr.h.

{
  std::array<double,q> discIntegral;
  for ( int iVec = 0; iVec < q; iVec++ ) {
    discIntegral[iVec] = 0;
    for ( int iSum = 0; iSum < q; iSum++ ) {
      discIntegral[iVec] += descriptors::t<double,DESCRIPTOR>(iSum) * phi[iSum][iVec];
    }
  }
  return discIntegral;
}

◆ testEnergyConservationRow()

template<int q, typename DESCRIPTOR >

std::array< double, q > olb::testEnergyConservationRow ( const std::array< std::array< double, q >, q > & phi )

Definition at line 76 of file anisoDiscr.h.

{
  std::array<double,q> discIntegral;
  for ( int iVec = 0; iVec < q; iVec++ ) {
    discIntegral[iVec] = 0;
    for ( int iSum = 0; iSum < q; iSum++ ) {
      discIntegral[iVec] += descriptors::t<double,DESCRIPTOR>(iSum) * phi[iVec][iSum];
    }
  }
  return discIntegral;
}

◆ toStdVector()

template<typename T , unsigned D, typename IMPL >

constexpr std::vector< T > olb::toStdVector ( const ScalarVector< T, D, IMPL > & a )

constexpr

Copies data into a standard vector.

Definition at line 88 of file scalarVector.h.

{
  std::vector<T> v(D);
  for (unsigned iDim=0; iDim < D; ++iDim) {
    v[iDim] = a[iDim];
  }
  return v;
}

◆ writeArrayData() [1/3]

template<typename ARRAYTYPE >

void olb::writeArrayData	(	std::string	fullFileName,
		std::string	headLine,
		std::vector< ARRAYTYPE > &	dataVector )

Write array data.

Definition at line 122 of file plainWriter.hh.

{
#ifdef PARALLEL_MODE_MPI
  if (singleton::mpi().isMainProcessor()){
#endif
    //Instantiate data writer
    std::ofstream dataWriter;
    dataWriter.open( fullFileName );
    //Write scalar data for each array entry
    for (unsigned int i=0; i<dataVector.size(); ++i){
      writeScalarData( dataWriter, fullFileName, headLine, dataVector[i], i );
    }
    //Close File
    dataWriter.close();
#ifdef PARALLEL_MODE_MPI
  }
#endif
}

References olb::singleton::mpi(), and writeScalarData().

Here is the call graph for this function:

◆ writeArrayData() [2/3]

void olb::writeArrayData	(	std::string	fullFileName,
		std::string	headLine,
		std::vector< std::string > &	dataVector )

Write array data.

Definition at line 98 of file plainWriter.hh.

{
#ifdef PARALLEL_MODE_MPI
  if (singleton::mpi().isMainProcessor()){
#endif
    //Instantiate data writer
    std::ofstream dataWriter;
    dataWriter.open( fullFileName );
    //Write headline
    dataWriter << headLine << std::endl;
    //Write Data
    for (unsigned int i=0; i<dataVector.size(); ++i){
      dataWriter << dataVector[i] << std::endl;
    }
    //Close File
    dataWriter.close();
#ifdef PARALLEL_MODE_MPI
  }
#endif
}

References olb::singleton::mpi().

Here is the call graph for this function:

Here is the caller graph for this function:

◆ writeArrayData() [3/3]

template<typename ARRAYTYPE >

void olb::writeArrayData	(	std::string	fullFileName,
		std::vector< std::string > &	headLineVector,
		std::vector< ARRAYTYPE > &	dataVector )

Write array data (including sanity check)

Definition at line 144 of file plainWriter.hh.

{
  //Perform sanity check
#ifdef PARALLEL_MODE_MPI
  if (singleton::mpi().isMainProcessor()){
#endif
    if (dataVector.size()==0){
      std::cerr << "WARNING: DataVector is empty!" << std::endl;
    } else {
      if (headLineVector.size()!=dataVector[0].size()){
        std::cerr << "WARNING (" << fullFileName << "): DataVector does not match provided headline!" << std::endl;
      }
    }
#ifdef PARALLEL_MODE_MPI
  }
#endif
  //Set up headLine string
  std::string headLineStringArray;
  for ( unsigned int iQ=0; iQ<headLineVector.size(); ++iQ ){
    if (iQ>0){ headLineStringArray+=" "; };
    headLineStringArray += headLineVector[iQ];
  }
  //Call write array data
  writeArrayData( fullFileName, headLineStringArray, dataVector);
}

References olb::singleton::mpi(), and writeArrayData().

Here is the call graph for this function:

◆ writeScalarData() [1/3]

template<typename ARRAYTYPE >

void olb::writeScalarData	(	std::ofstream &	dataWriterOpened,
		std::string	fullFileName,
		std::string	headLine,
		ARRAYTYPE &	dataVector,
		int	iE,
		int	iE0 = 0 )

Write functions for scalar and array data.

Assuming that data is only written by main processor! Write scalar data (single core only)

Definition at line 32 of file plainWriter.hh.

{
  //Write headline if first element
  if (iE == iEinit){
    dataWriterOpened << headLine << std::endl;
  }
  //Write Data
  dataWriterOpened << dataVector[0];
  for (unsigned int i=1; i<dataVector.size(); ++i){
    dataWriterOpened << " " << dataVector[i];
  }
  dataWriterOpened << std::endl;
}

Here is the caller graph for this function:

◆ writeScalarData() [2/3]

template<typename ARRAYTYPE >

void olb::writeScalarData	(	std::string	fullFileName,
		std::string	headLine,
		ARRAYTYPE &	dataVector,
		int	iE,
		int	iE0 = 0 )

Write scalar data.

Definition at line 50 of file plainWriter.hh.

{
#ifdef PARALLEL_MODE_MPI
  if (singleton::mpi().isMainProcessor()){
#endif
    //Instantiate data writer
    std::ofstream dataWriter;
    dataWriter.open( fullFileName, std::ofstream::app );
    //Write scalar data
    writeScalarData( dataWriter, fullFileName, headLine,
                     dataVector, iE, iEinit );
    //Close File
    dataWriter.close();
#ifdef PARALLEL_MODE_MPI
  }
#endif
}

References olb::singleton::mpi(), and writeScalarData().

Here is the call graph for this function:

◆ writeScalarData() [3/3]

template<typename ARRAYTYPE >

void olb::writeScalarData	(	std::string	fullFileName,
		std::vector< std::string > &	headLineVector,
		ARRAYTYPE &	dataVector,
		int	iT,
		int	iTinit = 0 )

Write scalar data (including sanity check)

Definition at line 71 of file plainWriter.hh.

{
  //Perform sanity check
#ifdef PARALLEL_MODE_MPI
  if (singleton::mpi().isMainProcessor()){
#endif
    if (headLineVector.size()!=dataVector.size()){
      std::cerr << "WARNING (" << fullFileName << "): DataVector does not match provided headline!" << std::endl;
    }
#ifdef PARALLEL_MODE_MPI
  }
#endif
  //Set up headLine string
  std::string headLineStringScalar;
  for ( unsigned int iQ=0; iQ<headLineVector.size(); ++iQ ){
    if (iQ>0){ headLineStringScalar+=" "; };
    headLineStringScalar += headLineVector[iQ];
  }
  //Call write scalar data
  writeScalarData( fullFileName, headLineStringScalar, dataVector, iT, iTinit );
}

References olb::singleton::mpi(), and writeScalarData().

Here is the call graph for this function:

◆ XMLreader::read< std::size_t >()

template<>

bool olb::XMLreader::read< std::size_t >	(	std::size_t &	value,
		bool	verboseOn,
		bool	exitIfMissing ) const

Definition at line 465 of file xmlReader.h.

{
  std::stringstream valueStr(_text);
  std::size_t tmp = std::size_t();
  if (!(valueStr >> tmp)) {
    std::stringstream ss;
    ss << value;
    _output.printWarning(_name, "std::size_t", ss.str(), verboseOn, exitIfMissing);
    return false;
  }
  value = tmp;
  return true;
}

◆ XMLreader::read< std::string >()

template<>

bool olb::XMLreader::read< std::string >	(	std::string &	entry,
		bool	verboseOn,
		bool	exitIfMissing ) const

Definition at line 523 of file xmlReader.h.

{
  if (_name == "XML node not found") {
    return false;
  }
  std::stringstream valueStr(_text);
  std::string tmp = std::string();
  if (!(valueStr >> tmp)) {
    std::stringstream ss;
    ss << entry;
    _output.printWarning(_name, "string", ss.str(), verboseOn, exitIfMissing);
    return false;
  }
 
  entry = _text;
  return true;
}

Variable Documentation

◆ getCallable

template<typename T , typename SOLVER >

std::function< T(const std::vector< T > &, unsigned) olb::getCallable) (std::shared_ptr< SOLVER > solver) ( std::shared_ptr< SOLVER > solver )

Returns a function that encapsulates the solving process.

Definition at line 317 of file lbSolver.h.

                                                                                        {
  return [=](const std::vector<T>& control, unsigned optiStep) -> T {
    solver->parameters(names::Opti()).applyControl(control);
    solver->parameters(names::OutputOpti()).counterOptiStep = optiStep;
    solver->solve();
    return solver->parameters(names::Results()).objective;
  };
}

Namespaces

Classes

Typedefs

Enumerations

Functions

Variables

Detailed Description

Typedef Documentation

◆ AdvectionDiffusionBGKdynamics

◆ AdvectionDiffusionMRTdynamics

◆ AdvectionDiffusionRLBdynamics

◆ AdvectionDiffusionTRTdynamics

◆ AdvectionLocalDiffusionBoundariesDynamics

◆ AdvectionLocalDiffusionCornerDynamics2D

◆ AdvectionLocalDiffusionCornerDynamics3D

◆ AdvectionLocalDiffusionEdgesDynamics

◆ AnalyticalComposed2D

◆ AnalyticalComposed3D

◆ AnalyticalConst1D

◆ AnalyticalConst2D

◆ AnalyticalConst3D

◆ AnalyticalF1D

◆ AnalyticalF2D

◆ AnalyticalF3D

◆ AnalyticalIdentity1D

◆ AnalyticalIdentity2D

◆ AnalyticalIdentity3D

◆ AnalyticalRandom1D

◆ AnalyticalRandom2D

◆ AnalyticalRandom3D

◆ AnalyticCalcDivision

◆ AnalyticCalcDivision1D

◆ AnalyticCalcDivision2D

◆ AnalyticCalcDivision3D

◆ AnalyticCalcMinus

◆ AnalyticCalcMinus1D

◆ AnalyticCalcMinus2D

◆ AnalyticCalcMinus3D

◆ AnalyticCalcMultiplication

◆ AnalyticCalcMultiplication1D

◆ AnalyticCalcMultiplication2D

◆ AnalyticCalcMultiplication3D

◆ AnalyticCalcPlus

◆ AnalyticCalcPlus1D

◆ AnalyticCalcPlus2D

◆ AnalyticCalcPlus3D

◆ BaseType

◆ BGKdynamics

◆ BlockCalcDivision2D

◆ BlockCalcDivision3D

◆ BlockCalcMinus2D

◆ BlockCalcMinus3D

◆ BlockCalcMultiplication2D

◆ BlockCalcMultiplication3D

◆ BlockCalcPlus2D

◆ BlockCalcPlus3D

◆ BlockF

◆ BlockGeometry2D

◆ BlockGeometry3D

◆ BlockGeometryStatistics

◆ BlockIndicatorBoundaryNeighbor

◆ BlockIndicatorF

◆ BlockIndicatorFfromIndicatorF

◆ BlockIndicatorMaterial

◆ BlockLatticeF

◆ BlockLatticeInterpPhysVelocity

◆ BlockLatticePhysF

◆ BlockStructure

◆ BounceBack

◆ BounceBackBulkDensity

◆ BounceBackVelocity

◆ CellDistance

◆ CellID

◆ ChopardDynamics

◆ Column

◆ Communicator

◆ ConSmagorinskyBGKdynamics

◆ ConStrainSmagorinskyBGKdynamics

◆ ConstRhoBGKdynamics

◆ Cuboid