OpenLB 1.8.1
Loading...
Searching...
No Matches
olb Namespace Reference

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

Namespaces

namespace  ade_forces
 Refactored AdvectionDiffusion forces to fit with new template style.
 
namespace  boundary
 
namespace  boundaryhelper
 
namespace  collision
 
namespace  concepts
 
namespace  couplers
 
namespace  cpu
 Implementations of CPU specifics.
 
namespace  cse
 
namespace  descriptors
 Descriptors for the 2D and 3D lattices.
 
namespace  dynamics
 
namespace  EOS
 
namespace  equilibria
 
namespace  fd
 
namespace  field
 
namespace  fields
 
namespace  forcing
 Dynamics combination rules for various forcing schemes.
 
namespace  FreeSurface
 
namespace  functor_dsl
 Helper functions for building functors via composition.
 
namespace  functors
 
namespace  gpu
 Implementations of GPU specifics.
 
namespace  graphics
 
namespace  guoZhao
 
namespace  heatmap
 
namespace  ibm
 
namespace  interaction
 
namespace  introspection
 
namespace  Isotherm
 This is a new version of Isotherm made to be suitable with the template format.
 
namespace  legacy
 
namespace  Light
 
namespace  membrane
 
namespace  meta
 
namespace  momenta
 
namespace  multicomponent_velocity
 
namespace  multiphase
 
namespace  names
 Define names as empty structs in order to enable calls like lattice(NavierStokes()).
 
namespace  operators
 
namespace  opti
 All optimization code is contained in this namespace.
 
namespace  parameters
 
namespace  particles
 
namespace  powerlaw
 
namespace  reduction
 
namespace  refinement
 
namespace  sdf
 
namespace  singleton
 
namespace  stage
 
namespace  statistics
 
namespace  TotalEnthalpy
 
namespace  uq
 
namespace  util
 
namespace  utilities
 
namespace  visco
 

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...
 
struct  AbstractFieldArrayBase
 Base to identify whether a type is some kind of AbstractFieldArrayD without caring about the specifics. 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
 
struct  AdsorptionFullCoupling3D
 Coupling for adsorption reaction. More...
 
struct  AdsorptionReaction
 
class  AdvDiffBuoyancyForce3D
 
class  AdvDiffDragForce3D
 
class  AdvDiffMagneticWireForce3D
 
class  AdvDiffRotatingForce3D
 
class  AdvDiffSNDragForce3D
 
struct  AdvectionDiffusionBoundariesDynamics
 
struct  AdvectionDiffusionCornerDynamics2D
 
struct  AdvectionDiffusionCornerDynamics3D
 
class  AdvectionDiffusionEdgesDynamics
 
struct  AdvectionDiffusionExternalVelocityCollision
 
class  AdvectionDiffusionForce3D
 
struct  AdvectionDiffusionParticleCoupling3D
 
struct  AllenCahnNonLocalHelper
 
struct  AllenCahnOutletCoupling
 
struct  AllenCahnPostProcessor
 
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  AnalyticalFfromCallableF
 User friendly AnalyticalF accepting strictly typed callables Vector<T,OUT>(Vector<S,D>) 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-n*stdDev, mean+n*stdDev]. 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  AnalyticalTurbulentWindProfileF3D
 
class  AnalyticalTypecast
 Perform explicit typecast for the arguments and results of functor. More...
 
class  AnalyticalVelocityVolumeF
 
class  AnalyticalWindProfileF3D
 Analytical functor for setting a wind profile at the inlet. More...
 
class  AnalyticalWindProfilePowerLawF3D
 Analytical functor for setting a wind profile based on the power law at the inlet. More...
 
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  AnyFieldTypeD
 Container for arbitrary data instances. More...
 
struct  ArbitrarilyRotateableReferenceLatticeWithWallModelPorosityF
 
struct  Array
 Describe FieldArray of a FIELD in Data. More...
 
struct  AXIS_DIRECTION
 
class  Base64Decoder
 
class  Base64Encoder
 
class  BaseSolver
 BaseSolver implements the solving process of an instationary simulation, consisting of preSimulationTasks, time-stepping and postprocessing. More...
 
class  BaseVTIreader
 
class  BaseVTIreader2D
 
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  BlockConst3D
 
class  BlockD
 
class  BlockData
 
class  BlockData2D
 
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  BlockIndicatorFfromCallableF2D
 Block indicator helper for people that don't like writing boilerplate. More...
 
class  BlockIndicatorFfromCallableF3D
 Block indicator helper for people that don't like writing boilerplate. 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  BlockIndicatorFieldThreshold3D
 Block indicator threshold for external field. 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  BlockIndicatorSubstraction3D
 Block indicator substraction. 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  BlockLaplacian3D
 functor to get pointwise finite difference Laplacian operator More...
 
class  BlockLattice
 
class  BlockLattice< T, DESCRIPTOR >
 Stub to filter construction on non-lattice descriptors. 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  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  BlockLatticeFfromCallableF
 Generate a BlockLatticeF from an arbitrary function. More...
 
class  BlockLatticeField2D
 
class  BlockLatticeField3D
 functor to get pointwise, lattice-dependent external field More...
 
struct  BlockLatticeFieldReductionO
 
class  BlockLatticeFlux3D
 functor returns pointwise lattice flux on local lattice More...
 
class  BlockLatticeFpop2D
 functor returns pointwise f population on local lattices 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  BlockLatticeHaiderLevenspielDragForce
 
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  BlockLatticePhysExternalVectorField3D
 
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  BlockLatticePhysIncPressure2D
 BlockLatticePhysPressure2D returns pointwise phys pressure from incompressible model on local lattices. 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  BlockLatticePhysStressTensor3D
 
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  BlockLatticeRowView
 
class  BlockLatticeSchillerNaumannDragForce
 
class  BlockLatticeSmoothDiracDelta3D
 
class  BlockLatticeSpheroidLiftForce
 
class  BlockLatticeSTLreader
 
class  BlockLatticeStokesDragForce
 
class  BlockLatticeStokesSpheroidDragForce
 
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  BlockLatticeStress3D
 
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  BlockLatticeTranCongDragForce
 
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  BlockReduction3D1D
 BlockReduction3D1D reduces the data of a SuperF3D functor to the intersection between a given 3D line3D and the super geometry. More...
 
class  BlockReduction3D2D
 BlockReduction3D2D reduces the data of a SuperF3D functor to the intersection between a given hyperplane and the super geometry. More...
 
struct  BlockReduction3D2DO
 
struct  BlockRefinementContextD
 Interface for the contextual data of a block refinement. More...
 
class  BlockRefinementOperatorPromise
 Untyped promise to execute some block refinement operator. 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 standard deviation in each component of f on a indicated subset. 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. More...
 
class  BlockVTIreader2D
 
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...
 
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  BouzidiSlipVelocityPostProcessor
 
class  BouzidiVelocityPostProcessor
 Post processor for the velocity Bouzidi boundary. More...
 
class  BufferSerializable
 Base class for serializable objects of dynamic size More...
 
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
 
class  Cell< T, DESCRIPTOR >
 Stub to filter construction on non-lattice descriptors. More...
 
class  CellD
 Single cell implementing the full field data interface. More...
 
class  CellIndexListD
 List of cell indices and associated field data. More...
 
struct  CellOperatorO
 
struct  CellOperatorO< OPERATOR >
 
struct  CellStatistic
 Return value of any collision. More...
 
struct  CellStatistic< cpu::simd::Pack< T > >
 
struct  ChemicalPotentialCoupling2D
 
struct  ChemicalPotentialCoupling3D
 
struct  ChemicalPotentialPostProcessor
 
struct  ChemPotentialPhaseFieldProcessor
 
class  CircleCasson3D
 This functor returns a Casson profile for use with a pipe with util::round cross-section. More...
 
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  CircularInterface2D
 
class  CLIreader
 Very simple CLI argument parser. More...
 
struct  CollectPorousBoundaryForceAndTorqueO
 Operator for calculating per-cell momentum exchange forces in a HLBM context. More...
 
struct  CollectPorousBoundaryForceO
 
struct  CollectPorousBoundaryStressO
 Operator for calculating per-cell stress in a HLBM context. More...
 
struct  CollectPorousBoundaryTorqueO
 Operator for calculating per-cell momentum exchange torque in a HLBM context. 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  ConcreteBlockD
 Implementation of BlockD on a concrete PLATFORM. 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  ConcreteBlockPointCouplingO
 Particle coupling of COUPLEES using concrete OPERATOR with SCOPE on PLATFORM lattices. More...
 
class  ConcreteBlockPointCouplingO< COUPLEES, PLATFORM, COUPLER, OperatorScope::PerCellWithParameters >
 
class  ConcreteBlockPointCouplingO< COUPLEES, Platform::GPU_CUDA, COUPLER, OperatorScope::PerCellWithParameters >
 Application of a block-wise particle COUPLER on concrete CUDA COUPLEES with parameters. More...
 
class  ConcreteBlockRefinementContextD
 Context for the execution of block refinement operators. More...
 
struct  ConcreteBlockRefinementO
 Executor of a concrete block refinement operator in a given context. More...
 
struct  ConcreteBlockRefinementO< T, DESCRIPTOR, PLATFORM, OPERATOR >
 
struct  ConcreteBlockRefinementO< T, DESCRIPTOR, Platform::GPU_CUDA, COUPLER >
 
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 > >
 
class  ConcreteData
 Storage of any FIELD_TYPE data on PLATFORM. More...
 
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  ConcretizableBlockCollisionO
 
struct  ConcretizableBlockD
 Curried ConcreteBlockD eemplate for use in callUsingConcretePlatform. 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  ConcretizableBlockO
 
struct  ConcretizableData
 Curried ConcreteData 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  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  ConvectivePostProcessor2D
 This class overcomes overwriting populations from streaming for convective boundary conditions. More...
 
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...
 
struct  CouplingFaceF2D
 
struct  CouplingPointF
 
class  CSE
 Wrapper for auto-generated CSE-optimized DYNAMICS. More...
 
struct  CSE_O
 Wrapper for auto-generated CSE-optimized OPERATOR. More...
 
struct  CSE_O< OPERATOR, DESCRIPTOR >
 
class  CSV
 
class  Cuboid
 
class  CuboidDecomposition
 Decomposition of a physical volume into a set of disjoint cuboids. More...
 
class  CuboidGeometry2D
 
struct  CuboidPorosityF
 
struct  cum
 
struct  CustomLoadBalancer
 
struct  CylinderPorosityF
 
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...
 
struct  CylinderWithWallModelPorosityF
 
class  Data
 Platform-indepentent interface to ConcreteData. More...
 
struct  DensityOutletCoupling2D
 
struct  dispersionLimiter
 
class  DoubleBuffer
 
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  DynamicsTupleParser
 
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  EfficientBlockReduction3D2D
 
struct  ElementParameters
 
class  EllipticPoiseuille3D
 This functor returns a quadratic Poiseuille profile for use with a pipe with elliptic cross-section. More...
 
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  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
 
class  ExtendedFdPlaneBoundaryProcessorGenerator3D
 
class  ExtendedStraightFdBoundaryPostProcessor2D
 
class  ExtendedStraightFdBoundaryProcessorGenerator2D
 
struct  ExternalFieldO
 
class  FdAdvectionDiffusionModel
 
class  FdBasePostProcessor2D
 
class  FdBasePostProcessor3D
 
class  FdBoundaryPostProcessor2D
 
class  FdBoundaryPostProcessor3D
 
class  FDMstrainRateTensorPostProcessor
 PostProcessor for FDM strain rate tensor calculation. More...
 
class  FdPostProcessor2D
 
class  FdPostProcessor3D
 
class  FdUpdater
 
class  FdUpdaterBase
 
struct  field_type_of_field_array_tag
 TODO Make nice. More...
 
class  FieldArrayD
 SoA storage for instances of a single FIELD. More...
 
class  FieldTypePromise
 Helper for conveying the ability for operations on FIELD_TYPE. 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
 
struct  FlatConvectivePhaseFieldPostProcessorA2D
 This class computes the convective boundary condition for the populations of a phase field solving LBE. More...
 
struct  FlatConvectivePhaseFieldPostProcessorB2D
 This class computes the convective boundary condition for phi at ghost nodes for a phase field solving LBE. 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...
 
struct  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  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  FreeEnergyChemPotBoundaryProcessor3DA
 
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...
 
struct  FreeEnergyForcedPostProcessor
 
class  FreeEnergyForceGenerator2D
 Generator class for the PostProcessors calculating the interfacial force. More...
 
class  FreeEnergyForceGenerator3D
 Generator class for the PostProcessors calculating the interfacial force. More...
 
struct  FreeEnergyInletMomentum2D
 PostProcessors for the chemical potential boundary condition in the free energy model. More...
 
struct  FreeEnergyInletMomentum3D
 PostProcessors for the chemical potential boundary condition in the free energy model. More...
 
struct  FreeEnergyInletOrderParameter2D
 
struct  FreeEnergyInletOrderParameter3D
 
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...
 
struct  FreeEnergyOutletMomentum2D
 
struct  FreeEnergyOutletMomentum3D
 
struct  FreeEnergyOutletOrderParameter2D
 
struct  FreeEnergyOutletOrderParameter3D
 
struct  FreeEnergyWallMomentumProcessor2D
 PostProcessor for the wetting boundary condition in the free energy model. More...
 
class  FreeEnergyWallMomentumProcessor3D
 
struct  FreeEnergyWallOrderParameterProcessor2D
 
class  FreeEnergyWallOrderParameterProcessor3D
 
class  FreeEnergyWallProcessor3D
 PostProcessor for the wetting boundary condition in the free energy model. More...
 
class  FreeSurface2DSetup
 
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  FreeSurfaceInterfaceReconstructionPostProcessor2D
 Free Surface Processor 2-3 Interface Reconstruction Replaces incoming DFs by calculating equilibrium functions and using the laplace pressure to include surface tension. More...
 
class  FreeSurfaceInterfaceReconstructionPostProcessor3D
 Free Surface Processor 2-3 Interface Reconstruction Replaces incoming DFs by calculating equilibrium functions and using the laplace pressure to include surface tension. 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 Mass Flow Cleans up leftover flags from the previous simulation step. More...
 
class  FreeSurfaceMassFlowPostProcessor3D
 Free Surface Processor 1 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  Fringe2D
 
class  Fringe3D
 
class  FullCellD
 Single cell with full field data and dynamics interface. More...
 
class  FunctorPtr
 Smart pointer for managing the various ways of passing functors around. 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  GeometricPhaseFieldCurvedWallProcessor2D
 
struct  GeometricPhaseFieldWallProcessor2D
 
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...
 
struct  GrowPaddingLayerO
 Operator for allowing migration of padding layer. More...
 
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  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  IncZouHeDynamics
 
class  IndicatorAirfoil2D
 indicator function for a 2D NACA airfoil More...
 
class  IndicatorBlockData2D
 indicator from VTIreader More...
 
class  IndicatorBlockData2Dvti
 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  IndicatorPolygon3D
 indicator function for a 3d-polygon More...
 
class  IndicatorRotate
 
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  InitializePorosityO
 Operator for discretizing FSI elements into HLBM porosities. More...
 
struct  initialPsi
 
struct  InletOutletCoupling2D
 
struct  InletOutletCoupling3D
 
struct  IntegratePorousElementFieldsO
 Operator for integrating per-element momentum exchange forces in a HLBM-FSI context. More...
 
struct  IsoPhaseFieldCurvedWallProcessor2D
 
class  KnudsenVelocityPostProcessor
 
class  Krause
 
class  LaplacePressure2D
 
class  LatticeBoltzmannReactingSpecies2D
 
class  LatticeBoltzmannReactingSpecies3D
 
class  LatticeCouplingGenerator2D
 
class  LatticeCouplingGenerator3D
 
class  LatticeData
 Encapsulates all necessary classes to run a simulation. More...
 
class  LatticeResults
 Wrapper of SuperVTMwriter allowing to specify which functors are dumped as .vtm, without having the actual SuperLattice instance. 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...
 
struct  LESADECoupling
 LES-ADE coupling with Schmidt number stabilization. More...
 
struct  LESReactionCoupling
 LES-ADE coupling for multiple reactions. More...
 
struct  LiangPostProcessor
 
struct  LiangSinglePostProcessor
 
class  LightSourceCylindrical3D
 light source as a cylinder along z-axis More...
 
struct  Line3D
 Definition of a analytical line embedded in 3D space. More...
 
class  LineLattice3D
 Parametrization of a line3D lattice (i.e. a line lattice). More...
 
struct  LinePorosityF
 
struct  LineSegmentPorosityF
 
class  LoadBalancer
 Base class for all LoadBalancer. More...
 
struct  LocalPostProcessor2D
 
struct  LocalPostProcessor3D
 
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  MagneticForceFromCylinder3D
 Magnetic field that creates magnetization in wire has to be orthogonal to the wire. More...
 
class  Matrix
 Matrix with a defined number of ROWS and columns (COLS) More...
 
class  MatrixView
 Provides matrix view access to serialized vector fields. 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  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 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  MultiPhaseUnitConverterFromRelaxationTime
 Conversion between physical and lattice units, as well as discretization for multiple component lattices. More...
 
class  Musker
 Musker profile. More...
 
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  Normal
 
struct  normGradPsi
 
struct  normGradPsiBoundary2D
 
struct  NSPNPCoupling
 Naver-Stokes-Poisson-Nernst-Planck coupling. More...
 
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  OSMParser
 
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  PartialSlipBoundaryProcessor3D
 This class computes a partial slip BC in 3D. More...
 
class  PartialSlipBoundaryProcessorGenerator3D
 
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  ParticleIndicatorF3D
 
class  PengRobinson
 
struct  PhaseFieldAdvectionDiffusionBGKdynamics
 
struct  PhaseFieldConvectiveOutletDynamics
 Implementation of convective boundary condition for the order parameter. More...
 
class  PhaseFieldCouplingGenerator2D
 
class  PhaseFieldCouplingGenerator3D
 
class  PhaseFieldCouplingPostProcessor2D
 
class  PhaseFieldCouplingPostProcessor3D
 
class  PhaseFieldInletDynamics
 Implementation of Dirichlet boundary condition for the order parameter. More...
 
class  PhysWallShearStressOnSurface3D
 
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  PLSsolution3D
 see Mink et al. 2016 in Sec.3.1. More...
 
struct  PNPCoupling
 Poisson-Nernst-Planck coupling. More...
 
struct  PointExtractionO
 
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*(6*y^5-15*y^4+10*y^3) More...
 
class  PopulationCellD
 Minimal cell storing only population data. More...
 
struct  PorousADECorrection
 Porous ADE correction 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 OPERATOR type. More...
 
class  PowerLaw2D
 
class  PowerLawProfile
 PowerLaw profile. More...
 
struct  PseudopotentialForcedCoupling
 
struct  PseudopotentialForcedPostProcessor
 
class  PsiEqualsRho
 
struct  psiEvolve
 
class  RadiativeUnitConverter
 Conversion between physical and lattice units, as well as discretization. More...
 
struct  RandomLoadBalancer
 Basic Random Load Balancer. More...
 
struct  RANSKE
 Coupling between Navier-Stokes and k-epsilon lattices. More...
 
class  Rate
 
class  ReactingSpecies2D
 
class  ReactingSpecies3D
 
struct  ReactionCoupling
 Reaction coupling for three species homogeneous bulk reaction. More...
 
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
 
struct  ReferenceLatticePorosityF
 
struct  ReferenceLatticeWithWallModelPorosityF
 
class  RefinedLoadBalancer
 Load balancer for refined lattice hierarchies. More...
 
class  RegularCachedIndicatorF3D
 
struct  RhoPsiStatistics
 
struct  RhoStatistics
 Multiphysics class for coupling between different lattices. More...
 
struct  RhoWettingStatistics
 
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  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...
 
struct  RTLBMdynamicsMcHardy
 Solves RTE according Christopher McHardy et al 2016. More...
 
struct  RTLBMdynamicsMcHardyRK
 
struct  SCALAR2
 
struct  ScalarVector
 Vector of scalars. 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...
 
struct  SetIncOutletCells
 
struct  SetOutletCells
 
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  ShanChenForcedHlbmCoupling
 
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...
 
class  ShiftedLaplacePressure2D
 
struct  SIGMA
 
struct  SimdBase
 
struct  SingleLatticeO
 Wrapper class for SuperLatticeCoupling with only a single lattice instance in order to allow operator executions with seperated ParameterD instances. More...
 
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...
 
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...
 
struct  SolidBoundary
 
struct  SourcedAdvectionDiffusionBGKdynamics
 
struct  SourcedLimitedAdvectionDiffusionBGKdynamics
 
class  SpecialAnalyticalFfromBlockF2D
 Converts block functors to analytical functors (special version for 2D) More...
 
class  SpecialAnalyticalFfromBlockF3D
 Converts block functors to analytical functors (special) More...
 
struct  SpherePorosityF
 
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...
 
struct  SpongeLayerDynamics
 
class  Spotlight
 
struct  StatisticsPostProcessor
 
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  StraightConvectionBoundaryProcessor2D
 This class computes a convection BC on a flat wall in 2D. More...
 
class  StraightConvectionBoundaryProcessor3D
 
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  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  SuperD
 
class  SuperData
 
class  SuperData2D
 
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
 Maintains per-block arrays of FIELD. More...
 
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  SuperGeometryF2D
 functor to get pointwise the material no. presenting the geometry on local lattice More...
 
class  SuperGeometryF3D
 functor to get pointwise the material no. presenting the geometry on local lattice 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  SuperImmersedBoundaryCoupling3D
 Wrapper class to perform the immersed boundary method. More...
 
class  SuperIndicatorBoundaryNeighbor2D
 Indicator identifying neighbors of boundary cells. More...
 
class  SuperIndicatorBoundaryNeighbor3D
 Indicator identifying neighbors of boundary cells. More...
 
struct  SuperIndicatorDomainFrontierDistanceF
 Indicator to identify a cell layer at given distance from the cuboid decomposition's frontier. 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  SuperIndicatorFieldThreshold3D
 threshold for external field 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  SuperIndicatorSubstraction3D
 Indicator substraction 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  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  SuperLatticeFfromCallableF
 Generate a SuperLatticeF from an arbitrary function. More...
 
class  SuperLatticeField2D
 
class  SuperLatticeField3D
 functor to get pointwise, lattice-dependent external field More...
 
class  SuperLatticeFieldReductionO
 
class  SuperLatticeFlux3D
 functor to get pointwise flux on local lattice More...
 
class  SuperLatticeFpop2D
 functor to get pointwise f population on local lattices More...
 
class  SuperLatticeFpop3D
 functor to get pointwise f population on local lattices 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  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  SuperLatticePhysExternalVectorField3D
 
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  SuperLatticePhysIncPressure2D
 functor to get pointwise phys pressure from incompressible model on local lattices 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  SuperLatticePhysStressTensor3D
 functor returns pointwise phys stress tensor for newtonian fluids 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  SuperLatticePointCoupling
 Coupling operator COUPLER on named COUPLEES. More...
 
class  SuperLatticePointExtraction
 Convenience class for extracting data associated to set of arbitrary physical points. More...
 
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  SuperLatticeRefinement
 
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  SuperLatticeStress3D
 
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  SuperLatticeTimeAveragedCrossCorrelationF2D
 
class  SuperLatticeTimeAveragedCrossCorrelationF3D
 
class  SuperLatticeTimeAveragedF2D
 
class  SuperLatticeTimeAveragedF3D
 
class  SuperLatticeTimeAveragedMagnitudesF3D
 
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  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  SuperPorousElementEmbeddingO
 
class  SuperPorousElementReductionO
 
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. 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. 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  TemperatureJumpPostProcessor
 
struct  TensorIndices
 
struct  ThermalCreepBouzidiCoupling
 
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  TransposedMatrixView
 Provides transposed matrix view access to serialized vector fields. More...
 
struct  TurbulentChannelForce
 
class  TurbulentWallModelFneqFDMPostProcessor
 
class  TurbulentWallModelFneqGuoPostProcessor
 
class  TurbulentWallModelFneqZeroPostProcessor
 
class  TurbulentWallModelPorousFneqFDMPostProcessor
 
class  TurbulentWallModelPostProcessor
 
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  UpdatePorosityO
 Operator for updating FSI element discretizations into HLBM porosities. More...
 
struct  VANSADECoupling
 VANS-ADE coupling. 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  VelocityCoupling
 
struct  VelocityNormF
 
struct  Vertex
 
class  VolumeAveragedNavierStokesAdvectionDiffusionParticleCouplingGenerator3D
 
class  VolumeAveragedNavierStokesAdvectionDiffusionParticleCouplingPostProcessor3D
 
struct  VortexMethodPostProcessor
 
struct  VortexMethodPreProcessor
 
class  VortexMethodTurbulentVelocityBoundary
 
class  VTIwriter3D
 
class  VTKwriter
 
class  VTUpointWriter
 
class  VTUpointWriter< T, W, 2 >
 
class  VTUpointWriter< T, W, 3 >
 
class  VTUsurfaceWriter
 
class  WallFunctionBoundaryProcessor3D
 
class  WallFunctionBoundaryProcessorGenerator3D
 
struct  wallFunctionParam
 
struct  WallModelParameters
 
class  WeisbrodKrause
 
struct  WellBalancedCahnHilliardPostProcessor
 
struct  WellBalancedWallProcessor2D
 
struct  WellBalancedWallProcessor3D
 
class  XMLreader
 
class  XMLreaderOutput
 
class  YuPostProcessor
 
struct  ZeroDistributionBoundaryO
 
class  ZeroDistributionBoundaryProcessor3D
 This class copies missing values in the external field from the neighbour in normal direction. 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
 Boundary condition details: 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 , typename DESCRIPTOR >
using NoCollideDynamicsExternalVelocity
 
template<typename T , typename DESCRIPTOR >
using ForcedWMHRRdynamics
 
template<typename T , typename DESCRIPTOR >
using WMHRRdynamics
 
template<typename T , typename DESCRIPTOR >
using ForcedVanDriestWMHRRdynamics
 
template<typename T , typename DESCRIPTOR >
using VanDriestWMHRRdynamics
 
template<typename T , typename DESCRIPTOR >
using ForcedVanDriestExternalRhoWMHRRdynamics
 
template<typename T , typename DESCRIPTOR >
using VanDriestExternalRhoWMHRRdynamics
 
template<typename T , typename DESCRIPTOR >
using ForcedExternalRhoWMHRRdynamics
 
template<typename T , typename DESCRIPTOR >
using ExternalRhoWMHRRdynamics
 
template<typename T , typename DESCRIPTOR >
using available_fields
 
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 , Platform PLATFORM = Platform::CPU_SISD>
using MultiFieldArrayForDescriptorD = typename MultiFieldArrayForDescriptorHelper<T,DESCRIPTOR,PLATFORM>::type
 MultiFieldArrayD containing each field in DESCRIPTOR::fields_t.
 
template<concepts::BaseType T, concepts::Descriptor 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 , typename DESCRIPTOR , typename LINEAR_FIELD >
using MatrixD = MatrixView<T,LINEAR_FIELD::template rows<DESCRIPTOR>(),LINEAR_FIELD::template cols<DESCRIPTOR>()>
 
template<typename T , typename DESCRIPTOR , typename LINEAR_FIELD >
using TransposedMatrixD = TransposedMatrixView<MatrixView<T,LINEAR_FIELD::template rows<DESCRIPTOR>(),LINEAR_FIELD::template cols<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 FIELD >
using FieldD
 Vector storing a single field instance.
 
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 >
using NoDynamicsWithFixedDensity
 Dynamics for "dead cells" with fixed density.
 
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 ThirdOrderBGKdynamics
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using ThirdOrderHRRdynamics
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using ThirdOrderRLBdynamics
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using ForcedThirdOrderRLBdynamics
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using ForcedThirdOrderHRRdynamics
 
template<typename T , typename DESCRIPTOR >
using ThirdOrderHRLBdynamics
 
template<typename T , typename DESCRIPTOR >
using ForcedThirdOrderHRLBdynamics
 
template<typename T , typename DESCRIPTOR >
using ThirdOrderHHRRdynamics
 
template<typename T , typename DESCRIPTOR >
using ForcedThirdOrderHHRRdynamics
 
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 ForcedWagnerBGKdynamics
 BGK collision step with external force (Wagner)
 
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 >
using MultiPhaseIncompressbileBGKdynamics
 Multi-phase incompressible BGK collision step with relaxation frequency 1 / TAU_EFF and external force.
 
template<typename T , typename DESCRIPTOR >
using MultiPhaseIncompressbileTRTdynamics
 
template<typename T , typename DESCRIPTOR >
using MultiPhaseIncompressbileInterfaceTRTdynamics
 
template<typename T , typename DESCRIPTOR >
using MultiPhaseIncompressbileSmagorinskyBGKdynamics
 
template<typename T , typename DESCRIPTOR >
using MultiPhaseIncompressbileSmagorinskyTRTdynamics
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::ExternalVelocityTuple>
using AllenCahnBGKdynamics
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::ExternalVelocityTuple>
using WellBalancedCahnHilliardBGKdynamics
 
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 BounceBackIncompressible
 
template<typename T , typename DESCRIPTOR >
using BounceBackBulkDensityADE
 
template<typename T , typename DESCRIPTOR >
using BounceBackBulkDensityWellBalanced
 
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 FreeSurfaceForcedBGKdynamics
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using SmagorinskyFreeSurfaceForcedBGKdynamics
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using SmagorinskyFreeSurfaceForcedMRTdynamics
 
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 MultiphaseBGKdynamics
 BGK collision using Multiphase collision frequency.
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using MultiphaseForcedBGKdynamics
 BGK collision using Multiphase collision frequency with Guo forcing.
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using CarreauYasudaBGKdynamics
 BGK collision using Carrau-Yasuda viscosity model.
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using CarreauYasudaForcedBGKdynamics
 BGK collision using Carrau-Yasuda viscosity model with Guo forcing.
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using CassonBGKdynamics
 BGK collision using Casson viscosity model.
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using CassonForcedBGKdynamics
 BGK collision using Casson viscosity model with Guo forcing.
 
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 LocalSmagorinskyBGKdynamics
 Smagorinsky BGK collision step with local Smagorinsky constant.
 
template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using SmagorinskyThirdOrderRLBdynamics
 Smagorinsky RLB Third Order 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 >
using Cuboid2D = Cuboid<T,2>
 
template<typename T >
using Cuboid3D = Cuboid<T,3>
 
template<typename T >
using CuboidDecomposition2D = CuboidDecomposition<T,2>
 
template<typename T >
using CuboidDecomposition3D = CuboidDecomposition<T,3>
 
template<concepts::Descriptor DESCRIPTOR>
using DiscreteNormal = Vector<int,DESCRIPTOR::d>
 
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 , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using DualForcedBGKDynamics
 
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 , unsigned D>
using SuperGeometryF
 
template<typename T , typename DESCRIPTOR >
using SuperLatticeCuboid
 
template<typename T , typename DESCRIPTOR >
using SuperLatticeRank
 
template<typename T , typename DESCRIPTOR >
using SuperLatticeF
 
template<unsigned DIM, typename T , typename W = T>
using SuperIntegral
 
template<typename T , typename DESCRIPTOR , typename FIELD >
using SuperLatticeField
 
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
 
template<typename T , typename DESCRIPTOR >
using SuperLatticeFpop
 
template<typename T , unsigned D>
using BlockIndicatorFfromCallableF
 
template<typename T , typename BaseType , unsigned D>
using BlockVTIreader
 
template<typename T , typename BaseType , unsigned D>
using BlockDataF
 
template<typename T , typename W , unsigned D>
using SpecialAnalyticalFfromBlockF
 
template<typename T , typename DESCRIPTOR , typename FIELD >
using SuperLatticePhysField
 

Enumerations

enum struct  CollisionDispatchStrategy { Dominant , Individual }
 Collision dispatch strategy. More...
 
enum struct  OperatorScope { PerCell , PerBlock , PerCellWithParameters }
 Block-wide operator application scopes. 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 class  DiscreteNormalType : int {
  Flat = 0 , ExternalCorner = 1 , InternalCorner = 2 , ExternalEdge = 3 ,
  InternalEdge = 4
}
 Type associated with a discrete normal vector. More...
 
enum class  SignMode { EXACT , CACHED , EXACT , CACHED }
 Enum class that specifies the mode to use for computing the sign of the signed distance. More...
 
enum class  RayMode : int {
  FastRayZ = 1 , Robust = 2 , FastRayX = 3 , FastRayY = 4 ,
  DoubleRay = 5 , FastRayZ = 1 , Robust = 2 , FastRayX = 3 ,
  FastRayY = 4 , DoubleRay = 5
}
 
enum class  SignMode { EXACT , CACHED , EXACT , CACHED }
 Enum class that specifies the mode to use for computing the sign of the signed distance. More...
 
enum class  RayMode : int {
  FastRayZ = 1 , Robust = 2 , FastRayX = 3 , FastRayY = 4 ,
  DoubleRay = 5 , FastRayZ = 1 , Robust = 2 , FastRayX = 3 ,
  FastRayY = 4 , DoubleRay = 5
}
 
enum  DataType { PointData , CellData }
 
enum  vtkType { VTI , VTU , VTP }
 
enum class  OutputChannel { TERMINAL , ERRCHANNEL }
 
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 >
void setLocalConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, 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, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, T *uAv)
 Initialising the LocalConvectionBoundary on the superLattice domain.
 
template<typename T , typename DESCRIPTOR >
void setLocalConvectionBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF2D< T > &indicator, T *uAv)
 Set LocalConvectionBoundary for indicated cells inside the block domain.
 
template<typename T , typename DESCRIPTOR >
void setLocalConvectionBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, 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, 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, BlockIndicatorF3D< T > &indicator, T *uAv)
 Add local convection 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, 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, 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, BlockIndicatorF2D< T > &indicator)
 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, 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, 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, BlockIndicatorF3D< T > &indicator)
 
template<typename T , typename DESCRIPTOR >
void setConvectivePhaseFieldBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 2 > &superGeometry, int material)
 Initialising the setConvectivePhaseFieldBoundary function on the superLattice domain.
 
template<typename T , typename DESCRIPTOR >
void setConvectivePhaseFieldBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
 Initialising the setConvectivePhaseFieldBoundary function on the superLattice domain.
 
template<typename T , typename DESCRIPTOR >
void setConvectivePhaseFieldBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF2D< T > &indicator)
 Set ConvectivePhaseFieldBoundary for any indicated cells inside the block domain.
 
template<typename CELL , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
void applyBouzidiVelocity (CELL &x_b) any_platform
 
template<typename CELL , typename V = typename CELL::value_t>
void applyBouzidiTemp (CELL &x_b) any_platform
 
template<typename CELL , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
Vector< V, DESCRIPTOR::d > interpolateMomentum (CELL &cell, Vector< V, DESCRIPTOR::d > distance) any_platform
 
template<typename CELL , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
void interpolateVelocity (CELL &cell, Vector< V, DESCRIPTOR::d > distance, V u_y2[DESCRIPTOR::d]) any_platform
 
template<typename CELL , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
void interpolateStrainRate (CELL &cell, Vector< V, DESCRIPTOR::d > distance, V pi[util::TensorVal< DESCRIPTOR >::n]) any_platform
 
template<typename V , typename Par_f >
spaldingWallFunction (Par_f &params) any_platform
 
template<typename V , typename Par_d >
spaldingDerivative (Par_d &param) any_platform
 
template<typename V , typename Funcf , typename Funcd , typename Par_f , typename Par_d >
newtonSpalding (Funcf f, Funcd d, Par_f &argsf, Par_d &argsd, int optArg, V convergeCrit, int iter) any_platform
 
template<typename V >
Vector< V, 2 > powerLawWallFunction (V nu, V u2, V y2, V y1) any_platform
 
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 , template< typename, typename, int... > typename OPERATOR>
void setOperatorForNormal (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF3D< T > > &&boundaryI, FunctorPtr< SuperIndicatorF3D< T > > &&fluidI, FunctorPtr< SuperIndicatorF3D< T > > &&outsideI)
 
template<typename T , typename DESCRIPTOR , template< typename, typename, int... > typename OPERATOR>
void setOperatorForNormal (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF3D< T > &boundaryI, BlockIndicatorF3D< T > &fluidI, BlockIndicatorF3D< T > &outsideI)
 
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 , bool thermalCreep = false>
void setBouzidiKnudsenSlipVelocity (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int material, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
 Set Bouzidi velocity boundary on material cells of sLattice.
 
template<typename T , typename DESCRIPTOR , bool thermalCreep = false>
void setBouzidiKnudsenSlipVelocity (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
 Set Bouzidi velocity boundary on indicated cells of sLattice.
 
template<typename T , typename DESCRIPTOR , bool thermalCreep = false>
void setBouzidiKnudsenSlipVelocity (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary)
 Set Bouzidi velocity boundary on indicated cells of sLattice.
 
template<typename T , typename DESCRIPTOR , bool thermalCreep = false>
void setBouzidiKnudsenSlipVelocity (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF< T, DESCRIPTOR::d > &boundaryIndicator, BlockIndicatorF< T, DESCRIPTOR::d > &bulkIndicator, Cuboid< T, DESCRIPTOR::d > &cuboid, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary)
 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 >
void setBouzidiSlipVelocity (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int material, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary, int gradientOrder=1, std::vector< int > bulkMaterials=std::vector< int >(1, 1), bool isOuterWall=true, bool useDiscreteNormal=false)
 Bouzidi General/Knudsen Slip Velocity 3D Sets slip velocity on general walls.
 
template<typename T , typename DESCRIPTOR >
void setBouzidiSlipVelocity (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary, int gradientOrder=1, std::vector< int > bulkMaterials=std::vector< int >(1, 1), bool isOuterWall=true, bool useDiscreteNormal=false)
 Set Bouzidi velocity boundary on indicated cells of sLattice.
 
template<typename T , typename DESCRIPTOR >
void setBouzidiSlipVelocity (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, int gradientOrder=1, bool isOuterWall=true, bool useDiscreteNormal=false)
 Set Bouzidi velocity boundary on indicated cells of sLattice.
 
template<typename T , typename DESCRIPTOR >
void setBouzidiSlipVelocity (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF< T, DESCRIPTOR::d > &boundaryIndicator, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary, BlockIndicatorF< T, DESCRIPTOR::d > &bulkIndicator, Cuboid< T, DESCRIPTOR::d > &cuboid, int gradientOrder=1, bool isOuterWall=true, bool useDiscreteNormal=false)
 Set Bouzidi velocity boundary on indicated cells of block lattice.
 
template<typename T , typename DESCRIPTOR >
void setBouzidiTemperatureJump (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 setBouzidiTemperatureJump (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 setBouzidiTemperatureJump (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 setBouzidiTemperatureJump (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 OPERATOR = BouzidiPostProcessor>
void setBouzidiPhaseField (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary)
 Set Bouzidi boundary with contact angle for phase field models on indicated cells of sLattice.
 
template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void setBouzidiPhaseField (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 setBouzidiPhaseField (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 , typename OPERATOR = BouzidiPostProcessor>
void setBouzidiWellBalanced (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, IndicatorF< T, DESCRIPTOR::d > &indicatorAnalyticalBoundary)
 Set Bouzidi boundary with contact angle for phase field models on indicated cells of sLattice.
 
template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void setBouzidiWellBalanced (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 setBouzidiWellBalanced (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 setSignedDistanceBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 2 > &superGeometry, int material)
 Initialising the setSignedDistanceBoundary function on the superLattice domain.
 
template<typename T , typename DESCRIPTOR >
void setSignedDistanceBoundary (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&indicator)
 Initialising the setSignedDistanceBoundary function on the superLattice domain.
 
template<typename T , typename DESCRIPTOR >
void setSignedDistanceBoundary (BlockLattice< T, DESCRIPTOR > &block, BlockIndicatorF2D< T > &indicator)
 Set signedDistanceBoundary for any indicated cells inside the block domain.
 
template<typename T , typename DESCRIPTOR >
void setTurbulentWallModelDynamics (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, WallModelParameters< T > &wallModelParameters)
 
template<typename T , typename DESCRIPTOR >
void setTurbulentWallModelDynamics (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int materialOfBulk, WallModelParameters< T > &wallModelParameters)
 
template<typename T , typename DESCRIPTOR >
void setTurbulentWallModel (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, WallModelParameters< T > &wallModelParameters, IndicatorF< T, DESCRIPTOR::d > *indicatorAnalyticalBoundary=nullptr)
 
template<typename T , typename DESCRIPTOR >
void setTurbulentWallModel (SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, DESCRIPTOR::d > &superGeometry, int materialOfSolidObstacle, WallModelParameters< T > &wallModelParameters, IndicatorF< T, DESCRIPTOR::d > *indicatorAnalyticalBoundary=nullptr, std::vector< int > bulkMaterials=std::vector< int >(1, 1))
 Set parameters of the turbulent wall model after Bouzidi bounce-back on material cells of sLattice.
 
template<typename T , typename DESCRIPTOR >
void setTurbulentWallModel (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockIndicatorF< T, DESCRIPTOR::d > &boundaryIndicator, BlockIndicatorF< T, DESCRIPTOR::d > &bulkIndicator, WallModelParameters< T > &wallModelParameters, IndicatorF< T, DESCRIPTOR::d > *indicatorAnalyticalBoundary=nullptr)
 Set parameters of the turbulent wall model after Bouzidi bounce-back on indicated cells of block lattice.
 
template<typename T , typename DESCRIPTOR >
void setWallDistance (SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&boundaryIndicator, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&bulkIndicator, IndicatorF< T, DESCRIPTOR::d > *indicatorAnalyticalBoundary)
 
template<typename T , typename DESCRIPTOR >
void setWallDistance (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 parameters of the turbulent wall model after Bouzidi bounce-back on material cells of sLattice.
 
template<typename T , typename DESCRIPTOR >
void setWallDistance (BlockLattice< T, DESCRIPTOR > &block, BlockGeometry< T, DESCRIPTOR::d > &blockGeometry, BlockIndicatorF< T, DESCRIPTOR::d > &boundaryIndicator, BlockIndicatorF< T, DESCRIPTOR::d > &bulkIndicator, IndicatorF< T, DESCRIPTOR::d > *indicatorAnalyticalBoundary)
 Set parameters of the turbulent wall model after Bouzidi bounce-back on indicated cells of block lattice.
 
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 >
LoadBalancer< T > * createLoadBalancer (XMLreader const &xmlReader, CuboidDecomposition3D< T > *cGeo=NULL)
 Creator Function for LoadBalancer from XMLreader.
 
template<typename T >
LoadBalancer< T > * createLoadBalancer (std::string const &fileName, CuboidDecomposition3D< T > *cGeo=NULL)
 Creator Function for LoadBalancer from fileName.
 
template<typename SUPER >
 SuperCommunicator (SUPER &) -> SuperCommunicator< typename SUPER::value_t, SUPER >
 
template<typename T , typename DESCRIPTOR >
DynamicsPromise< T, DESCRIPTOR > mapStringToDynamics (std::string name)
 
template<typename T , typename DESCRIPTOR >
void defineDynamicsAndSetParameterFromXml (std::string xmlFileName, SuperGeometry< T, 3 > &sGeometry, SuperLattice< T, DESCRIPTOR > &sLattice)
 
template<typename T , typename DESCRIPTOR >
void defineDynamicsFromXml (std::string xmlFileName, SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &sGeometry)
 
template<typename T , typename DESCRIPTOR >
void defineDynamicsFromString (SuperLattice< T, DESCRIPTOR > &sLattice, std::unique_ptr< olb::SuperIndicatorF< T, 3U > > indicatorF, std::string modelName)
 
template<typename T , typename DESCRIPTOR >
void setParameterFromXml (SuperLattice< T, DESCRIPTOR > &sLattice, std::string xmlFileName)
 
template<typename T , typename DESCRIPTOR , typename... ARGS>
std::unique_ptr< BlockD< T, DESCRIPTOR > > makeSharedBlockD (LoadBalancer< T > &loadBalancer, ARGS &&... args)
 Constructs BlockD accessible on all locally used platforms.
 
template<typename DYNAMICS >
 DynamicsPromise (meta::id< DYNAMICS >) -> DynamicsPromise< typename DYNAMICS::value_t, typename DYNAMICS::descriptor_t >
 
template<typename PP >
 PostProcessorPromise (meta::id< PP >) -> PostProcessorPromise< typename PP::value_t, typename PP::descriptor_t >
 
template<typename T , typename DESCRIPTOR , typename... ARGS>
std::unique_ptr< Data< T, DESCRIPTOR > > makeSharedData (LoadBalancer< T > &loadBalancer, ARGS &&... args)
 Constructs Data accessible on all locally used platforms.
 
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)
 
Expr operator% (Expr lhs, int rhs)
 
bool operator== (const Expr &rhs, const Expr &lhs)
 
bool operator!= (const Expr &rhs, const Expr &lhs)
 
bool operator> (const Expr &rhs, const Expr &lhs)
 
bool operator< (const Expr &rhs, const Expr &lhs)
 
bool operator>= (const Expr &rhs, const Expr &lhs)
 
bool operator<= (const Expr &rhs, const Expr &lhs)
 
template<typename T , typename DESCRIPTOR , typename FIELD >
std::unique_ptr< AbstractFieldArrayD< T, DESCRIPTOR, FIELD > > makeSharedAbstractFieldArrayD (LoadBalancer< T > &loadBalancer, std::size_t count=1)
 Constructs FieldArrayD accessible on all locally used platforms.
 
template<concepts::BaseType T, concepts::Descriptor DESCRIPTOR, typename... MAP>
auto makeParametersD (MAP &&... args)
 Builds a ParametersD from field-value pairs.
 
template<typename FIELD >
constexpr std::string_view getFieldName ()
 
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 >
residualPhysDiffusivity (const UnitConverter< T, DESCRIPTOR > &converterFractional, T physDiffusivity)
 
void initialize (int *argc, char ***argv, bool multiOutput=false, bool verbose=true)
 Initialize OpenLB.
 
void initialize (int argc, char **argv, bool multiOutput=false, bool verbose=true)
 Initialize OpenLB.
 
std::string getName (OperatorScope scope)
 Returns human-readable name of scope.
 
template<typename CONCRETIZABLE , typename F >
auto callUsingConcretePlatform (Platform platform, typename CONCRETIZABLE::base_t *ptr, F f)
 Dispatcher for concrete platform access.
 
template<typename CONCRETIZABLE , typename F >
auto callUsingConcretePlatform (Platform platform, const typename CONCRETIZABLE::base_t *ptr, F f)
 Dispatcher for read-only 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)
 
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<typename T , typename DESCRIPTOR , typename REDUCTION_OP , typename CONDITION >
void reduceKernelInBlock (thrust::device_ptr< const T > field, T *g_odata, gpu::cuda::DeviceBlockLattice< T, DESCRIPTOR > lattice, CellID size) __global__
 ref: https://github.com/NVIDIA/cuda-samples/blob/master/Samples/2_Concepts_and_Techniques/reduction/reduction_kernel.cu
 
template<typename T , typename REDUCTION_OP >
void reduceKernelInGrid (const T *partialSums, int partialCount, T *d_result) __global__
 
template<typename T , typename DESCRIPTOR , typename REDUCTION_OP , typename CONDITION >
void reductionFunctionDevice (thrust::device_ptr< const T > devPtr, ConcreteBlockLattice< T, DESCRIPTOR, Platform::GPU_CUDA > &blockLattice, T *paramInDevice)
 
template<Platform PLATFORM>
void checkPlatform ()
 Verifies requirements for using PLATFORM.
 
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) any_platform
 Squared euclidean vector norm.
 
template<typename T , unsigned D, typename IMPL >
constexpr T norm (const ScalarVector< T, D, IMPL > &a) any_platform
 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 COUPLER , typename... MAP>
 SuperLatticePointCoupling (COUPLER, MAP &&...) -> SuperLatticePointCoupling< COUPLER, typename meta::map< MAP... >::template map_values< descriptors::extract_valued_descriptor_t > >
 SuperPointLatticeCoupling.
 
template<typename T , typename DESCRIPTOR >
UnitConverter< T, DESCRIPTOR > convectivelyRefineUnitConverter (const UnitConverter< T, DESCRIPTOR > &converter, unsigned scale=2)
 
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) any_platform
 
template<typename T , typename... Ts>
 Vector (T &&t, Ts &&... ts) -> Vector< std::remove_cvref_t< T >, 1+sizeof...(Ts)>
 
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) any_platform
 
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 IMPL >
constexpr Vector< T, D > round (const ScalarVector< T, D, IMPL > &a) 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< 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, 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)
 
template<typename T , unsigned D, typename IMPL >
constexpr T max (const ScalarVector< T, D, IMPL > &v)
 
any_platform FreeSurface::Flags operator& (FreeSurface::Flags lhs, FreeSurface::Flags rhs)
 
any_platform FreeSurface::Flags operator| (FreeSurface::Flags lhs, FreeSurface::Flags rhs)
 
template<typename V , typename DESCRIPTOR >
int findClosedLatticeVector (Vector< V, DESCRIPTOR::d > tangent) any_platform
 
template<typename T >
bool isCouplingFaceInterior (Vector< T, 2 > p, Vector< T, 2 > a, Vector< T, 2 > b, Vector< T, 2 > c, T w) any_platform
 
template<int WIDTH, typename... MAP>
 SuperImmersedBoundaryCoupling3D (std::integral_constant< int, WIDTH >, MAP &&...) -> SuperImmersedBoundaryCoupling3D< WIDTH, typename meta::map< MAP... >::template map_values< descriptors::extract_valued_descriptor_t > >
 
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 >
IndicatorAirfoil2D< S > * createIndicatorAirfoil2D (XMLreader const &params, bool verbose)
 
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 >
 SuperLatticePhysIncPressure2D (SuperLattice< T, DESCRIPTOR > &, const UnitConverter< T, DESCRIPTOR > &) -> SuperLatticePhysIncPressure2D< 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<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void interpolate2d (CELL &cell, RESULT &result, const Vector< V, 2 > distance, F f) any_platform
 Bilinear interpolation between four neighboring mesh points.
 
template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void interpolate2d_help (CELL &cell, RESULT &result, const Vector< V, 2 > distance, F f, Vector< int, 2 > pointA, Vector< int, 2 > pointB, Vector< int, 2 > pointC) any_platform
 Linear interpolation between three points.
 
template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void interpolate2d_help (CELL &cell, RESULT &result, const Vector< V, 2 > distance, F f, Vector< int, 2 > pointA, Vector< int, 2 > pointB) any_platform
 Linear interpolation between two points (constant in the orthogonal direction)
 
template<unsigned NEIGHBORS, unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void interpolate2d (CELL &cell, RESULT &result, const Vector< V, 2 > distance, F f) any_platform
 linear interpolation/ extrapolation of function f
 
template<unsigned NEIGHBORS, typename FIELD , typename CELL , typename RESULT , typename V = typename CELL::value_t>
void interpolate2d (CELL &cell, RESULT &result, const Vector< V, 2 > distance) any_platform
 linear interpolation/ extrapolation of FIELD
 
template<typename FIELD , typename CELL , typename RESULT , typename V = typename CELL::value_t>
void interpolate2d (CELL &cell, RESULT &result, const Vector< V, 2 > distance) any_platform
 bilinear interpolation/ extrapolation of FIELD
 
template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void interpolate3d (CELL &cell, RESULT &result, const Vector< V, 3 > distance, F f) any_platform
 trilinear interpolation of function f
 
template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void interpolate3d_help_li (CELL &cell, RESULT &result, const Vector< V, 3 > distance, F f, Vector< int, 3 > pointA, Vector< int, 3 > pointB, Vector< int, 3 > pointC, Vector< int, 3 > pointD) any_platform
 Interpolation between four points (linear independent case)
 
template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void interpolate3d_help_plane (CELL &cell, RESULT &result, const Vector< V, 3 > distance, F f, Vector< int, 3 > pointA, Vector< int, 3 > pointB, Vector< int, 3 > pointC, Vector< int, 3 > pointD) any_platform
 Interpolation between four points (coplanar case)
 
template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void interpolate3d_help (CELL &cell, RESULT &result, const Vector< V, 3 > distance, F f, Vector< int, 3 > pointA, Vector< int, 3 > pointB, Vector< int, 3 > pointC) any_platform
 Linear interpolation between three points (constant in the orthogonal direction)
 
template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void interpolate3d_help (CELL &cell, RESULT &result, const Vector< V, 3 > distance, F f, Vector< int, 3 > pointA, Vector< int, 3 > pointB) any_platform
 Linear interpolation between two points (constant in the orthogonal directions)
 
template<unsigned NEIGHBORS, unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void interpolate3d (CELL &cell, RESULT &result, const Vector< V, 3 > distance, F f) any_platform
 interpolation of function f
 
template<unsigned NEIGHBORS, typename FIELD , typename CELL , typename RESULT , typename V = typename CELL::value_t>
void interpolate3d (CELL &cell, RESULT &result, const Vector< V, 3 > distance) any_platform
 Trilinear interpolation of FIELD see above for explanation of the parameters.
 
template<typename FIELD , typename CELL , typename RESULT , typename V = typename CELL::value_t>
void interpolate3d (CELL &cell, RESULT &result, const Vector< V, 3 > distance) any_platform
 Trilinear interpolation of FIELD.
 
template<typename CELL , typename V = typename CELL::value_t>
Vector< V, 6 > strainRateTensorFDM2D (CELL &cell) any_platform
 
template<typename CELL , typename V = typename CELL::value_t>
Vector< V, 6 > strainRateTensorFDM3D (CELL &cell) any_platform
 
template<typename T , unsigned D>
std::unique_ptr< CuboidDecomposition< T, D > > createCuboidDecomposition (std::string fileName)
 Load CuboidDecomposition from XML File.
 
template<typename T >
void continueMinimizeByVolume (CuboidDecomposition< T, 3 > &cGeometry, IndicatorF3D< T > &indicatorF, int nC)
 Splits largest cuboid by-volume until there are nC cuboids.
 
template<typename T >
void minimizeByVolume (CuboidDecomposition< T, 3 > &cGeometry, IndicatorF3D< T > &indicatorF, int nC)
 Splits into nC cuboids by-volume.
 
template<typename T >
void minimizeByWeight (CuboidDecomposition< T, 3 > &cGeometry, IndicatorF3D< T > &indicatorF, int nC)
 
template<concepts::BaseType T>
std::pair< DiscreteNormalType, Vector< int, 2 > > computeBoundaryTypeAndNormal (BlockIndicatorF2D< T > &fluidI, BlockIndicatorF2D< T > &outsideI, Vector< int, 2 > latticeR)
 Returns type (e.g. edge / corner) and discrete normal in 2D.
 
template<concepts::BaseType T>
std::pair< DiscreteNormalType, Vector< int, 3 > > computeBoundaryTypeAndNormal (BlockIndicatorF3D< T > &fluidI, BlockIndicatorF3D< T > &outsideI, Vector< int, 3 > latticeR)
 Returns type (e.g. edge / corner) and discrete normal in 3D.
 
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
 
void setLogScale (size_t dim)
 
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<typename T , typename W >
void writeVTK (SuperF2D< T, W > &f, int iT=0)
 Write out functor F to VTK file (helper)
 
template<typename T , typename W >
void writeVTK (SuperF3D< T, W > &f, int iT=0)
 Write out functor F to VTK file (helper)
 
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 S >
std::vector< S > getDataFromTag (const XMLreader &reader, std::string attrName, int nData)
 Helper Function to retrieve nData-dimensional std::vector of type S from space separated tag.
 
template<typename FIELD , typename T , typename DESCRIPTOR >
std::vector< T > getSerializedFromField (SuperLattice< T, DESCRIPTOR > &lattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&indicator)
 Returns serialized vector of field data inside indicated region.
 
template<typename FIELD , typename T , typename DESCRIPTOR >
void setFieldFromSerialized (const std::vector< T > &serial, SuperLattice< T, DESCRIPTOR > &lattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&indicator)
 Set field content from a serialized data vector inside indicated region.
 
template<typename FIELD , typename T , typename DESCRIPTOR >
std::size_t getSerializedFieldSize (SuperLattice< T, DESCRIPTOR > &lattice)
 Returns size of serialized data vector of a field.
 
template<typename FIELD , typename T , typename DESCRIPTOR >
std::size_t getSerializedFieldSize (SuperLattice< T, DESCRIPTOR > &lattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&indicator)
 Returns size of serialized data vector of a field.
 
template<typename FROM , typename TO , typename T_FROM , typename DESCRIPTOR_FROM , typename T_TO , typename DESCRIPTOR_TO >
void copyFields (SuperLattice< T_FROM, DESCRIPTOR_FROM > &lattice_from, SuperLattice< T_TO, DESCRIPTOR_TO > &lattice_to)
 Copies field data stored in FROM in lattice_from to TO in lattice_to.
 
template<typename FUNCTOR , typename TO , typename T , typename DESCRIPTOR >
auto makeWriteFunctorO (SuperLattice< T, DESCRIPTOR > &lattice)
 
template<typename FUNCTOR , typename TO , typename T , typename DESCRIPTOR >
void writeFunctorTo (SuperLattice< T, DESCRIPTOR > &lattice)
 
template<typename FUNCTOR , typename TO , typename T , typename DESCRIPTOR >
void writeFunctorTo (SuperLattice< T, DESCRIPTOR > &lattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&indicator)
 
template<typename FUNCTOR , typename TO , typename T , typename DESCRIPTOR >
void writePhysFunctorTo (SuperLattice< T, DESCRIPTOR > &lattice, FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > &&indicator, T conversionFactor=1.0)
 
template<typename OPERATOR , typename T , typename DESCRIPTOR >
auto makeSuperLatticeO (SuperLattice< T, DESCRIPTOR > &lattice)
 
template<typename T , unsigned D>
void evaluateCuboidDecompositionNeighbourhood (CuboidDecomposition< T, D > &cuboidDecomposition, std::map< int, std::vector< int > > &neighbourhood, int offset)
 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 , unsigned D>
std::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 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.
 
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)
 
template<typename T , bool check = false>
getConfinedPermeability (T latticeViscosity, T latticeRelaxationTime, T physDeltaX, T charPhysLength, T physPermeability)
 
template<typename T , typename DESCRIPTOR , bool check = false>
getConfinedPermeability (const UnitConverter< T, DESCRIPTOR > &converter, T physPermeability)
 
template<typename T >
getPhysPermeability (T latticeViscosity, T latticeRelaxationTime, T physDeltaX, T charPhysLength, T confinedPermeability)
 
template<typename T , typename DESCRIPTOR , bool check = false>
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)
 

Detailed Description

Top level namespace for all of OpenLB.

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.

This file is part of the OpenLB library.

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.

Copyright (C) 2024 Mathias Krause, Simon Zimny, Adrian Kummerlaender E-mail contact: info@.nosp@m.open.nosp@m.lb.ne.nosp@m.t The most recent release of OpenLB can be downloaded at http://www.openlb.net/

This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2 of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.

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

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 174 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 954 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 104 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 186 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 116 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 258 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 329 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 187 of file advectionDiffusionBoundaries.h.

◆ AllenCahnBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::ExternalVelocityTuple>
using olb::AllenCahnBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::FirstOrder,
collision::BGK,
forcing::AllenCahn
>

Definition at line 357 of file dynamics.h.

◆ AnalyticalComposed2D

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

Definition at line 391 of file analyticalF.h.

◆ AnalyticalComposed3D

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

Definition at line 393 of file analyticalF.h.

◆ AnalyticalConst1D

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

Definition at line 384 of file analyticalF.h.

◆ AnalyticalConst2D

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

Definition at line 386 of file analyticalF.h.

◆ AnalyticalConst3D

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

Definition at line 388 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 396 of file analyticalF.h.

◆ AnalyticalRandom2D

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

Definition at line 398 of file analyticalF.h.

◆ AnalyticalRandom3D

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

Definition at line 400 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.

◆ available_fields

template<typename T , typename DESCRIPTOR >
using olb::available_fields

Definition at line 76 of file availableDynamicList.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 90 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

Block level multiplication functor (T==bool: Intersection)

Definition at line 88 of file blockCalcF2D.h.

◆ BlockCalcMultiplication3D

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.

◆ BlockDataF

template<typename T , typename BaseType , unsigned D>
using olb::BlockDataF
Initial value:
std::conditional_t<
D == 2,
BlockDataF2D<T, BaseType>,
BlockDataF3D<T, BaseType>
>

Definition at line 392 of file aliases.h.

◆ BlockF

template<typename T , unsigned D>
using olb::BlockF
Initial value:
std::conditional_t<
D == 2,
BlockF2D<T>,
BlockF3D<T>
>

Definition at line 177 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 167 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 227 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 207 of file aliases.h.

◆ BlockIndicatorFfromCallableF

template<typename T , unsigned D>
using olb::BlockIndicatorFfromCallableF
Initial value:
std::conditional_t<
D == 2,
BlockIndicatorFfromCallableF2D<T>,
BlockIndicatorFfromCallableF3D<T>
>

Definition at line 370 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 237 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 217 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 147 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 349 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 328 of file aliases.h.

◆ BlockStructure

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

Definition at line 386 of file blockStructure.h.

◆ BlockVTIreader

template<typename T , typename BaseType , unsigned D>
using olb::BlockVTIreader
Initial value:
std::conditional_t<
D == 2,
BlockVTIreader2D<T, BaseType>,
BlockVTIreader3D<T, BaseType>
>

Definition at line 381 of file aliases.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 477 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 496 of file dynamics.h.

◆ BounceBackBulkDensityADE

template<typename T , typename DESCRIPTOR >
using olb::BounceBackBulkDensityADE
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::ZeroMomentum,
momenta::ZeroStress,
momenta::DefineSeparately
>,
equilibria::FirstOrder,
collision::Revert
>

Definition at line 522 of file dynamics.h.

◆ BounceBackBulkDensityWellBalanced

template<typename T , typename DESCRIPTOR >
using olb::BounceBackBulkDensityWellBalanced
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::ZeroMomentum,
momenta::ZeroStress,
momenta::DefineSeparately
>,
equilibria::CahnHilliardZerothOrder,
collision::Revert
>

Definition at line 535 of file dynamics.h.

◆ BounceBackIncompressible

template<typename T , typename DESCRIPTOR >
using olb::BounceBackIncompressible
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::FixedDensity,
momenta::ZeroMomentum,
momenta::ZeroStress,
momenta::DefineSeparately
>,
equilibria::MPIncompressible,
collision::Revert
>

Definition at line 509 of file dynamics.h.

◆ BounceBackVelocity

template<typename T , typename DESCRIPTOR >
using olb::BounceBackVelocity
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::ExternalVelocityFixedDensityTuple,
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 554 of file dynamics.h.

◆ CarreauYasudaBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::CarreauYasudaBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
visco::OmegaFromCell<collision::BGK,visco::CarreauYasuda>
>

BGK collision using Carrau-Yasuda viscosity model.

Definition at line 204 of file nonNewtonianBGKdynamics.h.

◆ CarreauYasudaForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::CarreauYasudaForcedBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
visco::OmegaFromCell<collision::BGK,visco::CarreauYasuda>,
forcing::Guo<momenta::ForcedWithStress>
>

BGK collision using Carrau-Yasuda viscosity model with Guo forcing.

Definition at line 213 of file nonNewtonianBGKdynamics.h.

◆ CassonBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::CassonBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
visco::OmegaFromCell<collision::BGK,visco::Casson>
>

BGK collision using Casson viscosity model.

Definition at line 223 of file nonNewtonianBGKdynamics.h.

◆ CassonForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::CassonForcedBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
visco::OmegaFromCell<collision::BGK,visco::Casson>,
forcing::Guo<momenta::ForcedWithStress>
>

BGK collision using Casson viscosity model with Guo forcing.

Definition at line 232 of file nonNewtonianBGKdynamics.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 645 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 37 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 152 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 137 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 200 of file dynamics.h.

◆ Cuboid2D

template<typename T >
using olb::Cuboid2D = Cuboid<T,2>

Definition at line 149 of file cuboid.h.

◆ Cuboid3D

template<typename T >
using olb::Cuboid3D = Cuboid<T,3>

Definition at line 151 of file cuboid.h.

◆ CuboidDecomposition2D

template<typename T >
using olb::CuboidDecomposition2D = CuboidDecomposition<T,2>

Definition at line 182 of file cuboidDecomposition.h.

◆ CuboidDecomposition3D

template<typename T >
using olb::CuboidDecomposition3D = CuboidDecomposition<T,3>

Definition at line 184 of file cuboidDecomposition.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 559 of file porousBGKdynamics.h.

◆ DiscreteNormal

template<concepts::Descriptor DESCRIPTOR>
using olb::DiscreteNormal = Vector<int,DESCRIPTOR::d>

Definition at line 42 of file discreteNormals.h.

◆ DualForcedBGKDynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::DualForcedBGKDynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
collision::DualForcedBGK
>

Definition at line 246 of file dualDynamics.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 238 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 658 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 671 of file dynamics.h.

◆ ExternalRhoWMHRRdynamics

template<typename T , typename DESCRIPTOR >
using olb::ExternalRhoWMHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::ParameterFromCell<collision::HYBRID,
collision::ParameterFromCell<collision::HYBRID_RHO,
collision::LocalSmagorinskyEffectiveOmega<collision::ExternalRhoHRR>>>
>

Definition at line 137 of file setTurbulentWallModel.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 161 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 121 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 77 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 86 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 296 of file dynamics.h.

◆ FieldD

template<typename T , typename DESCRIPTOR , typename FIELD >
using olb::FieldD
Initial value:
typename FIELD::template value_type<T>,
DESCRIPTOR::template size<FIELD>()
>
Vector(T &&t, Ts &&... ts) -> Vector< std::remove_cvref_t< T >, 1+sizeof...(Ts)>

Vector storing a single field instance.

Definition at line 480 of file vector.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 214 of file dynamics.h.

◆ ForcedExternalRhoWMHRRdynamics

template<typename T , typename DESCRIPTOR >
using olb::ForcedExternalRhoWMHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::ParameterFromCell<collision::HYBRID,
collision::ParameterFromCell<collision::HYBRID_RHO,
collision::LocalSmagorinskyEffectiveOmega<collision::ExternalRhoHRR>>>,
forcing::WFGuoThirdOrder<momenta::ForcedWithStress>
>

Definition at line 121 of file setTurbulentWallModel.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 286 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 254 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 269 of file dynamics.h.

◆ ForcedThirdOrderHHRRdynamics

template<typename T , typename DESCRIPTOR >
using olb::ForcedThirdOrderHHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::HRR,
forcing::GuoThirdOrder<momenta::Forced>
>

Definition at line 185 of file dynamics.h.

◆ ForcedThirdOrderHRLBdynamics

template<typename T , typename DESCRIPTOR >
using olb::ForcedThirdOrderHRLBdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::RLBThirdOrder,
forcing::GuoThirdOrder<momenta::Forced>
>

Definition at line 158 of file dynamics.h.

◆ ForcedThirdOrderHRRdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::ForcedThirdOrderHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::ThirdOrder,
collision::HRR,
forcing::GuoThirdOrder<momenta::Forced>
>

Definition at line 136 of file dynamics.h.

◆ ForcedThirdOrderRLBdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::ForcedThirdOrderRLBdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::ThirdOrder,
collision::RLBThirdOrder,
forcing::GuoThirdOrder<momenta::Forced>
>

Definition at line 127 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 462 of file dynamics.h.

◆ ForcedVanDriestExternalRhoWMHRRdynamics

template<typename T , typename DESCRIPTOR >
using olb::ForcedVanDriestExternalRhoWMHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::ParameterFromCell<collision::HYBRID,
collision::ParameterFromCell<collision::HYBRID_RHO,
collision::LocalVanDriestSmagorinskyEffectiveOmega<collision::ExternalRhoHRR>>>,
forcing::WFGuoThirdOrder<momenta::ForcedWithStress>
>

Definition at line 90 of file setTurbulentWallModel.h.

◆ ForcedVanDriestWMHRRdynamics

template<typename T , typename DESCRIPTOR >
using olb::ForcedVanDriestWMHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::ParameterFromCell<collision::HYBRID,collision::LocalVanDriestSmagorinskyEffectiveOmega<collision::HRR>>,
forcing::WFGuoThirdOrder<momenta::ForcedWithStress>
>

Definition at line 63 of file setTurbulentWallModel.h.

◆ ForcedWagnerBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::ForcedWagnerBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
collision::ParameterFromCell<descriptors::OMEGA, collision::BGK>,
forcing::Wagner
>

BGK collision step with external force (Wagner)

Wagner, A (2006) Thermodynamic consistency of liquid-gas lattice Boltzmann simulations. Phys Rev E 74, 056703 DOI: 10.1103/PhysRevE.74.056703

Definition at line 239 of file dynamics.h.

◆ ForcedWMHRRdynamics

template<typename T , typename DESCRIPTOR >
using olb::ForcedWMHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::ParameterFromCell<collision::HYBRID,collision::LocalSmagorinskyEffectiveOmega<collision::HRR>>,
forcing::WFGuoThirdOrder<momenta::ForcedWithStress>
>

Definition at line 36 of file setTurbulentWallModel.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 172 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 193 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 180 of file freeEnergyDynamics.h.

◆ FreeSurfaceForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::FreeSurfaceForcedBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
collision::BGK,
forcing::FreeSurfaceGuo<momenta::Forced>
>

Definition at line 285 of file freeSurfaceHelpers.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 178 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 279 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 257 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 247 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 180 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 569 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 157 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.

◆ LocalSmagorinskyBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::LocalSmagorinskyBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
collision::ParameterFromCell<collision::LES::SMAGORINSKY,
collision::SmagorinskyEffectiveOmega<collision::BGK>>
>

Smagorinsky BGK collision step with local Smagorinsky constant.

Definition at line 48 of file smagorinskyBGKdynamics.h.

◆ MatrixD

template<typename T , typename DESCRIPTOR , typename LINEAR_FIELD >
using olb::MatrixD = MatrixView<T,LINEAR_FIELD::template rows<DESCRIPTOR>(),LINEAR_FIELD::template cols<DESCRIPTOR>()>

Definition at line 150 of file matrixView.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 224 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 694 of file fieldArrayD.h.

◆ MultiphaseBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::MultiphaseBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
multiphase::OmegaFromCell<collision::BGK>
>

BGK collision using Multiphase collision frequency.

Definition at line 103 of file multiphaseBGKdynamics.h.

◆ MultiphaseForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::MultiphaseForcedBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
multiphase::OmegaFromCell<collision::BGK>,
forcing::Guo<momenta::Forced>
>

BGK collision using Multiphase collision frequency with Guo forcing.

Definition at line 112 of file multiphaseBGKdynamics.h.

◆ MultiPhaseIncompressbileBGKdynamics

template<typename T , typename DESCRIPTOR >
using olb::MultiPhaseIncompressbileBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::IncBulkTuple<momenta::ForcedMomentum<momenta::IncompressibleBulkMomentum>>,
equilibria::MPIncompressible,
collision::OmegaFromCellTauEff<collision::BGK>,
forcing::Liang<momenta::Forced>
>

Multi-phase incompressible BGK collision step with relaxation frequency 1 / TAU_EFF and external force.

Liang, H., Xu, J., Chen, J., Wang, H., Chai, Z., & Shi, B. (2018). Phase-field-based lattice Boltzmann modeling of large-density-ratio two-phase flows. Physical Review E, 97(3), 033309. DOI: 10.1103/PhysRevE.97.033309

Definition at line 312 of file dynamics.h.

◆ MultiPhaseIncompressbileInterfaceTRTdynamics

template<typename T , typename DESCRIPTOR >
using olb::MultiPhaseIncompressbileInterfaceTRTdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::IncBulkTuple<momenta::ForcedMomentum<momenta::IncompressibleBulkMomentum>>,
equilibria::MPIncompressible,
collision::OmegaFromCellTauEff<collision::ITRT>,
forcing::LiangTRT<momenta::Forced>
>

Definition at line 330 of file dynamics.h.

◆ MultiPhaseIncompressbileSmagorinskyBGKdynamics

template<typename T , typename DESCRIPTOR >
using olb::MultiPhaseIncompressbileSmagorinskyBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::IncBulkTuple<momenta::ForcedMomentum<momenta::IncompressibleBulkMomentum>>,
equilibria::MPIncompressible,
collision::OmegaFromCellTauEff<collision::IncompressibleSmagorinskyEffectiveOmega<collision::BGK>>,
forcing::Liang<momenta::ForcedWithIncompressibleStress>
>

Definition at line 339 of file dynamics.h.

◆ MultiPhaseIncompressbileSmagorinskyTRTdynamics

template<typename T , typename DESCRIPTOR >
using olb::MultiPhaseIncompressbileSmagorinskyTRTdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::IncBulkTuple<momenta::ForcedMomentum<momenta::IncompressibleBulkMomentum>>,
equilibria::MPIncompressible,
collision::OmegaFromCellTauEff<collision::IncompressibleSmagorinskyEffectiveOmega<collision::TRT>>,
forcing::LiangTRT<momenta::ForcedWithIncompressibleStress>
>

Definition at line 348 of file dynamics.h.

◆ MultiPhaseIncompressbileTRTdynamics

template<typename T , typename DESCRIPTOR >
using olb::MultiPhaseIncompressbileTRTdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::IncBulkTuple<momenta::ForcedMomentum<momenta::IncompressibleBulkMomentum>>,
equilibria::MPIncompressible,
collision::OmegaFromCellTauEff<collision::TRT>,
forcing::Liang<momenta::Forced>
>

Definition at line 321 of file dynamics.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 963 of file advectionDiffusionDynamics.h.

◆ NoCollideDynamicsExternalVelocity

template<typename T , typename DESCRIPTOR >
using olb::NoCollideDynamicsExternalVelocity
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::ExternalVelocityTuple,
equilibria::FirstOrder,
collision::None
>

Definition at line 145 of file phaseFieldBoundaryDynamics.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 51 of file dynamics.h.

◆ NoDynamicsWithFixedDensity

template<typename T , typename DESCRIPTOR >
using olb::NoDynamicsWithFixedDensity
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::FixedDensity,
momenta::ZeroMomentum,
momenta::ZeroStress,
momenta::DefineSeparately
>,
equilibria::None,
collision::None
>

Dynamics for "dead cells" with fixed density.

Definition at line 75 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 66 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 584 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 250 of file fieldParametersD.h.

◆ ParametersOfOperatorD

template<concepts::BaseType T, concepts::Descriptor 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 244 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 566 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 575 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 521 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 177 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 47 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 57 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 188 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 197 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 207 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 216 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 588 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 382 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 102 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 111 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 67 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.

◆ SmagorinskyFreeSurfaceForcedBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::SmagorinskyFreeSurfaceForcedBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
collision::SmagorinskyEffectiveOmega<collision::BGK>,
forcing::FreeSurfaceGuo<momenta::ForcedWithStress>
>

Definition at line 295 of file freeSurfaceHelpers.h.

◆ SmagorinskyFreeSurfaceForcedMRTdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::SmagorinskyFreeSurfaceForcedMRTdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::SecondOrder,
collision::SmagorinskyEffectiveOmega<collision::MRT>,
forcing::FreeSurfaceLaddVerberg
>

Definition at line 305 of file freeSurfaceHelpers.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 187 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 189 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 541 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 226 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 235 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 245 of file powerLawBGKdynamics.h.

◆ SmagorinskyThirdOrderRLBdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::SmagorinskyThirdOrderRLBdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::ThirdOrder,
collision::SmagorinskyEffectiveOmega<collision::ThirdOrderRLB>
>

Smagorinsky RLB Third Order collision step.

Definition at line 58 of file smagorinskyBGKdynamics.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 578 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 267 of file aliases.h.

◆ SpecialAnalyticalFfromBlockF

template<typename T , typename W , unsigned D>
using olb::SpecialAnalyticalFfromBlockF
Initial value:
std::conditional_t<
D == 2,
SpecialAnalyticalFfromBlockF2D<T, W>,
SpecialAnalyticalFfromBlockF3D<T, W>
>

Definition at line 403 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 531 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 187 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 550 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 187 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 307 of file aliases.h.

◆ SuperGeometryF

template<typename T , unsigned D>
using olb::SuperGeometryF
Initial value:
std::conditional_t<
D == 2,
SuperGeometryF2D<T>,
SuperGeometryF3D<T>
>

Definition at line 88 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 68 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 297 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 197 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 277 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 287 of file aliases.h.

◆ SuperIntegral

template<unsigned DIM, typename T , typename W = T>
using olb::SuperIntegral
Initial value:
std::conditional_t<
DIM == 2,
SuperIntegral2D<T,W>,
SuperIntegral3D<T,W>
>

Definition at line 127 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 98 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 118 of file aliases.h.

◆ SuperLatticeField

template<typename T , typename DESCRIPTOR , typename FIELD >
using olb::SuperLatticeField
Initial value:
std::conditional_t<
DESCRIPTOR::d == 2,
SuperLatticeField2D<T,DESCRIPTOR,FIELD>,
SuperLatticeField3D<T,DESCRIPTOR,FIELD>
>

Definition at line 137 of file aliases.h.

◆ SuperLatticeFpop

template<typename T , typename DESCRIPTOR >
using olb::SuperLatticeFpop
Initial value:
std::conditional_t<
DESCRIPTOR::d == 2,
SuperLatticeFpop2D<T,DESCRIPTOR>,
SuperLatticeFpop3D<T,DESCRIPTOR>
>

Definition at line 359 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 338 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 109 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 318 of file aliases.h.

◆ SuperLatticePhysField

template<typename T , typename DESCRIPTOR , typename FIELD >
using olb::SuperLatticePhysField
Initial value:
std::conditional_t<
DESCRIPTOR::d == 2,
SuperLatticePhysField2D<T, DESCRIPTOR, FIELD>,
SuperLatticePhysField3D< T, DESCRIPTOR, FIELD>
>

Definition at line 414 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 108 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 116 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 78 of file aliases.h.

◆ ThirdOrderBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::ThirdOrderBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::ThirdOrder,
collision::BGK
>

Definition at line 102 of file dynamics.h.

◆ ThirdOrderHHRRdynamics

template<typename T , typename DESCRIPTOR >
using olb::ThirdOrderHHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::HRR
>

Definition at line 172 of file dynamics.h.

◆ ThirdOrderHRLBdynamics

template<typename T , typename DESCRIPTOR >
using olb::ThirdOrderHRLBdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::RLBThirdOrder
>

Definition at line 145 of file dynamics.h.

◆ ThirdOrderHRRdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::ThirdOrderHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::ThirdOrder,
collision::HRR
>

Definition at line 111 of file dynamics.h.

◆ ThirdOrderRLBdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::BulkTuple>
using olb::ThirdOrderRLBdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::ThirdOrder,
collision::RLBThirdOrder
>

Definition at line 119 of file dynamics.h.

◆ TransposedMatrixD

template<typename T , typename DESCRIPTOR , typename LINEAR_FIELD >
using olb::TransposedMatrixD = TransposedMatrixView<MatrixView<T,LINEAR_FIELD::template rows<DESCRIPTOR>(),LINEAR_FIELD::template cols<DESCRIPTOR>()>>

Definition at line 153 of file matrixView.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 450 of file dynamics.h.

◆ VanDriestExternalRhoWMHRRdynamics

template<typename T , typename DESCRIPTOR >
using olb::VanDriestExternalRhoWMHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::ParameterFromCell<collision::HYBRID,
collision::ParameterFromCell<collision::HYBRID_RHO,
collision::LocalVanDriestSmagorinskyEffectiveOmega<collision::ExternalRhoHRR>>>
>

Definition at line 106 of file setTurbulentWallModel.h.

◆ VanDriestWMHRRdynamics

template<typename T , typename DESCRIPTOR >
using olb::VanDriestWMHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::ParameterFromCell<collision::HYBRID,collision::LocalVanDriestSmagorinskyEffectiveOmega<collision::HRR>>
>

Definition at line 77 of file setTurbulentWallModel.h.

◆ VTIwriter

template<typename T , typename DESCRIPTOR >
using olb::VTIwriter
Initial value:
VTKwriter<
T,
SuperF3D<T,T>,
>
@ VTI
Definition vtkWriter.h:52

Definition at line 156 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 vtkWriter.h:52

Definition at line 144 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 171 of file smagorinskyBGKdynamics.h.

◆ WellBalancedCahnHilliardBGKdynamics

template<typename T , typename DESCRIPTOR , typename MOMENTA = momenta::ExternalVelocityTuple>
using olb::WellBalancedCahnHilliardBGKdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
MOMENTA,
equilibria::CahnHilliardZerothOrder,
collision::BGK,
forcing::WellBalancedCahnHilliard
>

Definition at line 366 of file dynamics.h.

◆ WMHRRdynamics

template<typename T , typename DESCRIPTOR >
using olb::WMHRRdynamics
Initial value:
dynamics::Tuple<
T, DESCRIPTOR,
momenta::Tuple<
momenta::BulkDensity,
momenta::MovingPorousMomentumCombination<momenta::BulkMomentum>,
momenta::BulkStress,
momenta::DefineToNEq
>,
equilibria::ThirdOrder,
collision::ParameterFromCell<collision::HYBRID,collision::LocalSmagorinskyEffectiveOmega<collision::HRR>>
>

Definition at line 50 of file setTurbulentWallModel.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.

35 {
40};
@ Discrete
Read block data from discrete lattice locations.
@ Analytical
Interpolate block data at exact physical locations.

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

43 {
49 None
50};
@ ReduceOnly
optimize for usage in e.g. BlockGifWriter, full data only available on main rank
@ ReduceAndBcast
default behavior, full block data available on all ranks after update

◆ 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 81 of file operator.h.

81 {
86};
@ Individual
Apply all dynamics individually (async for Platform::GPU_CUDA)
@ Dominant
Apply dominant dynamics using mask and fallback to virtual dispatch for others.

◆ DataType

Enumerator
PointData 
CellData 

Definition at line 80 of file vtiReader.h.

80 {
83};
@ PointData
Definition vtiReader.h:81
@ CellData
Definition vtiReader.h:82

◆ DiscreteNormalType

enum class olb::DiscreteNormalType : int
strong

Type associated with a discrete normal vector.

Enumerator
Flat 
ExternalCorner 

Normal detected as flat plane.

InternalCorner 

Normal detected as external corner.

ExternalEdge 

Normal detected as internal corner.

InternalEdge 

Normal detected as external edge (only 3D)

Definition at line 33 of file discreteNormals.h.

33 : int {
34 Flat = 0,
35 ExternalCorner = 1,
36 InternalCorner = 2,
37 ExternalEdge = 3,
38 InternalEdge = 4
39};
@ ExternalCorner
Normal detected as flat plane.
@ ExternalEdge
Normal detected as internal corner.
@ InternalEdge
Normal detected as external edge (only 3D)
@ InternalCorner
Normal detected as external corner.

◆ 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 33 of file operatorScope.h.

33 {
35 PerCell,
40};
@ PerBlock
Per-block application, i.e. OPERATOR::apply is passed a ConcreteBlockLattice.
@ PerCell
Per-cell application, i.e. OPERATOR::apply is passed a CELL concept implementation.
@ PerCellWithParameters
Per-cell application with parameters, i.e. OPERATOR::apply is passed a CELL concept implementation an...

◆ OutputChannel

enum class olb::OutputChannel
strong
Enumerator
TERMINAL 
ERRCHANNEL 

Definition at line 35 of file xmlReaderOutput.h.

◆ 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 35 of file platform.h.

35 : std::uint8_t {
36 CPU_SISD,
37 CPU_SIMD,
38 GPU_CUDA,
39};
@ CPU_SIMD
Basic scalar CPU.
@ GPU_CUDA
Vector CPU (AVX2 / AVX-512 collision)

◆ 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 54 of file platform.h.

54 {
57};
@ Simulation
Data available on host for e.g. functor evaluation.

◆ RayMode [1/2]

enum class olb::RayMode : int
strong
Enumerator
FastRayZ 
Robust 

Indicate function with ray in Z-direction(faster, less stable). Default option.

FastRayX 

Old indicate function (slower, more stable)

FastRayY 

Indicate function with ray in X-direction(faster, less stable).

DoubleRay 

Indicate function with ray in Y-direction(faster, less stable).

FastRayZ 
Robust 

Indicate function with ray in Z-direction(faster, less stable). Default option.

FastRayX 

Old indicate function (slower, more stable)

FastRayY 

Indicate function with ray in X-direction(faster, less stable).

DoubleRay 

Indicate function with ray in Y-direction(faster, less stable).

Definition at line 209 of file stlReader.h.

209 : int {
210 FastRayZ = 1,
211 Robust = 2,
212 FastRayX = 3,
213 FastRayY = 4,
214 DoubleRay = 5
215};
@ DoubleRay
Indicate function with ray in Y-direction(faster, less stable).
@ FastRayX
Old indicate function (slower, more stable)
@ FastRayY
Indicate function with ray in X-direction(faster, less stable).
@ Robust
Indicate function with ray in Z-direction(faster, less stable). Default option.

◆ RayMode [2/2]

enum class olb::RayMode : int
strong
Enumerator
FastRayZ 
Robust 

Indicate function with ray in Z-direction(faster, less stable). Default option.

FastRayX 

Old indicate function (slower, more stable)

FastRayY 

Indicate function with ray in X-direction(faster, less stable).

DoubleRay 

Indicate function with ray in Y-direction(faster, less stable).

FastRayZ 
Robust 

Indicate function with ray in Z-direction(faster, less stable). Default option.

FastRayX 

Old indicate function (slower, more stable)

FastRayY 

Indicate function with ray in X-direction(faster, less stable).

DoubleRay 

Indicate function with ray in Y-direction(faster, less stable).

Definition at line 230 of file STLreaderForSubgridParticleWallContact.h.

230 : int {
231 FastRayZ = 1,
232 Robust = 2,
233 FastRayX = 3,
234 FastRayY = 4,
235 DoubleRay = 5
236};

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

30 {
32 None,
36 Floor,
38 Ceil,
39};
@ Ceil
Rounds down.
@ NearestInteger
Rounds to nearest Integer.
@ Floor
Rounds up.

◆ SignMode [1/2]

enum class olb::SignMode
strong

Enum class that specifies the mode to use for computing the sign of the signed distance.

This enum class specifies the mode to use for computing the sign of the signed distance. It can take one of the following values:

  • SignMode::EXACT: The sign is computed exactly using the winding number close to the surface (slow).
  • SignMode::CACHED: The sign is computed from cache (fast, but less accurate in vicinity of the surface).
Enumerator
EXACT 
CACHED 
EXACT 
CACHED 

Definition at line 206 of file stlReader.h.

◆ SignMode [2/2]

enum class olb::SignMode
strong

Enum class that specifies the mode to use for computing the sign of the signed distance.

This enum class specifies the mode to use for computing the sign of the signed distance. It can take one of the following values:

  • SignMode::EXACT: The sign is computed exactly using the winding number close to the surface (slow).
  • SignMode::CACHED: The sign is computed from cache (fast, but less accurate in vicinity of the surface).
Enumerator
EXACT 
CACHED 
EXACT 
CACHED 

Definition at line 227 of file STLreaderForSubgridParticleWallContact.h.

227{ EXACT, CACHED };

◆ vtkType

Enumerator
VTI 
VTU 
VTP 

Definition at line 52 of file vtkWriter.h.

52{ VTI, VTU, VTP };
@ VTP
Definition vtkWriter.h:52

Function Documentation

◆ abs() [1/2]

template<typename T , unsigned D, typename IMPL >
Vector< T, D > olb::abs ( const ScalarVector< T, D, IMPL > & a)
constexpr

Definition at line 293 of file vector.h.

294{
295 using namespace util;
296 return Vector<T,D>([&a](unsigned iDim) -> T {
297 return abs(a[iDim]);
298 });
299}
Plain old scalar vector.

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 464 of file util.h.

465{
466 return util::fabs(x);
467}

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 58 of file setBoundary2D.h.

59{
60 /* local boundaries: _overlap = 0;
61 * interp boundaries: _overlap = 1;
62 * bouzidi boundaries: _overlap = 1;
63 * extField boundaries: _overlap = 1;
64 * advectionDiffusion boundaries: _overlap = 1;
65 */
66
67 if (_overlap == 0) {
68 return;
69 }
70
71 auto& communicator = sLattice.getCommunicator(stage::PostStream());
72 communicator.template requestField<descriptors::POPULATION>();
73
74 SuperGeometry<T,2>& superGeometry = indicator->getSuperGeometry();
75 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
76 const int nX = superGeometry.getBlockGeometry(iCloc).getNx();
77 const int nY = superGeometry.getBlockGeometry(iCloc).getNy();
78
79 for (int iX = -_overlap; iX < nX+_overlap; ++iX) {
80 for (int iY = -_overlap; iY < nY+_overlap; ++iY) {
81 if (iX < 0 || iX > nX - 1 ||
82 iY < 0 || iY > nY - 1 ) { // if within overlap
83 if (superGeometry.getBlockGeometry(iCloc).getMaterial(iX,iY) != 0) {
84 bool found = false;
85 for (int iXo = -_overlap; iXo <= _overlap && !found; ++iXo) {
86 for (int iYo = -_overlap; iYo <= _overlap && !found; ++iYo) {
87 const int nextX = iXo + iX;
88 const int nextY = iYo + iY;
89 if (indicator->getBlockIndicatorF(iCloc)(nextX, nextY)) {
90 communicator.requestCell({iCloc, iX, iY});
91 found = true;
92 }
93 }
94 }
95 }
96 }
97 }
98 }
99 }
100
101 communicator.exchangeRequests();
102}
SuperCommunicator< T, SuperLattice > & getCommunicator(STAGE stage=STAGE())
Return communicator for given communication stage.
LoadBalancer< T > & getLoadBalancer()
Read and write access to the load balancer.

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.

58{
59 /* local boundaries: _overlap = 0;
60 * interp boundaries: _overlap = 1;
61 * bouzidi boundaries: _overlap = 1;
62 * extField boundaries: _overlap = 1;
63 * advectionDiffusion boundaries: _overlap = 1;
64 */
65
66 if (_overlap == 0) {
67 return;
68 }
69
70 auto& communicator = sLattice.getCommunicator(stage::PostStream());
71 communicator.template requestField<descriptors::POPULATION>();
72
73 SuperGeometry<T,3>& superGeometry = indicator->getSuperGeometry();
74 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
75 const int nX = superGeometry.getBlockGeometry(iCloc).getNx();
76 const int nY = superGeometry.getBlockGeometry(iCloc).getNy();
77 const int nZ = superGeometry.getBlockGeometry(iCloc).getNz();
78
79 for (int iX = -_overlap; iX < nX+_overlap; ++iX) {
80 for (int iY = -_overlap; iY < nY+_overlap; ++iY) {
81 for (int iZ = -_overlap; iZ < nZ+_overlap; ++iZ) {
82 if (iX < 0 || iX > nX - 1 ||
83 iY < 0 || iY > nY - 1 ||
84 iZ < 0 || iZ > nZ - 1 ) { // if within overlap
85 if (superGeometry.getBlockGeometry(iCloc).getMaterial(iX,iY,iZ) != 0) {
86 bool found = false;
87 for (int iXo = -_overlap; iXo <= _overlap && !found; ++iXo) {
88 for (int iYo = -_overlap; iYo <= _overlap && !found; ++iYo) {
89 for (int iZo = -_overlap; iZo <= _overlap && !found; ++iZo) {
90 const int nextX = iXo + iX;
91 const int nextY = iYo + iY;
92 const int nextZ = iZo + iZ;
93 if (indicator->getBlockIndicatorF(iCloc)(nextX, nextY, nextZ)
94 && nextX >= -_overlap && nextX < nX+_overlap
95 && nextY >= -_overlap && nextY < nY+_overlap
96 && nextZ >= -_overlap && nextZ < nZ+_overlap) {
97 communicator.requestCell({iCloc, iX, iY, iZ});
98 found = true;
99 }
100 }
101 }
102 }
103 }
104 }
105 }
106 }
107 }
108 }
109
110 communicator.exchangeRequests();
111}

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

◆ applyBouzidiTemp()

template<typename CELL , typename V = typename CELL::value_t>
void olb::applyBouzidiTemp ( CELL & x_b)

Definition at line 63 of file bouzidiTemperatureJumpPostProcessor3D.h.

64{
65 using DESCRIPTOR = typename CELL::descriptor_t;
66 const auto q = x_b.template getFieldPointer<descriptors::BOUZIDI_DISTANCE>();
67 const auto phi_d =
68 x_b.template getFieldPointer<descriptors::BOUZIDI_JUMP_TEMP>();
69 V f = V {1 / 3}; // D2Q5
70 if (descriptors::q<DESCRIPTOR>() == 7) {
71 f = V {0.25}; // D3Q7
72 }
73 for (int iPop = 1; iPop < descriptors::q<DESCRIPTOR>(); ++iPop) {
74 // update missing population if valid bouzidi distance
75 if (q[iPop] > V {0}) {
76 const auto c = descriptors::c<DESCRIPTOR>(iPop);
77 const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
78 auto x_s = x_b.neighbor(c); // solid side neighbor
79 auto x_f = x_b.neighbor(descriptors::c<DESCRIPTOR>(
80 iPop_opposite)); // fluid side neighbor opposite to the missing population
81 auto source_d =
82 phi_d[iPop] * f; // source term set by the dirichlet condition
83 auto t_i = descriptors::t<V, DESCRIPTOR>(iPop);
84 auto t_iopp = descriptors::t<V, DESCRIPTOR>(iPop_opposite);
85
86 x_b[iPop_opposite] =
87 (q[iPop] <= V {0.5}) // cut is closer to the fluid cell
88 * (V {-2} * q[iPop] * (x_s[iPop] + t_i) +
89 (V {2} * q[iPop] - V {1}) * (x_b[iPop] + t_i) + source_d) +
90 (q[iPop] > V {0.5}) // cut is closer to the solid cell
91 * (V {-1} / (V {2} * q[iPop]) * (x_s[iPop] + t_i) +
92 (V {1} - V {1} / (V {2} * q[iPop])) *
93 (x_f[iPop_opposite] + t_iopp) +
94 (V {1} / (V {2} * q[iPop])) * source_d) -
95 t_iopp;
96 }
97 // if intersection point is on the cell then fall back to full-way bounce back
98 else if (q[iPop] == V {0}) {
99 const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
100 auto source_d = phi_d[iPop] * f;
101 auto t_i = descriptors::t<V, DESCRIPTOR>(iPop);
102 auto t_iopp = descriptors::t<V, DESCRIPTOR>(iPop_opposite);
103 x_b[iPop_opposite] = -(x_b[iPop] + t_i) + source_d - t_iopp;
104 }
105 }
106};
platform_constant int c[Q][D]
Definition functions.h:57
constexpr int q() any_platform
Definition functions.h:140

References olb::descriptors::c(), olb::descriptors::opposite(), olb::descriptors::q(), and olb::descriptors::t().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ applyBouzidiVelocity()

template<typename CELL , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
void olb::applyBouzidiVelocity ( CELL & x_b)

Definition at line 62 of file bouzidiSlipVelocityPostProcessor3D.h.

63{
64 const auto q = x_b.template getFieldPointer<descriptors::BOUZIDI_DISTANCE>();
65 const auto veloCoeff =
66 x_b.template getFieldPointer<descriptors::BOUZIDI_VELOCITY>();
67 //const auto material = x_b.template getField<descriptors::MATERIAL>();
68 for (int iPop = 1; iPop < descriptors::q<DESCRIPTOR>(); ++iPop) {
69 // update missing population if valid bouzidi distance
70 if (q[iPop] > 0) {
71 const auto c = descriptors::c<DESCRIPTOR>(iPop);
72 const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
73 auto x_s = x_b.neighbor(c); // solid side neighbor
74 auto x_f = x_b.neighbor(descriptors::c<DESCRIPTOR>(
75 iPop_opposite)); // fluid side neighbor opposite to the missing population
76 auto veloTerm = veloCoeff[iPop] * (descriptors::t<V, DESCRIPTOR>(iPop)) *
77 (descriptors::invCs2<V, DESCRIPTOR>());
78
79 x_b[iPop_opposite] =
80 (q[iPop] <= V {0.5}) // cut is closer to the fluid cell
81 * (V {2} * q[iPop] * x_s[iPop] +
82 (V {1} - V {2} * q[iPop]) * x_b[iPop] - V {2} * veloTerm) +
83 (q[iPop] > V {0.5}) // cut is closer to the solid cell
84 * (V {0.5} / q[iPop] * x_s[iPop] +
85 V {0.5} * (V {2} * q[iPop] - V {1}) / q[iPop] *
86 x_f[iPop_opposite] -
87 V {1} / q[iPop] * veloTerm);
88 }
89 // if intersection point is on the cell then fall back to full-way bounce back
90 else if (q[iPop] == V {0}) {
91 const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
92 auto veloTerm = veloCoeff[iPop] * (descriptors::t<V, DESCRIPTOR>(iPop)) *
93 (descriptors::invCs2<V, DESCRIPTOR>());
94 x_b[iPop_opposite] = x_b[iPop] - V {2} * veloTerm;
95 }
96 }
97};

References olb::descriptors::c(), olb::descriptors::invCs2(), olb::descriptors::opposite(), and olb::descriptors::t().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

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

122 {
123 //If scalar
124 if constexpr (std::is_arithmetic<O>::value) {
125 if (input){
126 return "true";
127 } else {
128 return "false";
129 }
130 //If e.g. Vector
131 } else {
132 std::stringstream stream;
133 stream << "[";
134 for(unsigned iDim=0; iDim<O::d; ++iDim){
135 stream << (iDim==0 ? "" : ",");
136 if (input[iDim]){
137 stream << "true";
138 } else {
139 stream << "false";
140 }
141 }
142 stream << "]";
143 return stream.str();
144 }
145}

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

109{
110 serializer.resetCounter();
111 std::size_t blockSize;
112 bool* dataBuffer = nullptr;
113 while (dataBuffer = serializer.getNextBlock(blockSize, true), dataBuffer != nullptr) {
114 std::memcpy(dataBuffer, buffer, blockSize);
115 buffer += blockSize;
116 }
117 serializer.resetCounter();
118}
void resetCounter()
Resets the _iBlock counter.
Definition serializer.hh:49
bool * getNextBlock(std::size_t &sizeBlock, const bool loadingMode)
Returns pointer to the memory of the current block and increments iBlock
Definition serializer.hh:59

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

template<typename CONCRETIZABLE , typename F >
auto olb::callUsingConcretePlatform ( Platform platform,
const typename CONCRETIZABLE::base_t * ptr,
F f )
inline

Dispatcher for read-only concrete platform access.

See e.g. ConcretizableBlockLattice usage in BlockLattice::getField

Definition at line 73 of file dispatch.h.

74{
75 return callUsingConcretePlatform<CONCRETIZABLE>(platform,
76 const_cast<typename CONCRETIZABLE::base_t*>(ptr),
77 [&](auto* concrete) {
78 return f(static_cast<typename std::add_const_t<decltype(concrete)>>(concrete));
79 });
80}

References callUsingConcretePlatform().

+ Here is the call graph for this function:

◆ callUsingConcretePlatform() [2/3]

template<typename F >
void olb::callUsingConcretePlatform ( Platform platform,
F f )
inline

Definition at line 83 of file dispatch.h.

84{
85 switch (platform) {
86#ifdef PLATFORM_CPU_SISD
87 case Platform::CPU_SISD:
89 break;
90#endif
91#ifdef PLATFORM_CPU_SIMD
92 case Platform::CPU_SIMD:
93 f(meta::value<Platform::CPU_SIMD>{});
94 break;
95#endif
96#ifdef PLATFORM_GPU_CUDA
97 case Platform::GPU_CUDA:
98 f(meta::value<Platform::GPU_CUDA>{});
99 break;
100#endif
101 default:
102 throw std::invalid_argument("Invalid PLATFORM");
103 }
104}
typename std::integral_constant< TYPE, VALUE >::type value
Identity type to wrap non-type template arguments.
Definition meta.h:96

References CPU_SIMD, CPU_SISD, and GPU_CUDA.

◆ callUsingConcretePlatform() [3/3]

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 41 of file dispatch.h.

42{
43 if constexpr (std::is_same_v<typename CONCRETIZABLE::value_t,Expr>) {
44 if (platform != Platform::CPU_SISD) {
45 throw std::domain_error("Only CPU_SISD supports Expr value type");
46 }
47 return f(static_cast<typename CONCRETIZABLE::template type<Platform::CPU_SISD>*>(ptr));
48 } else {
49 switch (platform) {
50#ifdef PLATFORM_CPU_SISD
51 case Platform::CPU_SISD:
52 return f(static_cast<typename CONCRETIZABLE::template type<Platform::CPU_SISD>*>(ptr));
53#endif
54#ifdef PLATFORM_CPU_SIMD
55 case Platform::CPU_SIMD:
56 return f(static_cast<typename CONCRETIZABLE::template type<Platform::CPU_SIMD>*>(ptr));
57#endif
58#ifdef PLATFORM_GPU_CUDA
59 case Platform::GPU_CUDA:
60 return f(static_cast<typename CONCRETIZABLE::template type<Platform::GPU_CUDA>*>(ptr));
61#endif
62 default:
63 throw std::invalid_argument("Invalid PLATFORM");
64 }
65 }
66}

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 50 of file utilities.h.

54{
55 bool consistent = true;
56 for ( auto cuboidNeighbourPair : neighbourhood){
57 //Retrieve iC and neighbours
58 int iC = cuboidNeighbourPair.first;
59 std::vector<int>& neighbours = cuboidNeighbourPair.second;
60 //Loop over neighbours
61 for (int iCN : neighbours){
62 //Retreive neighbour's neighbours
63 std::vector<int>& neighboursNeighbours = neighbourhood[iCN];
64 bool iCfound = false;
65 //Loop over neighbour's neighbours
66 for (int iCNN : neighboursNeighbours ){
67 if (iCNN == iC){
68 iCfound=true;
69 break;
70 }
71 }
72 if (!iCfound){
73 //Set consistency boolean to false
74 consistent = false;
75 //Output, if desired
76 if (verbose){
77 std::cout << "iC " << iC << " not found in list of neighbour iC "
78 << iCN << std::endl;
79 }
80 //Correct, if desired
81 if (correct){
82 neighbourhood[iCN].push_back(iC);
83 }
84 }
85 }
86 }
87 //Return whether consistent
88 return consistent;
89}
+ 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.

47{
48 OstreamManager clout(std::cout, "GPU_CUDA");
49
50 int nDevices{};
51 cudaGetDeviceCount(&nDevices);
52
53 clout.setMultiOutput(true);
54 if (nDevices < 1) {
55 clout << "No CUDA device found" << std::endl;
56 } else if (nDevices > 1) {
57 clout << "Found " << nDevices << " CUDA devices but only one can be used per MPI process." << std::endl;
58 }
59#ifdef OLB_DEBUG
60 for (int deviceI=0; deviceI < nDevices; ++deviceI) {
61 cudaDeviceProp deviceProp;
62 cudaGetDeviceProperties(&deviceProp, deviceI);
63 clout << deviceProp.name << " visible" << std::endl;
64 }
65#endif
66 clout.setMultiOutput(false);
67
68#ifdef PARALLEL_MODE_MPI
69#if defined(MPIX_CUDA_AWARE_SUPPORT) && MPIX_CUDA_AWARE_SUPPORT
70 if (!MPIX_Query_cuda_support()) {
71 clout << "The used MPI Library is not CUDA-aware. Multi-GPU execution will fail." << std::endl;
72 }
73#endif
74#if defined(MPIX_CUDA_AWARE_SUPPORT) && !MPIX_CUDA_AWARE_SUPPORT
75 clout << "The used MPI Library is not CUDA-aware. Multi-GPU execution will fail." << std::endl;
76#endif
77#if !defined(MPIX_CUDA_AWARE_SUPPORT)
78 clout << "Unable to check for CUDA-aware MPI support. Multi-GPU execution may fail." << std::endl;
79#endif
80#endif // PARALLEL_MODE_MPI
81}
class for marking output with some text

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.

47{
48 OstreamManager clout(std::cout, "GPU_CUDA");
49
50 int nDevices{};
51 cudaGetDeviceCount(&nDevices);
52
53 clout.setMultiOutput(true);
54 if (nDevices < 1) {
55 clout << "No CUDA device found" << std::endl;
56 } else if (nDevices > 1) {
57 clout << "Found " << nDevices << " CUDA devices but only one can be used per MPI process." << std::endl;
58 }
59#ifdef OLB_DEBUG
60 for (int deviceI=0; deviceI < nDevices; ++deviceI) {
61 cudaDeviceProp deviceProp;
62 cudaGetDeviceProperties(&deviceProp, deviceI);
63 clout << deviceProp.name << " visible" << std::endl;
64 }
65#endif
66 clout.setMultiOutput(false);
67
68#ifdef PARALLEL_MODE_MPI
69#if defined(MPIX_CUDA_AWARE_SUPPORT) && MPIX_CUDA_AWARE_SUPPORT
70 if (!MPIX_Query_cuda_support()) {
71 clout << "The used MPI Library is not CUDA-aware. Multi-GPU execution will fail." << std::endl;
72 }
73#endif
74#if defined(MPIX_CUDA_AWARE_SUPPORT) && !MPIX_CUDA_AWARE_SUPPORT
75 clout << "The used MPI Library is not CUDA-aware. Multi-GPU execution will fail." << std::endl;
76#endif
77#if !defined(MPIX_CUDA_AWARE_SUPPORT)
78 clout << "Unable to check for CUDA-aware MPI support. Multi-GPU execution may fail." << std::endl;
79#endif
80#endif // PARALLEL_MODE_MPI
81}

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 97 of file cliReader.h.

98 {
99 if (contains(name)) {
100 return operator[](name);
101 } else {
102 return fallback;
103 }
104}

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

76{
77 const T eps = std::numeric_limits<T>::epsilon();
78 for (unsigned iDim=0; iDim < D; ++iDim) {
79 if (util::fabs(a[iDim]) > eps) {
80 return false;
81 }
82 }
83 return true;
84}

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
DESCRIPTORa lattice stencil
qnumber of lattice stencils MINUS one, 0th direction not needed
Parameters
stepsizechoose precision
anisotropyFactoralso known as g
solutionfor debugging
phiis anisotropy matrix(sym), element [i][j] probability of scattering from i into j (direction)
breakAfterto limit endless iteration for testing

Definition at line 132 of file anisoDiscr.h.

135{
136 using namespace descriptors;
137 if ( !DESCRIPTOR::template provides<descriptors::tag::RTLBM>() ) {
138 std::cout << "Warning: Compute anisotropy matrix for wrong latice stencil!" << std::endl;
139 std::cout << "Weight for direction 0 is required to be 0." << std::endl;
140 return;
141 }
142
143 OstreamManager clout( std::cout, "AnisotropyMatrix" );
144 clout << "Call AnistorpiyMatrix()" << std::endl;
145#ifdef FEATURE_OPENBLAS
146 clout << "Compute anisotropy matrix ..." << std::endl;
147 typedef DESCRIPTOR L;
148 int const q = L::q-1;
149 int const mm = 2*q;
150 int const nn = (q+1)*q/2;
151
152 // qxq matrix 0th row and 0th column are empty
153 std::array<std::array<double,q>,q> angleProb;
154 double dotProduct;
155 double normI;
156 double normJ;
157 for (int iPop=0; iPop<q; iPop++) {
158 for (int jPop=0; jPop<q; jPop++) {
159 // shift by 1 due to notation in DESCRIPTOR/DESCRIPTOR
160 // exclude 0th direction
161 dotProduct = c<L>(iPop+1)*c<L>(jPop+1);
162 normI = util::sqrt( c<L>(iPop+1)*c<L>(iPop+1) );
163 normJ = util::sqrt( c<L>(jPop+1)*c<L>(jPop+1) );
164 angleProb[iPop][jPop] = dotProduct / (normI*normJ);
165 }
166 }
167
168 for (int i=0; i<q; i++) {
169 for (int j=0; j<q; j++) {
170 phi[i][j]=1.0;
171 }
172 }
173
174 for ( int i = 0; i < nn; i++ ) {
175 solution[i] = 0;
176 };
177
178 int iter;
179 double U[mm][nn];
180 double U_array[nn*mm];
181 std::vector<double> anisoIterVector = linespace( stepsize, 0, anisotropyFactor );
182
183 // additional condition only for unit testing
184 size_t index = 0;
185 for ( ; index < anisoIterVector.size() && index != (std::size_t)(breakAfter); index++) {
186 // wipe matrices and vectors
187 for (int m = 0; m < mm; m++) {
188 for (int n = 0; n < nn; n++) {
189 U[m][n] = 0;
190 }
191 }
192
193 // compute matrix U, iter handels symmetry
194 iter = 0;
195 for (int m=0; m<q; m++) {
196 for (int n=m; n<q; n++) {
197 U[m][iter] = t<double,L>(m+1)*phi[n][m];
198 U[n][iter] = t<double,L>(n+1)*phi[m][n];
199 U[m+q][iter] = t<double,L>(m+1)*phi[n][m]*angleProb[n][m];
200 U[n+q][iter] = t<double,L>(n+1)*phi[m][n]*angleProb[m][n];
201 iter++;
202 }
203 }
204
205 double sum1;
206 double sum2;
207 // compute vector b
208 for (int n=0; n<q; n++) {
209 // get sum
210 sum1 = 0;
211 sum2 = 0;
212 for (int k=0; k<q; k++) {
213 sum1 += t<double,L>(k+1)*phi[k][n];
214 sum2 += t<double,L>(k+1)*phi[k][n]*angleProb[k][n];
215 }
216 solution[n] = 1 - sum1;
217 solution[q+n] = anisoIterVector[index] - sum2;
218 }
219
220 // transform 2d array to 1d array, column major
221 for ( int n = 0; n < nn; ++n) {
222 for ( int m = 0; m < mm; ++m ) {
223 U_array[n*mm +m] = U[m][n];
224 }
225 }
226
227 //util::print(b, nn, "b");
228
229 // solve Ax = QRx = R'Q'x = b
230 // equiv x = Q*R'\x
231 LAPACKE_dgels( LAPACK_COL_MAJOR, 'N', mm,
232 nn, 1, U_array,
233 mm, solution, nn);
234 //util::print(b, nn, "b after");
235
236 iter = 0;
237 for (int m=0; m<q; m++) {
238 for (int n=m; n<q; n++) {
239 phi[n][m] = phi[n][m]*(1+solution[iter]);
240 phi[m][n] = phi[n][m];
241 iter++;
242 }
243 }
244 //util::print( testEnergyConservationColumn<q>(phi,L::t), "colum sum elementwise" );
245 //util::print( testEnergyConservationRow<q>(phi,L::t), "row sum elementwise" );
246 //util::print( testEnergyConservationSec<q>(phi,L::t,angleProb), "second Moment" );
247 }
248 clout << "Terminate after " << index << " iterations" << std::endl;
249#endif
250}
constexpr T m(unsigned iPop, unsigned jPop, tag::MRT)
Definition mrt.h:386
std::vector< double > linespace(double const stepsize, double const a, double const b)
Computes vector [a, a+stepsize, a+2*stepsize, ..., b].
Definition anisoDiscr.h:109

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.

256{
257 OstreamManager clout( std::cout, "AnisotropyMatrix_KimAndLee" );
258 clout << "Compute anisotropy matrix ..." << std::endl;
259 typedef DESCRIPTOR L;
260 int const q = L::q;
261
262 // qxq matrix 0th row and 0th column are empty
263 std::array<std::array<double,q>, q> cosTheta;
264 double dotProduct;
265 double normI;
266 double normJ;
267 for (int iPop=0; iPop<q; iPop++) {
268 for (int jPop=0; jPop<q; jPop++) {
269 dotProduct = descriptors::c<L>(iPop) * descriptors::c<L>(jPop);
270 normI = util::sqrt( util::normSqr<int,3>(descriptors::c<L>(iPop)) );
271 normJ = util::sqrt( util::normSqr<int,3>(descriptors::c<L>(jPop)) );
272 cosTheta[iPop][jPop] = dotProduct /(normI*normJ);
273 if ( util::normSqr<int,3>(descriptors::c<L>(iPop)) == 0 || util::normSqr<int,3>(descriptors::c<L>(jPop)) == 0) {
274 cosTheta[iPop][jPop] = 0.0;
275 }
276 }
277 }
278
279 std::array<std::array<double,q>, q> phaseFunction;
280 for (int m=0; m<q; m++) {
281 for (int n=0; n<q; n++) {
282 phaseFunction[m][n] = henyeyGreenstein(cosTheta[m][n], anisotropyFactor);
283 }
284 }
285
286 for (int m=0; m<q; m++) {
287 for (int n=0; n<q; n++) {
288 dotProduct = 0;
289 for (int i = 0; i < q; ++i) {
290 dotProduct += phaseFunction[m][i]*descriptors::t<double,L>(i);
291 }
292 phi[m][n] = phaseFunction[m][n] / dotProduct;
293 }
294 }
295 //util::print( testEnergyConservationColumn<q>(phi,L::t), "colum sum elementwise" );
296 //util::print( testEnergyConservationRow<q>(phi,L::t), "row sum elementwise" );
297 //util::print( testAnisotropyConservationColumn<q>(phi,L::t,cosTheta), "anisotropyConservation Moment" );
298}
T dotProduct(const std::vector< T > &a, const std::vector< T > &b)
double henyeyGreenstein(double cosTheta, double g)
Function to compute Henyey Greenstein phase funtion.
Definition anisoDiscr.h:55

References olb::descriptors::c(), henyeyGreenstein(), olb::util::normSqr(), olb::util::sqrt(), and olb::descriptors::t().

+ Here is the call graph for this function:

◆ computeBoundaryTypeAndNormal() [1/2]

template<concepts::BaseType T>
std::pair< DiscreteNormalType, Vector< int, 2 > > olb::computeBoundaryTypeAndNormal ( BlockIndicatorF2D< T > & fluidI,
BlockIndicatorF2D< T > & outsideI,
Vector< int, 2 > latticeR )

Returns type (e.g. edge / corner) and discrete normal in 2D.

boundary0N and boundary 0P

boundary1N and boundary1P

externalCornerNN and externalCornerNP

externalCornerPN and externalCornerPP

internalCornerNN and internalCornerNP

internalCornerPN and internalCornerPP

boundary0N and boundary 0P

boundary1N and boundary1P

externalCornerNN and externalCornerNP

externalCornerPN and externalCornerPP

internalCornerNN and internalCornerNP

internalCornerPN and internalCornerPP

Definition at line 31 of file discreteNormals.hh.

35{
36 const int iX = latticeR[0];
37 const int iY = latticeR[1];
38
39 std::vector<int> discreteNormal(3, 0);
40
41 if (!fluidI({iX, iY})
42 && !outsideI({iX, iY})) {
43
45 if (!fluidI({iX, iY + 1})
46 && !outsideI({iX, iY + 1})
47 && !fluidI({iX, iY - 1})
48 && !outsideI({iX, iY - 1})) {
49
50 if (fluidI({iX + 1, iY})) {
51 discreteNormal[0] = 0;
52 discreteNormal[1] = -1;
53 discreteNormal[2] = 0;
54 }
55
56 if (fluidI({iX - 1, iY})) {
57 discreteNormal[0] = 0;
58 discreteNormal[1] = 1;
59 discreteNormal[2] = 0;
60 }
61 }
62
64 if (!fluidI({iX + 1, iY})
65 && !outsideI({iX + 1, iY})
66 && !fluidI({iX - 1, iY})
67 && !outsideI({iX - 1, iY})) {
68
69 if (fluidI({iX, iY + 1})) {
70 discreteNormal[0] = 0;
71 discreteNormal[1] = 0;
72 discreteNormal[2] = -1;
73 }
74
75 if (fluidI({iX, iY - 1})) {
76 discreteNormal[0] = 0;
77 discreteNormal[1] = 0;
78 discreteNormal[2] = 1;
79 }
80 }
81
83 if ( !fluidI({iX + 1, iY})
84 && !outsideI({iX + 1, iY})) {
85
86 if (!fluidI({iX, iY + 1})
87 && !outsideI({iX, iY + 1})
88 && fluidI({iX + 1, iY + 1})) {
89 discreteNormal[0] = 1;
90 discreteNormal[1] = -1;
91 discreteNormal[2] = -1;
92 }
93
94 if (!fluidI({iX, iY - 1})
95 && !outsideI({iX, iY - 1})
96 && fluidI({iX + 1, iY - 1})) {
97 discreteNormal[0] = 1;
98 discreteNormal[1] = -1;
99 discreteNormal[2] = 1;
100 }
101 }
102
104 if (!fluidI({iX - 1, iY})
105 && !outsideI({iX - 1, iY})) {
106
107 if (!fluidI({iX, iY + 1})
108 && !outsideI({iX, iY + 1})
109 && fluidI({iX - 1, iY + 1})) {
110 discreteNormal[0] = 1;
111 discreteNormal[1] = 1;
112 discreteNormal[2] = -1;
113 }
114
115 if (!fluidI({iX, iY - 1})
116 && !outsideI({iX, iY - 1})
117 && fluidI({iX - 1, iY - 1})) {
118 discreteNormal[0] = 1;
119 discreteNormal[1] = 1;
120 discreteNormal[2] = 1;
121 }
122 }
123
125 if (!fluidI({iX - 1, iY})
126 && !outsideI({iX - 1, iY})) {
127
128 if (!fluidI({iX, iY - 1})
129 && !outsideI({iX, iY - 1})
130 && (outsideI({iX - 1, iY - 1}) || !fluidI({iX - 1, iY - 1}))
131 && fluidI({iX + 1, iY + 1})) {
132 discreteNormal[0] = 2;
133 discreteNormal[1] = -1;
134 discreteNormal[2] = -1;
135 }
136
137 if (!fluidI({iX, iY + 1})
138 && !outsideI({iX, iY + 1})
139 && (outsideI({iX - 1, iY + 1}) || !fluidI({iX - 1, iY + 1}))
140 && fluidI({iX + 1, iY - 1})) {
141 discreteNormal[0] = 2;
142 discreteNormal[1] = -1;
143 discreteNormal[2] = 1;
144 }
145 }
146
148 if (!fluidI({iX + 1, iY})
149 && !outsideI({iX + 1, iY})) {
150
151 if (!fluidI({iX, iY - 1})
152 && !outsideI({iX, iY - 1})
153 && (outsideI({iX + 1, iY - 1}) || !fluidI({iX + 1, iY - 1}))
154 && fluidI({iX - 1, iY + 1})) {
155 discreteNormal[0] = 2;
156 discreteNormal[1] = 1;
157 discreteNormal[2] = -1;
158 }
159
160 if (!fluidI({iX, iY + 1})
161 && !outsideI({iX, iY + 1})
162 && (outsideI({iX + 1, iY + 1}) || !fluidI({iX + 1, iY + 1}))
163 && fluidI({iX - 1, iY - 1})) {
164 discreteNormal[0] = 2;
165 discreteNormal[1] = 1;
166 discreteNormal[2] = 1;
167 }
168 }
169 }
170
171 return {static_cast<DiscreteNormalType>(discreteNormal[0]), discreteNormal.data()+1};
172}
DiscreteNormalType
Type associated with a discrete normal vector.
+ Here is the caller graph for this function:

◆ computeBoundaryTypeAndNormal() [2/2]

template<concepts::BaseType T>
std::pair< DiscreteNormalType, Vector< int, 3 > > olb::computeBoundaryTypeAndNormal ( BlockIndicatorF3D< T > & fluidI,
BlockIndicatorF3D< T > & outsideI,
Vector< int, 3 > latticeR )

Returns type (e.g. edge / corner) and discrete normal in 3D.

Definition at line 176 of file discreteNormals.hh.

180{
181 const int iX = latticeR[0];
182 const int iY = latticeR[1];
183 const int iZ = latticeR[2];
184
185 std::vector<int> discreteNormal(4,0);
186 std::vector<int> discreteNormal2(4,0);
187 std::vector<int> nullVector(4,0);
188
189 if ( !fluidI({iX, iY, iZ})
190 && !outsideI({iX, iY, iZ})) {
191
192 //boundary0N and boundary 0P
193 if ( !fluidI({iX, iY, iZ + 1})
194 && !outsideI({iX, iY, iZ + 1})
195 && !fluidI({iX, iY, iZ - 1})
196 && !outsideI({iX, iY, iZ - 1})
197 && !fluidI({iX, iY + 1, iZ})
198 && !outsideI({iX, iY + 1, iZ})
199 && !fluidI({iX, iY - 1, iZ})
200 && !outsideI({iX, iY - 1, iZ})) {
201
202 if (fluidI({iX + 1, iY, iZ})) {
203 if (discreteNormal == nullVector) {
204 discreteNormal[0] = 0;
205 discreteNormal[1] = -1;
206 discreteNormal[2] = 0;
207 discreteNormal[3] = 0;
208 }
209 else {
210 discreteNormal2[0] = 0;
211 discreteNormal2[1] = -1;
212 discreteNormal2[2] = 0;
213 discreteNormal2[3] = 0;
214 }
215 }
216
217 if (fluidI({iX - 1, iY, iZ})) {
218 if (discreteNormal == nullVector) {
219 discreteNormal[0] = 0;
220 discreteNormal[1] = 1;
221 discreteNormal[2] = 0;
222 discreteNormal[3] = 0;
223 }
224 else {
225 discreteNormal2[0] = 0;
226 discreteNormal2[1] = 1;
227 discreteNormal2[2] = 0;
228 discreteNormal2[3] = 0;
229 }
230 }
231 }
232
233 // boundary1N and boundary1P
234 if ( !fluidI({iX, iY, iZ + 1})
235 && !outsideI({iX, iY, iZ + 1})
236 && !fluidI({iX, iY, iZ - 1})
237 && !outsideI({iX, iY, iZ - 1})
238 && !fluidI({iX + 1, iY, iZ})
239 && !outsideI({iX + 1, iY, iZ})
240 && !fluidI({iX - 1, iY, iZ})
241 && !outsideI({iX - 1, iY, iZ})) {
242
243 if (fluidI({iX, iY + 1, iZ})) {
244 if (discreteNormal == nullVector) {
245 discreteNormal[0] = 0;
246 discreteNormal[1] = 0;
247 discreteNormal[2] = -1;
248 discreteNormal[3] = 0;
249 }
250 else {
251 discreteNormal2[0] = 0;
252 discreteNormal2[1] = 0;
253 discreteNormal2[2] = -1;
254 discreteNormal2[3] = 0;
255 }
256 }
257
258 if (fluidI({iX, iY - 1, iZ})) {
259 if (discreteNormal == nullVector) {
260 discreteNormal[0] = 0;
261 discreteNormal[1] = 0;
262 discreteNormal[2] = 1;
263 discreteNormal[3] = 0;
264 }
265 else {
266 discreteNormal2[0] = 0;
267 discreteNormal2[1] = 0;
268 discreteNormal2[2] = 1;
269 discreteNormal2[3] = 0;
270 }
271 }
272 }
273
274 // boundary2N and boundary2P
275 if (!fluidI({iX + 1, iY, iZ})
276 && !outsideI({iX + 1, iY, iZ})
277 && !fluidI({iX - 1, iY, iZ})
278 && !outsideI({iX - 1, iY, iZ})
279 && !fluidI({iX, iY + 1, iZ})
280 && !outsideI({iX, iY + 1, iZ})
281 && !fluidI({iX, iY - 1, iZ})
282 && !outsideI({iX, iY - 1, iZ})) {
283
284 if (fluidI({iX, iY, iZ + 1})) {
285 if (discreteNormal == nullVector) {
286 discreteNormal[0] = 0;
287 discreteNormal[1] = 0;
288 discreteNormal[2] = 0;
289 discreteNormal[3] = -1;
290 }
291 else {
292 discreteNormal2[0] = 0;
293 discreteNormal2[1] = 0;
294 discreteNormal2[2] = 0;
295 discreteNormal2[3] = -1;
296 }
297 }
298
299 if (fluidI({iX, iY, iZ - 1})) {
300 if (discreteNormal == nullVector) {
301 discreteNormal[0] = 0;
302 discreteNormal[1] = 0;
303 discreteNormal[2] = 0;
304 discreteNormal[3] = 1;
305 }
306 else {
307 discreteNormal2[0] = 0;
308 discreteNormal2[1] = 0;
309 discreteNormal2[2] = 0;
310 discreteNormal2[3] = 1;
311 }
312 }
313 }
314
315 // externalCornerNNN and externalCornerNPN
316 if ( !fluidI({iX + 1, iY, iZ})
317 && !outsideI({iX + 1, iY, iZ})
318 && !fluidI({iX, iY, iZ + 1})
319 && !outsideI({iX, iY, iZ + 1})
320 && !fluidI({iX + 1, iY, iZ + 1})
321 && !outsideI({iX + 1, iY, iZ + 1})) {
322
323 if ( !fluidI({iX, iY + 1, iZ})
324 && !outsideI({iX, iY + 1, iZ})
325 && !fluidI({iX + 1, iY + 1, iZ})
326 && !outsideI({iX + 1, iY + 1, iZ})
327 && !fluidI({iX, iY + 1, iZ + 1})
328 && !outsideI({iX, iY + 1, iZ + 1})
329 && fluidI({iX + 1, iY + 1, iZ + 1})) {
330
331 if (discreteNormal == nullVector) {
332 discreteNormal[0] = 1;
333 discreteNormal[1] = -1;
334 discreteNormal[2] = -1;
335 discreteNormal[3] = -1;
336 }
337 else {
338 discreteNormal2[0] = 1;
339 discreteNormal2[1] = -1;
340 discreteNormal2[2] = -1;
341 discreteNormal2[3] = -1;
342 }
343 }
344
345 if ( !fluidI({iX, iY - 1, iZ})
346 && !outsideI({iX, iY - 1, iZ})
347 && !fluidI({iX + 1, iY - 1, iZ})
348 && !outsideI({iX + 1, iY - 1, iZ})
349 && !fluidI({iX, iY - 1, iZ + 1})
350 && !outsideI({iX, iY - 1, iZ + 1})
351 && fluidI({iX + 1, iY - 1, iZ + 1})) {
352
353 if (discreteNormal == nullVector) {
354 discreteNormal[0] = 1;
355 discreteNormal[1] = -1;
356 discreteNormal[2] = 1;
357 discreteNormal[3] = -1;
358 }
359 else {
360 discreteNormal2[0] = 1;
361 discreteNormal2[1] = -1;
362 discreteNormal2[2] = 1;
363 discreteNormal2[3] = -1;
364 }
365 }
366 }
367
368 // externalCornerNPP and externalCornerNNP
369 if ( !fluidI({iX + 1, iY, iZ})
370 && !outsideI({iX + 1, iY, iZ})
371 && !fluidI({iX, iY, iZ - 1})
372 && !outsideI({iX, iY, iZ - 1})
373 && !fluidI({iX + 1, iY, iZ - 1})
374 && !outsideI({iX + 1, iY, iZ - 1})) {
375
376 if ( !fluidI({iX, iY - 1, iZ})
377 && !outsideI({iX, iY - 1, iZ})
378 && !fluidI({iX + 1, iY - 1, iZ})
379 && !outsideI({iX + 1, iY - 1, iZ})
380 && !fluidI({iX, iY - 1, iZ - 1})
381 && !outsideI({iX, iY - 1, iZ - 1})
382 && fluidI({iX + 1, iY - 1, iZ - 1})) {
383
384 if (discreteNormal == nullVector) {
385 discreteNormal[0] = 1;
386 discreteNormal[1] = -1;
387 discreteNormal[2] = 1;
388 discreteNormal[3] = 1;
389 }
390 else {
391 discreteNormal2[0] = 1;
392 discreteNormal2[1] = -1;
393 discreteNormal2[2] = 1;
394 discreteNormal2[3] = 1;
395 }
396 }
397
398 if ( !fluidI({iX, iY + 1, iZ})
399 && !outsideI({iX, iY + 1, iZ})
400 && !fluidI({iX + 1, iY + 1, iZ})
401 && !outsideI({iX + 1, iY + 1, iZ})
402 && !fluidI({iX, iY + 1, iZ - 1})
403 && !outsideI({iX, iY + 1, iZ - 1})
404 && fluidI({iX + 1, iY + 1, iZ - 1})) {
405
406 if (discreteNormal == nullVector) {
407 discreteNormal[0] = 1;
408 discreteNormal[1] = -1;
409 discreteNormal[2] = -1;
410 discreteNormal[3] = 1;
411 }
412
413 else {
414 discreteNormal2[0] = 1;
415 discreteNormal2[1] = -1;
416 discreteNormal2[2] = -1;
417 discreteNormal2[3] = 1;
418 }
419 }
420 }
421
422 // externalCornerPPP and externalCornerPNP
423 if ( !fluidI({iX - 1, iY, iZ})
424 && !outsideI({iX - 1, iY, iZ})
425 && !fluidI({iX, iY, iZ - 1})
426 && !outsideI({iX, iY, iZ - 1})
427 && !fluidI({iX - 1, iY, iZ - 1})
428 && !outsideI({iX - 1, iY, iZ - 1})) {
429
430 if ( !fluidI({iX, iY - 1, iZ})
431 && !outsideI({iX, iY - 1, iZ})
432 && !fluidI({iX, iY - 1, iZ - 1})
433 && !outsideI({iX, iY - 1, iZ - 1})
434 && !fluidI({iX - 1, iY - 1, iZ})
435 && !outsideI({iX - 1, iY - 1, iZ})
436 && fluidI({iX - 1, iY - 1, iZ - 1})) {
437
438 if (discreteNormal == nullVector) {
439 discreteNormal[0] = 1;
440 discreteNormal[1] = 1;
441 discreteNormal[2] = 1;
442 discreteNormal[3] = 1;
443 }
444 else {
445 discreteNormal2[0] = 1;
446 discreteNormal2[1] = 1;
447 discreteNormal2[2] = 1;
448 discreteNormal2[3] = 1;
449 }
450 }
451
452 if ( !fluidI({iX, iY + 1, iZ})
453 && !outsideI({iX, iY + 1, iZ})
454 && !fluidI({iX, iY + 1, iZ - 1})
455 && !outsideI({iX, iY + 1, iZ - 1})
456 && !fluidI({iX - 1, iY + 1, iZ})
457 && !outsideI({iX - 1, iY + 1, iZ})
458 && fluidI({iX - 1, iY + 1, iZ - 1})) {
459
460 if (discreteNormal == nullVector) {
461 discreteNormal[0] = 1;
462 discreteNormal[1] = 1;
463 discreteNormal[2] = -1;
464 discreteNormal[3] = 1;
465 }
466 else {
467 discreteNormal2[0] = 1;
468 discreteNormal2[1] = 1;
469 discreteNormal2[2] = -1;
470 discreteNormal2[3] = 1;
471 }
472 }
473 }
474
475 // externalCornerPNN and externalCornerPPN
476 if ( !fluidI({iX - 1, iY, iZ})
477 && !outsideI({iX - 1, iY, iZ})
478 && !fluidI({iX, iY, iZ + 1})
479 && !outsideI({iX, iY, iZ + 1})
480 && !fluidI({iX - 1, iY, iZ + 1})
481 && !outsideI({iX - 1, iY, iZ + 1})) {
482
483 if ( !fluidI({iX, iY + 1, iZ})
484 && !outsideI({iX, iY + 1, iZ})
485 && !fluidI({iX, iY + 1, iZ + 1})
486 && !outsideI({iX, iY + 1, iZ + 1})
487 && !fluidI({iX - 1, iY + 1, iZ})
488 && !outsideI({iX - 1, iY + 1, iZ})
489 && fluidI({iX - 1, iY + 1, iZ + 1})) {
490
491 if (discreteNormal == nullVector) {
492 discreteNormal[0] = 1;
493 discreteNormal[1] = 1;
494 discreteNormal[2] = -1;
495 discreteNormal[3] = -1;
496 }
497 else {
498 discreteNormal2[0] = 1;
499 discreteNormal2[1] = 1;
500 discreteNormal2[2] = -1;
501 discreteNormal2[3] = -1;
502 }
503 }
504
505 if ( !fluidI({iX, iY - 1, iZ})
506 && !outsideI({iX, iY - 1, iZ})
507 && !fluidI({iX, iY - 1, iZ + 1})
508 && !outsideI({iX, iY - 1, iZ + 1})
509 && !fluidI({iX - 1, iY - 1, iZ})
510 && !outsideI({iX - 1, iY - 1, iZ})
511 && fluidI({iX - 1, iY - 1, iZ + 1})) {
512
513 if (discreteNormal == nullVector) {
514
515 discreteNormal[0] = 1;
516 discreteNormal[1] = 1;
517 discreteNormal[2] = 1;
518 discreteNormal[3] = -1;
519 }
520
521 else {
522 discreteNormal2[0] = 1;
523 discreteNormal2[1] = 1;
524 discreteNormal2[2] = 1;
525 discreteNormal2[3] = -1;
526 }
527 }
528 }
529
530 // internalCornerPPP and internalCornerPNP
531 if ( fluidI({iX - 1, iY, iZ})
532 && fluidI({iX, iY, iZ - 1})
533 && !fluidI({iX, iY, iZ + 1})
534 && !outsideI({iX, iY, iZ + 1})
535 && !fluidI({iX + 1, iY, iZ})
536 && !outsideI({iX + 1, iY, iZ})) {
537
538 if ( fluidI({iX, iY - 1, iZ})
539 && !fluidI({iX, iY + 1, iZ})
540 && !outsideI({iX, iY + 1, iZ})) {
541
542 if (discreteNormal == nullVector) {
543 discreteNormal[0] = 2;
544 discreteNormal[1] = 1;
545 discreteNormal[2] = 1;
546 discreteNormal[3] = 1;
547 }
548 else {
549 discreteNormal2[0] = 2;
550 discreteNormal2[1] = 1;
551 discreteNormal2[2] = 1;
552 discreteNormal2[3] = 1;
553 }
554 }
555
556 if ( fluidI({iX, iY + 1, iZ})
557 && !fluidI({iX, iY - 1, iZ})
558 && !outsideI({iX, iY - 1, iZ})) {
559
560 if (discreteNormal == nullVector) {
561 discreteNormal[0] = 2;
562 discreteNormal[1] = 1;
563 discreteNormal[2] = -1;
564 discreteNormal[3] = 1;
565 }
566
567 else {
568 discreteNormal2[0] = 2;
569 discreteNormal2[1] = 1;
570 discreteNormal2[2] = -1;
571 discreteNormal2[3] = 1;
572 }
573 }
574 }
575
576 // internalCornerPNN and InternalCornerPPN
577 if ( fluidI({iX - 1, iY, iZ})
578 && fluidI({iX, iY, iZ + 1})
579 && !fluidI({iX, iY, iZ - 1})
580 && !outsideI({iX, iY, iZ - 1})
581 && !fluidI({iX + 1, iY, iZ})
582 && !outsideI({iX + 1, iY, iZ})) {
583
584 if ( fluidI({iX, iY + 1, iZ})
585 && !fluidI({iX, iY - 1, iZ})
586 && !outsideI({iX, iY - 1, iZ})) {
587
588 if (discreteNormal == nullVector) {
589 discreteNormal[0] = 2;
590 discreteNormal[1] = 1;
591 discreteNormal[2] = -1;
592 discreteNormal[3] = -1;
593 }
594 else {
595 discreteNormal2[0] = 2;
596 discreteNormal2[1] = 1;
597 discreteNormal2[2] = -1;
598 discreteNormal2[3] = -1;
599 }
600 }
601
602 if ( fluidI({iX, iY - 1, iZ})
603 && !fluidI({iX, iY + 1, iZ})
604 && !outsideI({iX, iY + 1, iZ})) {
605
606 if (discreteNormal == nullVector) {
607 discreteNormal[0] = 2;
608 discreteNormal[1] = 1;
609 discreteNormal[2] = 1;
610 discreteNormal[3] = -1;
611 }
612 else {
613 discreteNormal2[0] = 2;
614 discreteNormal2[1] = 1;
615 discreteNormal2[2] = 1;
616 discreteNormal2[3] = -1;
617 }
618 }
619 }
620
621 // internalCornerNPP and internalCornerNNP
622 if ( fluidI({iX + 1, iY, iZ})
623 && fluidI({iX, iY, iZ - 1})
624 && !fluidI({iX - 1, iY, iZ})
625 && !outsideI({iX - 1, iY, iZ})
626 && !fluidI({iX, iY, iZ + 1})
627 && !outsideI({iX, iY, iZ + 1})) {
628
629 if ( fluidI({iX, iY - 1, iZ})
630 && !fluidI({iX, iY + 1, iZ})
631 && !outsideI({iX, iY + 1, iZ})) {
632
633 if (discreteNormal == nullVector) {
634 discreteNormal[0] = 2;
635 discreteNormal[1] = -1;
636 discreteNormal[2] = 1;
637 discreteNormal[3] = 1;
638 }
639 else {
640 discreteNormal2[0] = 2;
641 discreteNormal2[1] = -1;
642 discreteNormal2[2] = 1;
643 discreteNormal2[3] = 1;
644 }
645 }
646
647 if ( fluidI({iX, iY + 1, iZ})
648 && !fluidI({iX, iY - 1, iZ})
649 && !outsideI({iX, iY - 1, iZ})) {
650
651 if (discreteNormal == nullVector) {
652 discreteNormal[0] = 2;
653 discreteNormal[1] = -1;
654 discreteNormal[2] = -1;
655 discreteNormal[3] = 1;
656 }
657
658 else {
659 discreteNormal2[0] = 2;
660 discreteNormal2[1] = -1;
661 discreteNormal2[2] = -1;
662 discreteNormal2[3] = 1;
663 }
664 }
665 }
666
667 // internalCornerNPN and internalCornerNNN
668 if ( fluidI({iX + 1, iY, iZ})
669 && fluidI({iX, iY, iZ + 1})
670 && !fluidI({iX - 1, iY, iZ})
671 && !outsideI({iX - 1, iY, iZ})
672 && !fluidI({iX, iY, iZ - 1})
673 && !outsideI({iX, iY, iZ - 1})) {
674
675 if ( fluidI({iX, iY - 1, iZ})
676 && !fluidI({iX, iY + 1, iZ})
677 && !outsideI({iX, iY + 1, iZ})) {
678
679 if (discreteNormal == nullVector) {
680 discreteNormal[0] = 2;
681 discreteNormal[1] = -1;
682 discreteNormal[2] = 1;
683 discreteNormal[3] = -1;
684 }
685
686 else {
687 discreteNormal2[0] = 2;
688 discreteNormal2[1] = -1;
689 discreteNormal2[2] = 1;
690 discreteNormal2[3] = -1;
691 }
692 }
693
694 if ( fluidI({iX, iY + 1, iZ})
695 && !fluidI({iX, iY - 1, iZ})
696 && !outsideI({iX, iY - 1, iZ})) {
697
698 if (discreteNormal == nullVector) {
699 discreteNormal[0] = 2;
700 discreteNormal[1] = -1;
701 discreteNormal[2] = -1;
702 discreteNormal[3] = -1;
703 }
704 else {
705 discreteNormal2[0] = 2;
706 discreteNormal2[1] = -1;
707 discreteNormal2[2] = -1;
708 discreteNormal2[3] = -1;
709 }
710 }
711 }
712
713 // externalEdge0PN and externalEdge0NN
714 if ( !fluidI({iX - 1, iY, iZ})
715 && !outsideI({iX - 1, iY, iZ})
716 && !fluidI({iX + 1, iY, iZ})
717 && !outsideI({iX + 1, iY, iZ})
718 && !fluidI({iX, iY, iZ + 1})
719 && !outsideI({iX, iY, iZ + 1})
720 && !fluidI({iX + 1, iY, iZ + 1})
721 && !fluidI({iX - 1, iY, iZ + 1})) {
722
723 if ( fluidI({iX, iY - 1, iZ + 1})
724 && !fluidI({iX, iY - 1, iZ})
725 && !outsideI({iX, iY - 1, iZ})) {
726
727 if (discreteNormal == nullVector) {
728 discreteNormal[0] = 3;
729 discreteNormal[1] = 0;
730 discreteNormal[2] = 1;
731 discreteNormal[3] = -1;
732 }
733 else {
734 discreteNormal2[0] = 3;
735 discreteNormal2[1] = 0;
736 discreteNormal2[2] = 1;
737 discreteNormal2[3] = -1;
738 }
739 }
740
741 if ( fluidI({iX, iY + 1, iZ + 1})
742 && !fluidI({iX, iY + 1, iZ})
743 && !outsideI({iX, iY + 1, iZ})) {
744
745 if (discreteNormal == nullVector) {
746 discreteNormal[0] = 3;
747 discreteNormal[1] = 0;
748 discreteNormal[2] = -1;
749 discreteNormal[3] = -1;
750 }
751 else {
752 discreteNormal2[0] = 3;
753 discreteNormal2[1] = 0;
754 discreteNormal2[2] = -1;
755 discreteNormal2[3] = -1;
756 }
757 }
758 }
759
760 // externalEdge0NP and externalEdge0PP
761 if ( !fluidI({iX - 1, iY, iZ})
762 && !outsideI({iX - 1, iY, iZ})
763 && !fluidI({iX + 1, iY, iZ})
764 && !outsideI({iX + 1, iY, iZ})
765 && !fluidI({iX, iY, iZ - 1})
766 && !outsideI({iX, iY, iZ - 1})
767 && !fluidI({iX + 1, iY, iZ - 1})
768 && !fluidI({iX - 1, iY, iZ - 1})) {
769
770 if ( fluidI({iX, iY + 1, iZ - 1})
771 && !fluidI({iX, iY + 1, iZ})) {
772 if (discreteNormal == nullVector) {
773 discreteNormal[0] = 3;
774 discreteNormal[1] = 0;
775 discreteNormal[2] = -1;
776 discreteNormal[3] = 1;
777 }
778 else {
779 discreteNormal2[0] = 3;
780 discreteNormal2[1] = 0;
781 discreteNormal2[2] = -1;
782 discreteNormal2[3] = 1;
783 }
784 }
785
786 if ( fluidI({iX, iY - 1, iZ - 1})
787 && !fluidI({iX, iY - 1, iZ})) {
788 if (discreteNormal == nullVector) {
789 discreteNormal[0] = 3;
790 discreteNormal[1] = 0;
791 discreteNormal[2] = 1;
792 discreteNormal[3] = 1;
793 }
794 else {
795 discreteNormal2[0] = 3;
796 discreteNormal2[1] = 0;
797 discreteNormal2[2] = 1;
798 discreteNormal2[3] = 1;
799 }
800 }
801 }
802
803 // externalEdge1NN and externalEdge1NP
804 if ( !fluidI({iX, iY + 1, iZ})
805 && !outsideI({iX, iY + 1, iZ})
806 && !fluidI({iX, iY - 1, iZ})
807 && !outsideI({iX, iY - 1, iZ})
808 && !fluidI({iX, iY, iZ + 1})
809 && !outsideI({iX, iY, iZ + 1})) {
810
811 if ( fluidI({iX + 1, iY, iZ + 1})
812 && !fluidI({iX + 1, iY, iZ})
813 && !outsideI({iX + 1, iY, iZ})
814 && !fluidI({iX - 1, iY, iZ})
815 && !fluidI({iX, iY, iZ - 1})) {
816
817 if (discreteNormal == nullVector) {
818 discreteNormal[0] = 3;
819 discreteNormal[1] = -1;
820 discreteNormal[2] = 0;
821 discreteNormal[3] = -1;
822 }
823 else {
824 discreteNormal2[0] = 3;
825 discreteNormal2[1] = -1;
826 discreteNormal2[2] = 0;
827 discreteNormal2[3] = -1;
828 }
829 }
830
831 if ( fluidI({iX - 1, iY, iZ + 1})
832 && !fluidI({iX - 1, iY, iZ})
833 && !outsideI({iX - 1, iY, iZ})
834 && !fluidI({iX + 1, iY, iZ})
835 && !fluidI({iX, iY, iZ - 1})) {
836
837 if (discreteNormal == nullVector) {
838 discreteNormal[0] = 3;
839 discreteNormal[1] = 1;
840 discreteNormal[2] = 0;
841 discreteNormal[3] = -1;
842 }
843 else {
844 discreteNormal2[0] = 3;
845 discreteNormal2[1] = 1;
846 discreteNormal2[2] = 0;
847 discreteNormal2[3] = -1;
848 }
849 }
850 }
851
852 // externalEdge1PN and externalEdge1PP
853 if ( !fluidI({iX, iY + 1, iZ})
854 && !outsideI({iX, iY + 1, iZ})
855 && !fluidI({iX, iY - 1, iZ})
856 && !outsideI({iX, iY - 1, iZ})
857 && !fluidI({iX, iY, iZ - 1})
858 && !outsideI({iX, iY, iZ - 1})) {
859
860 if ( fluidI({iX + 1, iY, iZ - 1})
861 && !fluidI({iX + 1, iY, iZ})
862 && !outsideI({iX + 1, iY, iZ})
863 && !fluidI({iX - 1, iY, iZ})
864 && !fluidI({iX, iY, iZ + 1})) {
865
866 if (discreteNormal == nullVector) {
867 discreteNormal[0] = 3;
868 discreteNormal[1] = -1;
869 discreteNormal[2] = 0;
870 discreteNormal[3] = 1;
871 }
872 else {
873 discreteNormal2[0] = 3;
874 discreteNormal2[1] = -1;
875 discreteNormal2[2] = 0;
876 discreteNormal2[3] = 1;
877 }
878 }
879
880 if ( fluidI({iX - 1, iY, iZ - 1})
881 && !fluidI({iX - 1, iY, iZ})
882 && !outsideI({iX - 1, iY, iZ})
883 && !fluidI({iX + 1, iY, iZ})
884 && !fluidI({iX, iY, iZ + 1})) {
885
886 if (discreteNormal == nullVector) {
887 discreteNormal[0] = 3;
888 discreteNormal[1] = 1;
889 discreteNormal[2] = 0;
890 discreteNormal[3] = 1;
891 }
892 else {
893 discreteNormal2[0] = 3;
894 discreteNormal2[1] = 1;
895 discreteNormal2[2] = 0;
896 discreteNormal2[3] = 1;
897 }
898 }
899 }
900
901 // externalEdge2NN and externalEdge2PN
902 if ( !fluidI({iX, iY, iZ + 1})
903 && !outsideI({iX, iY, iZ + 1})
904 && !fluidI({iX, iY, iZ - 1})
905 && !outsideI({iX, iY, iZ - 1})
906 && !fluidI({iX, iY + 1, iZ})
907 && !outsideI({iX, iY + 1, iZ})) {
908
909 if ( !fluidI({iX + 1, iY, iZ})
910 && fluidI({iX + 1, iY + 1, iZ})) {
911 if (discreteNormal == nullVector) {
912 discreteNormal[0] = 3;
913 discreteNormal[1] = -1;
914 discreteNormal[2] = -1;
915 discreteNormal[3] = 0;
916 }
917 else {
918 discreteNormal2[0] = 3;
919 discreteNormal2[1] = -1;
920 discreteNormal2[2] = -1;
921 discreteNormal2[3] = 0;
922 }
923 }
924
925 if ( !fluidI({iX - 1, iY, iZ})
926 && fluidI({iX - 1, iY + 1, iZ})) {
927 if (discreteNormal == nullVector) {
928 discreteNormal[0] = 3;
929 discreteNormal[1] = 1;
930 discreteNormal[2] = -1;
931 discreteNormal[3] = 0;
932 }
933 else {
934 discreteNormal2[0] = 3;
935 discreteNormal2[1] = 1;
936 discreteNormal2[2] = -1;
937 discreteNormal2[3] = 0;
938 }
939 }
940 }
941
942 // externalEdge2PP and externalEdge2NP
943 if ( !fluidI({iX, iY, iZ + 1})
944 && !outsideI({iX, iY, iZ + 1})
945 && !fluidI({iX, iY, iZ - 1})
946 && !outsideI({iX, iY, iZ - 1})
947 && !fluidI({iX, iY - 1, iZ})
948 && !outsideI({iX, iY - 1, iZ})) {
949
950 if ( !fluidI({iX - 1, iY, iZ})
951 && fluidI({iX - 1, iY - 1, iZ})) {
952 if (discreteNormal == nullVector) {
953 discreteNormal[0] = 3;
954 discreteNormal[1] = 1;
955 discreteNormal[2] = 1;
956 discreteNormal[3] = 0;
957 }
958 else {
959 discreteNormal2[0] = 3;
960 discreteNormal2[1] = 1;
961 discreteNormal2[2] = 1;
962 discreteNormal2[3] = 0;
963 }
964 }
965
966 if ( !fluidI({iX + 1, iY, iZ})
967 && fluidI({iX + 1, iY - 1, iZ})) {
968 if (discreteNormal == nullVector) {
969 discreteNormal[0] = 3;
970 discreteNormal[1] = -1;
971 discreteNormal[2] = 1;
972 discreteNormal[3] = 0;
973 }
974 else {
975 discreteNormal2[0] = 3;
976 discreteNormal2[1] = -1;
977 discreteNormal2[2] = 1;
978 discreteNormal2[3] = 0;
979 }
980 }
981 }
982
983 // internalEdge0NN and internalEdge0PN
984 if ( !fluidI({iX - 1, iY, iZ})
985 && !outsideI({iX - 1, iY, iZ})
986 && !fluidI({iX + 1, iY, iZ})
987 && !outsideI({iX + 1, iY, iZ})
988 && !fluidI({iX, iY, iZ - 1})
989 && !outsideI({iX, iY, iZ - 1})
990 && fluidI({iX, iY, iZ + 1})) {
991
992 if ( fluidI({iX, iY + 1, iZ})
993 && !fluidI({iX, iY - 1, iZ})
994 && !outsideI({iX, iY - 1, iZ})
995 && !fluidI({iX - 1, iY - 1, iZ})
996 && !outsideI({iX - 1, iY - 1, iZ})
997 && !fluidI({iX + 1, iY - 1, iZ})
998 && !outsideI({iX + 1, iY - 1, iZ})) {
999
1000 discreteNormal[0] = 4;
1001 discreteNormal[1] = 0;
1002 discreteNormal[2] = -1;
1003 discreteNormal[3] = -1;
1004 }
1005 if ( fluidI({iX, iY - 1, iZ})
1006 && !fluidI({iX, iY + 1, iZ})
1007 && !outsideI({iX, iY + 1, iZ})
1008 && !fluidI({iX - 1, iY + 1, iZ})
1009 && !outsideI({iX - 1, iY + 1, iZ})
1010 && !fluidI({iX + 1, iY + 1, iZ})
1011 && !outsideI({iX + 1, iY + 1, iZ})) {
1012
1013 discreteNormal[0] = 4;
1014 discreteNormal[1] = 0;
1015 discreteNormal[2] = 1;
1016 discreteNormal[3] = -1;
1017 }
1018 }
1019
1020 // internalEdge0NP and internalEdge0PP
1021 if ( !fluidI({iX + 1, iY, iZ})
1022 && !outsideI({iX + 1, iY, iZ})
1023 && !fluidI({iX - 1, iY, iZ})
1024 && !outsideI({iX - 1, iY, iZ})
1025 && !fluidI({iX, iY, iZ + 1})
1026 && !outsideI({iX, iY, iZ + 1})
1027 && fluidI({iX, iY, iZ - 1})) {
1028
1029 if ( fluidI({iX, iY + 1, iZ})
1030 && !fluidI({iX - 1, iY - 1, iZ})
1031 && !outsideI({iX - 1, iY - 1, iZ})
1032 && !fluidI({iX, iY - 1, iZ})
1033 && !outsideI({iX, iY - 1, iZ})
1034 && !fluidI({iX + 1, iY - 1, iZ})
1035 && !outsideI({iX + 1, iY - 1, iZ})) {
1036
1037 discreteNormal[0] = 4;
1038 discreteNormal[1] = 0;
1039 discreteNormal[2] = -1;
1040 discreteNormal[3] = 1;
1041 }
1042
1043 if ( fluidI({iX, iY - 1, iZ})
1044 && !fluidI({iX - 1, iY + 1, iZ})
1045 && !outsideI({iX - 1, iY + 1, iZ})
1046 && !fluidI({iX, iY + 1, iZ})
1047 && !outsideI({iX, iY + 1, iZ})
1048 && !fluidI({iX + 1, iY + 1, iZ})
1049 && !outsideI({iX + 1, iY + 1, iZ})) {
1050
1051 discreteNormal[0] = 4;
1052 discreteNormal[1] = 0;
1053 discreteNormal[2] = 1;
1054 discreteNormal[3] = 1;
1055 }
1056 }
1057
1058 // internalEdge1PP and internalEdge 1NP
1059 if ( fluidI({iX - 1, iY, iZ})
1060 && !fluidI({iX + 1, iY, iZ})
1061 && !outsideI({iX + 1, iY, iZ})
1062 && !fluidI({iX, iY + 1, iZ})
1063 && !outsideI({iX, iY + 1, iZ})
1064 && !fluidI({iX, iY - 1, iZ})
1065 && !outsideI({iX, iY - 1, iZ})) {
1066
1067 if ( fluidI({iX, iY, iZ - 1})
1068 && !fluidI({iX, iY, iZ + 1})
1069 && !outsideI({iX, iY, iZ + 1})
1070 && !fluidI({iX, iY + 1, iZ + 1})
1071 && !outsideI({iX, iY + 1, iZ + 1})
1072 && !fluidI({iX, iY - 1, iZ + 1})
1073 && !outsideI({iX, iY - 1, iZ + 1})) {
1074
1075 discreteNormal[0] = 4;
1076 discreteNormal[1] = 1;
1077 discreteNormal[2] = 0;
1078 discreteNormal[3] = 1;
1079 }
1080
1081 if ( fluidI({iX, iY, iZ + 1})
1082 && !fluidI({iX, iY, iZ - 1})
1083 && !outsideI({iX, iY, iZ - 1})
1084 && !fluidI({iX, iY + 1, iZ - 1})
1085 && !outsideI({iX, iY + 1, iZ - 1})
1086 && !fluidI({iX, iY - 1, iZ - 1})
1087 && !outsideI({iX, iY - 1, iZ - 1})) {
1088
1089 discreteNormal[0] = 4;
1090 discreteNormal[1] = 1;
1091 discreteNormal[2] = 0;
1092 discreteNormal[3] = -1;
1093 }
1094 }
1095
1096 // internalEdge1PN and internalEdge1NN
1097 if ( fluidI({iX + 1, iY, iZ})
1098 && !fluidI({iX - 1, iY, iZ})
1099 && !outsideI({iX - 1, iY, iZ})
1100 && !fluidI({iX, iY - 1, iZ})
1101 && !outsideI({iX, iY - 1, iZ})
1102 && !fluidI({iX, iY + 1, iZ})
1103 && !outsideI({iX, iY + 1, iZ})) {
1104
1105 if ( fluidI({iX, iY, iZ - 1})
1106 && !fluidI({iX, iY, iZ + 1})
1107 && !outsideI({iX, iY, iZ + 1})
1108 && !fluidI({iX, iY + 1, iZ + 1})
1109 && !outsideI({iX, iY + 1, iZ + 1})
1110 && !fluidI({iX, iY - 1, iZ + 1})
1111 && !outsideI({iX, iY - 1, iZ + 1})) {
1112
1113 discreteNormal[0] = 4;
1114 discreteNormal[1] = -1;
1115 discreteNormal[2] = 0;
1116 discreteNormal[3] = 1;
1117 }
1118
1119 if ( fluidI({iX, iY, iZ + 1})
1120 && !fluidI({iX, iY, iZ - 1})
1121 && !outsideI({iX, iY, iZ - 1})
1122 && !fluidI({iX, iY + 1, iZ - 1})
1123 && !outsideI({iX, iY + 1, iZ - 1})
1124 && !fluidI({iX, iY - 1, iZ - 1})
1125 && !outsideI({iX, iY - 1, iZ - 1})) {
1126
1127 discreteNormal[0] = 4;
1128 discreteNormal[1] = -1;
1129 discreteNormal[2] = 0;
1130 discreteNormal[3] = -1;
1131 }
1132 }
1133
1134 // internalEdge2PP and internalEdge2NP
1135 if ( fluidI({iX, iY - 1, iZ})
1136 && !fluidI({iX, iY, iZ - 1})
1137 && !outsideI({iX, iY, iZ - 1})
1138 && !fluidI({iX, iY, iZ + 1})
1139 && !outsideI({iX, iY, iZ + 1})
1140 && !fluidI({iX, iY + 1, iZ})
1141 && !outsideI({iX, iY + 1, iZ})) {
1142
1143 if (fluidI({iX - 1, iY, iZ})
1144 && fluidI({iX - 1, iY - 1, iZ})) {
1145
1146 discreteNormal[0] = 4;
1147 discreteNormal[1] = 1;
1148 discreteNormal[2] = 1;
1149 discreteNormal[3] = 0;
1150 }
1151
1152 if ( fluidI({iX + 1, iY, iZ})
1153 && fluidI({iX + 1, iY - 1, iZ})) {
1154
1155 discreteNormal[0] = 4;
1156 discreteNormal[1] = -1;
1157 discreteNormal[2] = 1;
1158 discreteNormal[3] = 0;
1159 }
1160 }
1161
1162 // internalEdge2PN and internalEdge2NN
1163 if ( fluidI({iX, iY + 1, iZ})
1164 && !fluidI({iX, iY, iZ - 1})
1165 && !outsideI({iX, iY, iZ - 1})
1166 && !fluidI({iX, iY, iZ + 1})
1167 && !outsideI({iX, iY, iZ + 1})
1168 && !fluidI({iX, iY - 1, iZ})
1169 && !outsideI({iX, iY - 1, iZ})) {
1170
1171 if ( fluidI({iX - 1, iY, iZ})
1172 && fluidI({iX - 1, iY + 1, iZ})) {
1173
1174 discreteNormal[0] = 4;
1175 discreteNormal[1] = 1;
1176 discreteNormal[2] = -1;
1177 discreteNormal[3] = 0;
1178 }
1179
1180 if ( fluidI({iX + 1, iY, iZ})
1181 && fluidI({iX + 1, iY + 1, iZ})) {
1182
1183 discreteNormal[0] = 4;
1184 discreteNormal[1] = -1;
1185 discreteNormal[2] = -1;
1186 discreteNormal[3] = 0;
1187 }
1188 }
1189 }
1190 return {static_cast<DiscreteNormalType>(discreteNormal[0]), discreteNormal.data()+1};
1191}

◆ constructSharedCoupling()

template<typename COUPLER , typename... MAP>
auto olb::constructSharedCoupling ( COUPLER ,
MAP &&... map )

Definition at line 350 of file superLatticeCoupling.h.

350 {
351 return std::make_shared<SuperLatticeCoupling<
352 COUPLER,
353 typename meta::map<MAP...>::template map_values<descriptors::extract_valued_descriptor_t>
354 >>(COUPLER{}, std::forward<decltype(map)>(map)...);
355}
Coupling operator COUPLER on named COUPLEES.

◆ constructUsingConcretePlatform()

template<typename CONCRETIZABLE , typename... ARGS>
CONCRETIZABLE::base_t * olb::constructUsingConcretePlatform ( Platform platform,
ARGS &&... args )

Definition at line 107 of file dispatch.h.

108{
109 if constexpr (std::is_same_v<typename CONCRETIZABLE::value_t,Expr>) {
110 if (platform != Platform::CPU_SISD) {
111 throw std::domain_error("Only CPU_SISD supports Expr value type");
112 }
113 return new typename CONCRETIZABLE::template type<Platform::CPU_SISD>(std::forward<decltype(args)>(args)...);
114 } else {
115 switch (platform) {
116#ifdef PLATFORM_CPU_SISD
117 case Platform::CPU_SISD:
118 return new typename CONCRETIZABLE::template type<Platform::CPU_SISD>(std::forward<decltype(args)>(args)...);
119#endif
120#ifdef PLATFORM_CPU_SIMD
121 case Platform::CPU_SIMD:
122 return new typename CONCRETIZABLE::template type<Platform::CPU_SIMD>(std::forward<decltype(args)>(args)...);
123#endif
124#ifdef PLATFORM_GPU_CUDA
125 case Platform::GPU_CUDA:
126 return new typename CONCRETIZABLE::template type<Platform::GPU_CUDA>(std::forward<decltype(args)>(args)...);
127#endif
128 default:
129 throw std::invalid_argument("Invalid PLATFORM");
130 }
131 }
132}

References CPU_SIMD, CPU_SISD, and GPU_CUDA.

+ Here is the caller graph for this function:

◆ continueMinimizeByVolume()

template<typename T >
void olb::continueMinimizeByVolume ( CuboidDecomposition< T, 3 > & cGeometry,
IndicatorF3D< T > & indicatorF,
int nC )

Splits largest cuboid by-volume until there are nC cuboids.

Definition at line 37 of file cuboidDecompositionMinimizer.h.

38{
39 cGeometry.shrink(indicatorF);
40
41 while (cGeometry.size() < nC) {
42 // Search for the largest child cuboid
43 T iCVolume[cGeometry.size()];
44 int maxiC = 0;
45 for (int iC = 0; iC < cGeometry.size(); iC++) {
46 iCVolume[iC] = cGeometry.get(iC).getLatticeVolume();
47 if ( iCVolume[iC] > iCVolume[maxiC] ) {
48 maxiC = iC;
49 }
50 }
51
52 // 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
53 auto& largest = cGeometry.get(maxiC);
54 if (largest.getNx() >= largest.getNy() && largest.getNx() >= largest.getNz()) {
55 // clout << "Cut in x direction!" << std::endl;
56 largest.divide({2,1,1}, cGeometry.cuboids());
57 }
58 else if (largest.getNy() >= largest.getNx() && largest.getNy() >= largest.getNz()) {
59 // clout << "Cut in y direction!" << std::endl;
60 largest.divide({1,2,1}, cGeometry.cuboids());
61 }
62 else {
63 // clout << "Cut in z direction!" << std::endl;
64 largest.divide({1,1,2}, cGeometry.cuboids());
65 }
66 cGeometry.remove(maxiC);
67 // shrink the two new cuboids
68 cGeometry.shrink(cGeometry.cuboids().size()-2, indicatorF);
69 cGeometry.shrink(cGeometry.cuboids().size()-1, indicatorF);
70 }
71}
int size() const
Returns number of cuboids in decomposition.
void shrink(int iC, IndicatorF< T, D > &indicatorF)
Shrink cuboid iC so that no empty planes are left.
const Cuboid< T, D > & get(int iC) const
Read access to a single cuboid.
std::vector< Cuboid< T, D > > & cuboids()
void remove(int iC)
Removes the cuboid iC.

References olb::CuboidDecomposition< T, D >::cuboids(), olb::CuboidDecomposition< T, D >::get(), olb::CuboidDecomposition< T, D >::remove(), olb::CuboidDecomposition< T, D >::shrink(), and olb::CuboidDecomposition< T, D >::size().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ convectivelyRefineUnitConverter()

template<typename T , typename DESCRIPTOR >
UnitConverter< T, DESCRIPTOR > olb::convectivelyRefineUnitConverter ( const UnitConverter< T, DESCRIPTOR > & converter,
unsigned scale = 2 )

Definition at line 466 of file unitConverter.h.

469{
470 const T refinementFactor = T{1} / scale;
471 return UnitConverter<T,DESCRIPTOR>(
472 converter.getPhysDeltaX() * refinementFactor,
473 converter.getPhysDeltaT() * refinementFactor,
474 converter.getCharPhysLength(),
475 converter.getCharPhysVelocity(),
476 converter.getPhysViscosity(),
477 converter.getPhysDensity(),
478 converter.getCharPhysPressure()
479 );
480}
constexpr T getCharPhysLength() const
return characteristic length in physical units
constexpr T getPhysDensity() const
return density in physical units
constexpr T getPhysViscosity() const
return viscosity in physical units
constexpr T getCharPhysVelocity() const
return characteristic velocity in physical units
constexpr T getPhysDeltaT() const
returns time spacing (timestep length) in s
constexpr T getCharPhysPressure() const
return characteristic pressure in physical units
constexpr T getPhysDeltaX() const
returns grid spacing (voxel length) in m

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(), olb::UnitConverter< T, DESCRIPTOR >::getPhysDensity(), and olb::UnitConverter< T, DESCRIPTOR >::getPhysViscosity().

+ Here is the call graph for this function:

◆ copyFields()

template<typename FROM , typename TO , typename T_FROM , typename DESCRIPTOR_FROM , typename T_TO , typename DESCRIPTOR_TO >
void olb::copyFields ( SuperLattice< T_FROM, DESCRIPTOR_FROM > & lattice_from,
SuperLattice< T_TO, DESCRIPTOR_TO > & lattice_to )

Copies field data stored in FROM in lattice_from to TO in lattice_to.

Definition at line 62 of file copyFieldsO.h.

63 {
65 names::Lattice{}, lattice_from,
66 names::Lattice2{}, lattice_to);
67 coupling.execute();
68}
void execute()
Execute coupling operation on all blocks.
Simple coupling operator for copying field data between two SuperLattice instances.
Definition copyFieldsO.h:37

References olb::SuperLatticeCoupling< COUPLER, COUPLEES >::execute().

+ Here is the call 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.

39{
40 if (fraction <= 0) {
41 throw std::out_of_range("fracton must be positive.");
42 }
43
44 T conversionViscosityOrDiffusivity = converter.getPhysDeltaX() * converter.getPhysDeltaX() / (converter.getPhysDeltaT() * fraction);
45 T physViscosiyOrDiffusivity = (targetLatticeRelaxationTime - 0.5) * conversionViscosityOrDiffusivity / descriptors::invCs2<T,DESCRIPTOR_AD>();
46
47 return UnitConverter<T,DESCRIPTOR> (
48 converter.getPhysDeltaX() / fraction,
49 converter.getPhysDeltaT() / fraction,
50 converter.getCharPhysLength(),
51 converter.getCharPhysVelocity(),
52 physViscosiyOrDiffusivity,
53 converter.getPhysDensity(),
54 converter.getCharPhysPressure()
55 );
56}

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(), olb::UnitConverter< T, DESCRIPTOR >::getPhysDensity(), and olb::descriptors::invCs2().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ createCuboidDecomposition()

template<typename T , unsigned D>
std::unique_ptr< CuboidDecomposition< T, D > > olb::createCuboidDecomposition ( std::string fileName)

Load CuboidDecomposition from XML File.

Definition at line 1062 of file cuboidDecomposition.hh.

1063{
1064 OstreamManager clout("saveCuboidDecomposition");
1065 XMLreader reader(fileName);
1066
1067 std::vector<T> origin = getDataFromTag<T>(reader["CuboidDecomposition"], "origin", 3);
1068 std::vector<int> extent = getDataFromTag<int>(reader["CuboidDecomposition"], "extent", 3);
1069 T deltaR = getDataFromTag<T>(reader["CuboidDecomposition"], "deltaR", 1)[0];
1070 std::size_t weight = getDataFromTag<size_t>(reader["CuboidDecomposition"], "weight", 1)[0];
1071
1072 auto cGeo = std::make_unique<CuboidDecomposition<T,D>>(origin, deltaR, extent);
1073 cGeo->getMotherCuboid().setWeight(weight);
1074 cGeo->cuboids().clear();
1075
1076 for ( XMLreader* cub: reader["CuboidDecomposition"] ) {
1077 origin = getDataFromTag<T>(*cub, "origin", 3);
1078 extent = getDataFromTag<int>(*cub, "extent", 3);
1079 deltaR = getDataFromTag<T>(*cub, "deltaR", 1)[0];
1080 weight = getDataFromTag<int>(*cub, "weight", 1)[0];
1081
1082 cGeo->cuboids().emplace_back(Cuboid<T,D>(origin, deltaR, extent));
1083 cGeo->get(cGeo->size() - 1).setWeight(weight);
1084 }
1085
1086 return cGeo;
1087}

References getDataFromTag().

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

35{
36 std::stringstream fNameStream;
37 fNameStream << name;
38 return fNameStream.str();
39}
+ 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.

43{
44 std::stringstream fNameStream;
45 fNameStream << name << "_"
46 << "iT" << std::setw(7) << std::setfill('0') << iT ;
47 return fNameStream.str();
48}

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

68{
69 std::stringstream fNameStream;
70 fNameStream << name << "_"
71 << "iT" << std::setw(7) << std::setfill('0') << iT
72 << "iC" << std::setw(5) << std::setfill('0') << iC ;
73 return fNameStream.str();
74}

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

86{
87 std::stringstream fNameStream;
88 fNameStream << name <<"_"<< functor << "iT" << std::setw(7) << std::setfill('0') << iT
89 << "iC" << std::setw(5) << std::setfill('0') << iC ;
90 return fNameStream.str();
91}

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

78{
79 std::stringstream fNameStream;
80 fNameStream << name <<"_"<< functor << "iT" << std::setw(7) << std::setfill('0') << iT;
81 return fNameStream.str();
82}

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

62{
63 return createADfractionalUnitConverter<T,DESCRIPTOR,DESCRIPTOR> (
64 converter, fraction, targetLatticeRelaxationTime );
65}

References createADfractionalUnitConverter().

+ Here is the call graph for this function:

◆ createIndicatorAirfoil2D()

template<typename S >
IndicatorAirfoil2D< S > * olb::createIndicatorAirfoil2D ( XMLreader const & params,
bool verbose )

Definition at line 142 of file indicatorF2D.hh.

143{
144 Vector<S,2> center;
145 S chordLength = 1; // Default chord length
146 S thicknessPercentage = 0.12; // Default thickness percentage
147
148 std::stringstream(params.getAttribute("center")) >> center[0] >> center[1];
149 std::stringstream(params.getAttribute("chord")) >> chordLength;
150
151 return new IndicatorAirfoil2D<S>(center, chordLength, thicknessPercentage);
152}
indicator function for a 2D NACA airfoil

References olb::XMLreader::getAttribute().

+ Here is the call graph for this function:

◆ createIndicatorCircle2D()

template<typename S >
IndicatorCircle2D< S > * olb::createIndicatorCircle2D ( XMLreader const & params,
bool verbose = false )

Definition at line 368 of file indicatorF2D.hh.

369{
370 OstreamManager clout(std::cout,"createIndicatorCircle2D");
371 params.setWarningsOn(verbose);
372
373 Vector<S,2> center;
374 S radius = 1;
375
376 std::stringstream xmlCenter( params.getAttribute("center") );
377 xmlCenter >> center[0] >> center[1];
378 std::stringstream xmlRadius( params.getAttribute("radius") );
379 xmlRadius >> radius;
380
381 return new IndicatorCircle2D<S>(center, radius);
382}
indicator function for a 2D circle

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 911 of file indicatorF3D.hh.

912{
913 OstreamManager clout(std::cout,"createIndicatorCircle3D");
914
915 Vector<S,3> center;
916 Vector<S,3> normal;
917 S radius = 1;
918
919 // params.setWarningsOn(false);
920 params.setWarningsOn(true);
921
922 std::stringstream xmlCenter1( params.getAttribute("center") );
923 xmlCenter1 >> center[0] >> center[1] >> center[2];
924 std::stringstream xmlCenter2( params.getAttribute("normal") );
925 xmlCenter2 >> normal[0] >> normal[1] >> normal[2];
926 std::stringstream xmlRadius( params.getAttribute("radius") );
927 xmlRadius >> radius;
928
929 return std::make_shared<IndicatorCircle3D<S>>(center, normal, radius);
930}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ createIndicatorCone3D()

template<typename S >
std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorCone3D ( XMLreader const & params,
bool verbose = false )

Definition at line 980 of file indicatorF3D.hh.

981{
982 OstreamManager clout(std::cout,"createIndicatorCone3D");
983
984 Vector<S,3> center1;
985 Vector<S,3> center2(S(1), S(1), S(1));
986 S radius1 = S(0);
987 S radius2 = S(1);
988
989 // params.setWarningsOn(false);
990 params.setWarningsOn(true);
991
992 std::stringstream xmlCenter1( params.getAttribute("center1") );
993 xmlCenter1 >> center1[0] >> center1[1] >> center1[2];
994 std::stringstream xmlCenter2( params.getAttribute("center2") );
995 xmlCenter2 >> center2[0] >> center2[1] >> center2[2];
996 std::stringstream xmlRadius1( params.getAttribute("radius1") );
997 xmlRadius1 >> radius1;
998 std::stringstream xmlRadius2( params.getAttribute("radius2") );
999 xmlRadius2 >> radius2;
1000
1001 return std::make_shared<IndicatorCone3D<S>>(center1, center2, radius1, radius2);
1002}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ createIndicatorCuboid2D()

template<typename S >
IndicatorCuboid2D< S > * olb::createIndicatorCuboid2D ( XMLreader const & params,
bool verbose = false )

Definition at line 248 of file indicatorF2D.hh.

249{
250 OstreamManager clout(std::cout,"createIndicatorCuboid2D");
251 params.setWarningsOn(verbose);
252
253 Vector<S,2> center;
254 S xLength;
255 S yLength;
256
257 std::stringstream xmlCenter( params.getAttribute("center") );
258 xmlCenter >> center[0] >> center[1];
259 std::stringstream xmlRadius( params.getAttribute("length") );
260 xmlRadius >> xLength >> yLength;
261
262 return new IndicatorCuboid2D<S>(xLength, yLength, center);
263}
indicator function for a 2D-cuboid, parallel to the planes x=0, y=0; theta rotates cuboid around its ...
Definition aliases.h:253

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 1005 of file indicatorF3D.hh.

1006{
1007 OstreamManager clout(std::cout,"createIndicatorCuboid3D");
1008
1009 Vector<S,3> origin;
1010 Vector<S,3> extend(S(1),S(1),S(1));
1011
1012 // params.setWarningsOn(false);
1013 params.setWarningsOn(true);
1014
1015 std::stringstream xmlOrigin( params.getAttribute("origin") );
1016 xmlOrigin >> origin[0] >> origin[1] >> origin[2];
1017 std::stringstream xmlExtend( params.getAttribute("extend") );
1018 xmlExtend >> extend[0] >> extend[1] >> extend[2];
1019
1020 return std::make_shared<IndicatorCuboid3D<S>>(extend, origin);
1021}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ createIndicatorCylinder3D()

template<typename S >
std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorCylinder3D ( XMLreader const & params,
bool verbose = false )

for debugging purpose

for debugging purpose

Definition at line 953 of file indicatorF3D.hh.

954{
955 OstreamManager clout(std::cout,"createIndicatorCylinder3D");
956
957 Vector<S,3> center1;
958 Vector<S,3> center2(S(1),S(1),S(1));
959 S radius = 1;
960
961 // params.setWarningsOn(false);
962 // params.setWarningsOn(true);
963
964 std::stringstream xmlCenter1( (params).getAttribute("center1") );
965 xmlCenter1 >> center1[0] >> center1[1] >> center1[2];
966 std::stringstream xmlCenter2( (params).getAttribute("center2") );
967 xmlCenter2 >> center2[0] >> center2[1] >> center2[2];
968 std::stringstream xmlRadius( (params).getAttribute("radius") );
969 xmlRadius >> radius;
970
972// print(center1, "center1: ");
973// print(center2, "center2: ");
974// print(radius, "radius: ");
975
976 return std::make_shared<IndicatorCylinder3D<S>>(center1, center2, radius);
977}
+ Here is the caller graph for this function:

◆ createIndicatorEquiTriangle2D()

template<typename S >
IndicatorEquiTriangle2D< S > * olb::createIndicatorEquiTriangle2D ( XMLreader const & params,
bool verbose )

Definition at line 509 of file indicatorF2D.hh.

510{
511 OstreamManager clout(std::cout,"createIndicatorEquiTriangle2D");
512 params.setWarningsOn(verbose);
513
514 Vector<S,2> center;
515 S radius = 1;
516
517 std::stringstream xmlCenter( params.getAttribute("center") );
518 xmlCenter>> center[0] >> center[1];
519 std::stringstream xmlRadius( params.getAttribute("radius") );
520 xmlRadius >> radius;
521
522 return new IndicatorEquiTriangle2D<S>(center, radius);
523}
indicator function for a 2D equilateral triangle

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 1073 of file indicatorF3D.hh.

1074{
1075 OstreamManager clout(std::cout,"createIndicatorF3D");
1076
1077 // clout << "XML element: "<< params.getName() << std::endl;
1078 // params.print(2);
1079
1080 std::string actualName = params.getName();
1081 if ( actualName == "IndicatorCircle3D" ) {
1082 return createIndicatorCircle3D<S>(params);
1083 }
1084 else if ( actualName == "IndicatorSphere3D" ) {
1085 return createIndicatorSphere3D<S>(params);
1086 }
1087 else if ( actualName == "IndicatorCylinder3D" ) {
1088 return createIndicatorCylinder3D<S>(params);
1089 }
1090 else if ( actualName == "IndicatorCone3D" ) {
1091 return createIndicatorCone3D<S>(params);
1092 }
1093 else if ( actualName == "IndicatorCuboid3D" ) {
1094 return createIndicatorCuboid3D<S>(params);
1095 }
1096 else if ( actualName == "IndicatorUnion3D" ) {
1097 return createIndicatorUnion3D<S>(params);
1098 }
1099 else if ( actualName == "IndicatorWithout3D" ) {
1100 return createIndicatorWithout3D<S>(params);
1101 }
1102 else if ( actualName == "IndicatorIntersection3D" ) {
1103 return createIndicatorIntersection3D<S>(params);
1104 }
1105 else {
1106 auto firstChild = params.begin(); // get iterator of childTree
1107 return createIndicatorF3D<S>( **firstChild );
1108 }
1109}

References olb::XMLreader::begin(), createIndicatorCircle3D(), createIndicatorCone3D(), createIndicatorCuboid3D(), createIndicatorCylinder3D(), createIndicatorF3D(), createIndicatorIntersection3D(), createIndicatorSphere3D(), createIndicatorUnion3D(), createIndicatorWithout3D(), and olb::XMLreader::getName().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ createIndicatorIntersection3D()

template<typename S >
std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorIntersection3D ( XMLreader const & params,
bool verbose = false )

Definition at line 1057 of file indicatorF3D.hh.

1058{
1059 OstreamManager clout(std::cout,"createIndicatorIntersection3D");
1060
1061 // clout << "xml position: " << params.getName() << std::endl;
1062 // params.print(2);
1063
1064 std::shared_ptr<IndicatorF3D<S>> output = createIndicatorF3D<S>(**params.begin());
1065 for (auto it = params.begin()+1; it != params.end(); ++it) {
1066 output = output * createIndicatorF3D<S>(**it);
1067 }
1068 return output;
1069}

References olb::XMLreader::begin(), createIndicatorF3D(), and olb::XMLreader::end().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ createIndicatorSphere3D()

template<typename S >
std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorSphere3D ( XMLreader const & params,
bool verbose = false )

Definition at line 933 of file indicatorF3D.hh.

934{
935 OstreamManager clout(std::cout,"createIndicatorSphere3D");
936
937 Vector<S,3> center;
938 S radius = 1;
939
940 // params.setWarningsOn(false);
941 params.setWarningsOn(true);
942
943 std::stringstream xmlCenter1( params.getAttribute("center") );
944 xmlCenter1 >> center[0] >> center[1] >> center[2];
945 std::stringstream xmlRadius( params.getAttribute("radius") );
946 xmlRadius >> radius;
947
948 return std::make_shared<IndicatorSphere3D<S>>(center, radius);
949}

References olb::XMLreader::getAttribute(), and olb::XMLreader::setWarningsOn().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ createIndicatorTriangle2D()

template<typename S >
IndicatorTriangle2D< S > * olb::createIndicatorTriangle2D ( XMLreader const & params,
bool verbose )

Definition at line 430 of file indicatorF2D.hh.

431{
432 OstreamManager clout(std::cout,"createIndicatorTriangle2D");
433 params.setWarningsOn(verbose);
434
435 Vector<S,2> a;
436 Vector<S,2> b;
437 Vector<S,2> c;
438
439 std::stringstream xmla( params.getAttribute("a") );
440 xmla>> a[0] >> a[1];
441 std::stringstream xmlb( params.getAttribute("b") );
442 xmlb >> b[0] >> b[1];
443 std::stringstream xmlc( params.getAttribute("c") );
444 xmlc >> c[0] >> c[1];
445
446 return new IndicatorTriangle2D<S>(a, b, c);
447}
indicator function for a 2D triangle

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 1025 of file indicatorF3D.hh.

1026{
1027 OstreamManager clout(std::cout,"createIndicatorUnion3D");
1028
1029 // clout << "xml position: " << params.getName() << std::endl;
1030 // params.print(2);
1031
1032 std::shared_ptr<IndicatorF3D<S>> output = createIndicatorF3D<S>(**params.begin());
1033 for (auto it = params.begin()+1; it != params.end(); ++it) {
1034 output = output + createIndicatorF3D<S>(**it);
1035 }
1036 return output;
1037}

References olb::XMLreader::begin(), createIndicatorF3D(), and olb::XMLreader::end().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ createIndicatorWithout3D()

template<typename S >
std::shared_ptr< IndicatorF3D< S > > olb::createIndicatorWithout3D ( XMLreader const & params,
bool verbose = false )

Definition at line 1041 of file indicatorF3D.hh.

1042{
1043 OstreamManager clout(std::cout,"createIndicatorWithout3D");
1044
1045 // clout << "xml position: " << params.getName() << std::endl;
1046 // params.print(2);
1047
1048 std::shared_ptr<IndicatorF3D<S>> output = createIndicatorF3D<S>(**params.begin());
1049 for (auto it = params.begin()+1; it != params.end(); ++it) {
1050 output = output - createIndicatorF3D<S>(**it);
1051 }
1052 return output;
1053}

References olb::XMLreader::begin(), createIndicatorF3D(), and olb::XMLreader::end().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ createLbSolver()

template<class SOLVER >
std::shared_ptr< SOLVER > olb::createLbSolver ( XMLreader const & xml)

Definition at line 343 of file lbSolver.h.

344{
345 using parameters_map = typename SOLVER::BaseSolver::Parameters_t;
346 auto paramsTuple = createParametersTuple<parameters_map>(xml);
347 return std::make_shared<SOLVER>(paramsTuple);
348}

References createParametersTuple().

+ Here is the call graph for this function:

◆ createLoadBalancer() [1/2]

template<typename T >
LoadBalancer< T > * olb::createLoadBalancer ( std::string const & fileName,
CuboidDecomposition3D< T > * cGeo = NULL )

Creator Function for LoadBalancer from fileName.

Definition at line 266 of file loadBalancer.h.

267{
268 std::string fname = singleton::directories().getLogOutDir() + fileName + ".xml";
269 XMLreader lbReader(fname);
270 return createLoadBalancer(lbReader["LoadBalancer"], cGeo);
271}
LoadBalancer< T > * createLoadBalancer(XMLreader const &xmlReader, CuboidDecomposition3D< T > *cGeo=NULL)
Creator Function for LoadBalancer from XMLreader.

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,
CuboidDecomposition3D< 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 193 of file loadBalancer.h.

194{
195 OstreamManager clout(std::cout, "createLoadBalancer");
196 std::string defaultMode = "Block";
197
198 LoadBalancer<T>* lb; // The LoadBalancer to be returned
199
200 // Read file attribute to decide if a new XML reader has to be created
201 XMLreader const* lbXml;
202 std::string fileAttr = xmlReader.getAttribute("file");
203 bool newFile = ( fileAttr != "Attribute not found." );
204 if ( newFile ) {
205 lbXml = new XMLreader(fileAttr);
206 }
207 else {
208 lbXml = &xmlReader;
209 }
210
211 bool verbose = false;
212 (*lbXml).setWarningsOn(false);
213
214 std::string mode = lbXml->getAttribute("mode");
215 if ( mode == "Attribute not found.") {
216 clout << "Warning: Cannot read parameter from Xml-file: Mode. Set default: mode = " << defaultMode << std::endl;
217 mode = defaultMode;
218 }
219
220 // Heuristic Mode
221 if ( mode == "Heuristic" ) {
222 // only read ratioFullEmpty - Heuristic LB will constructed from cuboidDecomposition deterministicly
223 double ratioFullEmpty;
224 if (!(*lbXml)["RatioFullEmpty"].read<double>(ratioFullEmpty, verbose)) {
225 lb = new HeuristicLoadBalancer<T>(*cGeo);
226 }
227 else {
228 lb = new HeuristicLoadBalancer<T>(*cGeo, ratioFullEmpty);
229 }
230 }
231
232 // Base Mode
233 else if ( mode == "Base" ) {
234 //LoadBalancer<T>* loadBalancer = new LoadBalancer<T>();
235 //loadBalancer->load(fileName);
236 clout << "LOADING BASE LB NOT IMPLEMENTED YET!" << std::endl;
237 (*lbXml).setWarningsOn(true);
238 //return loadBalancer;
239 lb = NULL;
240 }
241
242 // Block Mode
243 else if ( mode == "Block" ) {
244 int size = 1;
245 if (!(*lbXml)["Size"].read<int>(size, verbose)) {
246 clout << "Warning: Cannot read parameter from Xml-file: Size. Set default: size = 1"
247 << std::endl;
248 }
249 lb = new LoadBalancer<T>(size);
250 }
251
252
253 (*lbXml).setWarningsOn(true);
254
255 // Delete XMLreader if it was created for the LB file
256 if ( newFile ) {
257 delete lbXml;
258 }
259
260 return lb;
261}
Base class for all LoadBalancer.
Definition vtiWriter.h:42
std::string getAttribute(const std::string &aName) const
Definition xmlReader.h:471

References olb::XMLreader::getAttribute().

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

52{
53 std::stringstream fNameStream;
54
55 std::stringstream fNameStreamTmp;
56 fNameStreamTmp << singleton::mpi().getSize();
57 std::size_t stringLength = fNameStream.str().length();
58
59 fNameStream << name << "_rank" << std::setw(stringLength) << std::setfill('0') << singleton::mpi().getRank();
60 if (withSize) {
61 fNameStream << "_size" << std::setw(stringLength) << std::setfill('0') << singleton::mpi().getSize();
62 }
63 return fNameStream.str();
64}

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 366 of file solverParameters.h.

367{
368 auto result = std::make_shared<PARAMETERS>();
370 result->initialize();
371 return result;
372}
Base struct for reading parameters from files.
virtual void read(XMLreader const &xml)

References olb::parameters::Reader().

+ Here is the call graph for this function:

◆ createParametersTuple()

template<class parameters_map >
auto olb::createParametersTuple ( XMLreader const & xml)

Definition at line 375 of file solverParameters.h.

376{
378 meta::tuple_for_each(paramsTuple.tuple, [&xml](auto& element, auto index) {
379 using parameter_type = typename std::remove_reference_t<decltype(element)>::element_type;
380 using tag = typename parameters_map::keys_t::template get<index()>;
381 element = createParameters<parameter_type,tag>(xml);
382 });
383 return paramsTuple;
384}
Mapping between KEYs and instances of type VALUEs.

References olb::utilities::TypeIndexedTuple< MAP >::tuple, and olb::meta::tuple_for_each().

+ Here is the call graph for this function:
+ Here is the caller 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.

95{
96 OstreamManager clout(std::cout,"createUnitConverter");
97 params.setWarningsOn(false);
98
99 T physDeltaX;
100 T physDeltaT;
101
102 T charPhysLength;
103 T charPhysVelocity;
104 T physViscosity;
105 T physConsistencyCoeff;
106 T powerLawIndex;
107 T physDensity;
108 T charPhysPressure = 0;
109
110 int resolution;
111 T latticeRelaxationTime;
112 T charLatticeVelocity;
113
114 int counter = 0; // counting the number of Discretization parameters and returning a warning if more than 2 are provided
115
116
117 // params[parameter].read(value) sets the value or returns false if the parameter can not be found
118 params["Application"]["PhysParameters"]["CharPhysLength"].read(charPhysLength);
119 params["Application"]["PhysParameters"]["CharPhysVelocity"].read(charPhysVelocity);
120 params["Application"]["PhysParameters"]["PhysConsistencyCoeff"].read(physConsistencyCoeff);
121 params["Application"]["PhysParameters"]["powerLawIndex"].read(powerLawIndex);
122 params["Application"]["PhysParameters"]["PhysDensity"].read(physDensity);
123 params["Application"]["PhysParameters"]["CharPhysPressure"].read(charPhysPressure);
124
125 physViscosity = physConsistencyCoeff * util::pow(charPhysVelocity / (2*charPhysLength), powerLawIndex-1);
126
127 std::vector<std::string> discretizationParam = {"PhysDeltaX", "Resolution",
128 "CharLatticeVelocity", "PhysDeltaT", "LatticeRelaxationTime"};
129
130 for(int i = 0; i<discretizationParam.size(); i++){
131 std::string test;
132 if(params["Application"]["Discretization"][discretizationParam[i]].read(test,false)){
133 counter++;
134 }
135 }
136 if(counter>2){
137 clout << "WARNING: More than 2 discretization parameters provided" << std::endl;
138 }
139
140 if (!params["Application"]["Discretization"]["PhysDeltaX"].read(physDeltaX,false)) {
141 if (!params["Application"]["Discretization"]["Resolution"].read<int>(resolution,false)) {
142 if (!params["Application"]["Discretization"]["CharLatticeVelocity"].read(charLatticeVelocity,false)) {
143 // NOT found physDeltaX, resolution or charLatticeVelocity
144 clout << "Error: Have not found PhysDeltaX, Resolution or CharLatticeVelocity in XML file."
145 << std::endl;
146 exit (1);
147 }
148 else {
149 // found charLatticeVelocity
150 if (params["Application"]["Discretization"]["PhysDeltaT"].read(physDeltaT,false)) {
151 physDeltaX = charPhysVelocity / charLatticeVelocity * physDeltaT;
152 }
153 else if (params["Application"]["Discretization"]["LatticeRelaxationTime"].read(latticeRelaxationTime,false)) {
154 physDeltaX = physViscosity * charLatticeVelocity / charPhysVelocity * descriptors::invCs2<T,DESCRIPTOR>() / (latticeRelaxationTime - 0.5);
155 }
156 }
157 }
158 else {
159 // found resolution
160 physDeltaX = charPhysLength / resolution;
161 }
162 }
163 // found physDeltaX
164 if (!params["Application"]["Discretization"]["PhysDeltaT"].read(physDeltaT,false)) {
165 if (!params["Application"]["Discretization"]["LatticeRelaxationTime"].read(latticeRelaxationTime,false)) {
166 if (!params["Application"]["Discretization"]["CharLatticeVelocity"].read(charLatticeVelocity,false)) {
167 // NOT found physDeltaT, latticeRelaxationTime and charLatticeVelocity
168 clout << "Error: Have not found PhysDeltaT, LatticeRelaxationTime or CharLatticeVelocity in XML file."
169 << std::endl;
170 exit (1);
171 }
172 else {
173 // found charLatticeVelocity
174 physDeltaT = charLatticeVelocity / charPhysVelocity * physDeltaX;
175 }
176 }
177 else {
178 // found latticeRelaxationTime
179 physDeltaT = (latticeRelaxationTime - 0.5) / descriptors::invCs2<T,DESCRIPTOR>() * physDeltaX * physDeltaX / physViscosity;
180 }
181 }
182
183 return new PowerLawUnitConverter<T, DESCRIPTOR>(physDeltaX, physDeltaT, charPhysLength, charPhysVelocity, physConsistencyCoeff, powerLawIndex, physDensity, charPhysPressure);
184}
void exit(int exitcode)
Definition singleton.h:177

References olb::descriptors::invCs2(), 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 122 of file unitConverter.hh.

123{
124 OstreamManager clout(std::cout,"createUnitConverter");
125 params.setWarningsOn(false);
126
127 T physDeltaX{};
128 T physDeltaT{};
129
130 T charPhysLength{};
131 T charPhysVelocity{};
132 T physViscosity{};
133 T physDensity{};
134 T charPhysPressure = 0;
135
136 int resolution{};
137 T latticeRelaxationTime{};
138 T charLatticeVelocity{};
139
140 int counter = 0; // counting the number of Discretization parameters and returning a warning if more than 2 are provided
141
142 // params[parameter].read(value) sets the value or returns false if the parameter can not be found
143 params["Application"]["PhysParameters"]["CharPhysLength"].read(charPhysLength);
144 params["Application"]["PhysParameters"]["CharPhysVelocity"].read(charPhysVelocity);
145 params["Application"]["PhysParameters"]["PhysViscosity"].read(physViscosity);
146 params["Application"]["PhysParameters"]["PhysDensity"].read(physDensity);
147 params["Application"]["PhysParameters"]["CharPhysPressure"].read(charPhysPressure);
148
149 std::vector<std::string> discretizationParam = {"PhysDeltaX", "Resolution",
150 "CharLatticeVelocity", "PhysDeltaT", "LatticeRelaxationTime"};
151
152 for(int i = 0; i<discretizationParam.size(); i++){
153 std::string test;
154 if(params["Application"]["Discretization"][discretizationParam[i]].read(test,false)){
155 counter++;
156 }
157 }
158 if(counter>2){
159 clout << "WARNING: More than 2 discretization parameters provided" << std::endl;
160 }
161
162 if (!params["Application"]["Discretization"]["PhysDeltaX"].read(physDeltaX,false)) {
163 if (!params["Application"]["Discretization"]["Resolution"].read<int>(resolution,false)) {
164 if (!params["Application"]["Discretization"]["CharLatticeVelocity"].read(charLatticeVelocity,false)) {
165 // NOT found physDeltaX, resolution or charLatticeVelocity
166 throw std::runtime_error("Error: Have not found PhysDeltaX, Resolution or CharLatticeVelocity in XML file.");
167
168 }
169 else {
170 // found charLatticeVelocity
171 if (params["Application"]["Discretization"]["PhysDeltaT"].read(physDeltaT,false)) {
172 physDeltaX = charPhysVelocity / charLatticeVelocity * physDeltaT;
173 }
174 else if (params["Application"]["Discretization"]["LatticeRelaxationTime"].read(latticeRelaxationTime,false)) {
175 physDeltaX = physViscosity * charLatticeVelocity / charPhysVelocity * descriptors::invCs2<T,DESCRIPTOR>() / (latticeRelaxationTime - 0.5);
176 }
177 else {
178 throw std::runtime_error("Error: Only found CharLatticeVelocity, missing PhysDeltaT or LatticeRelaxationTime");
179 }
180 }
181 }
182 else {
183 // found resolution
184 physDeltaX = charPhysLength / resolution;
185
186 if (params["Application"]["Discretization"]["CharLatticeVelocity"].read(charLatticeVelocity,false)) {
187 latticeRelaxationTime = physViscosity * charLatticeVelocity * descriptors::invCs2<T,DESCRIPTOR>() * resolution + 0.5;
188 }
189 else {
190 if (!params["Application"]["Discretization"]["LatticeRelaxationTime"].read(latticeRelaxationTime,false)) {
191 throw std::runtime_error("Error: Have not found LatticeRelaxationTime and was not able to derive it using CharLatticeVelocity");
192 }
193 }
194 }
195 }
196 // found physDeltaX
197 if (!params["Application"]["Discretization"]["PhysDeltaT"].read(physDeltaT,false)) {
198 if (!params["Application"]["Discretization"]["LatticeRelaxationTime"].read(latticeRelaxationTime,false)) {
199 if (!params["Application"]["Discretization"]["CharLatticeVelocity"].read(charLatticeVelocity,false)) {
200 // NOT found physDeltaT, latticeRelaxationTime and charLatticeVelocity
201 throw std::runtime_error("Error: Have not found PhysDeltaT, LatticeRelaxationTime or CharLatticeVelocity in XML file.");
202 }
203 else {
204 // found charLatticeVelocity
205 physDeltaT = charLatticeVelocity / charPhysVelocity * physDeltaX;
206 }
207 }
208 else {
209 // found latticeRelaxationTime
210 physDeltaT = (latticeRelaxationTime - 0.5) / descriptors::invCs2<T,DESCRIPTOR>() * physDeltaX * physDeltaX / physViscosity;
211 }
212 }
213
214 return new UnitConverter<T, DESCRIPTOR>(physDeltaX, physDeltaT, charPhysLength, charPhysVelocity, physViscosity, physDensity, charPhysPressure);
215}

References olb::descriptors::invCs2(), olb::XMLreader::read(), and olb::XMLreader::setWarningsOn().

+ Here is the call graph for this function:
+ Here is the caller 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 274 of file vector.h.

274 {
275 static_assert((D==2 || D==3), "ERROR: Unknown dimension!");
276 if constexpr (D==2){
277 return crossProduct2D(a,b);
278 } else {
279 return crossProduct3D(a,b);
280 }
281}
constexpr T crossProduct2D(const ScalarVector< T, 2, IMPL > &a, const ScalarVector< T, 2, IMPL_ > &b)
Definition vector.h:256

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_ >
T olb::crossProduct2D ( const ScalarVector< T, 2, IMPL > & a,
const ScalarVector< T, 2, IMPL_ > & b )
constexpr

Definition at line 256 of file vector.h.

258{
259 return (a[0]*b[1] - a[1]*b[0]);
260}
+ Here is the caller graph for this function:

◆ crossProduct3D()

template<typename T , typename IMPL , typename IMPL_ >
Vector< T, 3 > olb::crossProduct3D ( const ScalarVector< T, 3, IMPL > & a,
const ScalarVector< T, 3, IMPL_ > & b )
constexpr

Definition at line 263 of file vector.h.

265{
266 return Vector<T,3>(
267 a[1]*b[2] - a[2]*b[1],
268 a[2]*b[0] - a[0]*b[2],
269 a[0]*b[1] - a[1]*b[0]
270 );
271}
+ Here is the caller graph for this function:

◆ defineDynamicsAndSetParameterFromXml()

template<typename T , typename DESCRIPTOR >
void olb::defineDynamicsAndSetParameterFromXml ( std::string xmlFileName,
SuperGeometry< T, 3 > & sGeometry,
SuperLattice< T, DESCRIPTOR > & sLattice )

Definition at line 186 of file availableDynamicList.h.

186 {
187 defineDynamicsFromXml(xmlFileName, sLattice,sGeometry);
188 setParameterFromXml(sLattice, xmlFileName);
189 }
void setParameterFromXml(SuperLattice< T, DESCRIPTOR > &sLattice, std::string xmlFileName)
void defineDynamicsFromXml(std::string xmlFileName, SuperLattice< T, DESCRIPTOR > &sLattice, SuperGeometry< T, 3 > &sGeometry)

References defineDynamicsFromXml(), and setParameterFromXml().

+ Here is the call graph for this function:

◆ defineDynamicsFromString()

template<typename T , typename DESCRIPTOR >
void olb::defineDynamicsFromString ( SuperLattice< T, DESCRIPTOR > & sLattice,
std::unique_ptr< olb::SuperIndicatorF< T, 3U > > indicatorF,
std::string modelName )

Definition at line 207 of file availableDynamicList.h.

208 {
209
210 sLattice.defineDynamics(indicatorF,
211 mapStringToDynamics<T,DESCRIPTOR>(modelName));
212
213 }
void defineDynamics()
Set dynamics of all cells to DYNAMICS.

References olb::SuperLattice< T, DESCRIPTOR >::defineDynamics(), and mapStringToDynamics().

+ Here is the call graph for this function:

◆ defineDynamicsFromXml()

template<typename T , typename DESCRIPTOR >
void olb::defineDynamicsFromXml ( std::string xmlFileName,
SuperLattice< T, DESCRIPTOR > & sLattice,
SuperGeometry< T, 3 > & sGeometry )

Definition at line 192 of file availableDynamicList.h.

192 {
193 OstreamManager clout("DynamicsFromXML");
194 DynamicsTupleParser<T, DESCRIPTOR> parser(xmlFileName);
195 std::vector<int> indicators = parser.readIndicatorFromXML();
196 clout << "size " << indicators.size() << std::endl;
197
198 auto dynamicsStrings = parser.readTupleFromXML();
199 for (int i = 0; i < dynamicsStrings.size(); i++) {
200 clout << indicators[i] << std::endl;
201 sLattice.defineDynamics(sGeometry.getMaterialIndicator(indicators[i]),
202 mapStringToDynamics<T, DESCRIPTOR>(dynamicsStrings[i]));
203 }
204 }
std::unique_ptr< SuperIndicatorF< T, D > > getMaterialIndicator(std::vector< int > &&materials)
Returns a material indicator using the given vector of materials.

References olb::SuperLattice< T, DESCRIPTOR >::defineDynamics(), olb::SuperGeometry< T, D >::getMaterialIndicator(), mapStringToDynamics(), olb::DynamicsTupleParser< T, DESCRIPTOR >::readIndicatorFromXML(), and olb::DynamicsTupleParser< T, DESCRIPTOR >::readTupleFromXML().

+ Here is the call graph for this function:
+ 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 333 of file lbSolver.h.

333 {
334 return [=]() {
335 solver->postProcess();
336 };
337}

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

◆ evaluateCuboidDecompositionNeighbourhood()

template<typename T , unsigned D>
void olb::evaluateCuboidDecompositionNeighbourhood ( CuboidDecomposition< T, D > & cuboidDecomposition,
std::map< int, std::vector< int > > & neighbourhood,
int offset )

Evaluate complete neighbourhood and store in std::map.

Definition at line 34 of file utilities.h.

38{
39 for (int iC=0; iC<cuboidDecomposition.size(); ++iC){
40 neighbourhood[iC].clear();
41 auto neighbours = cuboidDecomposition.getNeighborhood(iC, offset);
42 for (int jC : neighbours) {
43 neighbourhood[iC].emplace_back(jC);
44 }
45 }
46}
std::set< int > getNeighborhood(int iCglob, int overlap=0) const
Returns set of neighbors to cuboid iCglob within overlap.

References olb::CuboidDecomposition< T, D >::getNeighborhood(), and olb::CuboidDecomposition< T, D >::size().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ findClosedLatticeVector()

template<typename V , typename DESCRIPTOR >
int olb::findClosedLatticeVector ( Vector< V, DESCRIPTOR::d > tangent)

Definition at line 45 of file thermalCreepBouzidiCoupling.h.

46{
47
48 int iPopClosest = 0;
49 V cos = 0.;
50 tangent = tangent / norm(tangent);
51
52 for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
53 auto c = descriptors::c<DESCRIPTOR>(iPop);
54 c = c / norm(c);
55 if (util::abs(tangent * c) > cos) {
56 cos = util::abs(tangent * c);
57 iPopClosest = iPop;
58 }
59 }
60 if (tangent * descriptors::c<DESCRIPTOR>(iPopClosest) < 0) {
61 iPopClosest = descriptors::opposite<DESCRIPTOR>(iPopClosest);
62 }
63 return iPopClosest;
64};
constexpr T norm(const ScalarVector< T, D, IMPL > &a) any_platform
Euclidean vector norm.

References olb::util::abs(), olb::descriptors::c(), norm(), and olb::descriptors::opposite().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ getCallable()

template<typename T , typename SOLVER >
std::function< T(const std::vector< T > &, unsigned)> olb::getCallable ( std::shared_ptr< SOLVER > solver)

Returns a function that encapsulates the solving process.

Definition at line 322 of file lbSolver.h.

322 {
323 return [=](const std::vector<T>& control, unsigned optiStep) -> T {
324 solver->parameters(names::Opti()).applyControl(control);
325 //solver->parameters(names::OutputOpti()).counterOptiStep = optiStep;
326 solver->solve();
327 return solver->parameters(names::Results()).objective;
328 };
329}

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

51 {
52 return getConfinedPermeability<T,check>(
53 converter.getLatticeViscosity(), converter.getLatticeRelaxationTime(),
54 converter.getPhysDeltaX(), converter.getCharPhysLength(),
55 physPermeability );
56}
constexpr T getLatticeViscosity() const
conversion from physical to lattice viscosity
constexpr T getLatticeRelaxationTime() const
return relaxation time in lattice units

References olb::UnitConverter< T, DESCRIPTOR >::getCharPhysLength(), getConfinedPermeability(), 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.

34{
35 T minPermeabiliy = physDeltaX * physDeltaX * latticeViscosity * latticeRelaxationTime;
36 if constexpr (check){
37 if ( physPermeability >= minPermeabiliy ){
38 throw std::invalid_argument( "Error: Min permeability exceeded!" );
39 return 1.0;
40 } else {
41 return 1. - minPermeabiliy / physPermeability;
42 }
43 } else {
44 return 1. - minPermeabiliy / physPermeability;
45 }
46
47 __builtin_unreachable();
48}
+ Here is the caller graph for this function:

◆ getDataFromTag()

template<typename S >
std::vector< S > olb::getDataFromTag ( const XMLreader & reader,
std::string attrName,
int nData )

Helper Function to retrieve nData-dimensional std::vector of type S from space separated tag.

Definition at line 482 of file xmlReader.h.

483{
484 std::vector<S> values(nData, S());
485 std::stringstream extstr(reader.getAttribute(attrName));
486 for (auto& valueI: values) {
487 extstr >> valueI;
488 }
489 return values;
490}

References olb::XMLreader::getAttribute().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ getFieldName()

template<typename FIELD >
std::string_view olb::getFieldName ( )
constexpr

Definition at line 34 of file fields.h.

34 {
35#ifndef USING_LEGACY_CODEGEN
36 const std::string_view raw = std::source_location::current().function_name();
37 return std::string_view(raw.cbegin() + raw.find_first_of('=')+2,
38 raw.cbegin() + std::min(raw.find_first_of(']'),
39 raw.find_first_of(';')));
40#else
41 return std::string_view();
42#endif
43}
+ Here is the caller graph for this function:

◆ getFresnelFunction()

double olb::getFresnelFunction ( double const & theta,
double const & refractiveRelative )

Definition at line 244 of file radiativeUnitConverter.h.

245{
246 double thetaRefracted = getThetaRefracted(theta, refractiveRelative);
247 double rf_1 = 0.5 * util::pow((refractiveRelative * util::cos(thetaRefracted) - util::cos(theta)) /
248 (refractiveRelative * util::cos(thetaRefracted) + util::cos(theta)), 2.);
249 double rf_2 = 0.5 * util::pow((refractiveRelative * util::cos(theta) - util::cos(thetaRefracted)) /
250 (refractiveRelative * util::cos(theta) + util::cos(thetaRefracted)), 2.);
251 return rf_1 + rf_2; // eq.(5.115)
252};
double getThetaRefracted(double const &thetaIncident, double const &refractiveRelative)
Documentation of implemented functions found in 5.2.2 Biomedical Optics, Principles and Imaging; Wang...

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

66{
67 std::set<int> materials;
68 for (const SolidBoundary<T,D>& solidBoundary : solidBoundaries ){
69 materials.insert( solidBoundary.getLatticeMaterial() );
70 }
71 return materials;
72}
+ Here is the caller graph for this function:

◆ getName()

std::string olb::getName ( OperatorScope scope)

Returns human-readable name of scope.

Definition at line 43 of file operatorScope.h.

43 {
44 switch (scope) {
45 case OperatorScope::PerCell:
46 return "PerCell";
47 case OperatorScope::PerBlock:
48 return "PerBlock";
49 case OperatorScope::PerCellWithParameters:
50 return "PerCellWithParameters";
51 default:
52 throw std::invalid_argument("OperatorScope value is not defined");
53 }
54}

References PerBlock, PerCell, and PerCellWithParameters.

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

279{
280 double C_R = getRefractionFunction( relativeRefractiveIndex );
281 return 2 - 2/(4*latticeDiffusionCoefficient*C_R +1);
282};
double getRefractionFunction(const double &refractiveRelative)

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.

56{
57 return getPartialBBCoefficient( converter.getLatticeDiffusion(), converter.getRefractiveRelative() );
58};
constexpr T getRefractiveRelative() const
double getPartialBBCoefficient(double const &latticeDiffusionCoefficient, double const &relativeRefractiveIndex)

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.

67 {
68 return getPhysPermeability<T>(
69 converter.getLatticeViscosity(), converter.getLatticeRelaxationTime(),
70 converter.getPhysDeltaX(), converter.getCharPhysLength(),
71 confinedPermeability );
72}

References olb::UnitConverter< T, DESCRIPTOR >::getCharPhysLength(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeRelaxationTime(), olb::UnitConverter< T, DESCRIPTOR >::getLatticeViscosity(), olb::UnitConverter< T, DESCRIPTOR >::getPhysDeltaX(), and getPhysPermeability().

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

61{
62 T minPermeabiliy = physDeltaX * physDeltaX * latticeViscosity * latticeRelaxationTime;
63 return minPermeabiliy / (1. - confinedPermeability);
64}
+ Here is the caller graph for this function:

◆ getRefractionFunction() [1/2]

double olb::getRefractionFunction ( const double & refractiveRelative)

Definition at line 264 of file radiativeUnitConverter.h.

265{
266 int N = 10000.0;
267 double h = (M_PI / 2.) /double(N);
268 double R_phi = 0.0;
269 double R_j = 0.0;
270 for (int i = 0; i < N; i++) {
271 R_phi += h*(R_phi_diff(0.5*h + h*i,refractiveRelative));
272 R_j += h*(R_j_diff (0.5*h + h*i,refractiveRelative));
273 }
274 double R_eff = (R_phi + R_j) / (2 - R_phi + R_j); // eq.(5.112)
275 return (1 + R_eff) / (1 - R_eff); // eq.(5.111) C_R = (1 + R_eff) / (1 - R_eff);
276};
#define M_PI
double R_j_diff(double const &theta, double const &refractiveRelative)
double R_phi_diff(double const &theta, double const &refractiveRelative)

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.

63{
65};

References getRefractionFunction(), and olb::RadiativeUnitConverter< T, DESCRIPTOR >::getRefractiveRelative().

+ Here is the call graph for this function:

◆ getSerializedFieldSize() [1/2]

template<typename FIELD , typename T , typename DESCRIPTOR >
std::size_t olb::getSerializedFieldSize ( SuperLattice< T, DESCRIPTOR > & lattice)

Returns size of serialized data vector of a field.

Definition at line 113 of file serialize.h.

113 {
114 const std::size_t numNodes = lattice.getCuboidDecomposition().getNumNodes();
115 const std::size_t fieldDim = DESCRIPTOR::template size<FIELD>();
116 return numNodes * fieldDim;
117}
CuboidDecomposition< T, D > & getCuboidDecomposition()
Read and write access to cuboid geometry.

References olb::SuperStructure< T, D >::getCuboidDecomposition().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ getSerializedFieldSize() [2/2]

template<typename FIELD , typename T , typename DESCRIPTOR >
std::size_t olb::getSerializedFieldSize ( SuperLattice< T, DESCRIPTOR > & lattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && indicator )

Returns size of serialized data vector of a field.

Definition at line 121 of file serialize.h.

122 {
123 auto& loadBalancer = lattice.getLoadBalancer();
124 auto& cDecomposition = indicator->getSuperStructure().getCuboidDecomposition();
125 auto& superGeometry = indicator->getSuperGeometry();
126 const std::size_t fieldDim = DESCRIPTOR::template size<FIELD>();
127
128 std::size_t numNodes = 0;
129 for (int iC=0; iC<cDecomposition.size(); ++iC) {
130 if (loadBalancer.isLocal(iC)) {
131 const int loc = loadBalancer.loc(iC);
132 auto& blockGeometry = superGeometry.getBlockGeometry(loc);
133 auto& blockIndicator = indicator->getBlockIndicatorF(loc);
134 blockGeometry.forCoreSpatialLocations([&](LatticeR<DESCRIPTOR::d> pos) {
135 if (blockIndicator(pos)) {
136 ++numNodes;
137 }
138 });
139 }
140 }
141#ifdef PARALLEL_MODE_MPI
142 singleton::mpi().reduceAndBcast(numNodes, MPI_SUM);
143#endif
144 return numNodes*fieldDim;
145}

References olb::SuperStructure< T, D >::getLoadBalancer(), olb::singleton::mpi(), and olb::singleton::MpiManager::reduceAndBcast().

+ Here is the call graph for this function:

◆ getSerializedFromField()

template<typename FIELD , typename T , typename DESCRIPTOR >
std::vector< T > olb::getSerializedFromField ( SuperLattice< T, DESCRIPTOR > & lattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && indicator )

Returns serialized vector of field data inside indicated region.

Definition at line 32 of file serialize.h.

34{
35 auto& loadBalancer = lattice.getLoadBalancer();
36 auto& cDecomposition = indicator->getSuperStructure().getCuboidDecomposition();
37 auto& superGeometry = indicator->getSuperGeometry();
38 const std::size_t serializedSize = getSerializedFieldSize<FIELD>(lattice,
39 std::forward<FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>>(indicator));
40
41 std::vector<T> serial;
42 serial.resize(serializedSize, 0);
43 std::size_t offset = 0;
44 for (int iC=0; iC<cDecomposition.size(); ++iC) {
45 std::size_t numNodes = 0;
46 if (loadBalancer.isLocal(iC)) {
47 const int loc = loadBalancer.loc(iC);
48 auto& blockGeometry = superGeometry.getBlockGeometry(loc);
49 auto& blockLattice = lattice.getBlock(loc);
50 auto& blockIndicator = indicator->getBlockIndicatorF(loc);
51 blockGeometry.forCoreSpatialLocations([&](LatticeR<DESCRIPTOR::d> pos) {
52 if (blockIndicator(pos)) {
53 std::size_t index = offset + numNodes;
54 for (std::size_t iD=0; iD<DESCRIPTOR::template size<FIELD>(); ++iD) {
55 serial.at(index + iD) = blockLattice.get(pos).template getFieldComponent<FIELD>(iD);
56 ++numNodes;
57 }
58 }
59 });
60 }
61#ifdef PARALLEL_MODE_MPI
62 singleton::mpi().reduceAndBcast(numNodes, MPI_SUM);
63#endif
64 offset += numNodes;
65 }
66#ifdef PARALLEL_MODE_MPI
67 std::vector<T> tmp;
68 tmp.resize(serializedSize, 0);
69 singleton::mpi().allreduce(serial.data(), tmp.data(), serializedSize, MPI_SUM);
70 serial = tmp;
71#endif
72 return serial;
73}
Smart pointer for managing the various ways of passing functors around.
Definition functorPtr.h:60
BlockLattice< T, DESCRIPTOR > & getBlock(int locC)
Return BlockLattice with local index locC.
std::conditional_t< D==2, SuperIndicatorF2D< T >, SuperIndicatorF3D< T > > SuperIndicatorF
Definition aliases.h:197

References olb::singleton::MpiManager::allreduce(), olb::BlockStructureD< D >::forCoreSpatialLocations(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), getSerializedFieldSize(), olb::singleton::mpi(), and olb::singleton::MpiManager::reduceAndBcast().

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

236{
237 double thetaRefracted = M_PI/2.;
238 if ( refractiveRelative * util::sin(thetaIncident) < 1 ) {
239 thetaRefracted = util::asin( refractiveRelative * util::sin(thetaIncident)); // eq.(5.118)
240 }
241 return thetaRefracted;
242};

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
cosThetautil::cos(theta) of scattering event with net direction theta
ganisotropy factor

Definition at line 55 of file anisoDiscr.h.

56{
57 return (1-g*g) / util::pow(1+g*g-2*g*cosTheta,1.5);
58}

References olb::util::pow().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ initialize() [1/2]

void olb::initialize ( int * argc,
char *** argv,
bool multiOutput = false,
bool verbose = true )

Initialize OpenLB.

Sets up MPI, thread pool and verifies platform requirements.

Verify requirements for using all enabled platforms

Definition at line 49 of file olbInit.cpp.

50{
51 // create an OstreamManager object in order to enable multi output
52 olb::OstreamManager clout(std::cout, "olbInit");
53 clout.setMultiOutput(multiOutput);
54 singleton::mpi().init(argc, argv, verbose);
55
56#ifdef PARALLEL_MODE_OMP
57 singleton::omp().init(verbose);
58#endif
59
60 int nThreads = 1;
61 if (const char* envOlbNumThreads = std::getenv("OLB_NUM_THREADS")) {
62 nThreads = std::stoi(envOlbNumThreads);
63 }
64 singleton::pool().init(nThreads, verbose);
65
67 #ifdef PLATFORM_GPU_CUDA
68 checkPlatform<Platform::GPU_CUDA>();
69 #endif
70
71 #ifdef FEATURE_VDB
72 openvdb::initialize();
73 #endif
74}

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:
+ Here is the caller graph for this function:

◆ initialize() [2/2]

void olb::initialize ( int argc,
char ** argv,
bool multiOutput,
bool verbose )

Initialize OpenLB.

Definition at line 76 of file olbInit.cpp.

77{
78 initialize(&argc, &argv, multiOutput, verbose);
79}
void initialize(int *argc, char ***argv, bool multiOutput, bool verbose)
Initialize OpenLB.
Definition olbInit.cpp:49

References initialize().

+ Here is the call graph for this function:

◆ interpolate2d() [1/4]

template<unsigned NEIGHBORS, typename FIELD , typename CELL , typename RESULT , typename V = typename CELL::value_t>
void olb::interpolate2d ( CELL & cell,
RESULT & result,
const Vector< V, 2 > distance )

linear interpolation/ extrapolation of FIELD

Template Parameters
NEIGHBORSencodes, which neighbors are accessible: e.g. 1100 refers to the first two neighbors of the point of interest (in lexicographic order) Hence, their order is as follows (w.r.t. the floor lattice point): 1000=(0,0), 100=(0,1), 10=(1,0), 1=(1,1).
Parameters
distanceDistance between point of interest and cell (in lattice units)
resultResult is written here

Definition at line 204 of file interpolation2d.h.

205{
207 constexpr unsigned DataDim = CELL::descriptor_t::template size<FIELD>();
208 auto f = [DataDim](const auto& c, RESULT& res) -> void {
209 for (unsigned i = 0; i < DataDim; ++i) {
210 res[i] = c.template getFieldComponent<FIELD>(i);
211 }
212 };
213 interpolate2d<NEIGHBORS,DataDim,CELL,RESULT,decltype(f),V>(cell, result, distance, f);
214}

References interpolate2d().

+ Here is the call graph for this function:

◆ interpolate2d() [2/4]

template<typename FIELD , typename CELL , typename RESULT , typename V = typename CELL::value_t>
void olb::interpolate2d ( CELL & cell,
RESULT & result,
const Vector< V, 2 > distance )

bilinear interpolation/ extrapolation of FIELD

Parameters
distanceDistance between point of interest and cell (in lattice units)
resultResult is written here

Definition at line 222 of file interpolation2d.h.

223{
224 interpolate2d<1111,FIELD,CELL,RESULT,V>(cell, result, distance);
225}

References interpolate2d().

+ Here is the call graph for this function:

◆ interpolate2d() [3/4]

template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void olb::interpolate2d ( CELL & cell,
RESULT & result,
const Vector< V, 2 > distance,
F f )

Bilinear interpolation between four neighboring mesh points.

Template Parameters
DataDimDimension of function return value
Parameters
resultResult is written here
distanceDistance from cell (in lattice units)
fFunction which is to interpolate

Definition at line 39 of file interpolation2d.h.

40{
41 const Vector<int,2> floorV (util::floor(distance[0]), util::floor(distance[1]));
42 Vector<Vector<int,2>,4> surroundingPoints (floorV);
43 surroundingPoints[1][0] += 1;
44 surroundingPoints[2][1] += 1;
45 surroundingPoints[3][0] += 1; surroundingPoints[3][1] += 1;
46
47 V resNeighbor[DataDim];
48 for (unsigned i=0; i<DataDim; ++i) {
49 result[i] = V();
50 }
51 for (auto point : surroundingPoints) {
52 const Vector<V,2> dist = distance - point;
53 const V weight = (V(1) - util::abs(dist[0])) * (V(1) - util::abs(dist[1]));
54 f(cell.neighbor(point), resNeighbor);
55 for (unsigned i = 0; i < DataDim; ++i) {
56 result[i] += weight * resNeighbor[i];
57 }
58 }
59}

References olb::util::abs(), and olb::util::floor().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ interpolate2d() [4/4]

template<unsigned NEIGHBORS, unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void olb::interpolate2d ( CELL & cell,
RESULT & result,
const Vector< V, 2 > distance,
F f )

linear interpolation/ extrapolation of function f

Template Parameters
DataDimDimension of function return value
NEIGHBORSencodes, which neighbors are accessible: e.g. 1100 refers to the first two neighbors of the point of interest (in lexicographic order). Hence, their order is as follows (w.r.t. the floor lattice point): 1000=(0,0), 100=(0,1), 10=(1,0), 1=(1,1).
Parameters
resultResult is written here
distanceDistance from cell (in lattice units)
fFunction which is to interpolate

Definition at line 122 of file interpolation2d.h.

123{
124 // four neighbors: bilinear interpolation
125 if constexpr (NEIGHBORS == 1111) {
126 interpolate2d<DataDim,CELL,RESULT,F,V>(cell, result, distance, f);
127 }
128 // three neighbors: linear interpolation
129 else if constexpr (NEIGHBORS == 1110) {
130 const Vector<int,2> pointA (util::floor(distance[0]), util::floor(distance[1]));
131 const Vector<int,2> pointB (util::floor(distance[0]+1), util::floor(distance[1]));
132 const Vector<int,2> pointC (util::floor(distance[0]), util::floor(distance[1])+1);
133 interpolate2d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
134 } else if constexpr (NEIGHBORS == 1101) {
135 const Vector<int,2> pointA (util::floor(distance[0]), util::floor(distance[1]));
136 const Vector<int,2> pointB (util::floor(distance[0]+1), util::floor(distance[1]));
137 const Vector<int,2> pointC (util::floor(distance[0]+1), util::floor(distance[1])+1);
138 interpolate2d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
139 } else if constexpr (NEIGHBORS == 1011) {
140 const Vector<int,2> pointA (util::floor(distance[0]), util::floor(distance[1]));
141 const Vector<int,2> pointB (util::floor(distance[0]), util::floor(distance[1])+1);
142 const Vector<int,2> pointC (util::floor(distance[0]+1), util::floor(distance[1])+1);
143 interpolate2d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
144 } else if constexpr (NEIGHBORS == 111) {
145 const Vector<int,2> pointA (util::floor(distance[0]+1), util::floor(distance[1]));
146 const Vector<int,2> pointB (util::floor(distance[0]), util::floor(distance[1])+1);
147 const Vector<int,2> pointC (util::floor(distance[0]+1), util::floor(distance[1])+1);
148 interpolate2d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
149 }
150 else if constexpr (NEIGHBORS == 1100) {
151 const Vector<int,2> pointA (util::floor(distance[0]), util::floor(distance[1]));
152 const Vector<int,2> pointB (util::floor(distance[0]+1), util::floor(distance[1]));
153 interpolate2d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
154 } else if constexpr (NEIGHBORS == 11) {
155 const Vector<int,2> pointA (util::floor(distance[0]), util::floor(distance[1])+1);
156 const Vector<int,2> pointB (util::floor(distance[0]+1), util::floor(distance[1])+1);
157 interpolate2d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
158 } else if constexpr (NEIGHBORS == 1010) {
159 const Vector<int,2> pointA (util::floor(distance[0]), util::floor(distance[1]));
160 const Vector<int,2> pointB (util::floor(distance[0]), util::floor(distance[1])+1);
161 interpolate2d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
162 } else if constexpr (NEIGHBORS == 101) {
163 const Vector<int,2> pointA (util::floor(distance[0]+1), util::floor(distance[1]));
164 const Vector<int,2> pointB (util::floor(distance[0]+1), util::floor(distance[1])+1);
165 interpolate2d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
166 } else if constexpr (NEIGHBORS == 1001) {
167 const Vector<int,2> pointA (util::floor(distance[0]), util::floor(distance[1]));
168 const Vector<int,2> pointB (util::floor(distance[0]+1), util::floor(distance[1])+1);
169 interpolate2d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
170 } else if constexpr (NEIGHBORS == 110) {
171 const Vector<int,2> pointA (util::floor(distance[0]), util::floor(distance[1])+1);
172 const Vector<int,2> pointB (util::floor(distance[0]+1), util::floor(distance[1]));
173 interpolate2d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
174 }
175 // one neighbor: constant extrapolation
176 else if constexpr (NEIGHBORS == 1) {
177 const Vector<int,2> point (util::floor(distance[0])+1, util::floor(distance[1])+1);
178 f(cell.neighbor(point), result);
179 } else if constexpr (NEIGHBORS == 10) {
180 const Vector<int,2> point (util::floor(distance[0]), util::floor(distance[1])+1);
181 f(cell.neighbor(point), result);
182 } else if constexpr (NEIGHBORS == 100) {
183 const Vector<int,2> point (util::floor(distance[0])+1, util::floor(distance[1]));
184 f(cell.neighbor(point), result);
185 } else if constexpr (NEIGHBORS == 1000) {
186 const Vector<int,2> point (util::floor(distance[0]), util::floor(distance[1]));
187 f(cell.neighbor(point), result);
188 }
189 else {
190 throw std::invalid_argument("Invalid NEIGHBORS");
191 }
192}

References olb::util::floor(), interpolate2d(), and interpolate2d_help().

+ Here is the call graph for this function:

◆ interpolate2d_help() [1/2]

template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void olb::interpolate2d_help ( CELL & cell,
RESULT & result,
const Vector< V, 2 > distance,
F f,
Vector< int, 2 > pointA,
Vector< int, 2 > pointB )

Linear interpolation between two points (constant in the orthogonal direction)

Definition at line 91 of file interpolation2d.h.

93{
94 const V refDistanceSq = norm_squared(Vector<V,2>(pointA - pointB));
95 const V alpha = ((distance - pointB) * (pointA - pointB)) / refDistanceSq;
96 V resNeighbor[DataDim];
97 for (unsigned i=0; i<DataDim; ++i) {
98 result[i] = V();
99 }
100 f(cell.neighbor(pointA), resNeighbor);
101 for (unsigned i = 0; i < DataDim; ++i) {
102 result[i] += alpha * resNeighbor[i];
103 }
104 f(cell.neighbor(pointB), resNeighbor);
105 for (unsigned i = 0; i < DataDim; ++i) {
106 result[i] += (1 - alpha) * resNeighbor[i];
107 }
108}
constexpr T norm_squared(const ScalarVector< T, D, IMPL > &a) any_platform
Squared euclidean vector norm.

References norm_squared().

+ Here is the call graph for this function:

◆ interpolate2d_help() [2/2]

template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void olb::interpolate2d_help ( CELL & cell,
RESULT & result,
const Vector< V, 2 > distance,
F f,
Vector< int, 2 > pointA,
Vector< int, 2 > pointB,
Vector< int, 2 > pointC )

Linear interpolation between three points.

Definition at line 63 of file interpolation2d.h.

65{
66 // express point as a linear combination of the two sides
67 const auto lc = util::solveLinearSystem(Vector<V,2>(pointB - pointA),
68 Vector<V,2>(pointC - pointA),
69 distance - pointA);
70 // evaluate linear function
71 V resNeighbor[DataDim];
72 for (unsigned i=0; i<DataDim; ++i) {
73 result[i] = V();
74 }
75 f(cell.neighbor(pointA), resNeighbor);
76 for (unsigned i = 0; i < DataDim; ++i) {
77 result[i] += (1 - lc[0] - lc[1]) * resNeighbor[i];
78 }
79 f(cell.neighbor(pointB), resNeighbor);
80 for (unsigned i = 0; i < DataDim; ++i) {
81 result[i] += lc[0] * resNeighbor[i];
82 }
83 f(cell.neighbor(pointC), resNeighbor);
84 for (unsigned i = 0; i < DataDim; ++i) {
85 result[i] += lc[1] * resNeighbor[i];
86 }
87}

References olb::util::solveLinearSystem().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ interpolate3d() [1/4]

template<unsigned NEIGHBORS, typename FIELD , typename CELL , typename RESULT , typename V = typename CELL::value_t>
void olb::interpolate3d ( CELL & cell,
RESULT & result,
const Vector< V, 3 > distance )

Trilinear interpolation of FIELD see above for explanation of the parameters.

Definition at line 1099 of file interpolation3d.h.

1100{
1102 constexpr unsigned DataDim = CELL::descriptor_t::template size<FIELD>();
1103 auto f = [DataDim](const auto& c, RESULT& res) -> void {
1104 for (unsigned i = 0; i < DataDim; ++i) {
1105 res[i] = c.template getFieldComponent<FIELD>(i);
1106 }
1107 };
1108 interpolate3d<NEIGHBORS,DataDim,CELL,RESULT,decltype(f),V>(cell, result, distance, f);
1109}

References interpolate3d().

+ Here is the call graph for this function:

◆ interpolate3d() [2/4]

template<typename FIELD , typename CELL , typename RESULT , typename V = typename CELL::value_t>
void olb::interpolate3d ( CELL & cell,
RESULT & result,
const Vector< V, 3 > distance )

Trilinear interpolation of FIELD.

Definition at line 1113 of file interpolation3d.h.

1114{
1115 interpolate3d<11111111,FIELD,CELL,RESULT,V>(cell, result, distance);
1116}

References interpolate3d().

+ Here is the call graph for this function:

◆ interpolate3d() [3/4]

template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void olb::interpolate3d ( CELL & cell,
RESULT & result,
const Vector< V, 3 > distance,
F f )

trilinear interpolation of function f

Template Parameters
DataDimDimension of function return value
Parameters
distanceDistance from cell
resultResult is written here
fFunction which is to interpolate

Definition at line 38 of file interpolation3d.h.

39{
40 const Vector<int,3> floorV (util::floor(distance[0]),
41 util::floor(distance[1]), util::floor(distance[2]));
42 Vector<Vector<int,3>,8> surroundingPoints (floorV);
43 surroundingPoints[1][0] += 1;
44 surroundingPoints[2][1] += 1;
45 surroundingPoints[3][2] += 1;
46 surroundingPoints[4][0] += 1; surroundingPoints[4][1] += 1;
47 surroundingPoints[5][0] += 1; surroundingPoints[5][2] += 1;
48 surroundingPoints[6][1] += 1; surroundingPoints[6][2] += 1;
49 surroundingPoints[7][0] += 1; surroundingPoints[7][1] += 1; surroundingPoints[7][2] += 1;
50
51 V resNeighbor[DataDim];
52 for (unsigned i=0; i<DataDim; ++i) {
53 result[i] = V();
54 }
55 for (auto point : surroundingPoints) {
56 const Vector<V,3> dist = distance - point;
57 const V weight = (V(1) - util::abs(dist[0])) * (V(1) - util::abs(dist[1]))
58 * (V(1) - util::abs(dist[2]));
59 f(cell.neighbor(point), resNeighbor);
60 for (unsigned i = 0; i < DataDim; ++i) {
61 result[i] += weight * resNeighbor[i];
62 }
63 }
64}

References olb::util::abs(), and olb::util::floor().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ interpolate3d() [4/4]

template<unsigned NEIGHBORS, unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void olb::interpolate3d ( CELL & cell,
RESULT & result,
const Vector< V, 3 > distance,
F f )

interpolation of function f

Template Parameters
NEIGHBORSencodes, which neighbors are accessible: e.g. 00001100 refers to the fifth and the sixth neighbor of the point of interest Their order is as follows (w.r.t. the floor lattice point): 10000000=(0,0,0), 1000000=(1,0,0), 100000=(0,1,0), 10000=(1,1,0), 1000=(0,0,1), 100=(1,0,1), 10=(0,1,1), 1=(1,1,1)
DataDimDimension of function return value
Parameters
distanceDistance from cell
resultResult is written here
fFunction which is to interpolate
missingDirectionsNeighbor points where function is not evaluable.

Definition at line 211 of file interpolation3d.h.

212{
213 // eight neighbors: trilinear interpolation
214 if constexpr (NEIGHBORS == 11111111) {
215 interpolate3d<DataDim,CELL,RESULT,F,V>(cell, result, distance, f);
216 }
217
218 // four neighbors (coplanar)
219 else if constexpr (NEIGHBORS == 1111) {
220 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
221 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
222 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
223 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
224 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
225 } else if constexpr (NEIGHBORS == 11110000) {
226 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
227 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
228 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
229 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
230 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
231 } else if constexpr (NEIGHBORS == 1010101) {
232 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
233 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
234 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
235 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
236 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
237 } else if constexpr (NEIGHBORS == 10101010) {
238 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
239 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
240 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
241 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
242 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
243 } else if constexpr (NEIGHBORS == 110011) {
244 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
245 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
246 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
247 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
248 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
249 } else if constexpr (NEIGHBORS == 11001100) {
250 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
251 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
252 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
253 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
254 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
255 } else if constexpr (NEIGHBORS == 10011001) {
256 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
257 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
258 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
259 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
260 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
261 } else if constexpr (NEIGHBORS == 1100110) {
262 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
263 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
264 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
265 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
266 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
267 } else if constexpr (NEIGHBORS == 10100101) {
268 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
269 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
270 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
271 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
272 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
273 } else if constexpr ((NEIGHBORS == 1011010) || (NEIGHBORS == 11011010)) {
274 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
275 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
276 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
277 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
278 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
279 } else if constexpr (NEIGHBORS == 11000011) {
280 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
281 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
282 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
283 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
284 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
285 } else if constexpr (NEIGHBORS == 111100) {
286 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
287 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
288 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
289 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
290 interpolate3d_help_plane<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
291 }
292
293 // three neighbors
294 else if constexpr (NEIGHBORS == 111) {
295 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
296 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
297 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
298 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
299 } else if constexpr (NEIGHBORS == 1011) {
300 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
301 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
302 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
303 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
304 } else if constexpr (NEIGHBORS == 1101) {
305 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
306 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
307 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
308 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
309 } else if constexpr (NEIGHBORS == 10011) {
310 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
311 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
312 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
313 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
314 } else if constexpr (NEIGHBORS == 10101) {
315 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
316 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
317 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
318 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
319 } else if constexpr (NEIGHBORS == 11001) {
320 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
321 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
322 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
323 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
324 } else if constexpr (NEIGHBORS == 100011) {
325 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
326 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
327 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
328 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
329 } else if constexpr (NEIGHBORS == 100101) {
330 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
331 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
332 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
333 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
334 } else if constexpr (NEIGHBORS == 101001) {
335 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
336 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
337 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
338 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
339 } else if constexpr (NEIGHBORS == 110001) {
340 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
341 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
342 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
343 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
344 } else if constexpr (NEIGHBORS == 1000011) {
345 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
346 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
347 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
348 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
349 } else if constexpr (NEIGHBORS == 1000101) {
350 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
351 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
352 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
353 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
354 } else if constexpr (NEIGHBORS == 1001001) {
355 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
356 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
357 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
358 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
359 } else if constexpr (NEIGHBORS == 1010001) {
360 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
361 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
362 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
363 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
364 } else if constexpr (NEIGHBORS == 1100001) {
365 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
366 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
367 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
368 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
369 } else if constexpr (NEIGHBORS == 10000011) {
370 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
371 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
372 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
373 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
374 } else if constexpr (NEIGHBORS == 10000101) {
375 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
376 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
377 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
378 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
379 } else if constexpr (NEIGHBORS == 10001001) {
380 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
381 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
382 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
383 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
384 } else if constexpr (NEIGHBORS == 10010001) {
385 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
386 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
387 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
388 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
389 } else if constexpr (NEIGHBORS == 10010001) {
390 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
391 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
392 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
393 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
394 } else if constexpr (NEIGHBORS == 10100001) {
395 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
396 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
397 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
398 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
399 } else if constexpr (NEIGHBORS == 11000001) {
400 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
401 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
402 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
403 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
404 } else if constexpr (NEIGHBORS == 1110) {
405 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
406 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
407 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
408 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
409 } else if constexpr (NEIGHBORS == 10110) {
410 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
411 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
412 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
413 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
414 } else if constexpr (NEIGHBORS == 11010) {
415 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
416 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
417 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
418 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
419 } else if constexpr (NEIGHBORS == 100110) {
420 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
421 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
422 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
423 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
424 } else if constexpr (NEIGHBORS == 101010) {
425 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
426 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
427 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
428 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
429 } else if constexpr (NEIGHBORS == 110010) {
430 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
431 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
432 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
433 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
434 } else if constexpr (NEIGHBORS == 1000110) {
435 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
436 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
437 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
438 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
439 } else if constexpr (NEIGHBORS == 1001010) {
440 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
441 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
442 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
443 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
444 } else if constexpr (NEIGHBORS == 1010010) {
445 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
446 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
447 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
448 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
449 } else if constexpr (NEIGHBORS == 1100010) {
450 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
451 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
452 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
453 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
454 } else if constexpr (NEIGHBORS == 10000110) {
455 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
456 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
457 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
458 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
459 } else if constexpr (NEIGHBORS == 10001010) {
460 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
461 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
462 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
463 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
464 } else if constexpr (NEIGHBORS == 10010010) {
465 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
466 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
467 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
468 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
469 } else if constexpr (NEIGHBORS == 10100010) {
470 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
471 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
472 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
473 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
474 } else if constexpr (NEIGHBORS == 11000010) {
475 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
476 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
477 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
478 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
479 } else if constexpr (NEIGHBORS == 11100) {
480 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
481 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
482 const Vector<int,3> pointC (util::floor(distance[0]+1), util::floor(distance[1]+1), util::floor(distance[2]));
483 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
484 } else if constexpr (NEIGHBORS == 101100) {
485 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
486 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
487 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]+1), util::floor(distance[2]));
488 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
489 } else if constexpr (NEIGHBORS == 110100) {
490 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
491 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
492 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]+1), util::floor(distance[2]));
493 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
494 } else if constexpr (NEIGHBORS == 1001100) {
495 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
496 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
497 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
498 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
499 } else if constexpr (NEIGHBORS == 1010100) {
500 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
501 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
502 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
503 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
504 } else if constexpr (NEIGHBORS == 1100100) {
505 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
506 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
507 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
508 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
509 } else if constexpr (NEIGHBORS == 10001100) {
510 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
511 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
512 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
513 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
514 } else if constexpr (NEIGHBORS == 10010100) {
515 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
516 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
517 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
518 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
519 } else if constexpr (NEIGHBORS == 10100100) {
520 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
521 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
522 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
523 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
524 } else if constexpr (NEIGHBORS == 11000100) {
525 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
526 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
527 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
528 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
529 } else if constexpr (NEIGHBORS == 111000) {
530 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
531 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
532 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
533 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
534 } else if constexpr (NEIGHBORS == 1011000) {
535 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
536 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
537 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
538 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
539 } else if constexpr (NEIGHBORS == 1101000) {
540 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
541 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
542 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
543 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
544 } else if constexpr (NEIGHBORS == 10011000) {
545 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
546 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
547 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
548 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
549 } else if constexpr (NEIGHBORS == 10101000) {
550 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
551 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
552 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
553 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
554 } else if constexpr (NEIGHBORS == 11001000) {
555 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
556 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
557 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
558 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
559 } else if constexpr (NEIGHBORS == 1110000) {
560 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
561 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
562 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
563 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
564 } else if constexpr (NEIGHBORS == 10110000) {
565 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
566 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
567 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
568 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
569 } else if constexpr (NEIGHBORS == 11010000) {
570 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
571 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
572 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
573 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
574 } else if constexpr (NEIGHBORS == 11100000) {
575 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
576 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
577 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
578 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC);
579 }
580
581 // two neighbors
582 else if constexpr (NEIGHBORS == 11) {
583 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
584 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
585 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
586 } else if constexpr (NEIGHBORS == 101) {
587 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
588 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
589 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
590 } else if constexpr (NEIGHBORS == 1001) {
591 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
592 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
593 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
594 } else if constexpr (NEIGHBORS == 10001) {
595 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
596 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
597 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
598 } else if constexpr (NEIGHBORS == 100001) {
599 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
600 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
601 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
602 } else if constexpr (NEIGHBORS == 1000001) {
603 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
604 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
605 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
606 } else if constexpr (NEIGHBORS == 10000001) {
607 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
608 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
609 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
610 } else if constexpr (NEIGHBORS == 110) {
611 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
612 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
613 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
614 } else if constexpr (NEIGHBORS == 1010) {
615 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
616 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
617 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
618 } else if constexpr (NEIGHBORS == 10010) {
619 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
620 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
621 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
622 } else if constexpr (NEIGHBORS == 100010) {
623 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
624 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
625 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
626 } else if constexpr (NEIGHBORS == 1000010) {
627 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
628 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
629 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
630 } else if constexpr (NEIGHBORS == 10000010) {
631 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
632 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
633 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
634 } else if constexpr (NEIGHBORS == 1100) {
635 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
636 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
637 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
638 } else if constexpr (NEIGHBORS == 10100) {
639 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
640 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
641 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
642 } else if constexpr (NEIGHBORS == 100100) {
643 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
644 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
645 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
646 } else if constexpr (NEIGHBORS == 1000100) {
647 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
648 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
649 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
650 } else if constexpr (NEIGHBORS == 10000100) {
651 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
652 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
653 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
654 } else if constexpr (NEIGHBORS == 11000) {
655 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
656 const Vector<int,3> pointB (util::floor(distance[0]+1), util::floor(distance[1]+1), util::floor(distance[2]));
657 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
658 } else if constexpr (NEIGHBORS == 101000) {
659 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
660 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]+1), util::floor(distance[2]));
661 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
662 } else if constexpr (NEIGHBORS == 1001000) {
663 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
664 const Vector<int,3> pointB (util::floor(distance[0]+1), util::floor(distance[1]), util::floor(distance[2]));
665 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
666 } else if constexpr (NEIGHBORS == 10001000) {
667 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
668 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
669 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
670 } else if constexpr (NEIGHBORS == 110000) {
671 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
672 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]+1), util::floor(distance[2]));
673 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
674 } else if constexpr (NEIGHBORS == 1010000) {
675 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
676 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
677 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
678 } else if constexpr (NEIGHBORS == 10010000) {
679 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
680 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
681 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
682 } else if constexpr (NEIGHBORS == 1100000) {
683 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
684 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
685 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
686 } else if constexpr (NEIGHBORS == 10100000) {
687 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
688 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
689 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
690 } else if constexpr (NEIGHBORS == 11000000) {
691 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
692 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
693 interpolate3d_help<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB);
694 }
695 // one neighbor: constant extrapolation
696 else if constexpr (NEIGHBORS == 1) {
697 const Vector<int,3> point (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
698 f(cell.neighbor(point), result);
699 } else if constexpr (NEIGHBORS == 10) {
700 const Vector<int,3> point (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
701 f(cell.neighbor(point), result);
702 } else if constexpr (NEIGHBORS == 100) {
703 const Vector<int,3> point (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
704 f(cell.neighbor(point), result);
705 } else if constexpr (NEIGHBORS == 1000) {
706 const Vector<int,3> point (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
707 f(cell.neighbor(point), result);
708 } else if constexpr (NEIGHBORS == 10000) {
709 const Vector<int,3> point (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
710 f(cell.neighbor(point), result);
711 } else if constexpr (NEIGHBORS == 100000) {
712 const Vector<int,3> point (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
713 f(cell.neighbor(point), result);
714 } else if constexpr (NEIGHBORS == 1000000) {
715 const Vector<int,3> point (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
716 f(cell.neighbor(point), result);
717 } else if constexpr (NEIGHBORS == 10000000) {
718 const Vector<int,3> point (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
719 f(cell.neighbor(point), result);
720 }
721
722 // four or more linearly independent neighbors: linear interpolation (use at most four points)
723 else if constexpr ((NEIGHBORS % 100000 == 10111) || (NEIGHBORS % 100000 == 11111)) {
724 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
725 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
726 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
727 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
728 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
729 } else if constexpr ((NEIGHBORS % 1000000 == 100111) || (NEIGHBORS % 1000000 == 101111)) {
730 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
731 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
732 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
733 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
734 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
735 } else if constexpr ((NEIGHBORS == 1000111) || (NEIGHBORS == 11000111) || (NEIGHBORS == 11001111) || (NEIGHBORS == 1001111)) {
736 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
737 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
738 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
739 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
740 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
741 } else if constexpr ((NEIGHBORS == 10000111) || (NEIGHBORS == 10001111)) {
742 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
743 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
744 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
745 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
746 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
747 }
748 else if constexpr (NEIGHBORS % 100000 == 11011) {
749 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
750 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
751 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
752 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
753 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
754 } else if constexpr (NEIGHBORS % 1000000 == 101011) {
755 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
756 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
757 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
758 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
759 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
760 } else if constexpr ((NEIGHBORS == 1001011) || (NEIGHBORS == 11001011)) {
761 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
762 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
763 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
764 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
765 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
766 } else if constexpr (NEIGHBORS == 10001011) {
767 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
768 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
769 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
770 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
771 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
772 }
773 else if constexpr (NEIGHBORS % 100000 == 11101) {
774 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
775 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
776 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
777 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
778 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
779 } else if constexpr (NEIGHBORS % 1000000 == 101101) {
780 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
781 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
782 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
783 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
784 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
785 } else if constexpr ((NEIGHBORS == 1001101) || (NEIGHBORS == 11001101)) {
786 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
787 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
788 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
789 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
790 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
791 } else if constexpr (NEIGHBORS == 10001101) {
792 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
793 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
794 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
795 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
796 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
797 }
798 else if constexpr (NEIGHBORS % 100000 == 11110) {
799 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
800 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
801 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
802 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
803 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
804 } else if constexpr (NEIGHBORS % 1000000 == 101110) {
805 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
806 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
807 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
808 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
809 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
810 } else if constexpr ((NEIGHBORS == 1001110) || (NEIGHBORS == 11001110)) {
811 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
812 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
813 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
814 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
815 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
816 } else if constexpr (NEIGHBORS == 10001110) {
817 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
818 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
819 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
820 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
821 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
822 }
823 else if constexpr (NEIGHBORS == 11101000) {
824 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
825 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
826 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
827 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
828 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
829 } else if constexpr (NEIGHBORS == 11100100) {
830 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
831 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
832 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
833 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
834 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
835 } else if constexpr (NEIGHBORS == 11100010) {
836 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
837 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
838 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
839 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
840 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
841 } else if constexpr (NEIGHBORS == 11100001) {
842 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
843 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
844 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
845 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
846 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
847 }
848 else if constexpr (NEIGHBORS == 11011000) {
849 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
850 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
851 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
852 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
853 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
854 } else if constexpr (NEIGHBORS == 11010100) {
855 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
856 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
857 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
858 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
859 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
860 } else if constexpr ((NEIGHBORS == 11010010) || (NEIGHBORS == 11110010)) {
861 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
862 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
863 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
864 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
865 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
866 } else if constexpr (NEIGHBORS == 11010001) {
867 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
868 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
869 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
870 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
871 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
872 }
873 else if constexpr (NEIGHBORS == 10111000) {
874 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
875 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
876 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
877 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
878 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
879 } else if constexpr (NEIGHBORS == 10110100) {
880 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
881 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
882 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
883 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
884 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
885 } else if constexpr (NEIGHBORS == 10110010) {
886 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
887 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
888 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
889 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
890 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
891 } else if constexpr (NEIGHBORS == 10110001) {
892 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
893 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
894 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
895 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
896 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
897 }
898 else if constexpr ((NEIGHBORS == 1111000) || (NEIGHBORS == 11111000)) {
899 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
900 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
901 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
902 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
903 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
904 } else if constexpr ((NEIGHBORS == 1110100) || (NEIGHBORS == 11110100)) {
905 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
906 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
907 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
908 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
909 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
910 } else if constexpr (NEIGHBORS == 1110010) {
911 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
912 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
913 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
914 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
915 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
916 } else if constexpr ((NEIGHBORS == 1110001) || (NEIGHBORS == 11110001)) {
917 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
918 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
919 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
920 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
921 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
922 }
923 else if constexpr (NEIGHBORS == 10101100) {
924 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
925 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
926 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
927 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
928 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
929 } else if constexpr (NEIGHBORS == 10101001) {
930 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
931 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
932 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
933 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
934 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
935 }
936 else if constexpr ((NEIGHBORS == 10100110) || (NEIGHBORS == 11100110)) {
937 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
938 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
939 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
940 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
941 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
942 } else if constexpr (NEIGHBORS == 10100011) {
943 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
944 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
945 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
946 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
947 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
948 }
949 else if constexpr (NEIGHBORS == 11001010) {
950 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
951 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
952 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
953 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
954 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
955 } else if constexpr (NEIGHBORS == 10011010) {
956 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
957 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
958 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
959 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
960 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
961 }
962 else if constexpr ((NEIGHBORS == 1101010) || (NEIGHBORS == 11101010)) {
963 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
964 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
965 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
966 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
967 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
968 } else if constexpr (NEIGHBORS % 1000000 == 111010) {
969 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
970 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
971 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
972 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
973 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
974 }
975 else if constexpr ((NEIGHBORS == 1011100) || (NEIGHBORS == 1111100) || (NEIGHBORS == 11111100) || (NEIGHBORS == 11011100)) {
976 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
977 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
978 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
979 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
980 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
981 } else if constexpr ((NEIGHBORS == 1010110) || (NEIGHBORS == 11010110)) {
982 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
983 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
984 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
985 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
986 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
987 }
988 else if constexpr ((NEIGHBORS == 1011001) || (NEIGHBORS == 11011001)) {
989 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
990 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
991 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
992 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
993 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
994 } else if constexpr ((NEIGHBORS == 1010011) || (NEIGHBORS == 1110011) || (NEIGHBORS == 11110011) || (NEIGHBORS == 11010011)) {
995 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
996 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
997 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
998 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
999 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1000 }
1001 else if constexpr (NEIGHBORS == 11000101) {
1002 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
1003 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
1004 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
1005 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
1006 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1007 } else if constexpr ((NEIGHBORS == 1100101) || (NEIGHBORS == 11100101)) {
1008 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
1009 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
1010 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
1011 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
1012 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1013 }
1014 else if constexpr ((NEIGHBORS == 10010101) || (NEIGHBORS == 11010101)) {
1015 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
1016 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
1017 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
1018 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
1019 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1020 } else if constexpr (NEIGHBORS % 1000000 == 110101) {
1021 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
1022 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
1023 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
1024 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
1025 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1026 }
1027 else if constexpr (NEIGHBORS == 11001001) {
1028 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
1029 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
1030 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
1031 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
1032 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1033 } else if constexpr (NEIGHBORS == 11000110) {
1034 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
1035 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
1036 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
1037 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
1038 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1039 } else if constexpr ((NEIGHBORS == 10011100) || (NEIGHBORS == 10111100)) {
1040 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
1041 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
1042 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
1043 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
1044 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1045 } else if constexpr ((NEIGHBORS == 1101100) || (NEIGHBORS == 11101100)) {
1046 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
1047 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
1048 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
1049 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
1050 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1051 } else if constexpr (NEIGHBORS % 1000000 == 110110) {
1052 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
1053 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
1054 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
1055 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
1056 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1057 } else if constexpr (NEIGHBORS % 1000000 == 111001) {
1058 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
1059 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
1060 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
1061 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
1062 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1063 } else if constexpr ((NEIGHBORS == 1100011) || (NEIGHBORS == 11100011)) {
1064 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
1065 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
1066 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
1067 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
1068 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1069 } else if constexpr ((NEIGHBORS == 10010011) || (NEIGHBORS == 10110011)) {
1070 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
1071 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
1072 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
1073 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
1074 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1075 }
1076 else if constexpr (NEIGHBORS == 10010110) {
1077 const Vector<int,3> pointA (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2]));
1078 const Vector<int,3> pointB (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2]));
1079 const Vector<int,3> pointC (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2])+1);
1080 const Vector<int,3> pointD (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2])+1);
1081 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1082 } else if constexpr ((NEIGHBORS == 1101001) || (NEIGHBORS == 11101001)) {
1083 const Vector<int,3> pointA (util::floor(distance[0])+1, util::floor(distance[1]), util::floor(distance[2]));
1084 const Vector<int,3> pointB (util::floor(distance[0]), util::floor(distance[1])+1, util::floor(distance[2]));
1085 const Vector<int,3> pointC (util::floor(distance[0]), util::floor(distance[1]), util::floor(distance[2])+1);
1086 const Vector<int,3> pointD (util::floor(distance[0])+1, util::floor(distance[1])+1, util::floor(distance[2])+1);
1087 interpolate3d_help_li<DataDim,CELL,RESULT,F,V>(cell, result, distance, f, pointA, pointB, pointC, pointD);
1088 }
1089
1090 else {
1091 std::string s = "Invalid NEIGHBORS" + std::to_string(NEIGHBORS);
1092 throw std::invalid_argument(s);
1093 }
1094}
platform_constant Fraction s[Q]
Definition mrt.h:65

References olb::util::floor(), interpolate3d(), interpolate3d_help(), interpolate3d_help_li(), and interpolate3d_help_plane().

+ Here is the call graph for this function:

◆ interpolate3d_help() [1/2]

template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void olb::interpolate3d_help ( CELL & cell,
RESULT & result,
const Vector< V, 3 > distance,
F f,
Vector< int, 3 > pointA,
Vector< int, 3 > pointB )

Linear interpolation between two points (constant in the orthogonal directions)

Definition at line 178 of file interpolation3d.h.

180{
181 const V refDistanceSq = norm_squared(Vector<V,3>(pointA - pointB));
182 const V alpha = ((distance - pointB) * (pointA - pointB)) / refDistanceSq;
183 for (unsigned i=0; i<DataDim; ++i) {
184 result[i] = V();
185 }
186 V resNeighbor[DataDim];
187 f(cell.neighbor(pointA), resNeighbor);
188 for (unsigned i = 0; i < DataDim; ++i) {
189 result[i] += alpha * resNeighbor[i];
190 }
191 f(cell.neighbor(pointB), resNeighbor);
192 for (unsigned i = 0; i < DataDim; ++i) {
193 result[i] += (1 - alpha) * resNeighbor[i];
194 }
195}

References norm_squared().

+ Here is the call graph for this function:

◆ interpolate3d_help() [2/2]

template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void olb::interpolate3d_help ( CELL & cell,
RESULT & result,
const Vector< V, 3 > distance,
F f,
Vector< int, 3 > pointA,
Vector< int, 3 > pointB,
Vector< int, 3 > pointC )

Linear interpolation between three points (constant in the orthogonal direction)

Definition at line 146 of file interpolation3d.h.

148{
149 const Vector<V,3> v1 = pointB - pointA;
150 const Vector<V,3> v2 = pointC - pointA;
151 const Vector<V,3> v = distance - pointA;
152 const auto normal = crossProduct3D(v1, v2);
153 const auto nLenSq = norm_squared(normal);
154 const auto lc = util::solveLinearSystem(v1, v2, normal,
155 v - ((v*normal)/nLenSq)*normal); // v projected to plane
156 // evaluate linear function
157 for (unsigned i=0; i<DataDim; ++i) {
158 result[i] = V();
159 }
160 V resNeighbor[DataDim];
161 f(cell.neighbor(pointA), resNeighbor);
162 for (unsigned i = 0; i < DataDim; ++i) {
163 result[i] += (1 - lc[0] - lc[1]) * resNeighbor[i];
164 }
165 f(cell.neighbor(pointB), resNeighbor);
166 for (unsigned i = 0; i < DataDim; ++i) {
167 result[i] += lc[0] * resNeighbor[i];
168 }
169 f(cell.neighbor(pointC), resNeighbor);
170 for (unsigned i = 0; i < DataDim; ++i) {
171 result[i] += lc[1] * resNeighbor[i];
172 }
173}
constexpr Vector< T, 3 > crossProduct3D(const ScalarVector< T, 3, IMPL > &a, const ScalarVector< T, 3, IMPL_ > &b) any_platform
Definition vector.h:263

References crossProduct3D(), norm_squared(), and olb::util::solveLinearSystem().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ interpolate3d_help_li()

template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void olb::interpolate3d_help_li ( CELL & cell,
RESULT & result,
const Vector< V, 3 > distance,
F f,
Vector< int, 3 > pointA,
Vector< int, 3 > pointB,
Vector< int, 3 > pointC,
Vector< int, 3 > pointD )

Interpolation between four points (linear independent case)

Definition at line 68 of file interpolation3d.h.

70{
71 const Vector<Vector<V,3>,3> v {pointB - pointA,
72 pointC - pointA,
73 pointD - pointA};
74 const V det = util::determinant(v[0], v[1], v[2]);
75 OLB_PRECONDITION (det != 0);
76
77 // linear interpolation
78 const auto lc = util::solveLinearSystem_help(v[0], v[1], v[2],
79 distance - pointA, det);
80 // evaluate linear function
81 for (unsigned i=0; i<DataDim; ++i) {
82 result[i] = V();
83 }
84 V resNeighbor[DataDim];
85 f(cell.neighbor(pointA), resNeighbor);
86 for (unsigned i = 0; i < DataDim; ++i) {
87 result[i] += (1 - lc[0] - lc[1] - lc[2]) * resNeighbor[i];
88 }
89 f(cell.neighbor(pointB), resNeighbor);
90 for (unsigned i = 0; i < DataDim; ++i) {
91 result[i] += lc[0] * resNeighbor[i];
92 }
93 f(cell.neighbor(pointC), resNeighbor);
94 for (unsigned i = 0; i < DataDim; ++i) {
95 result[i] += lc[1] * resNeighbor[i];
96 }
97 f(cell.neighbor(pointD), resNeighbor);
98 for (unsigned i = 0; i < DataDim; ++i) {
99 result[i] += lc[2] * resNeighbor[i];
100 }
101}
#define OLB_PRECONDITION(COND)
Definition olbDebug.h:46

References olb::util::determinant(), OLB_PRECONDITION, and olb::util::solveLinearSystem_help().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ interpolate3d_help_plane()

template<unsigned DataDim, typename CELL , typename RESULT , typename F , typename V = typename CELL::value_t>
void olb::interpolate3d_help_plane ( CELL & cell,
RESULT & result,
const Vector< V, 3 > distance,
F f,
Vector< int, 3 > pointA,
Vector< int, 3 > pointB,
Vector< int, 3 > pointC,
Vector< int, 3 > pointD )

Interpolation between four points (coplanar case)

Definition at line 106 of file interpolation3d.h.

108{
109 const Vector<Vector<V,3>,3> v {pointB - pointA,
110 pointC - pointA,
111 pointD - pointA};
112 // bilinear interpolation in plane (constant in other direction)
113 const auto normal = crossProduct3D(v[0], v[1]);
114 const auto nLenSq = norm_squared(normal);
115 const auto projBase = distance - pointA
116 - (((distance - pointA)*normal)/nLenSq)*normal;
117
118 const V w0 = projBase* v[0] / norm_squared(v[0]);
119 const V w1 = projBase* v[2] / norm_squared(v[2]);
120
121 // evaluate bilinear function
122 for (unsigned i=0; i<DataDim; ++i) {
123 result[i] = V();
124 }
125 V resNeighbor[DataDim];
126 f(cell.neighbor(pointA), resNeighbor);
127 for (unsigned i = 0; i < DataDim; ++i) {
128 result[i] += (1-w0) * (1-w1) * resNeighbor[i];
129 }
130 f(cell.neighbor(pointC), resNeighbor);
131 for (unsigned i = 0; i < DataDim; ++i) {
132 result[i] += w0 * w1 * resNeighbor[i];
133 }
134 f(cell.neighbor(pointB), resNeighbor);
135 for (unsigned i = 0; i < DataDim; ++i) {
136 result[i] += w0 * (1-w1) * resNeighbor[i];
137 }
138 f(cell.neighbor(pointD), resNeighbor);
139 for (unsigned i = 0; i < DataDim; ++i) {
140 result[i] += (1-w0) * w1 * resNeighbor[i];
141 }
142}

References crossProduct3D(), and norm_squared().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ interpolateMomentum()

template<typename CELL , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
Vector< V, DESCRIPTOR::d > olb::interpolateMomentum ( CELL & cell,
Vector< V, DESCRIPTOR::d > distance )

Definition at line 33 of file knudsenVelocityPostProcessor.h.

33 {
36 for( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
37 floorV[iD] = util::floor(distance[iD]);
38 }
39 Vector<Vector<V,DESCRIPTOR::d>,(DESCRIPTOR::d==2)*4+(DESCRIPTOR::d==3)*8> surroundingPoints(floorV);
40 surroundingPoints[1][0] += 1.;
41 surroundingPoints[2][1] += 1.;
42 surroundingPoints[3][0] += 1.; surroundingPoints[3][1] += 1.;
43 if( DESCRIPTOR::d == 3) {
44 surroundingPoints[4][2] += 1.;
45 surroundingPoints[5][0] += 1.; surroundingPoints[5][2] += 1.;
46 surroundingPoints[6][1] += 1.; surroundingPoints[6][2] += 1.;
47 surroundingPoints[7][0] += 1.; surroundingPoints[7][1] += 1.; surroundingPoints[7][2] += 1.;
48 }
49
50 V sumWeight = V(0);
51 for (auto point : surroundingPoints) {
52 const Vector<V,DESCRIPTOR::d> dist = distance - point;
53 V weight = V(1);
54 for( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
55 weight *=(V(1.) - util::abs(dist[iD]));
56 }
57 auto jNP = cell.neighbor(point).template getField<descriptors::VELOCITY>();
58 for( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
59 if(!std::isnan(jNP[iD])) {
60 momentum[iD] += jNP[iD]*weight;
61 sumWeight += (iD==0)*weight;
62 }
63 }
64 }
65 momentum *= V(1)/sumWeight;
66 return momentum;
67 };
bool distance(S &distance, const Vector< S, D > &origin, const Vector< S, D > &direction, S precision, S pitch, F1 isInside, F2 isInsideBoundingBox)

References olb::util::abs(), and olb::util::floor().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ interpolateStrainRate()

template<typename CELL , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
void olb::interpolateStrainRate ( CELL & cell,
Vector< V, DESCRIPTOR::d > distance,
V pi[util::TensorVal< DESCRIPTOR >::n] )

Definition at line 62 of file turbulentWallModelPostProcessor.h.

62 {
64 for( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
65 floorV[iD] = util::floor(distance[iD]);
66 }
67 Vector<Vector<V,DESCRIPTOR::d>,(DESCRIPTOR::d==2)*4+(DESCRIPTOR::d==3)*8> surroundingPoints(floorV);
68 surroundingPoints[1][0] += 1.;
69 surroundingPoints[2][1] += 1.;
70 surroundingPoints[3][0] += 1.; surroundingPoints[3][1] += 1.;
71 if( DESCRIPTOR::d == 3) {
72 surroundingPoints[4][2] += 1.;
73 surroundingPoints[5][0] += 1.; surroundingPoints[5][2] += 1.;
74 surroundingPoints[6][1] += 1.; surroundingPoints[6][2] += 1.;
75 surroundingPoints[7][0] += 1.; surroundingPoints[7][1] += 1.; surroundingPoints[7][2] += 1.;
76 }
77
78 for (auto point : surroundingPoints) {
79 const Vector<V,DESCRIPTOR::d> dist = distance - point;
80 V weight = V(1);
81 for( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
82 weight *=(V(1.) - util::abs(dist[iD]));
83 }
84 V piNP[util::TensorVal<DESCRIPTOR>::n] {V(0)};
85 cell.neighbor(point).computeStress(piNP);
86 for ( int iN = 0; iN < util::TensorVal<DESCRIPTOR>::n; iN++ ) {
87 pi[iN] += piNP[iN] * weight;
88 }
89 }
90 };

References olb::util::abs(), and olb::util::floor().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ interpolateVelocity()

template<typename CELL , typename V = typename CELL::value_t, typename DESCRIPTOR = typename CELL::descriptor_t>
void olb::interpolateVelocity ( CELL & cell,
Vector< V, DESCRIPTOR::d > distance,
V u_y2[DESCRIPTOR::d] )

Definition at line 31 of file turbulentWallModelPostProcessor.h.

31 {
33 for( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
34 floorV[iD] = util::floor(distance[iD]);
35 }
36 Vector<Vector<V,DESCRIPTOR::d>,(DESCRIPTOR::d==2)*4+(DESCRIPTOR::d==3)*8> surroundingPoints(floorV);
37 surroundingPoints[1][0] += 1.;
38 surroundingPoints[2][1] += 1.;
39 surroundingPoints[3][0] += 1.; surroundingPoints[3][1] += 1.;
40 if( DESCRIPTOR::d == 3) {
41 surroundingPoints[4][2] += 1.;
42 surroundingPoints[5][0] += 1.; surroundingPoints[5][2] += 1.;
43 surroundingPoints[6][1] += 1.; surroundingPoints[6][2] += 1.;
44 surroundingPoints[7][0] += 1.; surroundingPoints[7][1] += 1.; surroundingPoints[7][2] += 1.;
45 }
46
47 for (auto point : surroundingPoints) {
48 const Vector<V,DESCRIPTOR::d> dist = distance - point;
49 V weight = V(1);
50 for( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
51 weight *=(V(1.) - util::abs(dist[iD]));
52 }
53 V uNP[DESCRIPTOR::d] = {0.};
54 cell.neighbor(point).computeU(uNP);
55 for( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
56 u_y2[iD] += uNP[iD]*weight;
57 }
58 }
59 };

References olb::util::abs(), and olb::util::floor().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ isCouplingFaceInterior()

template<typename T >
bool olb::isCouplingFaceInterior ( Vector< T, 2 > p,
Vector< T, 2 > a,
Vector< T, 2 > b,
Vector< T, 2 > c,
T w )

Definition at line 34 of file couplingFaceF2D.h.

35{
36 const bool isFrontAB = (a != b) && (((b[0] - a[0]) * (p[1] - a[1]) - (b[1] - a[1]) * (p[0] - a[0])) >= 0);
37 const bool isFrontBC = (c != b) && (((c[0] - b[0]) * (p[1] - b[1]) - (c[1] - b[1]) * (p[0] - b[0])) >= 0);
38
39 return !(isFrontAB || isFrontBC);
40}
+ Here is the caller graph for this function:

◆ isPlatformCPU()

bool olb::isPlatformCPU ( Platform platform)
constexpr

Returns true if platform is equal to Platform::CPU_*.

Definition at line 83 of file platform.h.

83 {
84 switch (platform) {
85#ifdef PLATFORM_CPU_SISD
86 case Platform::CPU_SISD:
87 return true;
88#endif
89#ifdef PLATFORM_CPU_SIMD
90 case Platform::CPU_SIMD:
91 return true;
92#endif
93#ifdef PLATFORM_GPU_CUDA
94 case Platform::GPU_CUDA:
95 return false;
96#endif
97 default:
98 throw std::invalid_argument("Invalid PLATFORM");
99 }
100}

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.

67{
68 //std::size_t binarySize = serializer.getSize();
69 serializer.resetCounter();
70
71 // read binary size from first integer of stream
72 std::size_t binarySize;
73 if (enforceUint) {
74 unsigned int uintBinarySize;
75 Base64Decoder<unsigned int> sizeDecoder(istr, 1);
76 sizeDecoder.decode(&uintBinarySize, 1);
77 binarySize = uintBinarySize;
78 }
79 else {
80 Base64Decoder<std::size_t> sizeDecoder(istr, 1);
81 sizeDecoder.decode(&binarySize, 1);
82 }
83 //OLB_PRECONDITION(binarySize == serializer.getSize());
84
85
86 Base64Decoder<bool> dataDecoder(istr, binarySize);
87
88 std::size_t blockSize;
89 bool* dataBuffer = nullptr;
90 while (dataBuffer = serializer.getNextBlock(blockSize, true), dataBuffer != nullptr) {
91 dataDecoder.decode(dataBuffer, blockSize);
92 }
93 serializer.resetCounter();
94}

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

147{
148 for (unsigned iDim=0; iDim < D; ++iDim) {
149 if (lhs[iDim] > rhs[iDim]) return true;
150 if (lhs[iDim] < rhs[iDim]) return false;
151 }
152 return false;
153}

◆ lex_greater_eq()

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
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.

169{
170 for (unsigned iDim=0; iDim < D; ++iDim) {
171 if (lhs[iDim] > rhs[iDim]) return true;
172 if (lhs[iDim] < rhs[iDim]) return false;
173 }
174 return true;
175}

◆ lex_smaller()

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
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.

136{
137 for (unsigned iDim=0; iDim < D; ++iDim) {
138 if (lhs[iDim] < rhs[iDim]) return true;
139 if (lhs[iDim] > rhs[iDim]) return false;
140 }
141 return false;
142}

◆ lex_smaller_eq()

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
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.

158{
159 for (unsigned iDim=0; iDim < D; ++iDim) {
160 if (lhs[iDim] < rhs[iDim]) return true;
161 if (lhs[iDim] > rhs[iDim]) return false;
162 }
163 return true;
164}

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

110{
111 std::vector<double> linspace{}; // initalize to empty
112 if ( util::nearZero( a-b ) ) {
113 return linspace;
114 }
115 int const h = (int) ( (b-a) / stepsize);
116 for (int n = 0; n <= h; n++) {
117 linspace.push_back( a +double(n)/h * b );
118 }
119 return linspace;
120}

References olb::util::nearZero().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ makeParametersD()

template<concepts::BaseType T, concepts::Descriptor DESCRIPTOR, typename... MAP>
auto olb::makeParametersD ( MAP &&... args)

Builds a ParametersD from field-value pairs.

Definition at line 194 of file fieldParametersD.h.

194 {
195 auto tuple = std::tie(args...);
196 using result_t = typename ParametersD<T,DESCRIPTOR>::template include<typename meta::map<MAP...>::keys_t>;
197 result_t params;
198 result_t::fields_t::for_each([&](auto id) {
199 using field_t = typename decltype(id)::type;
200 constexpr unsigned idx = result_t::fields_t::template index<field_t>();
201 // If parameter is pointer-valued…
202 if constexpr (std::is_pointer_v<typename field_t::template value_type<T>>) {
203 auto& fieldArray = std::get<2*idx+1>(tuple);
204 // …and AbstractFieldArrayD is provided
205 if constexpr (std::is_base_of_v<AbstractFieldArrayBase,
206 typename std::remove_reference_t<decltype(fieldArray)>>) {
207 using arg_field_t = typename std::remove_reference_t<decltype(fieldArray)>::field_t;
208 using arg_descriptor_t = typename std::remove_reference_t<decltype(fieldArray)>::descriptor_t;
209 static_assert(arg_descriptor_t::template size<arg_field_t>() == DESCRIPTOR::template size<field_t>(),
210 "Pointer field and field array must match dimension");
211 callUsingConcretePlatform<ConcretizableFieldArrayD<T,arg_descriptor_t,arg_field_t>>(
212 fieldArray.getPlatform(),
213 &fieldArray.asColumnVectorBase(),
214 [&](auto* concreteFieldArray) {
215 if constexpr (std::remove_reference_t<decltype(*concreteFieldArray)>::platform == Platform::GPU_CUDA) {
216 FieldD<T,DESCRIPTOR,field_t> fieldPtr{};
217 for (unsigned iD=0; iD < concreteFieldArray->d; ++iD) {
218 fieldPtr[iD] = concreteFieldArray->operator[](iD).deviceData();
219 }
220 params.template set<field_t>(fieldPtr);
221 } else {
222 FieldD<T,DESCRIPTOR,field_t> fieldPtr{};
223 for (unsigned iD=0; iD < concreteFieldArray->d; ++iD) {
224 fieldPtr[iD] = concreteFieldArray->operator[](iD).data();
225 }
226 params.template set<field_t>(fieldPtr);
227 }
228 }
229 );
230 } else {
231 params.template set<field_t>(fieldArray);
232 }
233 // Default case, just try to set what is given
234 } else {
235 params.template set<field_t>(std::get<2*idx+1>(tuple));
236 }
237 });
238 return params;
239}
Base to identify whether a type is some kind of AbstractFieldArrayD without caring about the specific...
Definition fieldArrayD.h:45
Set of FIELD-valued parameters.

References callUsingConcretePlatform().

+ Here is the call graph for this function:

◆ makeSharedAbstractFieldArrayD()

template<typename T , typename DESCRIPTOR , typename FIELD >
std::unique_ptr< AbstractFieldArrayD< T, DESCRIPTOR, FIELD > > olb::makeSharedAbstractFieldArrayD ( LoadBalancer< T > & loadBalancer,
std::size_t count = 1 )

Constructs FieldArrayD accessible on all locally used platforms.

For data that is shared between blocks, e.g. reference porosity fields

Definition at line 342 of file fieldArrayD.h.

344{
345 #if defined(PLATFORM_GPU_CUDA)
346 if (loadBalancer.isLocal(Platform::GPU_CUDA)) {
347 return std::unique_ptr<AbstractFieldArrayD<T,DESCRIPTOR,FIELD>>(
349 } else {
350 return std::unique_ptr<AbstractFieldArrayD<T,DESCRIPTOR,FIELD>>(
351 new FieldArrayD<T,DESCRIPTOR,Platform::CPU_SISD,FIELD>(count));
352 }
353 #else
354 return std::unique_ptr<AbstractFieldArrayD<T,DESCRIPTOR,FIELD>>(
355 new FieldArrayD<T,DESCRIPTOR,Platform::CPU_SISD,FIELD>(count));
356 #endif
357}
SoA storage for instances of a single FIELD.
bool isLocal(const int &glob) const
returns whether glob is on this process

References GPU_CUDA, and olb::LoadBalancer< T >::isLocal().

+ Here is the call graph for this function:

◆ makeSharedBlockD()

template<typename T , typename DESCRIPTOR , typename... ARGS>
std::unique_ptr< BlockD< T, DESCRIPTOR > > olb::makeSharedBlockD ( LoadBalancer< T > & loadBalancer,
ARGS &&... args )

Constructs BlockD accessible on all locally used platforms.

For data that is shared between blocks, e.g. reference porosity fields

Definition at line 358 of file blockD.h.

360{
361 #if defined(PLATFORM_GPU_CUDA)
362 if (loadBalancer.isLocal(Platform::GPU_CUDA)) {
363 return std::unique_ptr<BlockD<T,DESCRIPTOR>>(
364 new ConcreteBlockD<T,DESCRIPTOR,Platform::GPU_CUDA>(std::forward<ARGS&&>(args)...));
365 } else {
366 return std::unique_ptr<BlockD<T,DESCRIPTOR>>(
367 new ConcreteBlockD<T,DESCRIPTOR,Platform::CPU_SISD>(std::forward<ARGS&&>(args)...));
368 }
369 #else
370 return std::unique_ptr<BlockD<T,DESCRIPTOR>>(
371 new ConcreteBlockD<T,DESCRIPTOR,Platform::CPU_SISD>(std::forward<ARGS&&>(args)...));
372 #endif
373}
Implementation of BlockD on a concrete PLATFORM.
Definition cell.h:32

References GPU_CUDA, and olb::LoadBalancer< T >::isLocal().

+ Here is the call graph for this function:

◆ makeSharedData()

template<typename T , typename DESCRIPTOR , typename... ARGS>
std::unique_ptr< Data< T, DESCRIPTOR > > olb::makeSharedData ( LoadBalancer< T > & loadBalancer,
ARGS &&... args )

Constructs Data accessible on all locally used platforms.

Definition at line 539 of file data.h.

541{
542 #if defined(PLATFORM_GPU_CUDA)
543 if (loadBalancer.isLocal(Platform::GPU_CUDA)) {
544 return std::unique_ptr<Data<T,DESCRIPTOR>>(
545 new ConcreteData<T,DESCRIPTOR,Platform::GPU_CUDA>(std::forward<ARGS&&>(args)...));
546 } else {
547 return std::unique_ptr<Data<T,DESCRIPTOR>>(
548 new ConcreteData<T,DESCRIPTOR,Platform::CPU_SISD>(std::forward<ARGS&&>(args)...));
549 }
550 #else
551 return std::unique_ptr<Data<T,DESCRIPTOR>>(
552 new ConcreteData<T,DESCRIPTOR,Platform::CPU_SISD>(std::forward<ARGS&&>(args)...));
553 #endif
554}
Storage of any FIELD_TYPE data on PLATFORM.
Definition data.h:424

References GPU_CUDA, and olb::LoadBalancer< T >::isLocal().

+ Here is the call graph for this function:

◆ makeSuperLatticeO()

template<typename OPERATOR , typename T , typename DESCRIPTOR >
auto olb::makeSuperLatticeO ( SuperLattice< T, DESCRIPTOR > & lattice)

Definition at line 50 of file superLatticeO.h.

50 {
51 return std::make_unique<SuperLatticeCoupling<SingleLatticeO<OPERATOR>,
55}
Wrapper class for SuperLatticeCoupling with only a single lattice instance in order to allow operator...
Pair of base value and descriptor type.
Definition base.h:123
+ Here is the caller graph for this function:

◆ makeWriteFunctorO()

template<typename FUNCTOR , typename TO , typename T , typename DESCRIPTOR >
auto olb::makeWriteFunctorO ( SuperLattice< T, DESCRIPTOR > & lattice)

Definition at line 57 of file writeFunctorO.h.

57 {
58 return makeSuperLatticeO<operators::WriteFunctorO<FUNCTOR,TO>>(lattice);
59}

References makeSuperLatticeO().

+ Here is the call graph for this function:

◆ mapStringToDynamics()

template<typename T , typename DESCRIPTOR >
DynamicsPromise< T, DESCRIPTOR > olb::mapStringToDynamics ( std::string name)

Definition at line 164 of file availableDynamicList.h.

164 {
165 OstreamManager clout("DynamicsFromXML");
166 bool dynamicFound = false;
168
169 momenta::available_dynamics<T, DESCRIPTOR>::for_each([&](auto dynamic) {
170 if (name == DynamicsPromise<T, DESCRIPTOR>(dynamic).realize()->getName()) {
171 tmp = DynamicsPromise<T, DESCRIPTOR>(dynamic);
172 clout << DynamicsPromise<T, DESCRIPTOR>(dynamic).realize()->getName() << std::endl;
173 dynamicFound = true;
174 }
175 });
176
177 if (dynamicFound) {
178 clout << "Returned dynamic" << std::endl;
179 return DynamicsPromise<T, DESCRIPTOR>(tmp);
180 } else {
181 throw std::invalid_argument("Model " + name + " not available");
182 }
183 }
Factory for instances of a specific Dynamics type.
Dynamics constructed as a tuple of momenta, equilibrium and collision.
Definition interface.h:308
Identity type to pass non-constructible types as value.
Definition meta.h:79

References DynamicsPromise(), olb::meta::list< TYPES >::for_each(), and getName().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ max()

template<typename T , unsigned D, typename IMPL >
T olb::max ( const ScalarVector< T, D, IMPL > & v)
constexpr

Definition at line 466 of file vector.h.

467{
468 T max = v[0];
469 for (unsigned iD=1; iD < D; ++iD) {
470 if (v[iD] > max) {
471 max = v[iD];
472 }
473 }
474 return max;
475}

References max().

+ 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_ >
Vector< T, D > olb::maxv ( const ScalarVector< T, D, IMPL > & v,
const ScalarVector< T, D, IMPL_ > & w )
constexpr

Definition at line 457 of file vector.h.

459{
460 return Vector<T,D>([&v,&w](unsigned iDim) -> T {
461 return util::max(v[iDim], w[iDim]);
462 });
463}

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 ( CuboidDecomposition< T, 3 > & cGeometry,
IndicatorF3D< T > & indicatorF,
int nC )

Splits into nC cuboids by-volume.

Definition at line 75 of file cuboidDecompositionMinimizer.h.

76{
77 // Search for the largest multiplier not dividable by two
78 int initalNc = nC;
79 while ( initalNc % 2 == 0 ) {
80 initalNc /= 2;
81 }
82
83 // Split evenly in initalNc many cuboids and shrink all
84 cGeometry.split(0, initalNc);
85 cGeometry.shrink(indicatorF);
86
87 continueMinimizeByVolume(cGeometry, indicatorF, nC);
88}
void split(int iC, int p)
Splits cuboid iC, removes it and adds p cuboids of same volume.

References continueMinimizeByVolume(), olb::CuboidDecomposition< T, D >::shrink(), and olb::CuboidDecomposition< T, D >::split().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ minimizeByWeight()

template<typename T >
void olb::minimizeByWeight ( CuboidDecomposition< T, 3 > & cGeometry,
IndicatorF3D< T > & indicatorF,
int nC )

Definition at line 91 of file cuboidDecompositionMinimizer.h.

92{
93 cGeometry.setWeights(indicatorF);
94
95 // conduct a prime factorisation for the number of cuboids nC
96 std::vector<int> factors;
97 int initalNc = nC;
98 // iterate over the prime numbes from 0 to 100 (may have to be extended)
99 for (int i : {2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, 41, 43, 47, 53, 59, 61, 67, 71}) {
100 while (initalNc % i == 0) {
101 initalNc /= i;
102 factors.push_back(i);
103 }
104 }
105
106 // recursively split the current cuboids by each prime factor
107 for (int i = factors.size() - 1; i >= 0; i--) {
108 int currentNc = cGeometry.cuboids().size();
109 for (int iC = 0; iC < currentNc; iC++) {
110 // clout << "split cuboid number #" << iC << " in " << factors[i] << " parts" << std::endl;
111 cGeometry.splitByWeight(iC, factors[i], indicatorF);
112 cGeometry.shrink(indicatorF);
113 }
114 for (int iC = 0; iC < currentNc; iC++) {
115 // clout << "delet cuboid number #" << iC << std::endl;
116 cGeometry.remove(0);
117 }
118 }
119}
void setWeights(IndicatorF< T, D > &indicatorF)
Sets the number of full cells of each cuboid.
void splitByWeight(int iC, int p, IndicatorF< T, D > &indicatorF)
Splits cuboid iC, removes it and adds p cuboids of same weight.

References olb::CuboidDecomposition< T, D >::cuboids(), olb::CuboidDecomposition< T, D >::remove(), olb::CuboidDecomposition< T, D >::setWeights(), olb::CuboidDecomposition< T, D >::shrink(), and olb::CuboidDecomposition< T, D >::splitByWeight().

+ Here is the call graph for this function:

◆ minv()

template<typename T , unsigned D, typename IMPL , typename IMPL_ >
Vector< T, D > olb::minv ( const ScalarVector< T, D, IMPL > & v,
const ScalarVector< T, D, IMPL_ > & w )
constexpr

Definition at line 448 of file vector.h.

450{
451 return Vector<T,D>([&v,&w](unsigned iDim) -> T {
452 return util::min(v[iDim], w[iDim]);
453 });
454}

References olb::util::min().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ newtonSpalding()

template<typename V , typename Funcf , typename Funcd , typename Par_f , typename Par_d >
V olb::newtonSpalding ( Funcf f,
Funcd d,
Par_f & argsf,
Par_d & argsd,
int optArg,
V convergeCrit,
int iter )

Definition at line 127 of file turbulentWallModelPostProcessor.h.

127 {
128 V x = argsf[optArg];
129 V x_old = argsf[optArg];
130 for(int i = 0; i<iter; i++){
131 argsf[optArg] = x;
132 argsd[0] = x;
133 x -= f(argsf)/d(argsd);
134 argsf[optArg] = x;
135 argsd[0] = x;
136 if(util::abs(f(argsf)) < convergeCrit ){
137 break;
138 }
139 if(util::isnan(x)){
140 //printf("x is NAN!!,Applied x=x_old, iter i x_old=%d,%lf,%d\n",i,x_old,optArg);
141 x = x_old;
142 break;
143 }
144 x_old = x;
145 }
146 return x;
147 };

References olb::util::abs(), and olb::util::isnan().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ norm()

template<typename T , unsigned D, typename IMPL >
T olb::norm ( const ScalarVector< T, D, IMPL > & a)
inlineconstexpr

Euclidean vector norm.

Definition at line 66 of file scalarVector.h.

67{
68 using namespace util;
69 T sqNorm = norm_squared(a);
70 return sqrt(sqNorm);
71}

References norm_squared().

+ Here is the call graph for this function:

◆ norm_squared()

template<typename T , unsigned D, typename IMPL >
T olb::norm_squared ( const ScalarVector< T, D, IMPL > & a)
inlineconstexpr

Squared euclidean vector norm.

Definition at line 55 of file scalarVector.h.

56{
57 T sqNorm{};
58 for (unsigned iDim=0; iDim < D; ++iDim) {
59 sqNorm += a[iDim] * a[iDim];
60 }
61 return sqNorm;
62}
+ Here is the caller graph for this function:

◆ normalize()

template<typename T , unsigned D, typename IMPL >
Vector< T, D > olb::normalize ( const ScalarVector< T, D, IMPL > & a,
T scale = T{1} )
constexpr

Definition at line 284 of file vector.h.

284 {1})
285{
286 T invScale (scale / norm(a));
287 return Vector<T,D>([invScale,&a](unsigned iDim) -> T {
288 return a[iDim] * invScale;
289 });
290}
+ Here is the caller graph for this function:

◆ operator!=()

bool olb::operator!= ( const Expr & rhs,
const Expr & lhs )

Definition at line 203 of file expr.cpp.

203 {
204 throw std::domain_error("Invalid operator for Expr type: '!='");
205}

◆ operator%() [1/2]

template<typename T , unsigned D, typename U , typename IMPL >
meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator% ( const ScalarVector< T, D, IMPL > & a,
U b )
constexpr

Definition at line 410 of file vector.h.

411{
412 Vector<T,D> r;
413 for (unsigned iDim=0; iDim < D; ++iDim) {
414 r[iDim] = a[iDim] % b;
415 }
416 return r;
417}

◆ operator%() [2/2]

Expr olb::operator% ( Expr lhs,
int rhs )

Definition at line 195 of file expr.cpp.

195 {
196 throw std::domain_error("Invalid operator for Expr type: '%'");
197}

◆ operator&()

Definition at line 313 of file freeSurfaceHelpers.h.

313 {
314 return static_cast<FreeSurface::Flags>(static_cast<std::uint8_t>(lhs) & static_cast<std::uint8_t>(rhs));
315}

◆ operator*() [1/17]

template<typename T , typename U , unsigned D, typename IMPL , typename IMPL_ >
auto olb::operator* ( const ScalarVector< T, D, IMPL > & a,
const ScalarVector< U, D, IMPL_ > & b )
constexpr

Inner product.

Definition at line 391 of file vector.h.

393{
394 decltype(T{}*U{}) scalarProduct{};
395 for (unsigned iDim=0; iDim < D; ++iDim) {
396 scalarProduct += a[iDim] * b[iDim];
397 }
398 return scalarProduct;
399}
T scalarProduct(const Vector< T, d > &u1, const Vector< T, d > &u2) any_platform
Definition util.h:191

◆ operator*() [2/17]

template<typename T , unsigned D, typename U , typename IMPL >
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 383 of file vector.h.

384{
385 Vector<decltype(T{}*U{}),D> result(a);
386 return result *= b;
387}

◆ operator*() [3/17]

Expr olb::operator* ( Expr lhs,
Expr rhs )

Definition at line 181 of file expr.cpp.

181 {
182 Expr::increment(Expr::Op::Mul);
183 return Expr(lhs, Expr::Op::Mul, rhs);
184}
Basic value-substitute enabling extraction of expression trees for code generation.
Definition expr.h:39

References olb::Expr::increment(), and olb::Expr::Mul.

+ Here is the call graph for this function:

◆ 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 257 of file indicCalc2D.hh.

258{
259 return lhs._f * rhs;
260}

◆ 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 162 of file indicComb3D.hh.

163{
164 return lhs._f * rhs;
165}

◆ 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 122 of file analyticCalcF.hh.

123{
124 return std::shared_ptr<AnalyticalF<D,T,S>>(
125 new AnalyticCalcMultiplication<D,T,S>(std::move(lhs), std::move(rhs)));
126}
arithmetic helper class for analytical functors

◆ 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 129 of file analyticCalcF.hh.

130{
131 return std::shared_ptr<AnalyticalF<D,T,S>>(
132 new AnalyticCalcMultiplication<D,T,S>(std::move(lhs), rhs));
133}

◆ 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 235 of file indicCalc2D.hh.

236{
237 return std::make_shared<IndicMultiplication2D<S>>(lhs, rhs);
238}

◆ 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 140 of file indicComb3D.hh.

141{
142 return std::make_shared<IndicMultiplication3D<S>>(lhs, rhs);
143}

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

181{
182 return std::shared_ptr<SuperF2D<T,W>>(
183 new SuperCalcMultiplication2D<T,W>(std::move(lhs), std::move(rhs)));
184}
Arithmetic operations for SuperF2D functors.

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

188{
189 return std::shared_ptr<SuperF2D<T,W>>(
190 new SuperCalcMultiplication2D<T,W>(std::move(lhs), rhs));
191}

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

181{
182 return std::shared_ptr<SuperF3D<T,W>>(
183 new SuperCalcMultiplication3D<T,W>(std::move(lhs), std::move(rhs)));
184}
Arithmetic operations for SuperF3D functors.

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

188{
189 return std::shared_ptr<SuperF3D<T,W>>(
190 new SuperCalcMultiplication3D<T,W>(std::move(lhs), rhs));
191}

◆ 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 136 of file analyticCalcF.hh.

137{
138 return std::shared_ptr<AnalyticalF<D,T,S>>(
139 new AnalyticCalcMultiplication<D,T,S>(lhs, std::move(rhs)));
140}

◆ operator*() [15/17]

template<typename T , unsigned D, typename U , typename IMPL >
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 375 of file vector.h.

376{
377 Vector<decltype(T{}*U{}),D> result(b);
378 return result *= a;
379}

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

195{
196 return std::shared_ptr<SuperF2D<T,W>>(
197 new SuperCalcMultiplication2D<T,W>(lhs, std::move(rhs)));
198}

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

195{
196 return std::shared_ptr<SuperF3D<T,W>>(
197 new SuperCalcMultiplication3D<T,W>(lhs, std::move(rhs)));
198}

◆ operator+() [1/18]

template<typename T , unsigned D, typename IMPL , typename IMPL_ >
Vector< T, D > olb::operator+ ( const ScalarVector< T, D, IMPL > & a,
const ScalarVector< T, D, IMPL_ > & b )
constexpr

Definition at line 324 of file vector.h.

326{
327 return Vector<T,D>(a) += b;
328}

◆ operator+() [2/18]

template<typename T , typename W , unsigned D, typename IMPL , typename IMPL_ >
Vector< decltype(T{}+W{}), D > olb::operator+ ( const ScalarVector< T, D, IMPL > & a,
const ScalarVector< W, D, IMPL_ > & b )
constexpr

Definition at line 331 of file vector.h.

331 {}+W{}),D> operator+ (
332 const ScalarVector<T,D,IMPL>& a, const ScalarVector<W,D,IMPL_>& b) any_platform
333{
334 Vector<decltype(T{}+W{}),D> result;
335 for (unsigned iDim=0; iDim < D; ++iDim) {
336 result[iDim] = a[iDim] + b[iDim];
337 }
338 return result;
339}
#define any_platform
Define preprocessor macros for device-side functions, constant storage.
Definition platform.h:77

◆ operator+() [3/18]

template<typename T , unsigned D, typename U , typename IMPL >
meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator+ ( const ScalarVector< T, D, IMPL > & a,
U b )
constexpr

Definition at line 318 of file vector.h.

319{
320 return Vector<T,D>(a) += b;
321}

◆ operator+() [4/18]

Expr olb::operator+ ( Expr lhs,
Expr rhs )

Definition at line 171 of file expr.cpp.

171 {
172 Expr::increment(Expr::Op::Add);
173 return Expr(lhs, Expr::Op::Add, rhs);
174}

References olb::Expr::Add, and olb::Expr::increment().

+ Here is the call graph for this function:

◆ 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 243 of file indicCalc2D.hh.

244{
245 return lhs._f + rhs;
246}

◆ 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 148 of file indicComb3D.hh.

149{
150 return lhs._f + rhs;
151}

◆ 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 80 of file analyticCalcF.hh.

81{
82 return std::shared_ptr<AnalyticalF<D,T,S>>(
83 new AnalyticCalcPlus<D,T,S>(std::move(lhs), std::move(rhs)));
84}

◆ 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 87 of file analyticCalcF.hh.

88{
89 return std::shared_ptr<AnalyticalF<D,T,S>>(
90 new AnalyticCalcPlus<D,T,S>(std::move(lhs), rhs));
91}

◆ 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 221 of file indicCalc2D.hh.

222{
223 return std::make_shared<IndicPlus2D<S>>(lhs, rhs);
224}

◆ 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
Susual type for source dimension of the functor
F1lhs has to be derived from IndicatorF3D, otherwise function is disabled
F2rhs

Definition at line 126 of file indicComb3D.hh.

127{
128 return std::make_shared<IndicPlus3D<S>>(lhs, rhs);
129}

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

139{
140 return std::shared_ptr<SuperF2D<T,W>>(
141 new SuperCalcPlus2D<T,W>(std::move(lhs), std::move(rhs)));
142}

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

146{
147 return std::shared_ptr<SuperF2D<T,W>>(
148 new SuperCalcPlus2D<T,W>(std::move(lhs), rhs));
149}

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

139{
140 return std::shared_ptr<SuperF3D<T,W>>(
141 new SuperCalcPlus3D<T,W>(std::move(lhs), std::move(rhs)));
142}

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

146{
147 return std::shared_ptr<SuperF3D<T,W>>(
148 new SuperCalcPlus3D<T,W>(std::move(lhs), rhs));
149}

◆ 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 94 of file analyticCalcF.hh.

95{
96 return std::shared_ptr<AnalyticalF<D,T,S>>(
97 new AnalyticCalcPlus<D,T,S>(lhs, std::move(rhs)));
98}

◆ operator+() [16/18]

template<typename T , unsigned D, typename U , typename IMPL >
meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator+ ( U a,
const ScalarVector< T, D, IMPL > & b )
constexpr

Definition at line 311 of file vector.h.

312{
313 return Vector<T,D>(b) += a;
314}

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

153{
154 return std::shared_ptr<SuperF2D<T,W>>(
155 new SuperCalcPlus2D<T,W>(lhs, std::move(rhs)));
156}

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

153{
154 return std::shared_ptr<SuperF3D<T,W>>(
155 new SuperCalcPlus3D<T,W>(lhs, std::move(rhs)));
156}

◆ operator-() [1/19]

template<typename T , unsigned D, typename IMPL , typename IMPL_ >
Vector< T, D > olb::operator- ( const ScalarVector< T, D, IMPL > & a,
const ScalarVector< T, D, IMPL_ > & b )
constexpr

Definition at line 356 of file vector.h.

358{
359 return Vector<T,D>(a) -= b;
360}

◆ operator-() [2/19]

template<typename T , typename W , unsigned D, typename IMPL , typename IMPL_ >
Vector< decltype(T{}-W{}), D > olb::operator- ( const ScalarVector< T, D, IMPL > & a,
const ScalarVector< W, D, IMPL_ > & b )
constexpr

Definition at line 363 of file vector.h.

363 {}-W{}),D> operator- (
364 const ScalarVector<T,D,IMPL>& a, const ScalarVector<W,D,IMPL_>& b) any_platform
365{
366 Vector<decltype(T{}-W{}),D> result;
367 for (unsigned iDim=0; iDim < D; ++iDim) {
368 result[iDim] = a[iDim] - b[iDim];
369 }
370 return result;
371}

◆ operator-() [3/19]

template<typename T , unsigned D, typename U , typename IMPL >
meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator- ( const ScalarVector< T, D, IMPL > & a,
U b )
constexpr

Definition at line 350 of file vector.h.

351{
352 return Vector<T,D>(a) -= b;
353}

◆ operator-() [4/19]

Expr olb::operator- ( Expr lhs,
Expr rhs )

Definition at line 176 of file expr.cpp.

176 {
177 Expr::increment(Expr::Op::Sub);
178 return Expr(lhs, Expr::Op::Sub, rhs);
179}

References olb::Expr::increment(), and olb::Expr::Sub.

+ Here is the call graph for this function:

◆ operator-() [5/19]

Expr olb::operator- ( Expr rhs)

Definition at line 191 of file expr.cpp.

191 {
192 return Expr(-1.) * rhs;
193}

◆ 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 250 of file indicCalc2D.hh.

251{
252 return lhs._f - rhs;
253}

◆ 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 155 of file indicComb3D.hh.

156{
157 return lhs._f - rhs;
158}

◆ 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 101 of file analyticCalcF.hh.

102{
103 return std::shared_ptr<AnalyticalF<D,T,S>>(
104 new AnalyticCalcMinus<D,T,S>(std::move(lhs), std::move(rhs)));
105}

◆ 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 108 of file analyticCalcF.hh.

109{
110 return std::shared_ptr<AnalyticalF<D,T,S>>(
111 new AnalyticCalcMinus<D,T,S>(std::move(lhs), rhs));
112}

◆ 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 228 of file indicCalc2D.hh.

229{
230 return std::make_shared<IndicMinus2D<S>>(lhs, rhs);
231}

◆ 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 133 of file indicComb3D.hh.

134{
135 return std::make_shared<IndicMinus3D<S>>(rhs, lhs);
136}

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

160{
161 return std::shared_ptr<SuperF2D<T,W>>(
162 new SuperCalcMinus2D<T,W>(std::move(lhs), std::move(rhs)));
163}

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

167{
168 return std::shared_ptr<SuperF2D<T,W>>(
169 new SuperCalcMinus2D<T,W>(std::move(lhs), rhs));
170}

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

160{
161 return std::shared_ptr<SuperF3D<T,W>>(
162 new SuperCalcMinus3D<T,W>(std::move(lhs), std::move(rhs)));
163}

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

167{
168 return std::shared_ptr<SuperF3D<T,W>>(
169 new SuperCalcMinus3D<T,W>(std::move(lhs), rhs));
170}

◆ 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 115 of file analyticCalcF.hh.

116{
117 return std::shared_ptr<AnalyticalF<D,T,S>>(
118 new AnalyticCalcMinus<D,T,S>(lhs, std::move(rhs)));
119}

◆ operator-() [17/19]

template<typename T , unsigned D, typename U , typename IMPL >
meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator- ( U a,
const ScalarVector< T, D, IMPL > & b )
constexpr

Definition at line 343 of file vector.h.

344{
345 return Vector<T,D>(a) - b;
346}

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

174{
175 return std::shared_ptr<SuperF2D<T,W>>(
176 new SuperCalcMinus2D<T,W>(lhs, std::move(rhs)));
177}

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

174{
175 return std::shared_ptr<SuperF3D<T,W>>(
176 new SuperCalcMinus3D<T,W>(lhs, std::move(rhs)));
177}

◆ operator/() [1/11]

template<typename T , unsigned D, typename U , typename IMPL >
meta::enable_if_arithmetic_t< U, Vector< T, D > > olb::operator/ ( const ScalarVector< T, D, IMPL > & a,
U b )
constexpr

Definition at line 403 of file vector.h.

404{
405 return Vector<T,D>(a) /= b;
406}

◆ operator/() [2/11]

Expr olb::operator/ ( Expr lhs,
Expr rhs )

Definition at line 186 of file expr.cpp.

186 {
187 Expr::increment(Expr::Op::Div);
188 return Expr(lhs, Expr::Op::Div, rhs);
189}

References olb::Expr::Div, and olb::Expr::increment().

+ Here is the call graph for this function:

◆ 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 143 of file analyticCalcF.hh.

144{
145 return std::shared_ptr<AnalyticalF<D,T,S>>(
146 new AnalyticCalcDivision<D,T,S>(std::move(lhs), std::move(rhs)));
147}

◆ 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 150 of file analyticCalcF.hh.

151{
152 return std::shared_ptr<AnalyticalF<D,T,S>>(
153 new AnalyticCalcDivision<D,T,S>(std::move(lhs), rhs));
154}

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

202{
203 return std::shared_ptr<SuperF2D<T,W>>(
204 new SuperCalcDivision2D<T,W>(std::move(lhs), std::move(rhs)));
205}

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

209{
210 return std::shared_ptr<SuperF2D<T,W>>(
211 new SuperCalcDivision2D<T,W>(std::move(lhs), rhs));
212}

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

202{
203 return std::shared_ptr<SuperF3D<T,W>>(
204 new SuperCalcDivision3D<T,W>(std::move(lhs), std::move(rhs)));
205}

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

209{
210 return std::shared_ptr<SuperF3D<T,W>>(
211 new SuperCalcDivision3D<T,W>(std::move(lhs), rhs));
212}

◆ 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 157 of file analyticCalcF.hh.

158{
159 return std::shared_ptr<AnalyticalF<D,T,S>>(
160 new AnalyticCalcDivision<D,T,S>(lhs, std::move(rhs)));
161}

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

216{
217 return std::shared_ptr<SuperF2D<T,W>>(
218 new SuperCalcDivision2D<T,W>(lhs, std::move(rhs)));
219}

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

216{
217 return std::shared_ptr<SuperF3D<T,W>>(
218 new SuperCalcDivision3D<T,W>(lhs, std::move(rhs)));
219}

◆ operator<() [1/3]

bool olb::operator< ( const Expr & rhs,
const Expr & lhs )

Definition at line 211 of file expr.cpp.

211 {
212 throw std::domain_error("Invalid operator for Expr type: '<'");
213}

◆ operator<() [2/3]

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
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.

100{
101 bool smaller = true;
102 for (unsigned iDim=0; iDim < D; ++iDim) {
103 smaller &= (lhs[iDim] < rhs[iDim]);
104 }
105 return smaller;
106}

◆ operator<() [3/3]

template<typename T , unsigned D, typename U , typename IMPL >
meta::enable_if_arithmetic_t< U, bool > olb::operator< ( U lhs,
const ScalarVector< T, D, IMPL > & rhs )
constexpr

Definition at line 420 of file vector.h.

422{
423 return Vector<U,D>(lhs) < rhs;
424}

References Vector().

+ Here is the call graph for this function:

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

51{
52 os << "<";
54 return os << ">";
55}
void print_index_sequence(std::basic_ostream< Ch, Tr > &os, const std::index_sequence< Is... > is)
Print std::index_sequence.
Definition printUtils.h:36

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.

69{
70 return os << fileName.str();
71}
std::string str()
Definition plainWriter.h:56

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

73{
74 os << "|[";
75 for(auto it = array.begin(); it != array.end(); ++it){
76 os << (it==array.begin()? "" : ",") << *it;
77 }
78 return os << "]|";
79}

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

85{
86 os << "|[";
87 for(auto it = list.begin(); it != list.end(); ++it){
88 os << (it==list.begin()? "" : ",") << *it;
89 }
90 return os << "]|";
91}

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

97{
98 os << "|[";
99 for(auto it = set.begin(); it != set.end(); ++it){
100 os << (it==set.begin()? "" : ",") << *it;
101 }
102 return os << "]|";
103}

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

109{
110 os << "|[";
111 for(auto it = set.begin(); it != set.end(); ++it){
112 os << (it==set.begin()? "" : ",") << *it;
113 }
114 return os << "]|";
115}

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

61{
62 os << "|[";
63 for(auto it = vec.begin(); it != vec.end(); ++it){
64 os << (it==vec.begin()? "" : ",") << *it;
65 }
66 return os << "]|";
67}

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

180{
181 if (D > 0) {
182 os << "[";
183 for (unsigned iDim=0; iDim < D-1; ++iDim) {
184 os << o[iDim] << " ";
185 }
186 os << o[D-1]<<"]";
187 }
188 else {
189 os << "[empty]";
190 }
191 return os;
192}

◆ operator<=() [1/3]

bool olb::operator<= ( const Expr & rhs,
const Expr & lhs )

Definition at line 219 of file expr.cpp.

219 {
220 throw std::domain_error("Invalid operator for Expr type: '<='");
221}

◆ operator<=() [2/3]

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
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.

118{
119 bool smallerEq = true;
120 for (unsigned iDim=0; iDim < D; ++iDim) {
121 smallerEq &= (lhs[iDim] <= rhs[iDim]);
122 }
123 return smallerEq;
124}

◆ operator<=() [3/3]

template<typename T , unsigned D, typename U , typename IMPL >
meta::enable_if_arithmetic_t< U, bool > olb::operator<= ( U lhs,
const ScalarVector< T, D, IMPL > & rhs )
constexpr

Definition at line 434 of file vector.h.

436{
437 return Vector<U,D>(lhs) <= rhs;
438}

References Vector().

+ Here is the call graph for this function:

◆ operator==()

bool olb::operator== ( const Expr & rhs,
const Expr & lhs )

Definition at line 199 of file expr.cpp.

199 {
200 throw std::domain_error("Invalid operator for Expr type: '=='");
201}

◆ operator>() [1/3]

bool olb::operator> ( const Expr & rhs,
const Expr & lhs )

Definition at line 207 of file expr.cpp.

207 {
208 throw std::domain_error("Invalid operator for Expr type: '>'");
209}

◆ operator>() [2/3]

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
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.

111{
112 return rhs < lhs;
113}

◆ operator>() [3/3]

template<typename T , unsigned D, typename U , typename IMPL >
meta::enable_if_arithmetic_t< U, bool > olb::operator> ( const ScalarVector< T, D, IMPL > & lhs,
U rhs )
constexpr

Definition at line 428 of file vector.h.

429{
430 return lhs > Vector<U,D>(rhs);
431}

References Vector().

+ Here is the call graph for this function:

◆ operator>=() [1/3]

bool olb::operator>= ( const Expr & rhs,
const Expr & lhs )

Definition at line 215 of file expr.cpp.

215 {
216 throw std::domain_error("Invalid operator for Expr type: '>='");
217}

◆ operator>=() [2/3]

template<typename T , unsigned D, typename U , typename IMPL , typename IMPL_ >
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.

129{
130 return rhs <= lhs;
131}

◆ operator>=() [3/3]

template<typename T , unsigned D, typename U , typename IMPL >
meta::enable_if_arithmetic_t< U, bool > olb::operator>= ( const ScalarVector< T, D, IMPL > & lhs,
U rhs )
constexpr

Definition at line 442 of file vector.h.

443{
444 return lhs >= Vector<U,D>(rhs);
445}

References Vector().

+ Here is the call graph for this function:

◆ operator|()

Definition at line 317 of file freeSurfaceHelpers.h.

317 {
318 return static_cast<FreeSurface::Flags>(static_cast<std::uint8_t>(lhs) | static_cast<std::uint8_t>(rhs));
319}

◆ PostProcessorPromise()

template<typename PP >
olb::PostProcessorPromise ( meta::id< PP > ) -> PostProcessorPromise< typename PP::value_t, typename PP::descriptor_t >

◆ powerLawWallFunction()

template<typename V >
Vector< V, 2 > olb::powerLawWallFunction ( V nu,
V u2,
V y2,
V y1 )

Definition at line 152 of file turbulentWallModelPostProcessor.h.

152 {
153 Vector<V,2> output(V(0), V(0));
154 V u_tau = util::sqrt(V(0.0246384) * util::pow(nu, V(0.25)) * util::pow(u2, V(1.75)) / util::pow(y2, V(0.25)));
155 V y_plus = y1 * u_tau / nu;
156
157 if (y_plus > V(28.178)) {
158 output[0] = u_tau;
159 output[1] = V(5.5) + V(1./0.399) * util::log(y_plus);
160 }
161 else if (y_plus < V(28.178) && y_plus > V(5.)) {
162 output[0] = u_tau;
163 output[1] = V(-3.05) + V(5.) * util::log(y_plus);
164 }
165 else {
166 output[0] = util::sqrt(V(2.) * u2 * nu / y2);
167 y_plus = y1 * output[0] / nu;
168 output[1] = y_plus;
169 }
170 return output;
171 };

References olb::util::log(), olb::util::pow(), and olb::util::sqrt().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

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

38{
39 std::size_t i=0;
40 ((os << (i++==0? "" : ",") << Is), ...);
41}
+ 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.

260{
261 return 3. * util::sin(theta) * util::pow(util::cos(theta),2.) * getFresnelFunction(theta,refractiveRelative);
262};
double getFresnelFunction(double const &theta, double const &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.

255{
256 return 2. * util::sin(theta) * util::cos(theta) * getFresnelFunction(theta,refractiveRelative);
257};

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:

◆ reduceKernelInBlock()

template<typename T , typename DESCRIPTOR , typename REDUCTION_OP , typename CONDITION >
void olb::reduceKernelInBlock ( thrust::device_ptr< const T > field,
T * g_odata,
gpu::cuda::DeviceBlockLattice< T, DESCRIPTOR > lattice,
CellID size )

ref: https://github.com/NVIDIA/cuda-samples/blob/master/Samples/2_Concepts_and_Techniques/reduction/reduction_kernel.cu

Definition at line 76 of file fieldReduction.hh.

78{
79 namespace cg = cooperative_groups; // ref :: https://developer.nvidia.com/blog/cooperative-groups/
80 CONDITION mask {};
81 // Handle to thread block group
82 cg::thread_block cta = cg::this_thread_block();
83 T* sdata = gpu::cuda::SharedMemory<T>();
84
85 // perform first level of reduction,
86 // reading from global memory, writing to shared memory
87 unsigned int tid = threadIdx.x;
88 CellID iCell = blockIdx.x * (blockDim.x * 2) + threadIdx.x; //for 2element per 1thread
89 gpu::cuda::Cell<T, DESCRIPTOR> cell(lattice, iCell);
90
91 T mySum = (iCell < size) && mask(cell) && (cell.template getField<field::reduction::TAG_CORE>() == (int)1)
92 ? field[iCell]
93 : (T)0.0;
94
95 //for 2elements per 1thread
96 if (iCell + blockDim.x < size) {
97 gpu::cuda::Cell<T, DESCRIPTOR> cell2(lattice, iCell + blockDim.x);
98
99 if (mask(cell2) && (cell2.template getField<field::reduction::TAG_CORE>() == (int)1)) {
100 mySum = REDUCTION_OP {}(mySum, thrust::raw_pointer_cast(field)[iCell + blockDim.x]);
101 }
102 }
103 sdata[tid] = mySum;
104 cg::sync(cta);
105
106 // do reduction in shared mem
107 for (unsigned int stride = blockDim.x / 2; stride > 0; stride >>= 1) {
108 if (tid < stride) {
109 sdata[tid] = mySum = REDUCTION_OP {}(mySum, sdata[tid + stride]);
110 }
111
112 cg::sync(cta);
113 }
114
115 // write result for this block to global mem
116 if (tid == 0)
117 g_odata[blockIdx.x] = mySum;
118 return;
119}
+ Here is the caller graph for this function:

◆ reduceKernelInGrid()

template<typename T , typename REDUCTION_OP >
void olb::reduceKernelInGrid ( const T * partialSums,
int partialCount,
T * d_result )

Definition at line 122 of file fieldReduction.hh.

123{
124 namespace cg = cooperative_groups; // ref :: https://developer.nvidia.com/blog/cooperative-groups/
125 cg::thread_block cta = cg::this_thread_block();
126 T* sdata = gpu::cuda::SharedMemory<T>();
127
128 unsigned int tid = threadIdx.x;
129 unsigned int i = threadIdx.x + blockDim.x * blockIdx.x;
130
131 T mySum = 0.0;
132
133 for (int idx = i; idx < partialCount; idx += blockDim.x) {
134 mySum = REDUCTION_OP {}(mySum, partialSums[idx]);
135 }
136 sdata[tid] = mySum;
137 cg::sync(cta);
138
139 for (unsigned int stride = blockDim.x / 2; stride > 0; stride >>= 1) {
140 if (tid < stride) {
141 sdata[tid] = mySum = REDUCTION_OP{}(mySum, sdata[tid + stride]);
142 }
143 cg::sync(cta);
144 }
145
146 if (tid == 0) {
147 d_result[0] = sdata[0];
148 }
149 return;
150}
+ Here is the caller graph for this function:

◆ reductionFunctionDevice()

template<typename T , typename DESCRIPTOR , typename REDUCTION_OP , typename CONDITION >
void olb::reductionFunctionDevice ( thrust::device_ptr< const T > devPtr,
ConcreteBlockLattice< T, DESCRIPTOR, Platform::GPU_CUDA > & blockLattice,
T * paramInDevice )

Definition at line 153 of file fieldReduction.hh.

155{
156
158 const auto nCells = lattice.getNcells();
159 const auto block_size = 32;
160 const auto block_count = (nCells + (block_size * 2) - 1) / (block_size * 2); //for 2elements per 1thread
161
162 thrust::device_vector<T> d_partial(block_count, (T)0.0);
163
164 reduceKernelInBlock<T, DESCRIPTOR, REDUCTION_OP, CONDITION><<<block_count, block_size, block_size * sizeof(T)>>>(
165 devPtr, thrust::raw_pointer_cast(d_partial.data()), lattice, nCells);
166 gpu::cuda::device::check();
167
168 reduceKernelInGrid<T, REDUCTION_OP><<<1, block_size, block_size * sizeof(T)>>>(
169 thrust::raw_pointer_cast(d_partial.data()), block_count, paramInDevice);
170 gpu::cuda::device::check();
171
172 return;
173}
Device-side view of a block lattice.
Definition context.hh:244

References olb::gpu::cuda::device::check(), olb::gpu::cuda::DeviceContext< T, DESCRIPTOR >::getNcells(), reduceKernelInBlock(), and reduceKernelInGrid().

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

69{
70 return physDiffusivity - converterFractional.getPhysViscosity();
71}

References olb::UnitConverter< T, DESCRIPTOR >::getPhysViscosity().

+ Here is the call graph for this function:

◆ round()

template<typename T , unsigned D, typename IMPL >
Vector< T, D > olb::round ( const ScalarVector< T, D, IMPL > & a)
constexpr

Definition at line 302 of file vector.h.

303{
304 return Vector<T,D>([&a](unsigned iDim) -> T {
305 return util::round(a[iDim]);
306 });
307}

References olb::util::round().

+ Here is the call graph for this function:
+ Here is the caller 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.

97{
98 serializer.resetCounter();
99 std::size_t blockSize;
100 const bool* dataBuffer = nullptr;
101 while (dataBuffer = serializer.getNextBlock(blockSize, false), dataBuffer != nullptr) {
102 std::memcpy(buffer, dataBuffer, blockSize);
103 buffer += blockSize;
104 }
105 serializer.resetCounter();
106}

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.

41{
42 serializer.resetCounter();
43 // write binary size into first integer of stream
44 std::size_t binarySize = serializer.getSize();
45 if (enforceUint) {
46 Base64Encoder<unsigned int> sizeEncoder(ostr, 1);
47 OLB_PRECONDITION(binarySize <= std::numeric_limits<unsigned int>::max());
48 unsigned int uintBinarySize = (unsigned int)binarySize;
49 sizeEncoder.encode(&uintBinarySize, 1);
50 }
51 else {
52 Base64Encoder<std::size_t> sizeEncoder(ostr, 1);
53 sizeEncoder.encode(&binarySize, 1);
54 }
55
56 Base64Encoder<bool> dataEncoder (ostr, binarySize);
57
58 std::size_t blockSize;
59 const bool* dataBuffer = nullptr;
60 while (dataBuffer = serializer.getNextBlock(blockSize, false), dataBuffer != nullptr) {
61 dataEncoder.encode(dataBuffer, blockSize);
62 }
63 serializer.resetCounter();
64}
std::size_t getSize() const
Returns the total memory size in bits.
Definition serializer.hh:54

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.

64{
65 OstreamManager clout(std::cout, "setAdvectionDiffusionConvectionBoundary");
66 const auto& blockGeometryStructure = indicator.getBlockGeometry();
67 const int margin = includeOuterCells ? 0 : 1;
68 std::vector<int> discreteNormal(4, 0);
69 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
70 if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
71 && indicator(iX, iY, iZ)) {
72 discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
73 if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {
74 auto postProcessor = std::unique_ptr<PostProcessorGenerator3D<T, DESCRIPTOR>>{
75 new ConvectionBoundaryProcessorGenerator3D<T, DESCRIPTOR>(iX, iX, iY, iY, iZ, iZ, -discreteNormal[1], -discreteNormal[2], -discreteNormal[3]) };
76 if (postProcessor) {
77 _block.addPostProcessor(*postProcessor);
78 }
79 }
80 else {
81 clout << "Warning: Could not setAdvectionDiffusionConvectionBoundary (" << iX << ", " << iY << ", " << iZ << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] << ", " << discreteNormal[3] << "), set to bounceBack" << std::endl;
82 }
83 }
84 });
85}
BlockGeometry< T, 3 > & getBlockGeometry()
Get underlying block geometry structure.
virtual void addPostProcessor(std::type_index stage, LatticeR< DESCRIPTOR::d > latticeR, PostProcessorPromise< T, DESCRIPTOR > &&promise)=0
Schedule post processor for application to latticeR in stage.

References 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

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setAdvectionDiffusionConvectionBoundary3D.hh.

44{
45 OstreamManager clout(std::cout, "setAdvectionDiffusionConvectionBoundary");
46 int _overlap = 1;
47 bool includeOuterCells = false;
48 if (indicator->getSuperGeometry().getOverlap() == 1) {
49 includeOuterCells = true;
50 clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
51 }
52 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
53 setAdvectionDiffusionConvectionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc), indicator->getBlockIndicatorF(iCloc),
54 includeOuterCells);
55 }
57 addPoints2CommBC(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
58}
void addPoints2CommBC(SuperLattice< T, DESCRIPTOR > &sLattice, FunctorPtr< SuperIndicatorF2D< T > > &&indicator, int _overlap)
Adds needed Cells to the Communicator _commBC in SuperLattice.

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setAdvectionDiffusionConvectionBoundary().

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

37{
38 setAdvectionDiffusionConvectionBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material));
39}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setAdvectionDiffusionConvectionBoundary().

+ Here is the call graph for this function:
+ Here is the caller 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.

47{
48 if (dynamics) {
49 _block.defineDynamics({iX, iY, iZ}, dynamics);
50 auto cell = _block.get(iX,iY,iZ);
51 dynamics->initialize(cell);
52 }
53}
void defineDynamics(LatticeR< DESCRIPTOR::d > latticeR, DynamicsPromise< T, DESCRIPTOR > &&promise)
Assign promised DYNAMICS to latticeR.
Cell< T, DESCRIPTOR > get(CellID iCell)
Get Cell interface for index iCell.
virtual void initialize(Cell< T, DESCRIPTOR > &cell)
Initialize dynamics-specific data for cell.
Definition interface.h:70

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

33{
34 if (dynamics) {
35 _block.defineDynamics({iX, iY, iZ}, dynamics);
36 auto cell = _block.get(iX,iY,iZ);
37 dynamics->initialize(cell);
38 }
39 if (postProcessor && !_block.isPadding({iX,iY,iZ})) {
40 _block.addPostProcessor(*postProcessor);
41 }
42}
bool isPadding(LatticeR< D > latticeR) const
Return whether location is valid.

References olb::Dynamics< T, DESCRIPTOR >::initialize().

+ 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 46 of file setBoundary2D.h.

48{
49 if (dynamics) {
50 block.defineDynamics({iX, iY}, dynamics);
51 auto cell = block.get(iX,iY);
52 dynamics->initialize(cell);
53 }
54}

References 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 31 of file setBoundary2D.h.

34{
35 if (dynamics) {
36 block.defineDynamics({iX, iY}, dynamics);
37 auto cell = block.get(iX,iY);
38 dynamics->initialize(cell);
39 }
40 if (postProcessor && !block.isPadding({iX,iY})) {
41 block.addPostProcessor(*postProcessor);
42 }
43}

References olb::Dynamics< T, DESCRIPTOR >::initialize().

+ 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 643 of file setBouzidiBoundary.h.

648{
649 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
650 if (boundaryIndicator(solidLatticeR)) {
651 for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
652 Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
653 if (block.isInside(boundaryLatticeR)) {
654 const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
655 auto x_b = block.get(boundaryLatticeR);
656 const auto opp_bouzidi_dist = x_b.template getFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite);
657
658 // check if distance from the fluid cell to the solid cell is a valid bouzidi distance
659 if (opp_bouzidi_dist >= 0) {
660 T phi_at_cell[1] { };
661 auto boundaryPhysR = cuboid.getPhysR(boundaryLatticeR);
662
663 phi_d(phi_at_cell, boundaryPhysR.data());
664
665 // set computed velocity into the bouzidi velocity field
666 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_ADE_DIRICHLET>(iPop_opposite, phi_at_cell[0]);
667 }
668 }
669 }
670 }
671 });
672}
void forSpatialLocations(F f) const
bool isInside(LatticeR< D > latticeR) const
Return whether location is valid.
Vector< T, D > getPhysR(LatticeR< D > latticeR) const
Definition cuboid.h:90

References olb::descriptors::c(), olb::Cuboid< T, D >::getPhysR(), and olb::descriptors::opposite().

+ 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 616 of file setBouzidiBoundary.h.

621{
622 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
623 if (boundaryIndicator(solidLatticeR)) {
624 for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
625 Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
626 if (block.isInside(boundaryLatticeR)) {
627 const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
628 auto x_b = block.get(boundaryLatticeR);
629 const auto opp_bouzidi_dist = x_b.template getFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite);
630
631 // check if distance from the fluid cell to the solid cell is a valid bouzidi distance
632 if (opp_bouzidi_dist >= 0) {
633 // set computed velocity into the bouzidi velocity field
634 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_ADE_DIRICHLET>(iPop_opposite, phi_d);
635 }
636 }
637 }
638 }
639 });
640}

References olb::descriptors::c(), and olb::descriptors::opposite().

+ 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 605 of file setBouzidiBoundary.h.

609{
610 setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
611 boundaryIndicator->getSuperGeometry().getMaterialIndicator(std::move(bulkMaterials)),
612 phi_d);
613}

References setBouzidiAdeDirichlet().

+ Here is the call graph for this function:

◆ 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 576 of file setBouzidiBoundary.h.

580{
581 auto& load = sLattice.getLoadBalancer();
582 auto& cuboidDecomposition = boundaryIndicator->getSuperGeometry().getCuboidDecomposition();
583 for (int iCloc = 0; iCloc < load.size(); ++iCloc) {
584 auto& cuboid = cuboidDecomposition.get(load.glob(iCloc));
585 setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
586 boundaryIndicator->getBlockIndicatorF(iCloc),
587 bulkIndicator->getBlockIndicatorF(iCloc),
588 phi_d,
589 cuboid);
590 }
591}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setBouzidiAdeDirichlet().

+ 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 558 of file setBouzidiBoundary.h.

562{
563 auto& load = sLattice.getLoadBalancer();
564 auto& cuboidDecomposition = boundaryIndicator->getSuperGeometry().getCuboidDecomposition();
565 for (int iCloc = 0; iCloc < load.size(); ++iCloc) {
566 auto& cuboid = cuboidDecomposition.get(load.glob(iCloc));
567 setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
568 boundaryIndicator->getBlockIndicatorF(iCloc),
569 bulkIndicator->getBlockIndicatorF(iCloc),
570 phi_d,
571 cuboid);
572 }
573}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setBouzidiAdeDirichlet().

+ 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 594 of file setBouzidiBoundary.h.

598{
599 setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
600 boundaryIndicator->getSuperGeometry().getMaterialIndicator(std::move(bulkMaterials)),
601 phi_d);
602}

References setBouzidiAdeDirichlet().

+ Here is the call graph for this function:

◆ 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 549 of file setBouzidiBoundary.h.

553{
554 setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material), phi_d, bulkMaterials);
555}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiAdeDirichlet().

+ 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 540 of file setBouzidiBoundary.h.

544{
545 setBouzidiAdeDirichlet<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material), phi_d, bulkMaterials);
546}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiAdeDirichlet().

+ Here is the call graph for this function:
+ Here is the caller 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 231 of file setBouzidiBoundary.h.

237{
238 OstreamManager clout(std::cout, "BouzidiBoundarySetter");
239 clout.setMultiOutput(true);
240
241 const T deltaR = blockGeometry.getDeltaR();
242 // for each solid cell: all of its fluid neighbors need population updates
243 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
244 // Check if cell is solid cell
245 if (boundaryIndicator(solidLatticeR)) {
246 for (int iPop=1; iPop < DESCRIPTOR::q; ++iPop) {
247
248 Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
249 const auto c = descriptors::c<DESCRIPTOR>(iPop);
250 const auto iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
251
252 if (blockGeometry.isInside(boundaryLatticeR)) {
253 auto boundaryPhysR = blockGeometry.getPhysR(boundaryLatticeR);
254
255 // check if neighbor is fluid cell
256 if (bulkIndicator(boundaryLatticeR)) {
257 T dist = -1; // distance to boundary
258 T qIpop = -1; // normed distance (Bouzidi distance) to boundary
259 const T norm = deltaR * util::norm<DESCRIPTOR::d>(descriptors::c<DESCRIPTOR>(iPop));
260 auto direction = -deltaR * c; // vector pointing from the boundary cell to the solid cell
261
262 // Check if distance calculation was performed correctly
263 if (indicatorAnalyticalBoundary.distance(dist, boundaryPhysR.data(), direction, blockGeometry.getIcGlob())) {
264 qIpop = dist / norm;
265
266 // if distance function returned a dist. not suitable for Bouzidi -> fall-back
267 if ((qIpop < 0) || (qIpop > 1)) {
268 if(verbose) {
269 clout << "Error, non suitable dist. at lattice: (" << boundaryLatticeR << "), physical: (" << blockGeometry.getPhysR(boundaryLatticeR) << "), direction " << iPop << ". Fall-back to bounce-back." << std::endl;
270 }
271
272 // fall-back: half-way bounce back
273 qIpop = 0.5;
274 }
275 }
276 // if distance function couldn't compute any distance -> fall-back
277 else {
278 if(verbose) {
279 clout << "Error, no boundary found at lattice:(" << boundaryLatticeR << "), physical: (" << blockGeometry.getPhysR(boundaryLatticeR) << "), direction: " << iPop << ".Fall-back to bounce-back." << std::endl;
280 }
281
282 // fall-back: half-way bounce back
283 qIpop = 0.5;
284 }
285
286 // double check
287 if (qIpop >= 0) {
288 // Bouzidi require the fluid side neighbor of the boundary cell also to be fluid
289 if (bulkIndicator(boundaryLatticeR + descriptors::c<DESCRIPTOR>(iPop))) {
290 // Standard case, c.f. Bouzidi paper, setting Bouzidi-distance
291 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, qIpop);
292 }
293 else {
294 // If no fluid cell found: fall-back to bounce-back
295 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, T{0.5});
296 }
297 // Initialize velocity coefficients if necessary
298 if constexpr (std::is_same_v<OPERATOR, BouzidiVelocityPostProcessor>) {
299 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_VELOCITY>(iPop_opposite, 0);
300 }
301 // Initialize ade dirichlet coefficients if necessary
302 if constexpr (std::is_same_v<OPERATOR, BouzidiAdeDirichletPostProcessor>) {
303 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_ADE_DIRICHLET>(iPop_opposite, 0);
304 }
305 // Setting up the post processor, if this cell does not have one yet.
306 if (!block.isPadding(boundaryLatticeR)) {
307 block.addPostProcessor(typeid(stage::PostStream),
308 boundaryLatticeR,
309 meta::id<OPERATOR>{});
310 }
311 }
312 }
313 // if neigbour cell is not fluid
314 else {
315 // check if neighbor cell is not solid
316 if (blockGeometry.getMaterial(boundaryLatticeR) != 0) {
317 // fall-back to half-way bounce-back
318 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, T{0.5});
319 // Initialize velocity coefficients if necessary
320 if constexpr (std::is_same_v<OPERATOR, BouzidiVelocityPostProcessor>) {
321 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_VELOCITY>(iPop_opposite, 0);
322 }
323 // Initialize velocity coefficients if necessary
324 if constexpr (std::is_same_v<OPERATOR, BouzidiAdeDirichletPostProcessor>) {
325 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_ADE_DIRICHLET>(iPop_opposite, 0);
326 }
327 if (!block.isPadding(boundaryLatticeR)) {
328 block.addPostProcessor(typeid(stage::PostStream),
329 boundaryLatticeR,
330 meta::id<OPERATOR>{});
331 }
332 }
333 }
334 }
335 }
336 }
337 });
338}
Vector< T, D > getPhysR(LatticeR< D > latticeR) const
int getMaterial(LatticeR< D > latticeR) const
returns the (iX,iY) entry in the 2D scalar field
int getIcGlob() const
Read only access to the global iC number which is given !=-1 if the block geometries are part of a su...
T getDeltaR() const
Read only access to the voxel size given in SI units (meter)

References olb::descriptors::c(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getIcGlob(), olb::BlockGeometry< T, D >::getMaterial(), olb::BlockGeometry< T, D >::getPhysR(), olb::BlockStructureD< D >::isInside(), norm(), olb::util::norm(), olb::descriptors::opposite(), 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 194 of file setBouzidiBoundary.h.

198{
199 int _overlap = 1;
200 OstreamManager clout(std::cout, "BouzidiBoundarySetter");
201 auto& load = sLattice.getLoadBalancer();
202 for (int iC=0; iC < load.size(); ++iC) {
203 setBouzidiBoundary<T,DESCRIPTOR,OPERATOR>(sLattice.getBlock(iC),
204 (bulkIndicator->getBlockIndicatorF(iC)).getBlockGeometry(),
205 boundaryIndicator->getBlockIndicatorF(iC),
206 bulkIndicator->getBlockIndicatorF(iC),
207 indicatorAnalyticalBoundary);
208 }
209 addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator), _overlap);
210 clout.setMultiOutput(false);
211}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), setBouzidiBoundary(), and olb::OstreamManager::setMultiOutput().

+ Here is the call graph for this function:
+ Here is the caller 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 215 of file setBouzidiBoundary.h.

220{
221 //Getting the indicators by material numbers and calling the superLattice method via the indicators:
222 setBouzidiBoundary<T,DESCRIPTOR,OPERATOR>(sLattice,
223 FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(materialOfSolidObstacle)),
224 FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(std::move(bulkMaterials))),
225 indicatorAnalyticalBoundary);
226}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiBoundary().

+ Here is the call graph for this function:

◆ setBouzidiKnudsenSlipVelocity() [1/4]

template<typename T , typename DESCRIPTOR , bool thermalCreep = false>
void olb::setBouzidiKnudsenSlipVelocity ( BlockLattice< T, DESCRIPTOR > & block,
BlockIndicatorF< T, DESCRIPTOR::d > & boundaryIndicator,
BlockIndicatorF< T, DESCRIPTOR::d > & bulkIndicator,
Cuboid< T, DESCRIPTOR::d > & cuboid,
IndicatorF< T, DESCRIPTOR::d > & indicatorAnalyticalBoundary )

Set Bouzidi velocity boundary on indicated cells of block lattice.

Definition at line 468 of file setBouzidiBoundary.h.

473{
474 const T deltaR = cuboid.getDeltaR();
475 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
476 if (boundaryIndicator(solidLatticeR)) {
477 for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
478 Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
479 if (block.isInside(boundaryLatticeR)) {
480 if ( bulkIndicator(boundaryLatticeR)) {
481 auto boundaryPhysR = cuboid.getPhysR(boundaryLatticeR);
482 Vector<T,DESCRIPTOR::d> normal = indicatorAnalyticalBoundary.surfaceNormal(boundaryPhysR, deltaR);
483 for ( int i = 0; i< DESCRIPTOR::d; ++i) {
484 block.get(boundaryLatticeR).template setFieldComponent<descriptors::NORMAL>(i,-normal[i]);
485 }
486 if(thermalCreep) {
487 Vector<T,DESCRIPTOR::d> normalRound {};
488 for(int iD = 0; iD < DESCRIPTOR::d; iD++){
489 normalRound[iD] = util::round(normal[iD]);
490 }
491 auto wallLatticeR = boundaryLatticeR + normalRound;
492 if(boundaryIndicator(wallLatticeR)) {
493 Vector<T,DESCRIPTOR::d> tempDerivative {};
494 T temp = block.get(wallLatticeR).template getField<descriptors::TEMPERATURE>();
495 if constexpr(DESCRIPTOR::d==2) {
496 using DESCR = descriptors::D2Q5<>;
497 for( int iPop=1; iPop < DESCR::q; iPop++) {
498 Vector<T,DESCRIPTOR::d> solidNeighborR(wallLatticeR + descriptors::c<DESCR>(iPop));
499 if (boundaryIndicator(solidNeighborR)) {
500 T tempNeighbor = block.get(solidNeighborR).template getField<descriptors::TEMPERATURE>();
501 for( int iD = 0; iD<DESCRIPTOR::d; iD++) {
502 if( descriptors::c<DESCR>(iPop,iD) > 0) {
503 tempDerivative[iD] = tempNeighbor - temp;
504 }
505 if( descriptors::c<DESCR>(iPop,iD) < 0) {
506 tempDerivative[iD] = temp - tempNeighbor;
507 }
508 }
509 }
510 }
511 } else {
512 using DESCR = descriptors::D3Q7<>;
513 for( int iPop=1; iPop < DESCR::q; iPop++) {
514 Vector<T,DESCRIPTOR::d> solidNeighborR(wallLatticeR + descriptors::c<DESCR>(iPop));
515 if (boundaryIndicator(solidNeighborR)) {
516 T tempNeighbor = block.get(solidNeighborR).template getField<descriptors::TEMPERATURE>();
517 for( int iD = 0; iD<DESCRIPTOR::d; iD++) {
518 if( descriptors::c<DESCR>(iPop,iD) > 0) {
519 tempDerivative[iD] = tempNeighbor - temp;
520 }
521 if( descriptors::c<DESCR>(iPop,iD) < 0) {
522 tempDerivative[iD] = temp - tempNeighbor;
523 }
524 }
525 }
526 }
527 }
528 tempDerivative -= (tempDerivative*normal)*normal;
529 block.get(boundaryLatticeR).template setField<descriptors::TEMPGRADIENT>(tempDerivative);
530 }
531 }
532 }
533 }
534 }
535 }
536 });
537}
T getDeltaR() const
Returns spacing of cuboid nodes.
Definition cuboid.h:76
Distribution< T > normal(T mean, T stddev)

References olb::descriptors::c(), olb::Cuboid< T, D >::getDeltaR(), olb::Cuboid< T, D >::getPhysR(), and olb::util::round().

+ Here is the call graph for this function:

◆ setBouzidiKnudsenSlipVelocity() [2/4]

template<typename T , typename DESCRIPTOR , bool thermalCreep = false>
void olb::setBouzidiKnudsenSlipVelocity ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && boundaryIndicator,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && bulkIndicator,
IndicatorF< T, DESCRIPTOR::d > & indicatorAnalyticalBoundary )

Set Bouzidi velocity boundary on indicated cells of sLattice.

Definition at line 448 of file setBouzidiBoundary.h.

452{
453 auto& load = sLattice.getLoadBalancer();
454 auto& cuboidDecomposition = boundaryIndicator->getSuperGeometry().getCuboidDecomposition();
455 for (int iCloc = 0; iCloc < load.size(); ++iCloc) {
456 auto& cuboid = cuboidDecomposition.get(load.glob(iCloc));
457 setBouzidiKnudsenSlipVelocity<T,DESCRIPTOR,thermalCreep>(sLattice.getBlock(iCloc),
458 boundaryIndicator->getBlockIndicatorF(iCloc),
459 bulkIndicator->getBlockIndicatorF(iCloc),
460 cuboid,
461 indicatorAnalyticalBoundary);
462 }
463 addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator), 5);
464}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setBouzidiKnudsenSlipVelocity().

+ Here is the call graph for this function:

◆ setBouzidiKnudsenSlipVelocity() [3/4]

template<typename T , typename DESCRIPTOR , bool thermalCreep = false>
void olb::setBouzidiKnudsenSlipVelocity ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && boundaryIndicator,
IndicatorF< T, DESCRIPTOR::d > & indicatorAnalyticalBoundary,
std::vector< int > bulkMaterials = std::vector<int>(1,1) )

Set Bouzidi velocity boundary on indicated cells of sLattice.

Definition at line 436 of file setBouzidiBoundary.h.

440{
441 setBouzidiKnudsenSlipVelocity<T,DESCRIPTOR,thermalCreep>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
442 boundaryIndicator->getSuperGeometry().getMaterialIndicator(std::move(bulkMaterials)),
443 indicatorAnalyticalBoundary);
444}

References setBouzidiKnudsenSlipVelocity().

+ Here is the call graph for this function:

◆ setBouzidiKnudsenSlipVelocity() [4/4]

template<typename T , typename DESCRIPTOR , bool thermalCreep = false>
void olb::setBouzidiKnudsenSlipVelocity ( SuperLattice< T, DESCRIPTOR > & sLattice,
SuperGeometry< T, DESCRIPTOR::d > & superGeometry,
int material,
IndicatorF< T, DESCRIPTOR::d > & indicatorAnalyticalBoundary,
std::vector< int > bulkMaterials = std::vector<int>(1,1) )

Set Bouzidi velocity boundary on material cells of sLattice.

Definition at line 426 of file setBouzidiBoundary.h.

430{
431 setBouzidiKnudsenSlipVelocity<T,DESCRIPTOR,thermalCreep>(sLattice, superGeometry.getMaterialIndicator(material), indicatorAnalyticalBoundary, bulkMaterials);
432}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiKnudsenSlipVelocity().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setBouzidiPhaseField() [1/3]

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void olb::setBouzidiPhaseField ( 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 949 of file setBouzidiBoundary.h.

955{
956 OstreamManager clout(std::cout, "BouzidiPhaseFieldSetter");
957 clout.setMultiOutput(true);
958
959 const T deltaR = blockGeometry.getDeltaR();
960 // for each solid cell: all of its fluid neighbors need population updates
961 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
962 // Check if cell is solid cell
963
964 if ( blockGeometry.getNeighborhoodRadius(solidLatticeR) >= 1
965 && boundaryIndicator(solidLatticeR)) {
966 std::vector<int> discreteNormal(DESCRIPTOR::d+1, 0);
967 discreteNormal = boundaryIndicator.getBlockGeometry().getStatistics().getType(solidLatticeR[0],solidLatticeR[1]);
968
969 for (int iPop=1; iPop < DESCRIPTOR::q; ++iPop) {
970 Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
971 const auto c = descriptors::c<DESCRIPTOR>(iPop);
972 const auto iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
973
974 if (blockGeometry.isInside(boundaryLatticeR)) {
975 auto boundaryPhysR = blockGeometry.getPhysR(boundaryLatticeR);
976 // check if neighbor is fluid cell
977 if (bulkIndicator(boundaryLatticeR.data())) {
978 T dist = -1; // distance to boundary
979 T qIpop = -1; // normed distance (Bouzidi distance) to boundary
980 const T norm = deltaR * util::norm<DESCRIPTOR::d>(descriptors::c<DESCRIPTOR>(iPop));
981 auto direction = -deltaR * c; // vector pointing from the boundary cell to the solid cell
982
983 // Check if distance calculation was performed correctly
984 if (indicatorAnalyticalBoundary.distance(dist, boundaryPhysR, direction, blockGeometry.getIcGlob())) {
985 qIpop = dist / norm;
986
987 // if distance function returned a dist. not suitable for Bouzidi -> fall-back
988 if ((qIpop < 0) || (qIpop > 1)) {
989 if(verbose) {
990 clout << "Error, non suitable dist. at lattice: (" << boundaryLatticeR << "), physical: (" << blockGeometry.getPhysR(boundaryLatticeR) << "), direction " << iPop << ". Fall-back to bounce-back." << std::endl;
991 }
992
993 // fall-back: half-way bounce back
994 qIpop = 0.5;
995 }
996 }
997 // if distance function couldn't compute any distance -> fall-back
998 else {
999 if(verbose) {
1000 clout << "Error, no boundary found at lattice:(" << boundaryLatticeR << "), physical: (" << blockGeometry.getPhysR(boundaryLatticeR) << "), direction: " << iPop << ".Fall-back to bounce-back." << std::endl;
1001 }
1002
1003 // fall-back: half-way bounce back
1004 qIpop = 0.5;
1005 }
1006 //clout << "Distance to boundary at lattice:(" << boundaryLatticeR << ") and direction (" << iPop << "): " << qIpop << std::endl;
1007 // double check
1008 if (qIpop >= 0) {
1009 // Bouzidi require the fluid side neighbor of the boundary cell also to be fluid
1010 if (bulkIndicator(boundaryLatticeR + descriptors::c<DESCRIPTOR>(iPop))) {
1011 // Standard case, c.f. Bouzidi paper, setting Bouzidi-distance
1012 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, qIpop);
1013 }
1014 else {
1015 // If no fluid cell found: fall-back to bounce-back
1016 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, T{0.5});
1017 }
1018 // Setting up the post processor, if this cell does not have one yet.
1019 if (!block.isPadding(boundaryLatticeR)) {
1020 block.addPostProcessor(typeid(stage::PostStream),
1021 boundaryLatticeR,
1022 meta::id<OPERATOR>{});
1023 }
1024 }
1025 }
1026 // if neigbour cell is not fluid
1027 else {
1028 // check if neighbor cell is not solid
1029 if (blockGeometry.getMaterial(boundaryLatticeR) != 0) {
1030 // fall-back to half-way bounce-back
1031 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, T{0.5});
1032 if (!block.isPadding(boundaryLatticeR)) {
1033 block.addPostProcessor(typeid(stage::PostStream),
1034 boundaryLatticeR,
1035 meta::id<OPERATOR>{});
1036 }
1037 }
1038 }
1039 }
1040 }
1041 T discreteNormalSum=0;
1042 for (int iD=0; iD<DESCRIPTOR::d; iD++) {
1043 discreteNormalSum += abs(discreteNormal[iD+1]);
1044 }
1045 if (discreteNormalSum == 0) {
1046 block.addPostProcessor(
1047 typeid(stage::PreCoupling), solidLatticeR, meta::id<GeometricPhaseFieldCurvedWallProcessor2D<T,DESCRIPTOR>>());
1048 } else {
1049 block.addPostProcessor(
1050 typeid(stage::PreCoupling), solidLatticeR,
1051 boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR,IsoPhaseFieldCurvedWallProcessor2D>(Vector<int,2>(discreteNormal.data() + 1)));
1052 }
1053 }
1054 });
1055}
CellDistance getNeighborhoodRadius(LatticeR< D > latticeR) const
Return maximum valid neighborhood sphere radius w.r.t. latticeR.

References abs(), olb::descriptors::c(), olb::Vector< T, Size >::data(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getIcGlob(), olb::BlockGeometry< T, D >::getMaterial(), olb::BlockStructureD< D >::getNeighborhoodRadius(), olb::BlockGeometry< T, D >::getPhysR(), olb::BlockStructureD< D >::isInside(), norm(), olb::util::norm(), olb::descriptors::opposite(), olb::boundaryhelper::promisePostProcessorForNormal(), and olb::OstreamManager::setMultiOutput().

+ Here is the call graph for this function:

◆ setBouzidiPhaseField() [2/3]

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void olb::setBouzidiPhaseField ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && boundaryIndicator,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && bulkIndicator,
IndicatorF< T, DESCRIPTOR::d > & indicatorAnalyticalBoundary )

Set Bouzidi boundary with contact angle for phase field models on indicated cells of sLattice.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 903 of file setBouzidiBoundary.h.

907{
908 int _overlap = 1;
909 OstreamManager clout(std::cout, "BouzidiPhaseFieldSetter");
910 auto& load = sLattice.getLoadBalancer();
911 for (int iC=0; iC < load.size(); ++iC) {
912 setBouzidiPhaseField<T,DESCRIPTOR,OPERATOR>(sLattice.getBlock(iC),
913 (bulkIndicator->getBlockIndicatorF(iC)).getBlockGeometry(),
914 boundaryIndicator->getBlockIndicatorF(iC),
915 bulkIndicator->getBlockIndicatorF(iC),
916 indicatorAnalyticalBoundary);
917 }
919 auto& communicator = sLattice.getCommunicator(stage::PostStream());
920 communicator.template requestField<descriptors::STATISTIC>();
921 communicator.template requestField<descriptors::BOUNDARY>();
922
923 SuperIndicatorBoundaryNeighbor<T,DESCRIPTOR::d> neighborIndicator(std::forward<decltype(boundaryIndicator)>(boundaryIndicator), _overlap);
924 communicator.requestOverlap(_overlap, neighborIndicator);
925 communicator.exchangeRequests();
926 //addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator), _overlap);
927 clout.setMultiOutput(false);
928}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperLattice< T, DESCRIPTOR >::getCommunicator(), olb::SuperStructure< T, D >::getLoadBalancer(), setBouzidiPhaseField(), and olb::OstreamManager::setMultiOutput().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setBouzidiPhaseField() [3/3]

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void olb::setBouzidiPhaseField ( 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 933 of file setBouzidiBoundary.h.

938{
939 //Getting the indicators by material numbers and calling the superLattice method via the indicators:
940 setBouzidiPhaseField<T,DESCRIPTOR,OPERATOR>(sLattice,
941 FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(materialOfSolidObstacle)),
942 FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(std::move(bulkMaterials))),
943 indicatorAnalyticalBoundary);
944}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiPhaseField().

+ Here is the call graph for this function:

◆ setBouzidiSlipVelocity() [1/4]

template<typename T , typename DESCRIPTOR >
void olb::setBouzidiSlipVelocity ( BlockLattice< T, DESCRIPTOR > & block,
BlockIndicatorF< T, DESCRIPTOR::d > & boundaryIndicator,
IndicatorF< T, DESCRIPTOR::d > & indicatorAnalyticalBoundary,
BlockIndicatorF< T, DESCRIPTOR::d > & bulkIndicator,
Cuboid< T, DESCRIPTOR::d > & cuboid,
int gradientOrder = 1,
bool isOuterWall = true,
bool useDiscreteNormal = false )

Set Bouzidi velocity boundary on indicated cells of block lattice.

Definition at line 740 of file setBouzidiBoundary.h.

748{
749 assert((gradientOrder==0) || (gradientOrder==1) || (gradientOrder==2));
750 const T deltaR = cuboid.getDeltaR();
751 block.template setParameter<descriptors::FD_DEG>(gradientOrder);
752 auto& blockGeometryStructure = bulkIndicator.getBlockGeometry();
753 // For each solid cell: all of its fluid neighbors need population updates
754 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
755 // Check if cell is solid cell
756 if (boundaryIndicator(solidLatticeR)) {
757 Vector<int, 3> discreteNormal =
758 blockGeometryStructure.getStatistics().computeNormal(
759 solidLatticeR[0], solidLatticeR[1], solidLatticeR[2]);
760 for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
761 Vector<T, DESCRIPTOR::d> boundaryLatticeR(
762 solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
763 if (block.isInside(boundaryLatticeR)) {
764 const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
765 auto x_b = block.get(boundaryLatticeR);
766 //int material = blockGeometryStructure.getMaterial(boundaryLatticeR);
767 const auto opp_bouzidi_dist = x_b.template getFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite);
768
769 // check if distance from the fluid cell to the solid cell is a valid bouzidi distance
770 if (opp_bouzidi_dist >= 0 && (bulkIndicator(boundaryLatticeR))){ // || boundaryIndicator(boundaryLatticeR))) { // )){ // Try if( bulkIndicator(boundaryLatticeR))opp_bouzidi_dist >= 0
771 auto boundaryPhysR = cuboid.getPhysR(boundaryLatticeR);
772 IndicatorLayer3D<T> indicatorAnalyticalBoundaryLayer(
773 indicatorAnalyticalBoundary, 0.5 * deltaR);
774 if (!useDiscreteNormal) {
775 Vector<T, 3> normal =
776 indicatorAnalyticalBoundaryLayer.surfaceNormal(boundaryPhysR.data(),
777 deltaR);
778 if (isOuterWall) {
779 normal = -1 * normal;
780 }
781 Vector<T, 3> ceilNormal(ceil(normal[0]), ceil(normal[1]),
782 ceil(normal[2]));
783 Vector<T, 3> floorNormal(floor(normal[0]), floor(normal[1]),
784 floor(normal[2]));
785 if (bulkIndicator(ceilNormal + boundaryLatticeR) ||
786 bulkIndicator(floorNormal + boundaryLatticeR)) {
787 block.get(boundaryLatticeR)
788 .template setField<descriptors::NORMAL>(
789 {normal[0], normal[1], normal[2]});
790 }
791 }
792 else {
793 block.get(boundaryLatticeR)
794 .template setField<descriptors::NORMAL>({(T) discreteNormal[0],
795 (T) discreteNormal[1],
796 (T) discreteNormal[2]});
797 }
798
799 block.get(boundaryLatticeR)
800 .template setFieldComponent<descriptors::BOUZIDI_VELOCITY>(
801 iPop_opposite, T(0));
802 }
803 }
804 }
805 }
806 });
807}
indicator function for a layer

References olb::descriptors::c(), olb::Cuboid< T, D >::getDeltaR(), olb::Cuboid< T, D >::getPhysR(), olb::descriptors::opposite(), and olb::IndicatorF3D< T >::surfaceNormal().

+ Here is the call graph for this function:

◆ setBouzidiSlipVelocity() [2/4]

template<typename T , typename DESCRIPTOR >
void olb::setBouzidiSlipVelocity ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && boundaryIndicator,
IndicatorF< T, DESCRIPTOR::d > & indicatorAnalyticalBoundary,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && bulkIndicator,
int gradientOrder = 1,
bool isOuterWall = true,
bool useDiscreteNormal = false )

Set Bouzidi velocity boundary on indicated cells of sLattice.

Definition at line 713 of file setBouzidiBoundary.h.

720{
721 auto& load = sLattice.getLoadBalancer();
722 auto& cuboidDecomposition =
723 boundaryIndicator->getSuperGeometry().getCuboidDecomposition();
724 for (int iCloc = 0; iCloc < load.size(); ++iCloc) {
725 auto& cuboid = cuboidDecomposition.get(load.glob(iCloc));
726 setBouzidiSlipVelocity<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
727 boundaryIndicator->getBlockIndicatorF(iCloc),
728 indicatorAnalyticalBoundary,
729 bulkIndicator->getBlockIndicatorF(iCloc),
730 cuboid, gradientOrder, isOuterWall, useDiscreteNormal);
731 }
732 int _overlap = 3;
733 addPoints2CommBC<T, DESCRIPTOR>(
734 sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
735 _overlap);
736}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setBouzidiSlipVelocity().

+ Here is the call graph for this function:

◆ setBouzidiSlipVelocity() [3/4]

template<typename T , typename DESCRIPTOR >
void olb::setBouzidiSlipVelocity ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && boundaryIndicator,
IndicatorF< T, DESCRIPTOR::d > & indicatorAnalyticalBoundary,
int gradientOrder = 1,
std::vector< int > bulkMaterials = std::vector<int>(1,1),
bool isOuterWall = true,
bool useDiscreteNormal = false )

Set Bouzidi velocity boundary on indicated cells of sLattice.

Definition at line 696 of file setBouzidiBoundary.h.

702{
703 setBouzidiSlipVelocity<T, DESCRIPTOR>(
704 sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
705 indicatorAnalyticalBoundary,
706 boundaryIndicator->getSuperGeometry().getMaterialIndicator(
707 std::move(bulkMaterials)),
708 gradientOrder, isOuterWall, useDiscreteNormal);
709}

References setBouzidiSlipVelocity().

+ Here is the call graph for this function:

◆ setBouzidiSlipVelocity() [4/4]

template<typename T , typename DESCRIPTOR >
void olb::setBouzidiSlipVelocity ( SuperLattice< T, DESCRIPTOR > & sLattice,
SuperGeometry< T, DESCRIPTOR::d > & superGeometry,
int material,
IndicatorF< T, DESCRIPTOR::d > & indicatorAnalyticalBoundary,
int gradientOrder = 1,
std::vector< int > bulkMaterials = std::vector<int>(1,1),
bool isOuterWall = true,
bool useDiscreteNormal = false )

Bouzidi General/Knudsen Slip Velocity 3D Sets slip velocity on general walls.

Definition at line 681 of file setBouzidiBoundary.h.

687{
688 setBouzidiSlipVelocity<T, DESCRIPTOR>(
689 sLattice, superGeometry.getMaterialIndicator(material),
690 indicatorAnalyticalBoundary, gradientOrder, bulkMaterials, isOuterWall,
691 useDiscreteNormal);
692}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiSlipVelocity().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setBouzidiTemperatureJump() [1/4]

template<typename T , typename DESCRIPTOR >
void olb::setBouzidiTemperatureJump ( 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 856 of file setBouzidiBoundary.h.

861{
862 auto& blockGeometryStructure = bulkIndicator.getBlockGeometry();
863 std::vector<int> discreteNormalOutwards(4, 0);
864 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
865 if (boundaryIndicator(solidLatticeR)) {
866
867 for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
868 Vector<T, DESCRIPTOR::d> boundaryLatticeR(
869 solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
870 if (block.isInside(boundaryLatticeR)) {
871 const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
872 auto x_b = block.get(boundaryLatticeR);
873 const auto opp_bouzidi_dist =
874 x_b.template getFieldComponent<descriptors::BOUZIDI_DISTANCE>(
875 iPop_opposite);
876
877 // check if distance from the fluid cell to the solid cell is a valid bouzidi distance
878 if ((opp_bouzidi_dist >= 0) && (bulkIndicator(boundaryLatticeR))) {
879 T phi_at_cell[1] {};
880 auto boundaryPhysR = cuboid.getPhysR(boundaryLatticeR);
881
882 phi_d(phi_at_cell, boundaryPhysR.data());
883 discreteNormalOutwards =
884 blockGeometryStructure.getStatistics().getType(
885 solidLatticeR[0], solidLatticeR[1], solidLatticeR[2]);
886 // set computed velocity into the bouzidi velocity field
887 block.get(boundaryLatticeR)
888 .template setFieldComponent<descriptors::BOUZIDI_WALL_TEMP>(
889 iPop_opposite, phi_at_cell[0]);
890 block.get(boundaryLatticeR)
891 .template setField<descriptors::NORMAL>(
892 {-discreteNormalOutwards[1], -discreteNormalOutwards[2],
893 -discreteNormalOutwards[3]});
894 }
895 }
896 }
897 }
898 });
899}

References olb::descriptors::c(), olb::Cuboid< T, D >::getPhysR(), and olb::descriptors::opposite().

+ Here is the call graph for this function:

◆ setBouzidiTemperatureJump() [2/4]

template<typename T , typename DESCRIPTOR >
void olb::setBouzidiTemperatureJump ( 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 842 of file setBouzidiBoundary.h.

846{
847 setBouzidiTemperatureJump<T, DESCRIPTOR>(
848 sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
849 boundaryIndicator->getSuperGeometry().getMaterialIndicator(
850 std::move(bulkMaterials)),
851 phi_d);
852}

References setBouzidiTemperatureJump().

+ Here is the call graph for this function:

◆ setBouzidiTemperatureJump() [3/4]

template<typename T , typename DESCRIPTOR >
void olb::setBouzidiTemperatureJump ( 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 822 of file setBouzidiBoundary.h.

826{
827 auto& load = sLattice.getLoadBalancer();
828 auto& cuboidDecomposition =
829 boundaryIndicator->getSuperGeometry().getCuboidDecomposition();
830 for (int iCloc = 0; iCloc < load.size(); ++iCloc) {
831 auto& cuboid = cuboidDecomposition.get(load.glob(iCloc));
832 setBouzidiTemperatureJump<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
833 boundaryIndicator->getBlockIndicatorF(iCloc),
834 bulkIndicator->getBlockIndicatorF(iCloc),
835 phi_d,
836 cuboid);
837 }
838}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setBouzidiTemperatureJump().

+ Here is the call graph for this function:

◆ setBouzidiTemperatureJump() [4/4]

template<typename T , typename DESCRIPTOR >
void olb::setBouzidiTemperatureJump ( 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 811 of file setBouzidiBoundary.h.

815{
816 setBouzidiTemperatureJump<T, DESCRIPTOR>(
817 sLattice, superGeometry.getMaterialIndicator(material), phi_d,
818 bulkMaterials);
819}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiTemperatureJump().

+ Here is the call graph for this function:
+ Here is the caller 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 383 of file setBouzidiBoundary.h.

388{
389 const T deltaR = cuboid.getDeltaR();
390 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
391 if (boundaryIndicator(solidLatticeR)) {
392 for (int iPop = 1; iPop < DESCRIPTOR::q; ++iPop) {
393 Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
394 if (block.isInside(boundaryLatticeR)) {
395 const int iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
396 auto x_b = block.get(boundaryLatticeR);
397 const auto opp_bouzidi_dist = x_b.template getFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite);
398
399 // check if distance from the fluid cell to the solid cell is a valid bouzidi distance
400 if (opp_bouzidi_dist >= 0) {
401 T wallVelocity[DESCRIPTOR::d] = { };
402 T physicalIntersection[DESCRIPTOR::d] = { };
403 auto boundaryPhysR = cuboid.getPhysR(boundaryLatticeR);
404
405 // calculating the intersection of the boundary with the missing link in physical coordinates
406 for ( int i = 0; i< DESCRIPTOR::d; ++i) {
407 physicalIntersection[i] = boundaryPhysR[i] + opp_bouzidi_dist * deltaR * descriptors::c<DESCRIPTOR>(iPop_opposite,i);
408 }
409
410 //Calculating the velocity at the wall intersection
411 u(wallVelocity, physicalIntersection);
412 const auto c = descriptors::c<DESCRIPTOR>(iPop_opposite);
413 T vel_coeff = c * Vector<T,DESCRIPTOR::d>(wallVelocity);
414
415 // set computed velocity into the bouzidi velocity field
416 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_VELOCITY>(iPop_opposite, vel_coeff);
417 }
418 }
419 }
420 }
421 });
422}

References olb::descriptors::c(), olb::Cuboid< T, D >::getDeltaR(), olb::Cuboid< T, D >::getPhysR(), and olb::descriptors::opposite().

+ 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 352 of file setBouzidiBoundary.h.

356{
357 setBouzidiVelocity<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator),
358 boundaryIndicator->getSuperGeometry().getMaterialIndicator(std::move(bulkMaterials)),
359 u);
360}

References setBouzidiVelocity().

+ Here is the call graph for this function:

◆ 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 364 of file setBouzidiBoundary.h.

368{
369 auto& load = sLattice.getLoadBalancer();
370 auto& cuboidDecomposition = boundaryIndicator->getSuperGeometry().getCuboidDecomposition();
371 for (int iCloc = 0; iCloc < load.size(); ++iCloc) {
372 auto& cuboid = cuboidDecomposition.get(load.glob(iCloc));
373 setBouzidiVelocity<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
374 boundaryIndicator->getBlockIndicatorF(iCloc),
375 bulkIndicator->getBlockIndicatorF(iCloc),
376 u,
377 cuboid);
378 }
379}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setBouzidiVelocity().

+ 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 342 of file setBouzidiBoundary.h.

346{
347 setBouzidiVelocity<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material), u, bulkMaterials);
348}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiVelocity().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setBouzidiWellBalanced() [1/3]

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void olb::setBouzidiWellBalanced ( 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 1106 of file setBouzidiBoundary.h.

1112{
1113 OstreamManager clout(std::cout, "BouzidiWellBalancedSetter");
1114 clout.setMultiOutput(true);
1115
1116 const T deltaR = blockGeometry.getDeltaR();
1117 // for each solid cell: all of its fluid neighbors need population updates
1118 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
1119 // Check if cell is solid cell
1120 if ( blockGeometry.getNeighborhoodRadius(solidLatticeR) >= 1
1121 && boundaryIndicator(solidLatticeR)) {
1122 std::vector<int> discreteNormal(DESCRIPTOR::d+1, 0);
1123 if constexpr ( DESCRIPTOR::d==2 ) {
1124 discreteNormal = boundaryIndicator.getBlockGeometry().getStatistics().getType(solidLatticeR[0],solidLatticeR[1]);
1125 block.addPostProcessor(
1126 typeid(stage::PreCoupling), solidLatticeR, boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR,WellBalancedWallProcessor2D>(
1127 Vector<int,DESCRIPTOR::d>(discreteNormal.data() + 1)));
1128 }
1129 else if constexpr ( DESCRIPTOR::d==3 ) {
1130 discreteNormal = boundaryIndicator.getBlockGeometry().getStatistics().getType(solidLatticeR[0],solidLatticeR[1],solidLatticeR[2]);
1131 block.addPostProcessor(
1132 typeid(stage::PreCoupling), solidLatticeR, boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR,WellBalancedWallProcessor3D>(
1133 Vector<int,DESCRIPTOR::d>(discreteNormal.data() + 1)));
1134 }
1135
1136 for (int iPop=1; iPop < DESCRIPTOR::q; ++iPop) {
1137 Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
1138 const auto c = descriptors::c<DESCRIPTOR>(iPop);
1139 const auto iPop_opposite = descriptors::opposite<DESCRIPTOR>(iPop);
1140
1141 if (blockGeometry.isInside(boundaryLatticeR)) {
1142 auto boundaryPhysR = blockGeometry.getPhysR(boundaryLatticeR);
1143 // check if neighbor is fluid cell
1144 if (bulkIndicator(boundaryLatticeR.data())) {
1145 T dist = -1; // distance to boundary
1146 T qIpop = -1; // normed distance (Bouzidi distance) to boundary
1147 const T norm = deltaR * util::norm<DESCRIPTOR::d>(descriptors::c<DESCRIPTOR>(iPop));
1148 auto direction = -deltaR * c; // vector pointing from the boundary cell to the solid cell
1149
1150 // Check if distance calculation was performed correctly
1151 if (indicatorAnalyticalBoundary.distance(dist, boundaryPhysR, direction, blockGeometry.getIcGlob())) {
1152 qIpop = dist / norm;
1153
1154 // if distance function returned a dist. not suitable for Bouzidi -> fall-back
1155 if ((qIpop < 0) || (qIpop > 1)) {
1156 if(verbose) {
1157 clout << "Error, non suitable dist. at lattice: (" << boundaryLatticeR << "), physical: (" << blockGeometry.getPhysR(boundaryLatticeR) << "), direction " << iPop << ". Fall-back to bounce-back." << std::endl;
1158 }
1159
1160 // fall-back: half-way bounce back
1161 qIpop = 0.5;
1162 }
1163 }
1164 // if distance function couldn't compute any distance -> fall-back
1165 else {
1166 if(verbose) {
1167 clout << "Error, no boundary found at lattice:(" << boundaryLatticeR << "), physical: (" << blockGeometry.getPhysR(boundaryLatticeR) << "), direction: " << iPop << ".Fall-back to bounce-back." << std::endl;
1168 }
1169
1170 // fall-back: half-way bounce back
1171 qIpop = 0.5;
1172 }
1173 //clout << "Distance to boundary at lattice:(" << boundaryLatticeR << ") and direction (" << iPop << "): " << qIpop << std::endl;
1174 // double check
1175 if (qIpop >= 0) {
1176 // Bouzidi require the fluid side neighbor of the boundary cell also to be fluid
1177 if (bulkIndicator(boundaryLatticeR + descriptors::c<DESCRIPTOR>(iPop))) {
1178 // Standard case, c.f. Bouzidi paper, setting Bouzidi-distance
1179 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, qIpop);
1180 }
1181 else {
1182 // If no fluid cell found: fall-back to bounce-back
1183 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, T{0.5});
1184 }
1185 // Setting up the post processor, if this cell does not have one yet.
1186 if (!block.isPadding(boundaryLatticeR)) {
1187 block.addPostProcessor(typeid(stage::PostStream),
1188 boundaryLatticeR,
1189 meta::id<OPERATOR>{});
1190 }
1191 }
1192 }
1193 // if neigbour cell is not fluid
1194 else {
1195 // check if neighbor cell is not solid
1196 if (blockGeometry.getMaterial(boundaryLatticeR) != 0) {
1197 // fall-back to half-way bounce-back
1198 block.get(boundaryLatticeR).template setFieldComponent<descriptors::BOUZIDI_DISTANCE>(iPop_opposite, T{0.5});
1199 if (!block.isPadding(boundaryLatticeR)) {
1200 block.addPostProcessor(typeid(stage::PostStream),
1201 boundaryLatticeR,
1202 meta::id<OPERATOR>{});
1203 }
1204 }
1205 }
1206 }
1207 }
1208 }
1209 });
1210}
Communication prior to coupling.
Definition stages.h:42

References olb::descriptors::c(), olb::Vector< T, Size >::data(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getIcGlob(), olb::BlockGeometry< T, D >::getMaterial(), olb::BlockStructureD< D >::getNeighborhoodRadius(), olb::BlockGeometry< T, D >::getPhysR(), olb::BlockStructureD< D >::isInside(), norm(), olb::util::norm(), olb::descriptors::opposite(), olb::boundaryhelper::promisePostProcessorForNormal(), and olb::OstreamManager::setMultiOutput().

+ Here is the call graph for this function:

◆ setBouzidiWellBalanced() [2/3]

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void olb::setBouzidiWellBalanced ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && boundaryIndicator,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && bulkIndicator,
IndicatorF< T, DESCRIPTOR::d > & indicatorAnalyticalBoundary )

Set Bouzidi boundary with contact angle for phase field models on indicated cells of sLattice.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 1060 of file setBouzidiBoundary.h.

1064{
1065 int _overlap = 1;
1066 OstreamManager clout(std::cout, "BouzidiWellBalancedSetter");
1067 auto& load = sLattice.getLoadBalancer();
1068 for (int iC=0; iC < load.size(); ++iC) {
1069 setBouzidiWellBalanced<T,DESCRIPTOR,OPERATOR>(sLattice.getBlock(iC),
1070 (bulkIndicator->getBlockIndicatorF(iC)).getBlockGeometry(),
1071 boundaryIndicator->getBlockIndicatorF(iC),
1072 bulkIndicator->getBlockIndicatorF(iC),
1073 indicatorAnalyticalBoundary);
1074 }
1076 auto& communicator = sLattice.getCommunicator(stage::PostStream());
1077 communicator.template requestField<descriptors::STATISTIC>();
1078 communicator.template requestField<descriptors::BOUNDARY>();
1079
1080 SuperIndicatorBoundaryNeighbor<T,DESCRIPTOR::d> neighborIndicator(std::forward<decltype(boundaryIndicator)>(boundaryIndicator), _overlap);
1081 communicator.requestOverlap(_overlap, neighborIndicator);
1082 communicator.exchangeRequests();
1083 //addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator), _overlap);
1084 clout.setMultiOutput(false);
1085}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperLattice< T, DESCRIPTOR >::getCommunicator(), olb::SuperStructure< T, D >::getLoadBalancer(), setBouzidiWellBalanced(), and olb::OstreamManager::setMultiOutput().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setBouzidiWellBalanced() [3/3]

template<typename T , typename DESCRIPTOR , typename OPERATOR = BouzidiPostProcessor>
void olb::setBouzidiWellBalanced ( 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 1090 of file setBouzidiBoundary.h.

1095{
1096 //Getting the indicators by material numbers and calling the superLattice method via the indicators:
1097 setBouzidiWellBalanced<T,DESCRIPTOR,OPERATOR>(sLattice,
1098 FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(materialOfSolidObstacle)),
1099 FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(std::move(bulkMaterials))),
1100 indicatorAnalyticalBoundary);
1101}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setBouzidiWellBalanced().

+ Here is the call graph for this function:

◆ setConvectivePhaseFieldBoundary() [1/3]

template<typename T , typename DESCRIPTOR >
void olb::setConvectivePhaseFieldBoundary ( BlockLattice< T, DESCRIPTOR > & block,
BlockIndicatorF2D< T > & indicator )

Set ConvectivePhaseFieldBoundary for any indicated cells inside the block domain.

Definition at line 182 of file phaseFieldBoundaryDynamics.h.

183{
184 using namespace boundaryhelper;
185 const auto& blockGeometryStructure = indicator.getBlockGeometry();
186 const int margin = 1;
187 std::vector<int> discreteNormal(3,0);
188 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
189 if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin && indicator(iX, iY)) {
190 discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY);
191 if ((abs(discreteNormal[1]) + abs(discreteNormal[2])) == 1) {
192 block.addPostProcessor(
193 typeid(stage::PostCollide), {iX,iY},
194 promisePostProcessorForNormal<T,DESCRIPTOR,FlatConvectivePhaseFieldPostProcessorA2D>(
195 Vector<int,2>(discreteNormal.data() + 1)));
196 block.addPostProcessor(
197 typeid(stage::PostStream), {iX,iY},
198 promisePostProcessorForNormal<T,DESCRIPTOR,FlatConvectivePhaseFieldPostProcessorB2D>(
199 Vector<int,2>(discreteNormal.data() + 1)));
200 block.template defineDynamics<NoCollideDynamicsExternalVelocity>({iX, iY});
201 } else {
202 throw std::runtime_error("No valid discrete normal found. This BC is not suited for curved walls.");
203 }
204 }
205 });
206}
BlockGeometry< T, 2 > & getBlockGeometry()
Get underlying block geometry structure.
Communication after collision.
Definition stages.h:34

References abs(), and olb::BlockIndicatorF2D< T >::getBlockGeometry().

+ Here is the call graph for this function:

◆ setConvectivePhaseFieldBoundary() [2/3]

template<typename T , typename DESCRIPTOR >
void olb::setConvectivePhaseFieldBoundary ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF2D< T > > && indicator )

Initialising the setConvectivePhaseFieldBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 160 of file phaseFieldBoundaryDynamics.h.

161{
162 OstreamManager clout(std::cout, "setConvectivePhaseFieldBoundary");
163
164 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); iCloc++) {
165 setConvectivePhaseFieldBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc), indicator->getBlockIndicatorF(iCloc));
166 }
168 int _overlap = 1;
169 {
170 auto& communicator = sLattice.getCommunicator(stage::PostCollide());
171 communicator.template requestField<descriptors::POPULATION>();
172
173 SuperIndicatorBoundaryNeighbor<T,DESCRIPTOR::d> neighborIndicator(std::forward<decltype(indicator)>(indicator), _overlap);
174 communicator.requestOverlap(_overlap, neighborIndicator);
175 communicator.exchangeRequests();
176 }
177}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperLattice< T, DESCRIPTOR >::getCommunicator(), olb::SuperStructure< T, D >::getLoadBalancer(), and setConvectivePhaseFieldBoundary().

+ Here is the call graph for this function:

◆ setConvectivePhaseFieldBoundary() [3/3]

template<typename T , typename DESCRIPTOR >
void olb::setConvectivePhaseFieldBoundary ( SuperLattice< T, DESCRIPTOR > & sLattice,
SuperGeometry< T, 2 > & superGeometry,
int material )

Initialising the setConvectivePhaseFieldBoundary function on the superLattice domain.

Definition at line 153 of file phaseFieldBoundaryDynamics.h.

154{
155 setConvectivePhaseFieldBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material));
156}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setConvectivePhaseFieldBoundary().

+ Here is the call graph for this function:
+ Here is the caller 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.

67{
68 auto& blockGeometryStructure = indicator.getBlockGeometry();
69 const int margin = includeOuterCells ? 0 : 1;
70 std::vector<int> discreteNormal(3, 0);
71 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
72 if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
73 && indicator(iX, iY)) {
74 discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
75 block.get(iX, iY).template setField<descriptors::NORMAL_X>(-discreteNormal[1]);
76 block.get(iX, iY).template setField<descriptors::NORMAL_Y>(-discreteNormal[2]);
77 }
78 });
79 block.addPostProcessor ( typeid(stage::PostStream), indicator,
80 meta::id<FdBoundaryPostProcessor2D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>>{} );
81}
const BlockGeometryStatistics< T, D > & getStatistics() const
Read only access to the associated block statistic.

References olb::BlockIndicatorF2D< T >::getBlockGeometry(), and olb::BlockGeometry< T, D >::getStatistics().

+ 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

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setFdBoundary2D.hh.

43{
44 bool includeOuterCells = false;
45 int _overlap = indicator->getSuperGeometry().getOverlap();
46 OstreamManager clout(std::cout, "setOnBCInterpolatedBoundary");
47 if (indicator->getSuperGeometry().getOverlap() == 1) {
48 includeOuterCells = true;
49 clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
50 }
51 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
52 setFdBoundary2D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>(sLattice.getBlock(iCloc),
53 indicator->getBlockIndicatorF(iCloc), includeOuterCells);
54 }
56 //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary2D.h/hh
57 addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
58
59
60}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setFdBoundary2D().

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

36{
37 setFdBoundary2D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>(sLattice, superGeometry.getMaterialIndicator(material));
38}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setFdBoundary2D().

+ Here is the call graph for this function:
+ Here is the caller 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.

67{
68 auto& blockGeometryStructure = indicator.getBlockGeometry();
69 const int margin = includeOuterCells ? 0 : 1;
70 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
71 if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
72 && indicator(iX, iY, iZ)) {
73 std::vector<int> discreteNormal(4,0);
74 discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY, iZ);
75 block.get(iX, iY, iZ).template setField<descriptors::NORMAL_X>(-discreteNormal[1]);
76 block.get(iX, iY, iZ).template setField<descriptors::NORMAL_Y>(-discreteNormal[2]);
77 block.get(iX, iY, iZ).template setField<descriptors::NORMAL_Z>(-discreteNormal[3]);
78 }
79 });
80 block.addPostProcessor ( typeid(stage::PostStream), indicator,
81 meta::id<FdBoundaryPostProcessor3D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>> {} );
82}

References olb::BlockStructureD< D >::forSpatialLocations(), 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

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setFdBoundary3D.hh.

45{
46 OstreamManager clout(std::cout, "setFdBoundary3D");
47 int _overlap = indicator->getSuperGeometry().getOverlap();
48 bool includeOuterCells = false;
49 if (indicator->getSuperGeometry().getOverlap() == 1) {
50 includeOuterCells = true;
51 clout << "WARNING: overlap == 1, boundary conditions set on overlap despite unknown neighbor materials" << std::endl;
52 }
53 for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
54 setFdBoundary3D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>(sLattice.getBlock(iC), indicator->getBlockIndicatorF(iC),includeOuterCells);
56 //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary3D.h/hh
57 addPoints2CommBC(sLattice,std::forward<decltype(indicator)>(indicator), _overlap);
58 }
59}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setFdBoundary3D().

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

37{
38 setFdBoundary3D<T,DESCRIPTOR,MODEL,SCHEME_BOUND,PARAMETERS,FIELD,SOURCE>(sLattice, superGeometry.getMaterialIndicator(material));
39}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setFdBoundary3D().

+ Here is the call graph for this function:
+ Here is the caller 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 )

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

42{
43 for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
44 setFdPostProcessor2D<T,DESCRIPTOR,MODEL,PARAMETERS,FIELD,SOURCE>(sLattice.getBlock(iC), indicator->getBlockIndicatorF(iC));
45 }
46}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setFdPostProcessor2D().

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

35{
36 setFdPostProcessor2D<T,DESCRIPTOR,MODEL,PARAMETERS,FIELD,SOURCE>(sLattice, superGeometry.getMaterialIndicator(material));
37}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setFdPostProcessor2D().

+ Here is the call graph for this function:
+ Here is the caller 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 )

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

42{
43 for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
44 setFdPostProcessor3D<T,DESCRIPTOR,MODEL,PARAMETERS,FIELD,SOURCE>(sLattice.getBlock(iC), indicator->getBlockIndicatorF(iC));
45 }
46}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setFdPostProcessor3D().

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

35{
36 setFdPostProcessor3D<T,DESCRIPTOR,MODEL,PARAMETERS,FIELD,SOURCE>(sLattice, superGeometry.getMaterialIndicator(material));
37}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setFdPostProcessor3D().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setFieldFromSerialized()

template<typename FIELD , typename T , typename DESCRIPTOR >
void olb::setFieldFromSerialized ( const std::vector< T > & serial,
SuperLattice< T, DESCRIPTOR > & lattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && indicator )

Set field content from a serialized data vector inside indicated region.

Definition at line 77 of file serialize.h.

79{
80 auto& loadBalancer = lattice.getLoadBalancer();
81 auto& cDecomposition = indicator->getSuperStructure().getCuboidDecomposition();
82 auto& superGeometry = indicator->getSuperGeometry();
83
84 std::size_t offset = 0;
85 for (int iC=0; iC<cDecomposition.size(); ++iC) {
86 std::size_t numNodes = 0;
87 if (loadBalancer.isLocal(iC)) {
88 const int loc = loadBalancer.loc(iC);
89 auto& blockGeometry = superGeometry.getBlockGeometry(loc);
90 auto& blockLattice = lattice.getBlock(loc);
91 auto& blockIndicator = indicator->getBlockIndicatorF(loc);
92 blockGeometry.forCoreSpatialLocations([&](LatticeR<DESCRIPTOR::d> pos) {
93 if (blockIndicator(pos)) {
94 std::size_t index = offset + numNodes;
96 for (std::size_t iD=0; iD<DESCRIPTOR::template size<FIELD>(); ++iD) {
97 field[iD] = serial.at(index + iD);
98 ++numNodes;
99 }
100 blockLattice.get(pos).template setField<FIELD>(field);
101 }
102 });
103 }
104#ifdef PARALLEL_MODE_MPI
105 singleton::mpi().reduceAndBcast(numNodes, MPI_SUM);
106#endif
107 offset += numNodes;
108 }
109}

References olb::BlockStructureD< D >::forCoreSpatialLocations(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), olb::singleton::mpi(), and olb::singleton::MpiManager::reduceAndBcast().

+ Here is the call graph for this function:

◆ setLocalConvectionBoundary() [1/6]

template<typename T , typename DESCRIPTOR >
void olb::setLocalConvectionBoundary ( BlockLattice< T, DESCRIPTOR > & _block,
BlockIndicatorF3D< T > & indicator,
T * uAv )

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.

64{
65 auto& blockGeometryStructure = indicator.getBlockGeometry();
66 const int margin = 1;
67 std::vector<int> discreteNormal(4,0);
68 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
69 if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
70 && indicator(iX, iY, iZ)) {
71 PostProcessorGenerator3D<T,DESCRIPTOR>* postProcessor = nullptr;
72 discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
73
74 if (discreteNormal[0] == 0) {//set postProcessors for indicated boundary cells
75 if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {
76 postProcessor = nullptr;
77 }
78 else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
79 postProcessor = nullptr;
80 }
81 else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
82 postProcessor = nullptr;
83 }
84 else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
85 postProcessor = nullptr;
86 }
87 else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
88 postProcessor = nullptr;
89 }
90 else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
91 postProcessor = nullptr;
92 }
93 if (postProcessor) {
94 _block.addPostProcessor(*postProcessor);
95 }
96 }
97 }
98 });
99}

References 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,
BlockIndicatorF2D< T > & indicator,
T * uAv )

Set LocalConvectionBoundary for indicated cells inside the block domain.

Definition at line 55 of file setLocalConvectionBoundary2D.hh.

56{
57 OstreamManager clout (std::cout, "setLocalConvectionBoundary");
58 bool _output = false;
59 auto& blockGeometryStructure = indicator.getBlockGeometry();
60 const int margin = 1;
61 std::vector<int> discreteNormal(3, 0);
62 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
63 if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
64 && indicator(iX, iY)) {
65 PostProcessorGenerator2D<T, DESCRIPTOR>* postProcessor = nullptr;
66 discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
67 if (discreteNormal[0] == 0) {//set postProcessors on indicated LocalConvectionBoundary cells
68 if (discreteNormal[1] == -1) {
69 if (_output) {
70 clout << "setLocalConvectionBoundary<" << 0 << ","<< -1 << ">(" << iX << ", "<< iX << ", " << iY << ", " << iY << " )" << std::endl;
71 }
72 postProcessor = nullptr;
73 }
74 else if (discreteNormal[1] == 1) {
75 if (_output) {
76 clout << "setLocalConvectionBoundary<" << 0 << ","<< 1 << ">(" << iX << ", "<< iX << ", " << iY << ", " << iY << " )" << std::endl;
77 }
78 postProcessor = nullptr;
79 }
80 else if (discreteNormal[2] == -1) {
81 if (_output) {
82 clout << "setLocalConvectionBoundary<" << 1 << ","<< -1 << ">(" << iX << ", "<< iX << ", " << iY << ", " << iY << " )" << std::endl;
83 }
84 postProcessor = nullptr;
85 }
86 else if (discreteNormal[2] == 1) {
87 if (_output) {
88 clout << "setLocalConvectionBoundary<" << 1 << ","<< 1 << ">(" << iX << ", "<< iX << ", " << iY << ", " << iY << " )" << std::endl;
89 }
90 postProcessor = nullptr;
91 }
92 if (postProcessor) {
93 block.addPostProcessor(*postProcessor);
94 }
95 }
96 }
97 });
98}

References olb::BlockIndicatorF2D< T >::getBlockGeometry(), and olb::BlockGeometry< T, D >::getStatistics().

+ Here is the call graph for this function:

◆ setLocalConvectionBoundary() [3/6]

template<typename T , typename DESCRIPTOR >
void olb::setLocalConvectionBoundary ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF2D< T > > && indicator,
T * uAv )

Initialising the LocalConvectionBoundary on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 41 of file setLocalConvectionBoundary2D.hh.

42{
43 int _overlap = 0; // TODO: This intended?
44 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
45 setLocalConvectionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),
46 indicator->getBlockIndicatorF(iCloc), uAv);
47 }
49 //TODO: Is communication really needed for this BC?
50 addPoints2CommBC<T, DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
51}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setLocalConvectionBoundary().

+ Here is the call graph for this function:

◆ setLocalConvectionBoundary() [4/6]

template<typename T , typename DESCRIPTOR >
void olb::setLocalConvectionBoundary ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF3D< T > > && indicator,
T * uAv )

Initialising the setLocalConvectionBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 43 of file setLocalConvectionBoundary3D.hh.

44{
45 int _overlap = 0; // TODO: Is intended?
46 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
47 setLocalConvectionBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc), indicator->getBlockIndicatorF(iCloc),
48 uAv);
49 }
51 // TODO: Is communication really needed for this BC?
52 auto& communicator = sLattice.getCommunicator(stage::PostStream());
53 communicator.template requestField<descriptors::POPULATION>();
54
55 SuperIndicatorBoundaryNeighbor<T,DESCRIPTOR::d> neighborIndicator(std::forward<decltype(indicator)>(indicator), _overlap);
56 communicator.requestOverlap(_overlap, neighborIndicator);
57 communicator.exchangeRequests();
58}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperLattice< T, DESCRIPTOR >::getCommunicator(), olb::SuperStructure< T, D >::getLoadBalancer(), and setLocalConvectionBoundary().

+ Here is the call graph for this function:

◆ setLocalConvectionBoundary() [5/6]

template<typename T , typename DESCRIPTOR >
void olb::setLocalConvectionBoundary ( SuperLattice< T, DESCRIPTOR > & sLattice,
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.

36{
37 setLocalConvectionBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material), uAv);
38}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setLocalConvectionBoundary().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setLocalConvectionBoundary() [6/6]

template<typename T , typename DESCRIPTOR >
void olb::setLocalConvectionBoundary ( SuperLattice< T, DESCRIPTOR > & sLattice,
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.

37{
38 setLocalConvectionBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material), uAv);
39}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setLocalConvectionBoundary().

+ Here is the call graph for this function:

◆ setLogScale()

void olb::setLogScale ( size_t dim)

◆ setOperatorForNormal() [1/2]

template<typename T , typename DESCRIPTOR , template< typename, typename, int... > typename OPERATOR>
void olb::setOperatorForNormal ( BlockLattice< T, DESCRIPTOR > & block,
BlockIndicatorF3D< T > & boundaryI,
BlockIndicatorF3D< T > & fluidI,
BlockIndicatorF3D< T > & outsideI )

Definition at line 705 of file setBoundary3D.h.

709{
710 OstreamManager clout(std::cout, "setOperatorForNormal");
711 auto& blockGeometryStructure = boundaryI.getBlockGeometry();
712 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
713 if ( blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= 1
714 && boundaryI(iX, iY, iZ)) {
715 auto [normalType, normal] = computeBoundaryTypeAndNormal(fluidI, outsideI, {iX,iY,iZ});
716 if (normal[0]!=0 || normal[1]!=0 || normal[2]!=0) {
717 block.addPostProcessor(
718 typeid(stage::PostCollide), {iX,iY,iZ},
719 boundaryhelper::promisePostProcessorForNormal<T,DESCRIPTOR,OPERATOR>(normal.data())
720 );
721 }
722 else {
723 clout << "Warning: Could not setOperatorForNormal("
724 << iX << ", " << iY << ", " << iZ
725 << "), discreteNormal=" << normal << "" << std::endl;
726 }
727 }
728 });
729}
std::pair< DiscreteNormalType, Vector< int, 2 > > computeBoundaryTypeAndNormal(BlockIndicatorF2D< T > &fluidI, BlockIndicatorF2D< T > &outsideI, Vector< int, 2 > latticeR)
Returns type (e.g. edge / corner) and discrete normal in 2D.

References computeBoundaryTypeAndNormal(), olb::BlockStructureD< D >::forSpatialLocations(), olb::BlockIndicatorF3D< T >::getBlockGeometry(), and olb::boundaryhelper::promisePostProcessorForNormal().

+ Here is the call graph for this function:

◆ setOperatorForNormal() [2/2]

template<typename T , typename DESCRIPTOR , template< typename, typename, int... > typename OPERATOR>
void olb::setOperatorForNormal ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF3D< T > > && boundaryI,
FunctorPtr< SuperIndicatorF3D< T > > && fluidI,
FunctorPtr< SuperIndicatorF3D< T > > && outsideI )

Definition at line 690 of file setBoundary3D.h.

694{
695 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
696 setOperatorForNormal<T,DESCRIPTOR,OPERATOR>(sLattice.getBlock(iCloc),
697 boundaryI->getBlockIndicatorF(iCloc),
698 fluidI->getBlockIndicatorF(iCloc),
699 outsideI->getBlockIndicatorF(iCloc));
700 }
701 addPoints2CommBC(sLattice, std::forward<decltype(boundaryI)>(boundaryI), 1);
702}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setOperatorForNormal().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setParameterFromXml()

template<typename T , typename DESCRIPTOR >
void olb::setParameterFromXml ( SuperLattice< T, DESCRIPTOR > & sLattice,
std::string xmlFileName )

Definition at line 216 of file availableDynamicList.h.

216 {
217 OstreamManager clout("ParameterFromXML");
218
219 DynamicsTupleParser<T, DESCRIPTOR> parser(xmlFileName);
220 std::map<std::string, float> parameters = parser.readParameterFromXML();
221
223 auto it = parameters.find(fields::name<decltype(field.get())>()); // Find the name in the map
224 if (it != parameters.end()) {
225 clout << "Name: " << fields::name<decltype(field.get())>() << ", Value: " << it->second << std::endl;
226 sLattice.template setParameter<decltype(field.get())>( it->second );
227 }
228 });
229 }
Plain wrapper for list of types.
Definition meta.h:276

References olb::meta::list< TYPES >::for_each(), olb::fields::name(), and olb::DynamicsTupleParser< T, DESCRIPTOR >::readParameterFromXML().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setSignedDistanceBoundary() [1/3]

template<typename T , typename DESCRIPTOR >
void olb::setSignedDistanceBoundary ( BlockLattice< T, DESCRIPTOR > & block,
BlockIndicatorF2D< T > & indicator )

Set signedDistanceBoundary for any indicated cells inside the block domain.

Set Signed Distance Function boundary for any indicated cells inside the block domain.

Definition at line 57 of file setSignedDistanceBoundary2D.hh.

58{
59 using namespace boundaryhelper;
60 auto& blockGeometryStructure = indicator.getBlockGeometry();
61 const int margin = 1;
62 std::vector<int> discreteNormal(3, 0);
63 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
64 if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
65 && indicator(iX, iY)) {
66 discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
67 T discreteNormalSum=0;
68 for (int iD=0; iD<DESCRIPTOR::d; iD++) {
69 discreteNormalSum += abs(discreteNormal[iD+1]);
70 }
71 if (discreteNormalSum == 0) {
72 block.addPostProcessor(typeid(stage::IterativePostProcess),{iX,iY},meta::id<normGradPsi>{});
73 } else {
74 block.addPostProcessor(typeid(stage::IterativePostProcess),{iX,iY},
75 promisePostProcessorForNormal<T,DESCRIPTOR,normGradPsiBoundary2D>(
76 Vector<int,2>(discreteNormal.data() + 1)));
77 }
78 }
79 });
80}

References abs(), olb::BlockIndicatorF2D< T >::getBlockGeometry(), and olb::BlockGeometry< T, D >::getStatistics().

+ Here is the call graph for this function:

◆ setSignedDistanceBoundary() [2/3]

template<typename T , typename DESCRIPTOR >
void olb::setSignedDistanceBoundary ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF2D< T > > && indicator )

Initialising the setSignedDistanceBoundary function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 40 of file setSignedDistanceBoundary2D.hh.

41{
42 int _overlap = 1;
43 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
44 setSignedDistanceBoundary<T,DESCRIPTOR>(sLattice.getBlock(iCloc),indicator->getBlockIndicatorF(iCloc));
45 }
47 auto& communicator = sLattice.getCommunicator(stage::IterativePostProcess());
48 communicator.template requestField<descriptors::PSI>();
49
50 SuperIndicatorBoundaryNeighbor<T,DESCRIPTOR::d> neighborIndicator(std::forward<decltype(indicator)>(indicator), _overlap);
51 communicator.requestOverlap(_overlap, neighborIndicator);
52 communicator.exchangeRequests();
53}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperLattice< T, DESCRIPTOR >::getCommunicator(), olb::SuperStructure< T, D >::getLoadBalancer(), and setSignedDistanceBoundary().

+ Here is the call graph for this function:

◆ setSignedDistanceBoundary() [3/3]

template<typename T , typename DESCRIPTOR >
void olb::setSignedDistanceBoundary ( SuperLattice< T, DESCRIPTOR > & sLattice,
SuperGeometry< T, 2 > & superGeometry,
int material )

Initialising the setSignedDistanceBoundary function on the superLattice domain.

Definition at line 33 of file setSignedDistanceBoundary2D.hh.

34{
35 setSignedDistanceBoundary<T,DESCRIPTOR>(sLattice, superGeometry.getMaterialIndicator(material));
36}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setSignedDistanceBoundary().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setSlipBoundaryWithDynamics() [1/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics >
void olb::setSlipBoundaryWithDynamics ( BlockLattice< T, DESCRIPTOR > & _block,
BlockIndicatorF3D< T > & indicator )

Definition at line 57 of file setSlipBoundaryWithDynamics3D.hh.

58{
59 using namespace boundaryhelper;
60 OstreamManager clout(std::cout, "setslipBoundaryWithDynamics");
61 auto& blockGeometryStructure = indicator.getBlockGeometry();
62 const int margin = 1;
63 std::vector<int> discreteNormal(4,0);
64 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
65 if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
66 && indicator(iX, iY, iZ)) {
67 Dynamics<T,DESCRIPTOR>* dynamics = nullptr;
68 discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY, iZ);
69 // Setting postProcessor as in setSlipBoundary3D
70 if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {//set postProcessors for indicated cells
71 bool _output = false;
72 if (_output) {
73 clout << "setSlipBoundary<" << discreteNormal[1] << ","<< discreteNormal[2] << ","<< discreteNormal[3] << ">(" << iX << ", "<< iX << ", " << iY << ", " << iY << ", " << iZ << ", " << iZ << " )" << std::endl;
74 }
75 PostProcessorGenerator3D<T, DESCRIPTOR>* postProcessor = new SlipBoundaryProcessorGenerator3D<T, DESCRIPTOR>(iX, iX, iY, iY, iZ, iZ, discreteNormal[1], discreteNormal[2], discreteNormal[3]);
76 if (postProcessor) {
77 block.addPostProcessor(*postProcessor);
78 }
79 }
80 else {//define dynamics for indicated cells
81 clout << "Warning: Could not setSlipBoundary (" << iX << ", " << iY << ", " << iZ << "), discreteNormal=(" << discreteNormal[0] <<","<< discreteNormal[1] <<","<< discreteNormal[2] <<","<< discreteNormal[3] <<"), set to bounceBack" << std::endl;
82 block.template defineDynamics<BounceBack>({iX, iY, iZ});
83 }
84 // Setting dynamics and momenta as in interpolatedVelocityBoundary3D
85 if (discreteNormal[0] == 0) {
86 if (discreteNormal[1] != 0 && discreteNormal[1] == -1) {//set momenta, dynamics and postProcessors on indicated velocityBoundaryCells
87 dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
88 momenta::BasicDirichletVelocityBoundaryTuple<0,-1>
89 >>();
90 }
91 else if (discreteNormal[1] != 0 && discreteNormal[1] == 1) {
92 dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
93 momenta::BasicDirichletVelocityBoundaryTuple<0,1>
94 >>();
95 }
96 else if (discreteNormal[2] != 0 && discreteNormal[2] == -1) {
97 dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
98 momenta::BasicDirichletVelocityBoundaryTuple<1,-1>
99 >>();
100 }
101 else if (discreteNormal[2] != 0 && discreteNormal[2] == 1) {
102 dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
103 momenta::BasicDirichletVelocityBoundaryTuple<1,1>
104 >>();
105 }
106 else if (discreteNormal[3] != 0 && discreteNormal[3] == -1) {
107 dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
108 momenta::BasicDirichletVelocityBoundaryTuple<2,-1>
109 >>();
110 }
111 else if (discreteNormal[3] != 0 && discreteNormal[3] == 1) {
112 dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
113 momenta::BasicDirichletVelocityBoundaryTuple<2,1>
114 >>();
115 }
116 }
117 else if (discreteNormal[0] == 1) {//set momenta,dynamics and postProcessors on indicated velocityBoundary External Corner cells
118 dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
119 momenta::FixedVelocityBoundaryTuple
120 >>();
121 }
122 else if (discreteNormal[0] == 2) {//Internalvelocitycorner
123 dynamics = block.getDynamics(PlainMixinDynamicsForNormalMomenta<T,DESCRIPTOR,
124 CombinedRLBdynamics,MixinDynamics,momenta::InnerCornerVelocityTuple3D
125 >::construct(Vector<int,3>(discreteNormal.data() + 1)));
126 }
127 //ExternalVelocityEdge
128 else if (discreteNormal[0] == 3) {//set momenta,dynamics and postProcessors on indicated velocityBoundary External Edge cells
129 dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
130 momenta::FixedVelocityBoundaryTuple
131 >>();
132 }
133 //InternalVelocityEdge
134 else if (discreteNormal[0] == 4) {//set momenta,dynamics and postProcessors on indicated velocityBoundary Inner Edge cells
135 dynamics = block.getDynamics(PlainMixinDynamicsForNormalSpecialMomenta<T,DESCRIPTOR,
136 CombinedRLBdynamics,MixinDynamics,momenta::InnerEdgeVelocityTuple3D
137 >::construct(Vector<int,3>(discreteNormal.data() + 1)));
138 }
139 setBoundary(block, iX,iY,iZ, dynamics);
140 }
141 });
142}
void setBoundary(BlockLattice< T, DESCRIPTOR > &block, int iX, int iY, Dynamics< T, DESCRIPTOR > *dynamics, PostProcessorGenerator2D< T, DESCRIPTOR > *postProcessor)
Interface for per-cell dynamics.
Definition interface.h:56

References olb::BlockIndicatorF3D< T >::getBlockGeometry(), olb::BlockGeometry< T, D >::getStatistics(), 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,
BlockIndicatorF2D< T > & indicator )

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 56 of file setSlipBoundaryWithDynamics2D.hh.

57{
58 using namespace boundaryhelper;
59 OstreamManager clout(std::cout, "setSlipBoundaryWithDynamics");
60 auto& blockGeometryStructure = indicator.getBlockGeometry();
61 const int margin = 1;
62 std::vector<int> discreteNormal(3, 0);
63 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY) {
64 if (blockGeometryStructure.getNeighborhoodRadius({iX, iY}) >= margin
65 && indicator(iX, iY)) {
66 Dynamics<T, DESCRIPTOR>* dynamics = nullptr;
67 PostProcessorGenerator2D<T, DESCRIPTOR>* postProcessor = nullptr;
68 discreteNormal = indicator.getBlockGeometry().getStatistics().getType(iX, iY);
69 if (discreteNormal[0] == 0) {
71 dynamics = block.getDynamics(MixinDynamicsExchangeDirectionOrientationMomenta<T,DESCRIPTOR,
73 >::construct(Vector<int,2>(discreteNormal.data()+1)));
74 postProcessor = new SlipBoundaryProcessorGenerator2D<T, DESCRIPTOR>(iX, iX, iY, iY, discreteNormal[1], discreteNormal[2]);
75 }
76 else if (discreteNormal[0] == 1) {
78 dynamics = block.template getDynamics<typename MixinDynamics::template exchange_momenta<
79 momenta::FixedVelocityBoundaryTuple
80 >>();
81 postProcessor = new SlipBoundaryProcessorGenerator2D<T, DESCRIPTOR>(iX, iX, iY, iY, discreteNormal[1], discreteNormal[2]);
82 }
83 else if (discreteNormal[0] == 2) {
85 dynamics = block.getDynamics(PlainMixinDynamicsForNormalMomenta<T,DESCRIPTOR,
86 CombinedRLBdynamics,MixinDynamics,momenta::InnerCornerVelocityTuple2D
87 >::construct(Vector<int,2>(discreteNormal.data()+1)));
88 postProcessor = nullptr;
89 }
90 setBoundary(block, iX,iY, dynamics, postProcessor);
91 }
92 });
93}
virtual Dynamics< T, DESCRIPTOR > * getDynamics(CellID iCell)=0
Return pointer to dynamics at iCell.

References olb::BlockIndicatorF2D< T >::getBlockGeometry(), olb::BlockGeometry< T, D >::getStatistics(), 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,
FunctorPtr< SuperIndicatorF2D< T > > && indicator )

Initialising the setSlipBoundaryWithDynamics function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 41 of file setSlipBoundaryWithDynamics2D.hh.

42{
43 int _overlap = indicator->getSuperGeometry().getOverlap();
44 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); ++iCloc) {
45 setSlipBoundaryWithDynamics<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc),
46 indicator->getBlockIndicatorF(iCloc));
47 }
49 //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary2D.h/hh
50 //TODO: Is communication really needed for this BC?
51 addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(indicator)>(indicator), _overlap);
52}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setSlipBoundaryWithDynamics().

+ 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,
FunctorPtr< SuperIndicatorF3D< T > > && indicator )

Initialising the setSlipBoundaryWithDynamics function on the superLattice domain.

Adds needed Cells to the Communicator _commBC in SuperLattice

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setSlipBoundaryWithDynamics3D.hh.

43{
44 int _overlap = 1;
45 for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
46 setSlipBoundaryWithDynamics<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iC), indicator->getBlockIndicatorF(iC));
47 }
49 //the addPoints2CommBC function is initialised inside setLocalVelocityBoundary3D.h/hh
50 //TODO: Is communication really needed for this BC?
51 addPoints2CommBC(sLattice,std::forward<decltype(indicator)>(indicator), _overlap);
52}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), and setSlipBoundaryWithDynamics().

+ 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,
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.

35{
36 setSlipBoundaryWithDynamics<T,DESCRIPTOR,MixinDynamics>(sLattice, superGeometry.getMaterialIndicator(material));
37}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setSlipBoundaryWithDynamics().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setSlipBoundaryWithDynamics() [6/6]

template<typename T , typename DESCRIPTOR , typename MixinDynamics = BGKdynamics<T,DESCRIPTOR>>
void olb::setSlipBoundaryWithDynamics ( SuperLattice< T, DESCRIPTOR > & sLattice,
SuperGeometry< T, 3 > & superGeometry,
int material )

Initialising the setSlipBoundaryWithDynamics function on the superLattice domain.

Definition at line 35 of file setSlipBoundaryWithDynamics3D.hh.

36{
37 setSlipBoundaryWithDynamics<T,DESCRIPTOR,MixinDynamics>(sLattice, superGeometry.getMaterialIndicator(material));
38}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setSlipBoundaryWithDynamics().

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

54{
55 FunctorPtr<SuperIndicatorF2D<T>>&& indicator = sGeometry.getMaterialIndicator(material);
56 const int overlap = indicator->getSuperGeometry().getOverlap();
57 for (int iC = 0; iC < sLattice.getLoadBalancer().size(); ++iC) {
58 int globIC = sLattice.getLoadBalancer().glob(iC);
59 BlockIndicatorF2D<T>& blockIndicator = indicator->getBlockIndicatorF(iC);
60 setBlockExternalPSMParticleField( sGeometry.getBlockGeometry(iC), velocity, size, epsilon,
61 sLattice.getBlock(iC), blockIndicator, globIC, overlap);
62 }
63}
Base block indicator functor (discrete)
Definition aliases.h:203
BlockGeometry< T, D > & getBlockGeometry(int locIC)
Read and write access to a single block geometry.

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:

◆ setTurbulentWallModel() [1/3]

template<typename T , typename DESCRIPTOR >
void olb::setTurbulentWallModel ( BlockLattice< T, DESCRIPTOR > & block,
BlockGeometry< T, DESCRIPTOR::d > & blockGeometry,
BlockIndicatorF< T, DESCRIPTOR::d > & boundaryIndicator,
BlockIndicatorF< T, DESCRIPTOR::d > & bulkIndicator,
WallModelParameters< T > & wallModelParameters,
IndicatorF< T, DESCRIPTOR::d > * indicatorAnalyticalBoundary = nullptr )

Set parameters of the turbulent wall model after Bouzidi bounce-back on indicated cells of block lattice.

Definition at line 392 of file setTurbulentWallModel.h.

398{
399 OstreamManager clout(std::cout, "TurbulentWallModelSetter");
400 clout.setMultiOutput(true);
401
402 // Defining boundary distance y1 and distance to exchange location y2 in wall normal direction for every boundary cell
403 const T deltaR = blockGeometry.getDeltaR();
404 // for each solid cell:
405 int kMax = 2;
406 if( wallModelParameters.fNeqMethod == 1 ) {
407 kMax = 3;
408 }
409 for(int k=1; k < kMax; k++){
410 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
411 // Check if cell is solid cell
412 if (boundaryIndicator(solidLatticeR)) {
413 for (int iPop=1; iPop < DESCRIPTOR::q; ++iPop) {
414 Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + k*descriptors::c<DESCRIPTOR>(iPop));
415 if (blockGeometry.getNeighborhoodRadius(boundaryLatticeR) >= 1) {
416 if (blockGeometry.isInside(boundaryLatticeR)) {
417 Vector<T,DESCRIPTOR::d> boundaryPhysR{ };
418 blockGeometry.getPhysR(boundaryPhysR,boundaryLatticeR);
419 // check if neighbor is fluid cell
420 if (bulkIndicator(boundaryLatticeR)) {
421 if (indicatorAnalyticalBoundary) {
422 // Calculate surface normal
423 Vector<T,DESCRIPTOR::d> normal = indicatorAnalyticalBoundary->surfaceNormal(boundaryPhysR, deltaR);
424 T y1 = 0.;
425 // Calculate boundary distance y1 in surface normal direction
426 indicatorAnalyticalBoundary->distance(y1, boundaryPhysR, normal, blockGeometry.getIcGlob());
427 if(y1 == T(0)) {
428 for ( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
429 normal[iD] *= T(-1);
430 }
431 indicatorAnalyticalBoundary->distance(y1, boundaryPhysR, normal, blockGeometry.getIcGlob());
432 }
433 y1 /= deltaR; // y1 in lattice units
434 if ( util::abs(y1) > T(k) ) {
435 y1 = util::sign(y1) * T(k);
436 }
437 block.get(boundaryLatticeR).template setField<descriptors::Y1>(-y1*normal);
438 } else {
439 Vector<T,DESCRIPTOR::d> normal;
440 for(int jPop = 0; jPop < DESCRIPTOR::q; jPop++){
441 Vector<T,DESCRIPTOR::d> boundaryLatticeR2(boundaryLatticeR + k*descriptors::c<DESCRIPTOR>(jPop));
442 if(boundaryIndicator(boundaryLatticeR2)){
443 for ( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
444 normal[iD] += k*descriptors::c<DESCRIPTOR>(jPop,iD);
445 }
446 }
447 }
448 T normalNorm = util::norm<DESCRIPTOR::d>(normal);
449 if(normalNorm != T(0)) {
450 for ( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
451 normal[iD] /= normalNorm;
452 }
453 }
454 for ( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
455 if(util::abs(normal[iD]) < T(0.4)) {
456 normal[iD] = T(0);
457 }
458 }
459 normalNorm = util::norm<DESCRIPTOR::d>(normal);
460 for ( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
461 normal[iD] /= normalNorm;
462 }
463 if(normal[0] != T(0) && normal[0] > T(0)) {
464 normal[0] /= normal[0];
465 }
466 else if(normal[0] != T(0) && normal[0] < T(0)) {
467 normal[0] /= normal[0];
468 normal[0] *= T(-1.);
469 }
470 if(normal[1] != T(0) && normal[1] > T(0)) {
471 normal[1] /= normal[1];
472 }
473 else if(normal[1] != T(0) && normal[1] < T(0)) {
474 normal[1] /= normal[1];
475 normal[1] *= T(-1.);
476 }
477 if ( DESCRIPTOR::d == 3) {
478 if(normal[2] != T(0) && normal[2] > T(0)) {
479 normal[2] /= normal[2];
480 }
481 else if(normal[2] != T(0) && normal[2] < T(0)) {
482 normal[2] /= normal[2];
483 normal[2] *= T(-1.);
484 }
485 }
486 if(normalNorm != T(0)) {
487 auto field = block.get(boundaryLatticeR).template getField<descriptors::Y1>();
488 if( util::norm<DESCRIPTOR::d>(field) == T(0)) {
489 T y1 = (k-1) + wallModelParameters.latticeWallDistance;
490 block.get(boundaryLatticeR).template setField<descriptors::Y1>(-y1*normal);
491 }
492 }
493 }
494 T pi[util::TensorVal<DESCRIPTOR>::n] {T(0)};
495 block.get(boundaryLatticeR).template setField<descriptors::TENSOR>(pi);
496 // Setting turbulent wall model post processor
497 if( wallModelParameters.movingWall) {
498 if( wallModelParameters.bodyForce ) {
499 if( wallModelParameters.interpolateSampleVelocity ) {
500 if( wallModelParameters.useVanDriest && k == 1 ) {
501 if( wallModelParameters.wallFunctionProfile == 0 ) {
502 block.addPostProcessor(typeid(stage::PostStream),
503 boundaryLatticeR,
504 meta::id<TurbulentWallModelPostProcessor<true,true,true,0,true>>{});
505 } else {
506 block.addPostProcessor(typeid(stage::PostStream),
507 boundaryLatticeR,
508 meta::id<TurbulentWallModelPostProcessor<true,true,true,1,true>>{});
509 }
510 } else {
511 if( wallModelParameters.wallFunctionProfile == 0 ) {
512 block.addPostProcessor(typeid(stage::PostStream),
513 boundaryLatticeR,
514 meta::id<TurbulentWallModelPostProcessor<true,true,false,0,true>>{});
515 } else {
516 block.addPostProcessor(typeid(stage::PostStream),
517 boundaryLatticeR,
518 meta::id<TurbulentWallModelPostProcessor<true,true,false,1,true>>{});
519 }
520 }
521 } else {
522 if( wallModelParameters.useVanDriest && k == 1 ) {
523 if( wallModelParameters.wallFunctionProfile == 0 ) {
524 block.addPostProcessor(typeid(stage::PostStream),
525 boundaryLatticeR,
526 meta::id<TurbulentWallModelPostProcessor<true,false,true,0,true>>{});
527 } else {
528 block.addPostProcessor(typeid(stage::PostStream),
529 boundaryLatticeR,
530 meta::id<TurbulentWallModelPostProcessor<true,false,true,1,true>>{});
531 }
532 } else {
533 if( wallModelParameters.wallFunctionProfile == 0 ) {
534 block.addPostProcessor(typeid(stage::PostStream),
535 boundaryLatticeR,
536 meta::id<TurbulentWallModelPostProcessor<true,false,false,0,true>>{});
537 } else {
538 block.addPostProcessor(typeid(stage::PostStream),
539 boundaryLatticeR,
540 meta::id<TurbulentWallModelPostProcessor<true,false,false,1,true>>{});
541 }
542 }
543 }
544 } else {
545 if( wallModelParameters.interpolateSampleVelocity ) {
546 if( wallModelParameters.useVanDriest && k == 1 ) {
547 if( wallModelParameters.wallFunctionProfile == 0 ) {
548 block.addPostProcessor(typeid(stage::PostStream),
549 boundaryLatticeR,
550 meta::id<TurbulentWallModelPostProcessor<false,true,true,0,true>>{});
551 } else {
552 block.addPostProcessor(typeid(stage::PostStream),
553 boundaryLatticeR,
554 meta::id<TurbulentWallModelPostProcessor<false,true,true,1,true>>{});
555 }
556 } else {
557 if( wallModelParameters.wallFunctionProfile == 0 ) {
558 block.addPostProcessor(typeid(stage::PostStream),
559 boundaryLatticeR,
560 meta::id<TurbulentWallModelPostProcessor<false,true,false,0,true>>{});
561 } else {
562 block.addPostProcessor(typeid(stage::PostStream),
563 boundaryLatticeR,
564 meta::id<TurbulentWallModelPostProcessor<false,true,false,1,true>>{});
565 }
566 }
567 } else {
568 if( wallModelParameters.useVanDriest && k == 1 ) {
569 if( wallModelParameters.wallFunctionProfile == 0 ) {
570 block.addPostProcessor(typeid(stage::PostStream),
571 boundaryLatticeR,
572 meta::id<TurbulentWallModelPostProcessor<false,false,true,0,true>>{});
573 } else {
574 block.addPostProcessor(typeid(stage::PostStream),
575 boundaryLatticeR,
576 meta::id<TurbulentWallModelPostProcessor<false,false,true,1,true>>{});
577 }
578 } else {
579 if( wallModelParameters.wallFunctionProfile == 0 ) {
580 block.addPostProcessor(typeid(stage::PostStream),
581 boundaryLatticeR,
582 meta::id<TurbulentWallModelPostProcessor<false,false,false,0,true>>{});
583 } else {
584 block.addPostProcessor(typeid(stage::PostStream),
585 boundaryLatticeR,
586 meta::id<TurbulentWallModelPostProcessor<false,false,false,1,true>>{});
587 }
588 }
589 }
590 }
591 } else {
592 if( wallModelParameters.bodyForce ) {
593 if( wallModelParameters.interpolateSampleVelocity ) {
594 if( wallModelParameters.useVanDriest && k == 1 ) {
595 if( wallModelParameters.wallFunctionProfile == 0 ) {
596 block.addPostProcessor(typeid(stage::PostStream),
597 boundaryLatticeR,
598 meta::id<TurbulentWallModelPostProcessor<true,true,true,0,false>>{});
599 } else {
600 block.addPostProcessor(typeid(stage::PostStream),
601 boundaryLatticeR,
602 meta::id<TurbulentWallModelPostProcessor<true,true,true,1,false>>{});
603 }
604 } else {
605 if( wallModelParameters.wallFunctionProfile == 0 ) {
606 block.addPostProcessor(typeid(stage::PostStream),
607 boundaryLatticeR,
608 meta::id<TurbulentWallModelPostProcessor<true,true,false,0,false>>{});
609 } else {
610 block.addPostProcessor(typeid(stage::PostStream),
611 boundaryLatticeR,
612 meta::id<TurbulentWallModelPostProcessor<true,true,false,1,false>>{});
613 }
614 }
615 } else {
616 if( wallModelParameters.useVanDriest && k == 1 ) {
617 if( wallModelParameters.wallFunctionProfile == 0 ) {
618 block.addPostProcessor(typeid(stage::PostStream),
619 boundaryLatticeR,
620 meta::id<TurbulentWallModelPostProcessor<true,false,true,0,false>>{});
621 } else {
622 block.addPostProcessor(typeid(stage::PostStream),
623 boundaryLatticeR,
624 meta::id<TurbulentWallModelPostProcessor<true,false,true,1,false>>{});
625 }
626 } else {
627 if( wallModelParameters.wallFunctionProfile == 0 ) {
628 block.addPostProcessor(typeid(stage::PostStream),
629 boundaryLatticeR,
630 meta::id<TurbulentWallModelPostProcessor<true,false,false,0,false>>{});
631 } else {
632 block.addPostProcessor(typeid(stage::PostStream),
633 boundaryLatticeR,
634 meta::id<TurbulentWallModelPostProcessor<true,false,false,1,false>>{});
635 }
636 }
637 }
638 } else {
639 if( wallModelParameters.interpolateSampleVelocity ) {
640 if( wallModelParameters.useVanDriest && k == 1 ) {
641 if( wallModelParameters.wallFunctionProfile == 0 ) {
642 block.addPostProcessor(typeid(stage::PostStream),
643 boundaryLatticeR,
644 meta::id<TurbulentWallModelPostProcessor<false,true,true,0,false>>{});
645 } else {
646 block.addPostProcessor(typeid(stage::PostStream),
647 boundaryLatticeR,
648 meta::id<TurbulentWallModelPostProcessor<false,true,true,1,false>>{});
649 }
650 } else {
651 if( wallModelParameters.wallFunctionProfile == 0 ) {
652 block.addPostProcessor(typeid(stage::PostStream),
653 boundaryLatticeR,
654 meta::id<TurbulentWallModelPostProcessor<false,true,false,0,false>>{});
655 } else {
656 block.addPostProcessor(typeid(stage::PostStream),
657 boundaryLatticeR,
658 meta::id<TurbulentWallModelPostProcessor<false,true,false,1,false>>{});
659 }
660 }
661 } else {
662 if( wallModelParameters.useVanDriest && k == 1 ) {
663 if( wallModelParameters.wallFunctionProfile == 0 ) {
664 block.addPostProcessor(typeid(stage::PostStream),
665 boundaryLatticeR,
666 meta::id<TurbulentWallModelPostProcessor<false,false,true,0,false>>{});
667 } else {
668 block.addPostProcessor(typeid(stage::PostStream),
669 boundaryLatticeR,
670 meta::id<TurbulentWallModelPostProcessor<false,false,true,1,false>>{});
671 }
672 } else {
673 if( wallModelParameters.wallFunctionProfile == 0 ) {
674 block.addPostProcessor(typeid(stage::PostStream),
675 boundaryLatticeR,
676 meta::id<TurbulentWallModelPostProcessor<false,false,false,0,false>>{});
677 } else {
678 block.addPostProcessor(typeid(stage::PostStream),
679 boundaryLatticeR,
680 meta::id<TurbulentWallModelPostProcessor<false,false,false,1,false>>{});
681 }
682 }
683 }
684 }
685 }
686 if( k == 1 ) {
687 if( wallModelParameters.fNeqMethod == 0 ) {
688 if( wallModelParameters.rhoMethod == 0 ) {
689 block.addPostProcessor(typeid(stage::PostStream),
690 boundaryLatticeR,
691 meta::id<TurbulentWallModelFneqGuoPostProcessor<0>>{});
692 }
693 else if( wallModelParameters.rhoMethod == 1 ) {
694 block.addPostProcessor(typeid(stage::PostStream),
695 boundaryLatticeR,
696 meta::id<TurbulentWallModelFneqGuoPostProcessor<1>>{});
697 }
698 else {
699 block.addPostProcessor(typeid(stage::PostStream),
700 boundaryLatticeR,
701 meta::id<TurbulentWallModelFneqGuoPostProcessor<2>>{});
702 }
703 }
704 else if( wallModelParameters.fNeqMethod == 1 ) {
705 if( wallModelParameters.rhoMethod == 0 ) {
706 block.addPostProcessor(typeid(stage::PostStream),
707 boundaryLatticeR,
708 meta::id<TurbulentWallModelFneqFDMPostProcessor<0>>{});
709 }
710 else if( wallModelParameters.rhoMethod == 1 ) {
711 block.addPostProcessor(typeid(stage::PostStream),
712 boundaryLatticeR,
713 meta::id<TurbulentWallModelFneqFDMPostProcessor<1>>{});
714 }
715 else {
716 block.addPostProcessor(typeid(stage::PostStream),
717 boundaryLatticeR,
718 meta::id<TurbulentWallModelFneqFDMPostProcessor<2>>{});
719 }
720 }
721 else {
722 if( wallModelParameters.rhoMethod == 0 ) {
723 block.addPostProcessor(typeid(stage::PostStream),
724 boundaryLatticeR,
725 meta::id<TurbulentWallModelFneqZeroPostProcessor<0>>{});
726 }
727 else if( wallModelParameters.rhoMethod == 1 ) {
728 block.addPostProcessor(typeid(stage::PostStream),
729 boundaryLatticeR,
730 meta::id<TurbulentWallModelFneqZeroPostProcessor<1>>{});
731 }
732 else {
733 block.addPostProcessor(typeid(stage::PostStream),
734 boundaryLatticeR,
735 meta::id<TurbulentWallModelFneqZeroPostProcessor<2>>{});
736 }
737 }
738 }
739 }
740 }
741 }
742 }
743 }
744 });
745 }
746}
std::enable_if_t< DESCRIPTOR::d==2, std::shared_ptr< SuperF2D< T > > > field(SuperLattice< T, DESCRIPTOR > &sLattice)
Returns external field functor.
bool useVanDriest
use van Driest damping function for turbulent viscosity in boundary cell
bool interpolateSampleVelocity
interpolate sampling velocity along given normal between lattice voxels
bool bodyForce
check if descriptor with body force is used
T latticeWallDistance
distance from cell to real wall in lattice units if no geometry indicator is given as input

References olb::util::abs(), olb::WallModelParameters< T >::bodyForce, olb::descriptors::c(), olb::WallModelParameters< T >::fNeqMethod, olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getIcGlob(), olb::BlockStructureD< D >::getNeighborhoodRadius(), olb::BlockGeometry< T, D >::getPhysR(), olb::WallModelParameters< T >::interpolateSampleVelocity, olb::BlockStructureD< D >::isInside(), olb::WallModelParameters< T >::latticeWallDistance, olb::WallModelParameters< T >::movingWall, olb::util::norm(), olb::WallModelParameters< T >::rhoMethod, olb::OstreamManager::setMultiOutput(), olb::util::sign(), olb::WallModelParameters< T >::useVanDriest, and olb::WallModelParameters< T >::wallFunctionProfile.

+ Here is the call graph for this function:

◆ setTurbulentWallModel() [2/3]

template<typename T , typename DESCRIPTOR >
void olb::setTurbulentWallModel ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && boundaryIndicator,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && bulkIndicator,
WallModelParameters< T > & wallModelParameters,
IndicatorF< T, DESCRIPTOR::d > * indicatorAnalyticalBoundary = nullptr )

Definition at line 330 of file setTurbulentWallModel.h.

335{
336 int _overlap = 3;
337 OstreamManager clout(std::cout, "TurbulentWallModelSetter");
338
341 AnalyticalConst<DESCRIPTOR::d, T, T> zeroVector(T(0.), T(0.));
342 sLattice.template defineField<descriptors::OMEGA>(std::move(boundaryIndicator), one);
343 sLattice.template defineField<descriptors::WMPOROSITY>(std::move(boundaryIndicator), zero);
344 sLattice.template defineField<descriptors::U_TAU>(std::move(boundaryIndicator), zero);
345 sLattice.template defineField<collision::HYBRID>(std::move(boundaryIndicator), one);
346 if( wallModelParameters.rhoMethod != 0) {
347 sLattice.template defineField<collision::HYBRID_RHO>(std::move(boundaryIndicator), one);
348 sLattice.template defineField<descriptors::DENSITY>(std::move(boundaryIndicator), one);
349 }
350 sLattice.template defineField<descriptors::Y1>(std::move(boundaryIndicator), zeroVector);
351 sLattice.template defineField<descriptors::WMVELOCITY>(std::move(boundaryIndicator), zeroVector);
352 if( wallModelParameters.useVanDriest ) {
353 sLattice.template defineField<descriptors::VISCOSITY>(std::move(bulkIndicator), zero);
354 }
355 if( wallModelParameters.movingWall ) {
356 sLattice.template defineField<descriptors::VELOCITY>(std::move(bulkIndicator), zeroVector);
357 }
358
359 auto& load = sLattice.getLoadBalancer();
360 for (int iC=0; iC < load.size(); ++iC) {
361 setTurbulentWallModel<T,DESCRIPTOR>(sLattice.getBlock(iC),
362 (bulkIndicator->getBlockIndicatorF(iC)).getBlockGeometry(),
363 boundaryIndicator->getBlockIndicatorF(iC),
364 bulkIndicator->getBlockIndicatorF(iC),
365 wallModelParameters,
366 indicatorAnalyticalBoundary);
367 }
368 addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator), _overlap);
369 clout.setMultiOutput(false);
370 sLattice.template setParameter<descriptors::SAMPLING_DISTANCE>( wallModelParameters.samplingCellDistance );
371}
AnalyticalConst: DD -> XD, where XD is defined by value.size()
T samplingCellDistance
distance from cell to velocity sampling point in lattice units

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), olb::WallModelParameters< T >::movingWall, olb::WallModelParameters< T >::rhoMethod, olb::WallModelParameters< T >::samplingCellDistance, olb::OstreamManager::setMultiOutput(), setTurbulentWallModel(), and olb::WallModelParameters< T >::useVanDriest.

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setTurbulentWallModel() [3/3]

template<typename T , typename DESCRIPTOR >
void olb::setTurbulentWallModel ( SuperLattice< T, DESCRIPTOR > & sLattice,
SuperGeometry< T, DESCRIPTOR::d > & superGeometry,
int materialOfSolidObstacle,
WallModelParameters< T > & wallModelParameters,
IndicatorF< T, DESCRIPTOR::d > * indicatorAnalyticalBoundary = nullptr,
std::vector< int > bulkMaterials = std::vector<int>(1,1) )

Set parameters of the turbulent wall model after Bouzidi bounce-back on material cells of sLattice.

Definition at line 375 of file setTurbulentWallModel.h.

381{
382 // Getting the indicators by material numbers and calling the superLattice method via the indicators:
383 setTurbulentWallModel<T,DESCRIPTOR>(sLattice,
384 FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(materialOfSolidObstacle)),
385 FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(std::move(bulkMaterials))),
386 wallModelParameters,
387 indicatorAnalyticalBoundary);
388}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setTurbulentWallModel().

+ Here is the call graph for this function:

◆ setTurbulentWallModelDynamics() [1/2]

template<typename T , typename DESCRIPTOR >
void olb::setTurbulentWallModelDynamics ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && bulkIndicator,
WallModelParameters< T > & wallModelParameters )

Definition at line 203 of file setTurbulentWallModel.h.

206{
207 if( wallModelParameters.averageVelocity ) {
208 if( wallModelParameters.bodyForce ) {
209 if( wallModelParameters.useVanDriest ) {
210 if( wallModelParameters.rhoMethod != 0 ) {
211 sLattice.template defineDynamics<typename ForcedVanDriestExternalRhoWMHRRdynamics<T,DESCRIPTOR>::template wrap_collision<collision::StoreAndTrackAverageVelocity>>(std::move(bulkIndicator));
212 } else {
213 sLattice.template defineDynamics<typename ForcedVanDriestWMHRRdynamics<T,DESCRIPTOR>::template wrap_collision<collision::StoreAndTrackAverageVelocity>>(std::move(bulkIndicator));
214 }
215 }
216 else {
217 if( wallModelParameters.rhoMethod != 0 ) {
218 sLattice.template defineDynamics<typename ForcedExternalRhoWMHRRdynamics<T,DESCRIPTOR>::template wrap_collision<collision::StoreAndTrackAverageVelocity>>(std::move(bulkIndicator));
219 } else {
220 sLattice.template defineDynamics<typename ForcedWMHRRdynamics<T,DESCRIPTOR>::template wrap_collision<collision::StoreAndTrackAverageVelocity>>(std::move(bulkIndicator));
221 }
222 }
223 }
224 else {
225 if( wallModelParameters.useVanDriest ) {
226 if( wallModelParameters.rhoMethod != 0 ) {
227 sLattice.template defineDynamics<typename VanDriestExternalRhoWMHRRdynamics<T,DESCRIPTOR>::template wrap_collision<collision::StoreAndTrackAverageVelocity>>(std::move(bulkIndicator));
228 } else {
229 sLattice.template defineDynamics<typename VanDriestWMHRRdynamics<T,DESCRIPTOR>::template wrap_collision<collision::StoreAndTrackAverageVelocity>>(std::move(bulkIndicator));
230 }
231 }
232 else {
233 if( wallModelParameters.rhoMethod != 0 ) {
234 sLattice.template defineDynamics<typename ExternalRhoWMHRRdynamics<T,DESCRIPTOR>::template wrap_collision<collision::StoreAndTrackAverageVelocity>>(std::move(bulkIndicator));
235 } else {
236 sLattice.template defineDynamics<typename WMHRRdynamics<T,DESCRIPTOR>::template wrap_collision<collision::StoreAndTrackAverageVelocity>>(std::move(bulkIndicator));
237 }
238 }
239 }
240 }
241 else {
242 if( wallModelParameters.bodyForce ) {
243 if( wallModelParameters.useVanDriest ) {
244 if( wallModelParameters.rhoMethod != 0 ) {
245 sLattice.template defineDynamics<ForcedVanDriestExternalRhoWMHRRdynamics>(std::move(bulkIndicator));
246 } else {
247 sLattice.template defineDynamics<ForcedVanDriestWMHRRdynamics>(std::move(bulkIndicator));
248 }
249 }
250 else {
251 if( wallModelParameters.rhoMethod != 0 ) {
252 sLattice.template defineDynamics<ForcedExternalRhoWMHRRdynamics>(std::move(bulkIndicator));
253 } else {
254 sLattice.template defineDynamics<ForcedWMHRRdynamics>(std::move(bulkIndicator));
255 }
256 }
257 }
258 else {
259 if( wallModelParameters.useVanDriest ) {
260 if( wallModelParameters.rhoMethod != 0 ) {
261 sLattice.template defineDynamics<VanDriestExternalRhoWMHRRdynamics>(std::move(bulkIndicator));
262 } else {
263 sLattice.template defineDynamics<VanDriestWMHRRdynamics>(std::move(bulkIndicator));
264 }
265 }
266 else {
267 if( wallModelParameters.rhoMethod != 0 ) {
268 sLattice.template defineDynamics<ExternalRhoWMHRRdynamics>(std::move(bulkIndicator));
269 } else {
270 sLattice.template defineDynamics<WMHRRdynamics>(std::move(bulkIndicator));
271 }
272 }
273 }
274 }
275
276 AnalyticalConst<DESCRIPTOR::d, T, T> one(T(1.));
277 AnalyticalConst<DESCRIPTOR::d, T, T> zero(T(0.));
278 AnalyticalConst<DESCRIPTOR::d, T, T> zeroVector(Vector<T,DESCRIPTOR::d>{});
279 std::vector<T> zeroStrainVec;
280 if(DESCRIPTOR::d == 2) {
281 zeroStrainVec = {T(0), T(0), T(0)};
282 } else {
283 zeroStrainVec = {T(0), T(0), T(0), T(0), T(0), T(0)};
284 }
285 AnalyticalConst<DESCRIPTOR::d, T, T> zeroStrain(zeroStrainVec);
286 sLattice.template defineField<descriptors::TENSOR>(std::move(bulkIndicator), zeroStrain);
287 sLattice.template defineField<descriptors::OMEGA>(std::move(bulkIndicator), one);
288 sLattice.template defineField<descriptors::WMPOROSITY>(std::move(bulkIndicator), one);
289 sLattice.template defineField<descriptors::U_TAU>(std::move(bulkIndicator), zero);
290 sLattice.template defineField<collision::HYBRID>(std::move(bulkIndicator), one);
291 if( wallModelParameters.rhoMethod != 0) {
292 sLattice.template defineField<collision::HYBRID_RHO>(std::move(bulkIndicator), one);
293 sLattice.template defineField<descriptors::DENSITY>(std::move(bulkIndicator), one);
294 }
295 sLattice.template defineField<descriptors::Y1>(std::move(bulkIndicator), zeroVector);
296 sLattice.template defineField<descriptors::WMVELOCITY>(std::move(bulkIndicator), zeroVector);
297 if( wallModelParameters.useVanDriest ) {
298 sLattice.template defineField<descriptors::VISCOSITY>(std::move(bulkIndicator), zero);
299 }
300 if( wallModelParameters.movingWall ) {
301 sLattice.template defineField<descriptors::VELOCITY>(std::move(bulkIndicator), zeroVector);
302 }
303 {
304 auto& communicator = sLattice.getCommunicator(stage::PostStream());
305 communicator.template requestField<descriptors::WMVELOCITY>();
306 communicator.template requestField<descriptors::POPULATION>();
307 communicator.requestOverlap(sLattice.getOverlap());
308 communicator.exchangeRequests();
309 }
310}
int getOverlap()
Read and write access to the overlap.

References olb::WallModelParameters< T >::averageVelocity, olb::WallModelParameters< T >::bodyForce, olb::SuperLattice< T, DESCRIPTOR >::getCommunicator(), olb::SuperStructure< T, D >::getOverlap(), olb::WallModelParameters< T >::movingWall, olb::WallModelParameters< T >::rhoMethod, and olb::WallModelParameters< T >::useVanDriest.

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setTurbulentWallModelDynamics() [2/2]

template<typename T , typename DESCRIPTOR >
void olb::setTurbulentWallModelDynamics ( SuperLattice< T, DESCRIPTOR > & sLattice,
SuperGeometry< T, DESCRIPTOR::d > & superGeometry,
int materialOfBulk,
WallModelParameters< T > & wallModelParameters )

Definition at line 313 of file setTurbulentWallModel.h.

317{
318 // Getting the indicators by material numbers and calling the superLattice method via the indicators:
319 setTurbulentWallModelDynamics<T,DESCRIPTOR>(sLattice,
321 wallModelParameters);
322}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setTurbulentWallModelDynamics().

+ Here is the call graph for this function:

◆ setWallDistance() [1/3]

template<typename T , typename DESCRIPTOR >
void olb::setWallDistance ( BlockLattice< T, DESCRIPTOR > & block,
BlockGeometry< T, DESCRIPTOR::d > & blockGeometry,
BlockIndicatorF< T, DESCRIPTOR::d > & boundaryIndicator,
BlockIndicatorF< T, DESCRIPTOR::d > & bulkIndicator,
IndicatorF< T, DESCRIPTOR::d > * indicatorAnalyticalBoundary )

Set parameters of the turbulent wall model after Bouzidi bounce-back on indicated cells of block lattice.

Definition at line 788 of file setTurbulentWallModel.h.

793{
794 OstreamManager clout(std::cout, "WallDistanceSetter");
795 clout.setMultiOutput(true);
796
797 // Defining boundary distance y1 and distance to exchange location y2 in wall normal direction for every boundary cell
798 const T deltaR = blockGeometry.getDeltaR();
799 // for each solid cell:
800 block.forSpatialLocations([&](LatticeR<DESCRIPTOR::d> solidLatticeR) {
801 // Check if cell is solid cell
802 if (boundaryIndicator(solidLatticeR)) {
803 for (int iPop=1; iPop < DESCRIPTOR::q; ++iPop) {
804 Vector<T,DESCRIPTOR::d> boundaryLatticeR(solidLatticeR + descriptors::c<DESCRIPTOR>(iPop));
805 if (blockGeometry.getNeighborhoodRadius(boundaryLatticeR) >= 1) {
806 if (blockGeometry.isInside(boundaryLatticeR)) {
807 Vector<T,DESCRIPTOR::d> boundaryPhysR{ };
808 blockGeometry.getPhysR(boundaryPhysR,boundaryLatticeR);
809 // check if neighbor is fluid cell
810 if (bulkIndicator(boundaryLatticeR)) {
811 if (indicatorAnalyticalBoundary) {
812 // Calculate surface normal
813 Vector<T,DESCRIPTOR::d> normal = indicatorAnalyticalBoundary->surfaceNormal(boundaryPhysR, deltaR);
814 T y1 = 0.;
815 // Calculate boundary distance y1 in surface normal direction
816 indicatorAnalyticalBoundary->distance(y1, boundaryPhysR, normal, blockGeometry.getIcGlob());
817 if(y1 == T(0)) {
818 for ( int iD = 0; iD < DESCRIPTOR::d; iD++ ) {
819 normal[iD] *= T(-1);
820 }
821 indicatorAnalyticalBoundary->distance(y1, boundaryPhysR, normal, blockGeometry.getIcGlob());
822 }
823 y1 /= deltaR; // y1 in lattice units
824 if(y1 > T(1)) {
825 y1 = T(1);
826 }
827 block.get(boundaryLatticeR).template setField<descriptors::Y1>(-y1*normal);
828 }
829 }
830 }
831 }
832 }
833 }
834 });
835}

References olb::descriptors::c(), olb::BlockGeometry< T, D >::getDeltaR(), olb::BlockGeometry< T, D >::getIcGlob(), olb::BlockStructureD< D >::getNeighborhoodRadius(), olb::BlockGeometry< T, D >::getPhysR(), olb::BlockStructureD< D >::isInside(), and olb::OstreamManager::setMultiOutput().

+ Here is the call graph for this function:

◆ setWallDistance() [2/3]

template<typename T , typename DESCRIPTOR >
void olb::setWallDistance ( SuperLattice< T, DESCRIPTOR > & sLattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && boundaryIndicator,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && bulkIndicator,
IndicatorF< T, DESCRIPTOR::d > * indicatorAnalyticalBoundary )

Definition at line 751 of file setTurbulentWallModel.h.

755{
756 int _overlap = 3;
757 OstreamManager clout(std::cout, "WallDistanceSetter");
758
759 auto& load = sLattice.getLoadBalancer();
760 for (int iC=0; iC < load.size(); ++iC) {
761 setWallDistance<T,DESCRIPTOR>(sLattice.getBlock(iC),
762 (bulkIndicator->getBlockIndicatorF(iC)).getBlockGeometry(),
763 boundaryIndicator->getBlockIndicatorF(iC),
764 bulkIndicator->getBlockIndicatorF(iC),
765 indicatorAnalyticalBoundary);
766 }
767 addPoints2CommBC<T,DESCRIPTOR>(sLattice, std::forward<decltype(boundaryIndicator)>(boundaryIndicator), _overlap);
768 clout.setMultiOutput(false);
769}

References addPoints2CommBC(), olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperStructure< T, D >::getLoadBalancer(), olb::OstreamManager::setMultiOutput(), and setWallDistance().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ setWallDistance() [3/3]

template<typename T , typename DESCRIPTOR >
void olb::setWallDistance ( 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 parameters of the turbulent wall model after Bouzidi bounce-back on material cells of sLattice.

Definition at line 773 of file setTurbulentWallModel.h.

778{
779 // Getting the indicators by material numbers and calling the superLattice method via the indicators:
780 setWallDistance<T,DESCRIPTOR>(sLattice,
781 FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(materialOfSolidObstacle)),
782 FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>(superGeometry.getMaterialIndicator(std::move(bulkMaterials))),
783 indicatorAnalyticalBoundary);
784}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setWallDistance().

+ 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 62 of file setZeroGradientBoundary3D.hh.

63{
64 using namespace boundaryhelper;
65 const auto& blockGeometryStructure = indicator.getBlockGeometry();
66 const int margin = 2;
67 std::vector<int> discreteNormal(4,0);
68 blockGeometryStructure.forSpatialLocations([&](auto iX, auto iY, auto iZ) {
69 if (blockGeometryStructure.getNeighborhoodRadius({iX, iY, iZ}) >= margin
70 && indicator(iX, iY, iZ)) {
71 discreteNormal = blockGeometryStructure.getStatistics().getType(iX, iY, iZ);
72 if (discreteNormal[1]!=0 || discreteNormal[2]!=0 || discreteNormal[3]!=0) {
73 for(int iPop = 0; iPop < DESCRIPTOR::q; iPop++){
74 auto c = descriptors::c<DESCRIPTOR>(iPop);
75 T k = c[0]*(-discreteNormal[1]) + c[1]*(-discreteNormal[2]) + c[2]*(-discreteNormal[3]);
76 if(k > T{0.} && blockGeometryStructure.getMaterial(iX+c[0], iY+c[1], iZ+c[2]) == 1 ){
77 _block.get(iX+c[0], iY+c[1], iZ+c[2]).template getFieldPointer<descriptors::NEIGHBOR>()[0] = T{1.};
78 }
79 if(k > T{0.} && blockGeometryStructure.getMaterial(iX+2*c[0], iY+2*c[1], iZ+2*c[2]) == 1 ){
80 _block.get(iX+2*c[0], iY+2*c[1], iZ+2*c[2]).template getFieldPointer<descriptors::NEIGHBOR>()[0] = T{1.};
81 }
82 }
83 _block.addPostProcessor(
84 typeid(stage::PostCollide), {iX,iY,iZ},
85 meta::id<ZeroGradientLatticePostProcessor3D<T,DESCRIPTOR>>{}
86 );
87 _block.template defineDynamics<NoCollideDynamics>({iX, iY, iZ});
88 } else {
89 _block.template defineDynamics<BounceBack>({iX, iY, iZ});
90 }
91 }
92 });
93}

References olb::descriptors::c(), 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

Adds needed Cells to the Communicator _commBC in SuperLattice

Definition at line 42 of file setZeroGradientBoundary3D.hh.

43{
44 OstreamManager clout(std::cout, "setZeroGradientBoundary");
45
46 for (int iCloc = 0; iCloc < sLattice.getLoadBalancer().size(); iCloc++) {
47 setZeroGradientBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice.getBlock(iCloc), indicator->getBlockIndicatorF(iCloc));
48 }
50 int _overlap = 2;
51 auto& communicator = sLattice.getCommunicator(stage::PostStream());
52 communicator.template requestField<descriptors::POPULATION>();
53
54 SuperIndicatorBoundaryNeighbor<T,DESCRIPTOR::d> neighborIndicator(std::forward<decltype(indicator)>(indicator), _overlap);
55 communicator.requestOverlap(_overlap, neighborIndicator);
56 communicator.exchangeRequests();
57}

References olb::SuperLattice< T, DESCRIPTOR >::getBlock(), olb::SuperLattice< T, DESCRIPTOR >::getCommunicator(), olb::SuperStructure< T, D >::getLoadBalancer(), and setZeroGradientBoundary().

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

36{
37 setZeroGradientBoundary<T,DESCRIPTOR,MixinDynamics>(sLattice, superGeometry.getMaterialIndicator(material));
38}

References olb::SuperGeometry< T, D >::getMaterialIndicator(), and setZeroGradientBoundary().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ spaldingDerivative()

template<typename V , typename Par_d >
V olb::spaldingDerivative ( Par_d & param)

Definition at line 110 of file turbulentWallModelPostProcessor.h.

110 {
111 V derivative = 0.;
112 V k = 0.4;
113 V b = 5.5;
114 if(int (param[4]) == 2){
115 derivative = (-param[1]*(util::pow(param[0],-2.))) + util::exp(-k*b)*( (util::exp(k*param[1]/param[0]))*(-k*param[1]*(util::pow(param[0],-2.))) + k*param[1]/(util::pow(param[0],2.)) + (util::pow(k*param[1]/param[0],2.))/param[0] + 0.5*(util::pow(k*param[1]/param[0],3.))/param[0] ) - (param[2]/param[3]);
116 }
117 if(int (param[4]) == 1){
118 derivative = 1. + util::exp(-k*b)*(util::exp(k*param[0])*k - k - k*k*param[0] - 0.5*k*util::pow(k*param[0],2));
119 }
120 return derivative;
121 };

References olb::util::exp(), and olb::util::pow().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ spaldingWallFunction()

template<typename V , typename Par_f >
V olb::spaldingWallFunction ( Par_f & params)

Definition at line 96 of file turbulentWallModelPostProcessor.h.

96 {
97 if(int (params[6]) == 2){
98 params[4] = params[1]/params[0];
99 params[5] = params[2]/params[3]*params[0];
100 }
101 V k = 0.4;
102 V b = 5.5;
103 V function = params[4] + util::exp(-k*b)*(util::exp(k*params[4]) - 1. - k*params[4] - 0.5*util::pow(k*params[4],2.) - 1./6.*util::pow(k*params[4],3.)) - params[5];
104 return function;
105 };

References olb::util::exp(), and olb::util::pow().

+ Here is the call graph for this function:
+ Here is the caller graph for this function:

◆ strainRateTensorFDM2D()

template<typename CELL , typename V = typename CELL::value_t>
Vector< V, 6 > olb::strainRateTensorFDM2D ( CELL & cell)

Definition at line 30 of file strainRateTensorFDM2D.h.

31{
32 using namespace olb::util::tensorIndices2D;
33 V inv2dx = 1./(2.);
34 V u_pXp[2], u_pXm[2], u_pYp[2], u_pYm[2];
35
36 cell.neighbor({1,0}).computeU(u_pXp);
37 cell.neighbor({-1,0}).computeU(u_pXm);
38 cell.neighbor({0,1}).computeU(u_pYp);
39 cell.neighbor({0,-1}).computeU(u_pYm);
40
41 Vector<V,6> strainRate;
42 strainRate[xx] = (u_pXp[0] - u_pXm[0])*inv2dx;
43 strainRate[xy] = 0.5*( (u_pYp[0] - u_pYm[0])*inv2dx + (u_pXp[1] - u_pXm[1])*inv2dx );
44 strainRate[yy] = (u_pYp[1] - u_pYm[1])*inv2dx;
45 return strainRate;
46};
+ Here is the caller graph for this function:

◆ strainRateTensorFDM3D()

template<typename CELL , typename V = typename CELL::value_t>
Vector< V, 6 > olb::strainRateTensorFDM3D ( CELL & cell)

Definition at line 30 of file strainRateTensorFDM3D.h.

31{
32 using namespace olb::util::tensorIndices3D;
33 V inv2dx = 1./(2.);
34 V u_pXp[3], u_pXm[3], u_pYp[3], u_pYm[3], u_pZp[3], u_pZm[3] {0.};
35
36 cell.neighbor({1,0,0}).computeU(u_pXp);
37 cell.neighbor({-1,0,0}).computeU(u_pXm);
38 cell.neighbor({0,1,0}).computeU(u_pYp);
39 cell.neighbor({0,-1,0}).computeU(u_pYm);
40 cell.neighbor({0,0,1}).computeU(u_pZp);
41 cell.neighbor({0,0,-1}).computeU(u_pZm);
42
43 Vector<V,6> strainRate;
44 strainRate[xx] = (u_pXp[0] - u_pXm[0])*inv2dx;
45 strainRate[xy] = 0.5*( (u_pYp[0] - u_pYm[0])*inv2dx + (u_pXp[1] - u_pXm[1])*inv2dx );
46 strainRate[xz] = 0.5*( (u_pZp[0] - u_pZm[0])*inv2dx + (u_pXp[2] - u_pXm[2])*inv2dx );
47 strainRate[yy] = (u_pYp[1] - u_pYm[1])*inv2dx;
48 strainRate[yz] = 0.5*( (u_pZp[1] - u_pZm[1])*inv2dx + (u_pYp[2] - u_pYm[2])*inv2dx );
49 strainRate[zz] = (u_pZp[2] - u_pZm[2])*inv2dx;
50 return strainRate;
51};
+ Here is the caller graph for this function:

◆ SuperCommunicator()

template<typename SUPER >
olb::SuperCommunicator ( SUPER & ) -> SuperCommunicator< typename SUPER::value_t, SUPER >

◆ SuperImmersedBoundaryCoupling3D()

template<int WIDTH, typename... MAP>
olb::SuperImmersedBoundaryCoupling3D ( std::integral_constant< int, WIDTH > ,
MAP && ... ) -> SuperImmersedBoundaryCoupling3D< WIDTH, typename meta::map< MAP... >::template map_values< descriptors::extract_valued_descriptor_t > >

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

◆ SuperLatticePhysIncPressure2D()

template<typename T , typename DESCRIPTOR >
olb::SuperLatticePhysIncPressure2D ( SuperLattice< T, DESCRIPTOR > & ,
const UnitConverter< T, DESCRIPTOR > &  ) -> SuperLatticePhysIncPressure2D< 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 >

◆ SuperLatticePointCoupling()

template<typename COUPLER , typename... MAP>
olb::SuperLatticePointCoupling ( COUPLER ,
MAP && ... ) -> SuperLatticePointCoupling< COUPLER, typename meta::map< MAP... >::template map_values< descriptors::extract_valued_descriptor_t > >

SuperPointLatticeCoupling.

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

92{
93 std::array<double,q> discIntegral;
94 for ( int iVec = 0; iVec < q; iVec++ ) {
95 discIntegral[iVec] = 0;
96 for ( int iSum = 0; iSum < q; iSum++ ) {
97 discIntegral[iVec] += weights[iSum] * cosTheta[iVec][iSum]* phi[iVec][iSum];
98 }
99 }
100 return discIntegral;
101}

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

63{
64 std::array<double,q> discIntegral;
65 for ( int iVec = 0; iVec < q; iVec++ ) {
66 discIntegral[iVec] = 0;
67 for ( int iSum = 0; iSum < q; iSum++ ) {
68 discIntegral[iVec] += descriptors::t<double,DESCRIPTOR>(iSum) * phi[iSum][iVec];
69 }
70 }
71 return discIntegral;
72}

References olb::descriptors::t().

+ Here is the call graph for this function:

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

77{
78 std::array<double,q> discIntegral;
79 for ( int iVec = 0; iVec < q; iVec++ ) {
80 discIntegral[iVec] = 0;
81 for ( int iSum = 0; iSum < q; iSum++ ) {
82 discIntegral[iVec] += descriptors::t<double,DESCRIPTOR>(iSum) * phi[iVec][iSum];
83 }
84 }
85 return discIntegral;
86}

References olb::descriptors::t().

+ Here is the call graph for this function:

◆ toStdVector()

template<typename T , unsigned D, typename IMPL >
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.

89{
90 std::vector<T> v(D);
91 for (unsigned iDim=0; iDim < D; ++iDim) {
92 v[iDim] = a[iDim];
93 }
94 return v;
95}

◆ Vector()

template<typename T , typename... Ts>
olb::Vector ( T && t,
Ts &&... ts ) -> Vector< std::remove_cvref_t< T >, 1+sizeof...(Ts)>
+ Here is the caller graph for this function:

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

124{
125#ifdef PARALLEL_MODE_MPI
126 if (singleton::mpi().isMainProcessor()){
127#endif
128 //Instantiate data writer
129 std::ofstream dataWriter;
130 dataWriter.open( fullFileName );
131 //Write scalar data for each array entry
132 for (unsigned int i=0; i<dataVector.size(); ++i){
133 writeScalarData( dataWriter, fullFileName, headLine, dataVector[i], i );
134 }
135 //Close File
136 dataWriter.close();
137#ifdef PARALLEL_MODE_MPI
138 }
139#endif
140}
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.

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.

100{
101#ifdef PARALLEL_MODE_MPI
102 if (singleton::mpi().isMainProcessor()){
103#endif
104 //Instantiate data writer
105 std::ofstream dataWriter;
106 dataWriter.open( fullFileName );
107 //Write headline
108 dataWriter << headLine << std::endl;
109 //Write Data
110 for (unsigned int i=0; i<dataVector.size(); ++i){
111 dataWriter << dataVector[i] << std::endl;
112 }
113 //Close File
114 dataWriter.close();
115#ifdef PARALLEL_MODE_MPI
116 }
117#endif
118}

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.

146{
147 //Perform sanity check
148#ifdef PARALLEL_MODE_MPI
149 if (singleton::mpi().isMainProcessor()){
150#endif
151 if (dataVector.size()==0){
152 std::cerr << "WARNING: DataVector is empty!" << std::endl;
153 } else {
154 if (headLineVector.size()!=dataVector[0].size()){
155 std::cerr << "WARNING (" << fullFileName << "): DataVector does not match provided headline!" << std::endl;
156 }
157 }
158#ifdef PARALLEL_MODE_MPI
159 }
160#endif
161 //Set up headLine string
162 std::string headLineStringArray;
163 for ( unsigned int iQ=0; iQ<headLineVector.size(); ++iQ ){
164 if (iQ>0){ headLineStringArray+=" "; };
165 headLineStringArray += headLineVector[iQ];
166 }
167 //Call write array data
168 writeArrayData( fullFileName, headLineStringArray, dataVector);
169}
void writeArrayData(std::string fullFileName, std::string headLine, std::vector< std::string > &dataVector)
Write array data.

References olb::singleton::mpi(), and writeArrayData().

+ Here is the call graph for this function:

◆ writeFunctorTo() [1/2]

template<typename FUNCTOR , typename TO , typename T , typename DESCRIPTOR >
void olb::writeFunctorTo ( SuperLattice< T, DESCRIPTOR > & lattice)

Definition at line 62 of file writeFunctorO.h.

62 {
63 auto superLatticeO = makeSuperLatticeO<operators::WriteFunctorO<FUNCTOR,TO>>(lattice);
64 superLatticeO->execute();
65}

References makeSuperLatticeO().

+ Here is the call graph for this function:

◆ writeFunctorTo() [2/2]

template<typename FUNCTOR , typename TO , typename T , typename DESCRIPTOR >
void olb::writeFunctorTo ( SuperLattice< T, DESCRIPTOR > & lattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && indicator )

Definition at line 68 of file writeFunctorO.h.

69 {
70 auto superLatticeO = makeSuperLatticeO<operators::WriteFunctorO<FUNCTOR,TO>>(lattice);
71 superLatticeO->restrictTo(std::forward<FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>>(indicator));
72 superLatticeO->execute();
73}

References makeSuperLatticeO().

+ Here is the call graph for this function:

◆ writePhysFunctorTo()

template<typename FUNCTOR , typename TO , typename T , typename DESCRIPTOR >
void olb::writePhysFunctorTo ( SuperLattice< T, DESCRIPTOR > & lattice,
FunctorPtr< SuperIndicatorF< T, DESCRIPTOR::d > > && indicator,
T conversionFactor = 1.0 )

Definition at line 76 of file writeFunctorO.h.

78 {
79 auto superLatticeO = makeSuperLatticeO<operators::WriteFunctorO<FUNCTOR,TO>>(lattice);
80 superLatticeO->template setParameter<descriptors::CONVERSION>(conversionFactor);
81 superLatticeO->restrictTo(std::forward<FunctorPtr<SuperIndicatorF<T,DESCRIPTOR::d>>>(indicator));
82 superLatticeO->execute();
83}

References makeSuperLatticeO().

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

35{
36 //Write headline if first element
37 if (iE == iEinit){
38 dataWriterOpened << headLine << std::endl;
39 }
40 //Write Data
41 dataWriterOpened << dataVector[0];
42 for (unsigned int i=1; i<dataVector.size(); ++i){
43 dataWriterOpened << " " << dataVector[i];
44 }
45 dataWriterOpened << std::endl;
46}
+ 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.

52{
53#ifdef PARALLEL_MODE_MPI
54 if (singleton::mpi().isMainProcessor()){
55#endif
56 //Instantiate data writer
57 std::ofstream dataWriter;
58 dataWriter.open( fullFileName, std::ofstream::app );
59 //Write scalar data
60 writeScalarData( dataWriter, fullFileName, headLine,
61 dataVector, iE, iEinit );
62 //Close File
63 dataWriter.close();
64#ifdef PARALLEL_MODE_MPI
65 }
66#endif
67}

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.

73{
74 //Perform sanity check
75#ifdef PARALLEL_MODE_MPI
76 if (singleton::mpi().isMainProcessor()){
77#endif
78 if (headLineVector.size()!=dataVector.size()){
79 std::cerr << "WARNING (" << fullFileName << "): DataVector does not match provided headline!" << std::endl;
80 }
81#ifdef PARALLEL_MODE_MPI
82 }
83#endif
84 //Set up headLine string
85 std::string headLineStringScalar;
86 for ( unsigned int iQ=0; iQ<headLineVector.size(); ++iQ ){
87 if (iQ>0){ headLineStringScalar+=" "; };
88 headLineStringScalar += headLineVector[iQ];
89 }
90 //Call write scalar data
91 writeScalarData( fullFileName, headLineStringScalar, dataVector, iT, iTinit );
92}

References olb::singleton::mpi(), and writeScalarData().

+ Here is the call graph for this function:

◆ writeVTK() [1/2]

template<typename T , typename W >
void olb::writeVTK ( SuperF2D< T, W > & f,
int iT = 0 )

Write out functor F to VTK file (helper)

Definition at line 122 of file superVtmWriter2D.h.

122 {
123 SuperVTMwriter2D<T> writer("");
124 writer.write(f, iT);
125}
SuperVTMwriter2D writes any SuperF2D to vtk-based output files.
Definition aliases.h:74
+ Here is the caller graph for this function:

◆ writeVTK() [2/2]

template<typename T , typename W >
void olb::writeVTK ( SuperF3D< T, W > & f,
int iT = 0 )

Write out functor F to VTK file (helper)

Definition at line 136 of file superVtmWriter3D.h.

136 {
137 SuperVTMwriter3D<T> writer("");
138 writer.write(f, iT);
139}
SuperVTMwriter3D writes any SuperF3D to vtk-based output files.
Definition aliases.h:75

◆ 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 395 of file xmlReader.h.

396{
397 std::stringstream valueStr(_text);
398 std::size_t tmp = std::size_t();
399 if (!(valueStr >> tmp)) {
400 std::stringstream ss;
401 ss << value;
402 _output.printWarning(_name, "std::size_t", ss.str(), verboseOn, exitIfMissing);
403 return false;
404 }
405 value = tmp;
406 return true;
407}

◆ XMLreader::read< std::string >()

template<>
bool olb::XMLreader::read< std::string > ( std::string & entry,
bool verboseOn,
bool exitIfMissing ) const

Definition at line 453 of file xmlReader.h.

454{
455 if (_name == "XML node not found") {
456 return false;
457 }
458 std::stringstream valueStr(_text);
459 std::string tmp = std::string();
460 if (!(valueStr >> tmp)) {
461 std::stringstream ss;
462 ss << entry;
463 _output.printWarning(_name, "string", ss.str(), verboseOn, exitIfMissing);
464 return false;
465 }
466
467 entry = _text;
468 return true;
469}