Palabos  Version 1.1
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
plb::A_dividedBy_alpha_functional2D< T >
plb::A_dividedBy_alpha_functional3D< T >
plb::A_dividedBy_alpha_inplace_functional2D< T >
plb::A_dividedBy_alpha_inplace_functional3D< T >
plb::A_dividedBy_B_functional2D< T >
plb::A_dividedBy_B_functional3D< T >
plb::A_dividedBy_B_inplace_functional2D< T >
plb::A_dividedBy_B_inplace_functional3D< T >
plb::A_gt_alpha_functional2D< T >
plb::A_gt_alpha_functional3D< T >
plb::A_gt_B_functional2D< T >
plb::A_gt_B_functional3D< T >
plb::A_lt_alpha_functional2D< T >
plb::A_lt_alpha_functional3D< T >
plb::A_lt_B_functional2D< T >
plb::A_lt_B_functional3D< T >
plb::A_minus_alpha_functional2D< T >
plb::A_minus_alpha_functional3D< T >
plb::A_minus_alpha_inplace_functional2D< T >
plb::A_minus_alpha_inplace_functional3D< T >
plb::A_minus_B_functional2D< T >
plb::A_minus_B_functional3D< T >
plb::A_minus_B_inplace_functional2D< T >
plb::A_minus_B_inplace_functional3D< T >
plb::A_plus_alpha_functional2D< T >
plb::A_plus_alpha_functional3D< T >
plb::A_plus_alpha_inplace_functional2D< T >
plb::A_plus_alpha_inplace_functional3D< T >
plb::A_plus_B_functional2D< T >
plb::A_plus_B_functional3D< T >
plb::A_plus_B_inplace_functional2D< T >
plb::A_plus_B_inplace_functional3D< T >
plb::A_times_alpha_functional2D< T >
plb::A_times_alpha_functional3D< T >
plb::A_times_alpha_inplace_functional2D< T >
plb::A_times_alpha_inplace_functional3D< T >
plb::A_times_B_functional2D< T >
plb::A_times_B_functional3D< T >
plb::A_times_B_inplace_functional2D< T >
plb::A_times_B_inplace_functional3D< T >
plb::AD_SmagoOperations< T, Descriptor >
plb::AddLayerFunctional3D< T >
plb::AddToExternalScalarFunctional2D< T, Descriptor >
plb::AddToExternalScalarFunctional3D< T, Descriptor >
plb::AdvectionDiffusionBGKdynamics< T, Descriptor >BGK Advection-Diffusion dynamics
plb::AdvectionDiffusionBoundaryConditionInstantiator2D< T, Descriptor, BoundaryManager >
plb::AdvectionDiffusionBoundaryConditionInstantiator3D< T, Descriptor, BoundaryManager >
plb::AdvectionDiffusionBoundaryDynamics< T, Descriptor, direction, orientation >Advection-diffusion dynamics on flat boundaries
plb::AdvectionDiffusionBoundaryManager2D< T, Descriptor >
plb::AdvectionDiffusionBoundaryManager3D< T, Descriptor >
plb::AdvectionDiffusionCornerDynamics2D< T, Descriptor, xNormal, yNormal >Advection-diffusion dynamics on 2D corners
plb::AdvectionDiffusionCornerDynamics3D< T, Descriptor, xNormal, yNormal, zNormal >Advection-diffusion dynamics on 3D corners
plb::descriptors::AdvectionDiffusionD2Q5Descriptor< T >AD D2Q5 lattice
plb::descriptors::AdvectionDiffusionD3Q7Descriptor< T >
plb::AdvectionDiffusionDynamics< T, Descriptor >Common base iso-thermal (or athermal) bulk dynamics
plb::advectionDiffusionDynamicsTemplates< T, Descriptor >This structure forwards the calls to the appropriate helper class
plb::advectionDiffusionDynamicsTemplatesImpl< T, Descriptor >All helper functions are inside this structure
plb::advectionDiffusionDynamicsTemplatesImpl< T, descriptors::D2Q5DescriptorBase< T > >All helper functions are inside this structure
plb::advectionDiffusionDynamicsTemplatesImpl< T, descriptors::D3Q7DescriptorBase< T > >All helper functions are inside this structure
plb::AdvectionDiffusionEdgeDynamics3D< T, Descriptor, plane, normal1, normal2 >Advection-diffusion dynamics on 3D edges
plb::advectionDiffusionMomentTemplates< T, Descriptor >
plb::advectionDiffusionMomentTemplatesImpl< T, Descriptor >
plb::advectionDiffusionMomentTemplatesImpl< T, descriptors::D2Q5DescriptorBase< T > >
plb::advectionDiffusionMomentTemplatesImpl< T, descriptors::D3Q7DescriptorBase< T > >
plb::AdvectionDiffusionRLBdynamics< T, Descriptor >Regularized Advection-Diffusion dynamics
plb::AdvectionDiffusionWithSourceBGKdynamics< T, Descriptor >BGK Advection-Diffusion dynamics
plb::descriptors::AdvectionDiffusionWithSourceD3Q7Descriptor< T >
plb::AdvectionDiffusionWithSourceRLBdynamics< T, Descriptor >
plb::AllFlagsTrueFunctional2D
plb::AllFlagsTrueFunctional3D
plb::Alpha_dividedBy_A_functional2D< T >
plb::Alpha_dividedBy_A_functional3D< T >
plb::Alpha_minus_A_functional2D< T >
plb::Alpha_minus_A_functional3D< T >
plb::AnalyticalIniVolumeFraction3D< T, InsideFunction >
plb::ApplyScalarFunctional2D< T, Function >
plb::ApplyScalarFunctional3D< T, Function >
plb::Array< T, size >
plb::Array< T, 2 >
plb::Array< T, 3 >
plb::Array< T, 4 >
plb::AsciiReader< T >
plb::AsciiWriter< T >
plb::AsinariDynamics< T, Descriptor >First part of collision in Asinari's LW-ACM model
plb::AsinariPostCollide2D< T, Descriptor >Second part of collision in Asinari's LW-ACM model, for 2D
plb::AsinariPostCollide3D< T, Descriptor >Second part of collision in Asinari's LW-ACM model, for 3D
plb::asinariTemplates< T, Descriptor >This structure forwards the calls to the appropriate helper class
plb::asinariTemplatesImpl< T, Descriptor >All helper functions are inside this structure
plb::asinariTemplatesImpl< T, descriptors::D2Q9DescriptorBase< T > >
plb::asinariTemplatesImpl< T, descriptors::D3Q15DescriptorBase< T > >
plb::asinariTemplatesImpl< T, descriptors::D3Q19DescriptorBase< T > >
plb::asinariTemplatesImpl< T, descriptors::D3Q27DescriptorBase< T > >
plb::AssignEntireCellFunctional2D< T, Descriptor >
plb::AssignEntireCellFunctional3D< T, Descriptor >
plb::AssignOmegaFunctional2D< T, Descriptor >
plb::AssignOmegaFunctional3D< T, Descriptor >
plb::AssignScalarFieldOmegaFunctional3D< T, Descriptor >
plb::AtomicBlock2D
plb::AtomicBlock3D
plb::AtomicBlockSerializer2D
plb::AtomicBlockSerializer3D
plb::AtomicBlockUnSerializer2D
plb::AtomicBlockUnSerializer3D
plb::AtomicContainerBlock2D
plb::AtomicContainerBlock3D
plb::AtomicContainerDataTransfer2D
plb::AtomicContainerDataTransfer3D
plb::Base64Decoder< T >
plb::Base64Encoder< T >
plb::Base64Reader
plb::Base64Writer
plb::BasicBulkDynamics< T, Descriptor >Common base for bulk dynamics
plb::BGKCarreauDynamics< T, Descriptor, N >Implementation of O(Ma^2) BGK dynamics with constant average density
plb::BGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics
plb::util::BisectStepper< T >Propose successive test values of a scalar (e.g. Re) to check stability of a system
plb::Block2D
plb::Block3D
plb::BlockCommunicator2D
plb::BlockCommunicator3D
plb::BlockDataTransfer2D
plb::BlockDataTransfer3D
plb::BlockLattice2D< T, Descriptor >
plb::BlockLattice3D< T, Descriptor >A regular lattice for highly efficient 3D LB dynamics
plb::BlockLatticeBase2D< T, Descriptor >An interface to all the variants of (more or less) regular lattices
plb::BlockLatticeBase3D< T, Descriptor >
plb::BlockLatticeDataTransfer2D< T, Descriptor >
plb::BlockLatticeDataTransfer3D< T, Descriptor >
plb::BlockStatisticsStore instances of observables, and compute their statistics
plb::BlockSurface2DFragmentation of the surface of a block into bulk, edges, and corners
plb::BlockSurface3DFragmentation of the surface of a block into bulk, surfaces, edges, and corners
plb::BounceBack< T, Descriptor >Implementation of "full-way bounce-back" dynamics
plb::BoundaryCompositeDynamics< T, Descriptor >Computation of the macroscopic variables is obtained after invoking completion scheme
plb::BoundaryConditionInstantiator2D< T, Descriptor, BoundaryManager >
plb::BoundaryConditionInstantiator3D< T, Descriptor, BoundaryManager >
plb::BoundaryProfile3D< T, SurfaceData >
plb::BoundaryProfiles3D< T, SurfaceData >
plb::BoundaryShape3D< T, SurfaceData >Description of a shape as the boundary of a given volume
plb::BoundaryShapeIntersection3D< T, SurfaceData >
plb::BoundaryShapeIsoSurface3D< T, SurfaceData >
plb::boundaryTemplates< T, Descriptor, direction, orientation >
plb::BoundedBoxProcessingFunctional2DEasy instantiation of boxed data processor special boundary treatment (general case)
plb::BoundedBoxProcessingFunctional2D_L< T, Descriptor >Easy instantiation of bounded boxed data processor for a single lattice
plb::BoundedBoxProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of bounded boxed data processor for lattice-lattice coupling
plb::BoundedBoxProcessingFunctional2D_LN< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-NTensorField coupling
plb::BoundedBoxProcessingFunctional2D_LS< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-ScalarField coupling
plb::BoundedBoxProcessingFunctional2D_LT< T1, Descriptor, T2, nDim >Easy instantiation of bounded boxed data processor for Lattice-TensorField coupling
plb::BoundedBoxProcessingFunctional2D_N< T >Easy instantiation of bounded boxed data processor for a single n-tensor field
plb::BoundedBoxProcessingFunctional2D_NN< T1, T2 >
plb::BoundedBoxProcessingFunctional2D_S< T >Easy instantiation of bounded boxed data processor for a single scalar field
plb::BoundedBoxProcessingFunctional2D_SN< T1, T2 >
plb::BoundedBoxProcessingFunctional2D_SS< T1, T2 >
plb::BoundedBoxProcessingFunctional2D_ST< T1, T2, nDim >
plb::BoundedBoxProcessingFunctional2D_T< T, nDim >Easy instantiation of bounded boxed data processor for a single tensor field
plb::BoundedBoxProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 >
plb::BoundedBoxProcessingFunctional3DEasy instantiation of boxed data processor special boundary treatment (general case)
plb::BoundedBoxProcessingFunctional3D_L< T, Descriptor >Easy instantiation of bounded boxed data processor for a single lattice
plb::BoundedBoxProcessingFunctional3D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of bounded boxed data processor for lattice-lattice coupling
plb::BoundedBoxProcessingFunctional3D_LN< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-NTensorField coupling
plb::BoundedBoxProcessingFunctional3D_LS< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-ScalarField coupling
plb::BoundedBoxProcessingFunctional3D_LT< T1, Descriptor, T2, nDim >Easy instantiation of bounded boxed data processor for Lattice-TensorField coupling
plb::BoundedBoxProcessingFunctional3D_N< T >Easy instantiation of bounded boxed data processor for a single n-tensor field
plb::BoundedBoxProcessingFunctional3D_NN< T1, T2 >Easy instantiation of bounded boxed data processor for NTensorField-NTensorField coupling
plb::BoundedBoxProcessingFunctional3D_S< T >Easy instantiation of bounded boxed data processor for a single scalar field
plb::BoundedBoxProcessingFunctional3D_SN< T1, T2 >Easy instantiation of bounded boxed data processor for ScalarField-NTensorField coupling
plb::BoundedBoxProcessingFunctional3D_SS< T1, T2 >Easy instantiation of bounded boxed data processor for ScalarField-ScalarField coupling
plb::BoundedBoxProcessingFunctional3D_ST< T1, T2, nDim >Easy instantiation of bounded boxed data processor for ScalarField-TensorField coupling
plb::BoundedBoxProcessingFunctional3D_T< T, nDim >Easy instantiation of bounded boxed data processor for a single tensor field
plb::BoundedBoxProcessingFunctional3D_TT< T1, nDim1, T2, nDim2 >Easy instantiation of bounded boxed data processor for TensorField-TensorField coupling
plb::BoundedBoxScalarSumFunctional2D< T >
plb::BoundedBoxScalarSumFunctional3D< T >
plb::BoundedLatticeBoxProcessingFunctional2D< T, Descriptor >Easy instantiation of bounded boxed data processor for multiple lattices
plb::BoundedLatticeBoxProcessingFunctional3D< T, Descriptor >Easy instantiation of bounded boxed data processor for multiple lattices
plb::BoundedMaskedBoxProcessingFunctional2D_LN< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-NTensorField coupling
plb::BoundedMaskedBoxProcessingFunctional2D_N< T >Easy instantiation of bounded boxed data processor for a single n-tensor field with bool mask
plb::BoundedMaskedBoxProcessingFunctional2D_NN< T1, T2 >
plb::BoundedMaskedBoxProcessingFunctional3D_LN< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-NTensorField coupling
plb::BoundedMaskedBoxProcessingFunctional3D_N< T >Easy instantiation of bounded boxed data processor for a single n-tensor field with bool mask
plb::BoundedMaskedBoxProcessingFunctional3D_NN< T1, T2 >Easy instantiation of bounded boxed data processor for NTensorField-NTensorField coupling with bool mask
plb::BoundedMaskedReductiveBoxProcessingFunctional2D_LN< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-NTensorField coupling
plb::BoundedMaskedReductiveBoxProcessingFunctional2D_N< T >Easy instantiation of bounded boxed data processor for a single n-tensor field
plb::BoundedMaskedReductiveBoxProcessingFunctional2D_NN< T1, T2 >
plb::BoundedMaskedReductiveBoxProcessingFunctional3D_LN< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-NTensorField coupling
plb::BoundedMaskedReductiveBoxProcessingFunctional3D_N< T >Easy instantiation of bounded boxed data processor for a single n-tensor field with bool mask
plb::BoundedMaskedReductiveBoxProcessingFunctional3D_NN< T1, T2 >Easy instantiation of bounded boxed data processor for NTensorField-NTensorField coupling
plb::BoundedNTensorFieldBoxProcessingFunctional2D< T >Easy instantiation of bounded boxed data processor for multiple n-tensor fields
plb::BoundedNTensorFieldBoxProcessingFunctional3D< T >Easy instantiation of bounded boxed data processor for multiple n-tensor fields
plb::BoundedReductiveBoxProcessingFunctional2DEasy instantiation of boxed reductive data processor special boundary treatment (general case)
plb::BoundedReductiveBoxProcessingFunctional2D_L< T, Descriptor >Easy instantiation of bounded boxed data processor for a single lattice
plb::BoundedReductiveBoxProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of bounded boxed data processor for lattice-lattice coupling
plb::BoundedReductiveBoxProcessingFunctional2D_LN< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-NTensorField coupling
plb::BoundedReductiveBoxProcessingFunctional2D_LS< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-ScalarField coupling
plb::BoundedReductiveBoxProcessingFunctional2D_LT< T1, Descriptor, T2, nDim >Easy instantiation of bounded boxed data processor for Lattice-TensorField coupling
plb::BoundedReductiveBoxProcessingFunctional2D_N< T >Easy instantiation of bounded boxed data processor for a single n-tensor field
plb::BoundedReductiveBoxProcessingFunctional2D_NN< T1, T2 >
plb::BoundedReductiveBoxProcessingFunctional2D_S< T >Easy instantiation of bounded boxed data processor for a single scalar field
plb::BoundedReductiveBoxProcessingFunctional2D_SN< T1, T2 >
plb::BoundedReductiveBoxProcessingFunctional2D_SS< T1, T2 >
plb::BoundedReductiveBoxProcessingFunctional2D_ST< T1, T2, nDim >
plb::BoundedReductiveBoxProcessingFunctional2D_T< T, nDim >Easy instantiation of bounded boxed data processor for a single tensor field
plb::BoundedReductiveBoxProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 >
plb::BoundedReductiveBoxProcessingFunctional3DEasy instantiation of boxed data processor special boundary treatment (general case)
plb::BoundedReductiveBoxProcessingFunctional3D_L< T, Descriptor >Easy instantiation of bounded boxed data processor for a single lattice
plb::BoundedReductiveBoxProcessingFunctional3D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of bounded boxed data processor for lattice-lattice coupling
plb::BoundedReductiveBoxProcessingFunctional3D_LN< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-NTensorField coupling
plb::BoundedReductiveBoxProcessingFunctional3D_LS< T1, Descriptor, T2 >Easy instantiation of bounded boxed data processor for Lattice-ScalarField coupling
plb::BoundedReductiveBoxProcessingFunctional3D_LT< T1, Descriptor, T2, nDim >Easy instantiation of bounded boxed data processor for Lattice-TensorField coupling
plb::BoundedReductiveBoxProcessingFunctional3D_N< T >Easy instantiation of bounded boxed data processor for a single n-tensor field
plb::BoundedReductiveBoxProcessingFunctional3D_NN< T1, T2 >Easy instantiation of bounded boxed data processor for NTensorField-NTensorField coupling
plb::BoundedReductiveBoxProcessingFunctional3D_S< T >Easy instantiation of bounded boxed data processor for a single scalar field
plb::BoundedReductiveBoxProcessingFunctional3D_SN< T1, T2 >Easy instantiation of bounded boxed data processor for ScalarField-NTensorField coupling
plb::BoundedReductiveBoxProcessingFunctional3D_SS< T1, T2 >Easy instantiation of bounded boxed data processor for ScalarField-ScalarField coupling
plb::BoundedReductiveBoxProcessingFunctional3D_ST< T1, T2, nDim >Easy instantiation of bounded boxed data processor for ScalarField-TensorField coupling
plb::BoundedReductiveBoxProcessingFunctional3D_T< T, nDim >Easy instantiation of bounded boxed data processor for a single tensor field
plb::BoundedReductiveBoxProcessingFunctional3D_TT< T1, nDim1, T2, nDim2 >Easy instantiation of bounded boxed data processor for TensorField-TensorField coupling
plb::BoundedReductiveLatticeBoxProcessingFunctional2D< T, Descriptor >Easy instantiation of bounded boxed data processor for multiple lattices
plb::BoundedReductiveLatticeBoxProcessingFunctional3D< T, Descriptor >Easy instantiation of bounded boxed data processor for multiple lattices
plb::BoundedReductiveNTensorFieldBoxProcessingFunctional2D< T >Easy instantiation of bounded boxed data processor for multiple n-tensor fields
plb::BoundedReductiveNTensorFieldBoxProcessingFunctional3D< T >Easy instantiation of bounded boxed data processor for multiple n-tensor fields
plb::BoundedReductiveScalarFieldBoxProcessingFunctional2D< T >Easy instantiation of bounded boxed data processor for multiple scalar fields
plb::BoundedReductiveScalarFieldBoxProcessingFunctional3D< T >Easy instantiation of bounded boxed data processor for multiple scalar fields
plb::BoundedReductiveTensorFieldBoxProcessingFunctional2D< T, nDim >Easy instantiation of bounded boxed data processor for multiple tensor fields
plb::BoundedReductiveTensorFieldBoxProcessingFunctional3D< T, nDim >Easy instantiation of bounded boxed data processor for multiple tensor fields
plb::BoundedScalarFieldBoxProcessingFunctional2D< T >Easy instantiation of bounded boxed data processor for multiple scalar fields
plb::BoundedScalarFieldBoxProcessingFunctional3D< T >Easy instantiation of bounded boxed data processor for multiple scalar fields
plb::BoundedTensorFieldBoxProcessingFunctional2D< T, nDim >Easy instantiation of bounded boxed data processor for multiple tensor fields
plb::BoundedTensorFieldBoxProcessingFunctional3D< T, nDim >Easy instantiation of bounded boxed data processor for multiple tensor fields
plb::BoussinesqThermalProcessor2D< T, FluidDescriptor, TemperatureDescriptor >
plb::BoussinesqThermalProcessor3D< T, FluidDescriptor, TemperatureDescriptor >
plb::Box2DCoordinates of a 2D Box
plb::Box3DCoordinates of a 3D Box
plb::BoxAllEquilibriumFunctional3D< T, Descriptor >
plb::BoxAllPopulationsFunctional2D< T, Descriptor >
plb::BoxAllPopulationsFunctional3D< T, Descriptor >
plb::BoxAllPopulationsToLatticeFunctional2D< T, Descriptor >
plb::BoxAllPopulationsToLatticeFunctional3D< T, Descriptor >
plb::BoxBulkDivergenceFunctional3D< T, nDim >
plb::BoxBulkGradientFunctional3D< T >
plb::BoxBulkStrainRateFunctional2D< T, nDim >
plb::BoxBulkStrainRateFunctional3D< T, nDim >
plb::BoxBulkVorticityFunctional2D< T, nDim >
plb::BoxBulkVorticityFunctional3D< T, nDim >
plb::BoxDensityFunctional2D< T, Descriptor >
plb::BoxDensityFunctional3D< T, Descriptor >
plb::BoxedDataProcessorGenerator2D
plb::BoxedDataProcessorGenerator3D
plb::BoxedReductiveDataProcessorGenerator2D
plb::BoxedReductiveDataProcessorGenerator3D
plb::BoxEquilibriumFunctional2D< T, Descriptor >
plb::BoxEquilibriumFunctional3D< T, Descriptor >
plb::BoxExternalForceFunctional2D< T, Descriptor >
plb::BoxExternalForceFunctional3D< T, Descriptor >
plb::BoxExternalScalarFunctional3D< T, Descriptor >
plb::BoxGradientFunctional3D< T >
plb::BoxGradientNormFunctional2D< T >
plb::BoxGradientNormFunctional3D< T >
plb::BoxKinematicViscosityFunctional3D< T, Descriptor >
plb::BoxKineticEnergyFunctional2D< T, Descriptor >
plb::BoxKineticEnergyFunctional3D< T, Descriptor >
plb::BoxOmegaFunctional2D< T, Descriptor >
plb::BoxOmegaFunctional3D< T, Descriptor >
plb::BoxPeriodicGradientFunctional3D< T >
plb::BoxPeriodicGradientNormFunctional3D< T >
plb::BoxPeriodicPoissonIteration3D< T >
plb::BoxPiNeqFunctional2D< T, Descriptor >
plb::BoxPiNeqFunctional3D< T, Descriptor >
plb::BoxPoissonIteration2D< T >
plb::BoxPoissonIteration3D< T >
plb::BoxPoissonResidueFunctional2D< T >
plb::BoxPoissonResidueFunctional3D< T >
plb::BoxPopulationFunctional2D< T, Descriptor >
plb::BoxPopulationFunctional3D< T, Descriptor >
plb::BoxProcessingFunctional2DEasy instantiation of boxed data processor (general case)
plb::BoxProcessingFunctional2D_L< T, Descriptor >Easy instantiation of boxed data processor for a single lattice
plb::BoxProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of boxed data processor for lattice-lattice coupling
plb::BoxProcessingFunctional2D_LN< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-NTensorField coupling
plb::BoxProcessingFunctional2D_LS< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-ScalarField coupling
plb::BoxProcessingFunctional2D_LT< T1, Descriptor, T2, nDim >Easy instantiation of boxed data processor for Lattice-TensorField coupling
plb::BoxProcessingFunctional2D_N< T >Easy instantiation of boxed data processor for a single n-tensor field
plb::BoxProcessingFunctional2D_NN< T1, T2 >Easy instantiation of boxed data processor for NTensorField-NTensorField coupling
plb::BoxProcessingFunctional2D_S< T >Easy instantiation of boxed data processor for a single scalar field
plb::BoxProcessingFunctional2D_SN< T1, T2 >Easy instantiation of boxed data processor for ScalarField-NTensorField coupling
plb::BoxProcessingFunctional2D_SS< T1, T2 >Easy instantiation of boxed data processor for ScalarField-ScalarField coupling
plb::BoxProcessingFunctional2D_ST< T1, T2, nDim >Easy instantiation of boxed data processor for ScalarField-TensorField coupling
plb::BoxProcessingFunctional2D_T< T, nDim >Easy instantiation of boxed data processor for a single tensor field
plb::BoxProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 >Easy instantiation of boxed data processor for TensorField-TensorField coupling
plb::BoxProcessingFunctional3DEasy instantiation of boxed data processor (general case)
plb::BoxProcessingFunctional3D_L< T, Descriptor >Easy instantiation of boxed data processor for a single lattice
plb::BoxProcessingFunctional3D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of boxed data processor for lattice-lattice coupling
plb::BoxProcessingFunctional3D_LN< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-NTensorField coupling
plb::BoxProcessingFunctional3D_LS< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-ScalarField coupling
plb::BoxProcessingFunctional3D_LT< T1, Descriptor, T2, nDim >Easy instantiation of boxed data processor for Lattice-TensorField coupling
plb::BoxProcessingFunctional3D_N< T >Easy instantiation of boxed data processor for a single n-tensor field
plb::BoxProcessingFunctional3D_NN< T1, T2 >Easy instantiation of boxed data processor for NTensorField-NTensorField coupling
plb::BoxProcessingFunctional3D_S< T >Easy instantiation of boxed data processor for a single scalar field
plb::BoxProcessingFunctional3D_SN< T1, T2 >Easy instantiation of boxed data processor for ScalarField-NTensorField coupling
plb::BoxProcessingFunctional3D_SS< T1, T2 >Easy instantiation of boxed data processor for ScalarField-ScalarField coupling
plb::BoxProcessingFunctional3D_ST< T1, T2, nDim >Easy instantiation of boxed data processor for ScalarField-TensorField coupling
plb::BoxProcessingFunctional3D_T< T, nDim >Easy instantiation of boxed data processor for a single tensor field
plb::BoxProcessingFunctional3D_TT< T1, nDim1, T2, nDim2 >Easy instantiation of boxed data processor for TensorField-TensorField coupling
plb::BoxProcessor2DA Boxed data processor, automatically generated from a BoxProcessingFunctional2D
plb::BoxProcessor3DA Boxed data processor, automatically generated from a BoxProcessingFunctional3D
plb::BoxProcessorGenerator2DAn automatically created generator for the BoxProcessor2D
plb::BoxProcessorGenerator3DAn automatically created generator for the BoxProcessor3D
plb::BoxQcriterionFunctional3D< T >
plb::BoxRhoBarFunctional2D< T, Descriptor >
plb::BoxRhoBarFunctional3D< T, Descriptor >
plb::BoxRhoBarJfunctional2D< T, Descriptor >
plb::BoxRhoBarJfunctional3D< T, Descriptor >
plb::BoxScalarMaxFunctional2D< T >
plb::BoxScalarMaxFunctional3D< T >
plb::BoxScalarMinFunctional2D< T >
plb::BoxScalarMinFunctional3D< T >
plb::BoxScalarSumFunctional2D< T >
plb::BoxScalarSumFunctional3D< T >
plb::BoxShearStressFunctional2D< T, Descriptor >
plb::BoxShearStressFunctional3D< T, Descriptor >
plb::BoxSoundSpeedFunctional2D< T, Descriptor >
plb::BoxStrainRateFromStressFunctional2D< T, Descriptor >
plb::BoxStrainRateFromStressFunctional3D< T, Descriptor >
plb::BoxStrainRateFunctional2D< T, nDim >
plb::BoxStrainRateFunctional3D< T, nDim >
plb::BoxSumEnergyFunctional2D< T, Descriptor >
plb::BoxSumEnergyFunctional3D< T, Descriptor >
plb::BoxSumRhoBarFunctional2D< T, Descriptor >
plb::BoxSumRhoBarFunctional3D< T, Descriptor >
plb::BoxSumVelocityTemperatureFunctional2D< T, FluidDescriptor, TemperatureDescriptor >
plb::BoxSumVelocityTemperatureFunctional3D< T, FluidDescriptor, TemperatureDescriptor >
plb::BoxTemperatureFunctional2D< T, Descriptor >
plb::BoxTemperatureFunctional3D< T, Descriptor >
plb::BoxVelocityComponentFunctional2D< T, Descriptor >
plb::BoxVelocityComponentFunctional3D< T, Descriptor >
plb::BoxVelocityFunctional2D< T, Descriptor >
plb::BoxVelocityFunctional3D< T, Descriptor >
plb::BoxVelocityNormFunctional2D< T, Descriptor >
plb::BoxVelocityNormFunctional3D< T, Descriptor >
plb::BoxVorticityFunctional2D< T, nDim >
plb::BoxVorticityFunctional3D< T, nDim >
plb::BoxXderivativeFunctional2D< T >
plb::BoxXderivativeFunctional3D< T >
plb::BoxXperiodicDerivativeFunctional3D< T >
plb::BoxYderivativeFunctional2D< T >
plb::BoxYderivativeFunctional3D< T >
plb::BoxYperiodicDerivativeFunctional3D< T >
plb::BoxZderivativeFunctional3D< T >
plb::BoxZperiodicDerivativeFunctional3D< T >
plb::BruteReAssignTriangleHash< T >
plb::util::Buffer< T >A simple class for handling buffer memory
plb::BulkCompositeDynamics< T, Descriptor >Computation of the macroscopic variables is forwarded to basic dynamics
plb::BoundedReductiveBoxProcessingFunctional3D::BulkWrapperFunctional
plb::BoundedBoxProcessingFunctional3D::BulkWrapperFunctional
plb::BoundedBoxProcessingFunctional2D::BulkWrapperFunctional
plb::BoundedReductiveBoxProcessingFunctional2D::BulkWrapperFunctional
plb::CachePolicy2D
plb::CachePolicy3D
plb::CarreauDynamics< T, Descriptor, N >This class recomputes omega for a generalied newtonian fluid with a carreau constitutive equation
plb::carreauDynamicsTemplates< T, N >This structure forwards the calls to the appropriate helper class
plb::CarreauFlowParam< T >Numeric parameters for isothermal, incompressible flow
plb::global::CarreauParametersClass
plb::Cell< T, Descriptor >A LB lattice cell
plb::CellInfo< T, Descriptor >Helper class to evaluate statically the full memory requirement of a cell
plb::CheckVoxelizationFunctional3D< T >
plb::ChopardDynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics with adjustable speed of sound
plb::CoarseGridInterfaceInstantiator< T, Descriptor >Interface for the class that creates the coarse grid interface
plb::CoarseToFineConverter2D< T, Descriptor1, Descriptor2 >
plb::CoarseToFineConverter3D< T, Descriptor >
plb::ColorMap
plb::CombinedStatistics
plb::CommunicationInfo2D
plb::CommunicationInfo3D
plb::Complex< T >
plb::CompositeDynamics< T, Descriptor >Base class for composite dynamics
plb::meta::CompositeDynamicsGenerator< T, Descriptor, CompDynamics >
plb::ComprFlowParam< T >Numeric parameters for isothermal, incompressible flow
plb::Compute_C_processor< T, Descriptor >Compute the concentration C of the heavy phase
plb::Compute_gradC_rho_mu_processor< T >Compute quantities derived from C
plb::Compute_gradMu_laplaceMu_processor< T, Descriptor >
plb::Compute_gradMu_laplaceMu_u_p1_processor< T, Descriptor >
plb::ComputeAbsoluteValueFunctional2D< T >
plb::ComputeAbsoluteValueFunctional3D< T >
plb::ComputeNormFunctional2D< T, nDim >
plb::ComputeNormFunctional3D< T, nDim >
plb::ComputeNormSqrFunctional2D< T, nDim >
plb::ComputeNormSqrFunctional3D< T, nDim >
plb::ComputeScalarLogFunctional2D< T >
plb::ComputeScalarSqrtFunctional2D< T >
plb::ComputeScalarSqrtFunctional3D< T >
plb::ComputeSmagoViscosityFunctional3D< T, Descriptor >
plb::ComputeSparsityFunctional2D< T >
plb::ComputeSparsityFunctional3D< T >
plb::ComputeSymmetricTensorNormFunctional2D< T >
plb::ComputeSymmetricTensorNormFunctional3D< T >
plb::ComputeSymmetricTensorNormSqrFunctional2D< T >
plb::ComputeSymmetricTensorNormSqrFunctional3D< T >
plb::ComputeSymmetricTensorTraceFunctional2D< T >
plb::ComputeSymmetricTensorTraceFunctional3D< T >
plb::ComputeTensorSqrtFunctional2D< T, nDim >
plb::ComputeTensorSqrtFunctional3D< T, nDim >
plb::ComputeValue3D< T, Descriptor, ValueT >
plb::ConstantIniVelocityFreeSurface3D< T, Descriptor >
plb::ConstantVelocityProfile3D< T >
plb::ConstRhoBGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics with constant average density
plb::ContainerBlockData
plb::ConvectiveMultiScaleManager
plb::ConvectiveRefinementParameters< T >In the convective scaling (dx=dt)
plb::ConvectiveRescaleEngine< T, Descriptor >Rescale values in a convective regime, dx=dt, with a factor 2 between coarse and fine grid
plb::CoProcessor3D< T >
plb::Copy_t1_to_t0_2D< T, Descriptor >Processor to be added to coarse lattice: copies t1 values to t0 after each numTimeSteps iteration
plb::Copy_t1_to_t0_3D< T, Descriptor >Processor to be added to coarse lattice: copies t1 values to t0 after each numTimeSteps iteration
plb::CopyAllPopulationsFunctional2D< T, Descriptor, normalX, normalY >
plb::CopyAllPopulationsFunctional3D< T, Descriptor, normalX, normalY, normalZ >
plb::CopyCoarseToFineBoundaryCubicInterp2D< T, Descriptor1, Descriptor2 >Copy over the boundary from coarse to fine with third order interpolation for unknown populations
plb::CopyCoarseToFineBoundaryHelper2D< T, Descriptor1, Descriptor2 >When performing a cubic interpolation there is one site that might not have the correct values near the border
plb::CopyCoarseToFineBoundaryLinearInterp2D< T, Descriptor1, Descriptor2 >Coupling to be added to coarse lattice: interpolates on the boundary of a grid-refined domain
plb::CopyCoarseToFineCubicInterp2D< T, Descriptor1, Descriptor2 >Copy from coarse to fine grid and perform a third order interpolation for unknown populations
plb::CopyCoarseToFineCubicInterpWithDeconvolution2D< T, Descriptor1, Descriptor2 >Copy from coarse to fine grid and perform a third order interpolation for unknown populations
plb::CopyCoarseToFineLinearInterp2D< T, Descriptor1, Descriptor2 >
plb::CopyConvertNTensorFunctional2D< T1, T2 >
plb::CopyConvertNTensorFunctional3D< T1, T2 >
plb::CopyConvertPopulationsFunctional2D< T1, Descriptor1, T2, Descriptor2 >
plb::CopyConvertPopulationsFunctional3D< T1, Descriptor1, T2, Descriptor2 >
plb::CopyConvertScalarFunctional2D< T1, T2 >
plb::CopyConvertScalarFunctional3D< T1, T2 >
plb::CopyConvertTensorFunctional2D< T1, T2, nDim >
plb::CopyConvertTensorFunctional3D< T1, T2, nDim >
plb::CopyDensityFunctional2D< T, Descriptor, normalX, normalY >
plb::CopyDensityFunctional3D< T, Descriptor, normalX, normalY, normalZ >
plb::CopyFineToCoarse2D< T, Descriptor1, Descriptor2 >Coupling to be added to fine lattice: copies data to coarse lattice after numTimeSteps interations
plb::CopyFineToCoarse3D< T, Descriptor1, Descriptor2 >Coupling to be added to fine lattice: copies data to coarse lattice after numTimeSteps interations
plb::CopyFineToCoarseWithFiltering2D< T, Descriptor1, Descriptor2 >Coupling to be added to fine lattice: copies data to coarse lattice after numTimeSteps interations and does a filtering operation
plb::CopyFineToCoarseWithFiltering3D< T, Descriptor1, Descriptor2 >Coupling to be added to fine lattice: copies data from fine to coarse and does a filtering operation
plb::CopyNormalVelocityFunctional2D< T, Descriptor, normalX, normalY >
plb::CopyNormalVelocityFunctional3D< T, Descriptor, normalX, normalY, normalZ >
plb::CopyPopulationsFunctional2D< T, Descriptor >
plb::CopyPopulationsFunctional3D< T, Descriptor >
plb::CopyRescaleParticles3D< T, Descriptor >Copy particles from a fine to a coarse field
plb::CopyTangentialVelocityFunctional2D< T, Descriptor, normalX, normalY >
plb::CopyTangentialVelocityFunctional3D< T, Descriptor, normalX, normalY, normalZ >
plb::CopyUnknown3D< T, Descriptor, direction, orientation >Copy Unknown Populations Plus Impose Constant Pressure
plb::CopyUnknownPopulationsFunctional2D< T, Descriptor, direction, orientation >
plb::CopyUnknownPopulationsFunctional3D< T, Descriptor, direction, orientation >
plb::CopyVelocityFunctional2D< T, Descriptor, normalX, normalY >
plb::CopyVelocityFunctional3D< T, Descriptor, normalX, normalY, normalZ >
plb::BoundedReductiveBoxProcessingFunctional3D::CornerWrapperFunctional
plb::BoundedBoxProcessingFunctional3D::CornerWrapperFunctional
plb::BoundedBoxProcessingFunctional2D::CornerWrapperFunctional
plb::BoundedReductiveBoxProcessingFunctional2D::CornerWrapperFunctional
plb::CountBBNeighbors_NTensor3D< T, Descriptor >
plb::CountBBNeighborsFunctional3D< T, Descriptor >
plb::CountFreeSurfaceElementsFunctional3D< T, Descriptor >
plb::CountLatticeElementsFunctional2D< T, Descriptor, BoolMask >
plb::CountLatticeElementsFunctional3D< T, Descriptor, BoolMask >
plb::CountScalarElementsFunctional2D< T, BoolMask >
plb::CountScalarElementsFunctional3D< T, BoolMask >
plb::CountTensorElementsFunctional2D< T, nDim, BoolMask >
plb::CountTensorElementsFunctional3D< T, nDim, BoolMask >
plb::CreateTriangleHash< T >
plb::CrystallizeAndAggregate< T, Descriptor >
plb::CubicInterpolationFineGridInterfaceInstantiator< T, Descriptor >Create a fine grid interface with cubic interpolation
plb::CubicInterpolationXYCornerHelper3D< T, Descriptor >The corners
plb::CubicInterpolationXYLineXHelper3D< T, Descriptor >The edges
plb::CubicInterpolationXYLineYHelper3D< T, Descriptor >
plb::CubicInterpolationXZCornerHelper3D< T, Descriptor >The corners
plb::CubicInterpolationXZLineXHelper3D< T, Descriptor >The edges
plb::CubicInterpolationXZLineZHelper3D< T, Descriptor >
plb::CubicInterpolationYZCornerHelper3D< T, Descriptor >The corners
plb::CubicInterpolationYZLineYHelper3D< T, Descriptor >The edges
plb::CubicInterpolationYZLineZHelper3D< T, Descriptor >
plb::Cuboid< T >Definition of a cuboid (rectangular parallelepiped)
plb::descriptors::D2Q37Constants< T >D2Q37 lattice constants
plb::descriptors::D2Q37Descriptor< T >
plb::descriptors::D2Q37DescriptorBase< T >
plb::descriptors::D2Q5Constants< T >D2Q5 lattice
plb::descriptors::D2Q5DescriptorBase< T >
plb::descriptors::D2Q9Constants< T >D2Q9 lattice constants
plb::descriptors::D2Q9Descriptor< T >
plb::descriptors::D2Q9DescriptorBase< T >
plb::descriptors::D3Q121Constants< T >D3Q121 lattice constants
plb::descriptors::D3Q121Descriptor< T >
plb::descriptors::D3Q121DescriptorBase< T >
plb::descriptors::D3Q13Constants< T >D3Q13 lattice
plb::descriptors::D3Q13Descriptor< T >
plb::descriptors::D3Q13DescriptorBase< T >
plb::d3q13Templates< T >Helper functions for the (somewhat special) D3Q13 lattice
plb::descriptors::D3Q15Constants< T >D3Q15 lattice
plb::descriptors::D3Q15Descriptor< T >
plb::descriptors::D3Q15DescriptorBase< T >
plb::descriptors::D3Q19Constants< T >D3Q19 lattice
plb::D3Q19CudaCoProcessor3D< T >
plb::descriptors::D3Q19Descriptor< T >
plb::descriptors::D3Q19DescriptorBase< T >
plb::D3Q19ExampleCoProcessor3D< T >
plb::descriptors::D3Q27Constants< T >D3Q27 lattice
plb::descriptors::D3Q27Descriptor< T >
plb::descriptors::D3Q27DescriptorBase< T >
plb::descriptors::D3Q7Constants< T >D3Q7 lattice
plb::descriptors::D3Q7DescriptorBase< T >
plb::DataProcessor2DDataProcessors are used to run extended operations on a lattice or data field
plb::DataProcessor3DDataProcessors are used to run extended operations on a lattice or data field
plb::DataProcessorGenerator2DThis is a factory class generating LatticeProcessors
plb::DataProcessorGenerator3DThis is a factory class generating LatticeProcessors
plb::DataSerializer
plb::DataUnSerializer
plb::DefaultInitializeFreeSurface3D< T, Descriptor >
plb::DefaultMultiBlockPolicy2D
plb::DefaultMultiBlockPolicy3D
plb::DefaultMultiGridPolicy2D
plb::DefaultMultiGridPolicy3D
plb::global::DefaultMultiScaleManager
plb::global::DefaultRandom< T >
plb::DefaultRoundOffPolicy< T >
plb::DefaultWallProfile3D< T, SurfaceData >
plb::DefaultWallProfile3D< T, Array< T, 2 > >
plb::DefaultWallProfile3D< T, Array< T, 3 > >
plb::DEFscaledMesh< T >
plb::DensityDirichletBoundaryDynamics< T, Descriptor, direction, orientation >Density Dirichlet boundary dynamics for a straight wall
plb::DensityFromRhoBarJfunctional3D< T >
plb::descriptors::DensityMomentumForceExternals2DDensity, Momentum and Force as external scalars
plb::descriptors::DensityMomentumForceExternals3DDensity, Momentum and Force as external scalars
plb::descriptors::DensityMomentumNoForceExternals2DDensity and Momentum as external scalars
plb::descriptors::DensityMomentumNoForceExternals3DDensity and Momentum as external scalars
plb::DensityNeumannBoundaryProfile3D< T >
plb::DensitySingleProbe3D< T, Descriptor >
plb::DetectBorderLineFunctional3D< T >
plb::DevNullBufferA buffer which reads and writes nothing
plb::DiagnosticFileSingleton
plb::DiffusiveRefinementParameters< T >In the convective scaling (dx=dt^2) so viscosity is constant
plb::fd::DirectedGradients2D< T, Descriptor, direction, orientation, orthogonal >
plb::fd::DirectedGradients2D< T, Descriptor, direction, orientation, false >
plb::fd::DirectedGradients2D< T, Descriptor, direction, orientation, true >
plb::fd::DirectedGradients3D< T, Descriptor, direction, orientation, deriveDirection, orthogonal >
plb::fd::DirectedGradients3D< T, Descriptor, direction, orientation, deriveDirection, false >
plb::fd::DirectedGradients3D< T, Descriptor, direction, orientation, deriveDirection, true >
plb::global::Directories
plb::DirichletDensityBoundarySolver< T, Descriptor, dir >
plb::DirichletMassConservingVelocityBoundarySolver< T, Descriptor >
plb::DirichletVelocityBoundarySolver< T, Descriptor >
plb::DomainAndId2D
plb::DomainAndId3D
plb::DomainFunctional2D
plb::DomainFunctional3D
plb::Dot2DCoordinates of a 2D point
plb::Dot3DCoordinates of a 3D point
plb::DotList2DList of 2D points, used to describe a subdomain
plb::DotList3DList of 3D points, used to describe a subdomain
plb::DotProcessingFunctional2DEasy instantiation of dotted data processor (general case)
plb::DotProcessingFunctional2D_L< T, Descriptor >Easy instantiation of dotted data processor for a single lattice
plb::DotProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of dotted data processor for lattice-lattice coupling
plb::DotProcessingFunctional2D_LN< T1, Descriptor, T2 >Easy instantiation of dotted data processor for Lattice-NTensorField coupling
plb::DotProcessingFunctional2D_LS< T1, Descriptor, T2 >Easy instantiation of dotted data processor for Lattice-ScalarField coupling
plb::DotProcessingFunctional2D_LT< T1, Descriptor, T2, nDim >Easy instantiation of dotted data processor for Lattice-TensorField coupling
plb::DotProcessingFunctional2D_N< T >Easy instantiation of dotted data processor for a single n-tensor field
plb::DotProcessingFunctional2D_NN< T1, T2 >Easy instantiation of dotted data processor for NTensorField-NTensorField coupling
plb::DotProcessingFunctional2D_S< T >Easy instantiation of dotted data processor for a single scalar field
plb::DotProcessingFunctional2D_SN< T1, T2 >Easy instantiation of dotted data processor for ScalarField-NTensorField coupling
plb::DotProcessingFunctional2D_SS< T1, T2 >Easy instantiation of dotted data processor for ScalarField-ScalarField coupling
plb::DotProcessingFunctional2D_ST< T1, T2, nDim >Easy instantiation of dotted data processor for ScalarField-TensorField coupling
plb::DotProcessingFunctional2D_T< T, nDim >Easy instantiation of dotted data processor for a single tensor field
plb::DotProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 >Easy instantiation of dotted data processor for TensorField-TensorField coupling
plb::DotProcessingFunctional3DEasy instantiation of dotted data processor (general case)
plb::DotProcessingFunctional3D_L< T, Descriptor >Easy instantiation of dotted data processor for a single lattice
plb::DotProcessingFunctional3D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of dotted data processor for lattice-lattice coupling
plb::DotProcessingFunctional3D_LN< T1, Descriptor, T2 >Easy instantiation of dotted data processor for Lattice-NTensorField coupling
plb::DotProcessingFunctional3D_LS< T1, Descriptor, T2 >Easy instantiation of dotted data processor for Lattice-ScalarField coupling
plb::DotProcessingFunctional3D_LT< T1, Descriptor, T2, nDim >Easy instantiation of dotted data processor for Lattice-TensorField coupling
plb::DotProcessingFunctional3D_N< T >Easy instantiation of dotted data processor for a single n-tensor field
plb::DotProcessingFunctional3D_NN< T1, T2 >Easy instantiation of dotted data processor for NTensorField-NTensorField coupling
plb::DotProcessingFunctional3D_S< T >Easy instantiation of dotted data processor for a single scalar field
plb::DotProcessingFunctional3D_SN< T1, T2 >Easy instantiation of dotted data processor for ScalarField-NTensorField coupling
plb::DotProcessingFunctional3D_SS< T1, T2 >Easy instantiation of dotted data processor for ScalarField-ScalarField coupling
plb::DotProcessingFunctional3D_ST< T1, T2, nDim >Easy instantiation of dotted data processor for ScalarField-TensorField coupling
plb::DotProcessingFunctional3D_T< T, nDim >Easy instantiation of dotted data processor for a single tensor field
plb::DotProcessingFunctional3D_TT< T1, nDim1, T2, nDim2 >Easy instantiation of dotted data processor for TensorField-TensorField coupling
plb::DotProcessor2DA Dotted data processor, automatically generated from a DotProcessingFunctional2D
plb::DotProcessor3DA Dotted data processor, automatically generated from a DotProcessingFunctional3D
plb::DotProcessorGenerator2DAn automatically created generator for the DotProcessor2D
plb::DotProcessorGenerator3DAn automatically created generator for the DotProcessor3D
plb::DottedDataProcessorGenerator2D
plb::DottedDataProcessorGenerator3D
plb::DottedReductiveDataProcessorGenerator2D
plb::DottedReductiveDataProcessorGenerator3D
plb::DynamicNativeType
plb::Dynamics< T, Descriptor >Interface for the dynamics classes
plb::DynamicsFromIntMaskFunctional2D< T, Descriptor >Assign dynamics to nodes specified by an integer mask
plb::DynamicsFromIntMaskFunctional3D< T, Descriptor >Assign dynamics to nodes specified by a boolean mask
plb::DynamicsFromMaskFunctional2D< T, Descriptor >Assign dynamics to nodes specified by a boolean mask
plb::DynamicsFromMaskFunctional3D< T, Descriptor >Assign dynamics to nodes specified by a boolean mask
plb::meta::DynamicsGenerator< T, Descriptor >
plb::meta::DynamicsRegistration< T, Descriptor >
plb::dynamicsTemplates< T, Descriptor >This structure forwards the calls to the appropriate helper class
plb::dynamicsTemplatesImpl< T, Descriptor >All helper functions are inside this structure
plb::dynamicsTemplatesImpl< T, descriptors::D2Q9DescriptorBase< T > >
plb::dynamicsTemplatesImpl< T, descriptors::D3Q15DescriptorBase< T > >
plb::dynamicsTemplatesImpl< T, descriptors::D3Q19DescriptorBase< T > >
plb::dynamicsTemplatesImpl< T, descriptors::D3Q27DescriptorBase< T > >
plb::EdgeHolds one of the three edges of a triangle
plb::MarchingCubeSurfaces3D< T >::EdgeOrientedTriangleSetData
plb::BoundedReductiveBoxProcessingFunctional3D::EdgeWrapperFunctional
plb::BoundedBoxProcessingFunctional3D::EdgeWrapperFunctional
plb::BoundedReductiveBoxProcessingFunctional2D::EdgeWrapperFunctional
plb::BoundedBoxProcessingFunctional2D::EdgeWrapperFunctional
plb::EntropicDynamics< T, Descriptor >Implementation of the entropic collision step
plb::entropicLbTemplates< T, Descriptor >
plb::entropicLbTemplates< T, descriptors::D2Q9Descriptor >
plb::entropicLbTemplates< T, descriptors::D3Q19Descriptor >
plb::meta::DynamicsRegistration< T, Descriptor >::Entry
plb::meta::ProcessorRegistration3D::Entry
plb::meta::ProcessorRegistration2D::Entry
plb::meta::DynamicsRegistration< T, Descriptor >::EntryLessThan
plb::meta::ProcessorRegistration3D::EntryLessThan
plb::meta::ProcessorRegistration2D::EntryLessThan
plb::EnumeratedUniqueObjects< T >
plb::EnumeratedUniqueTypeIds
plb::EquilibriumBoundaryManager2D< T, Descriptor >
plb::EquilibriumBoundaryManager3D< T, Descriptor >
plb::EquilibriumDensityAndVelocityBoundaryDynamics< T, Descriptor >Equilibrium boundary dynamics, on which both density and velocity are imposed
plb::EquilibriumDensityBoundaryDynamics< T, Descriptor, direction, orientation >Equilibrium density Dirichlet boundary dynamics for a straight wall
plb::EquilibriumVelocityBoundaryDynamics< T, Descriptor, direction, orientation >Equilibrium velocity boundary dynamics for a straight wall
plb::EuclideanIterator2DIterate in a structured way over a sparse multi-block structure
plb::EuclideanIterator3DIterate in a structured way over a sparse multi-block structure
plb::EvaluateScalarFunctional2D< T, EvalFunction >
plb::EvaluateScalarFunctional3D< T, EvalFunction >
plb::ExecuteCornerNLD_3D< T, Descriptor >Invoke NLD dynamics objects on a corner
plb::ExecuteEdgeNLD_3D< T, Descriptor >Invoke NLD dynamics objects on an edge
plb::ExecuteNonLocalDynamics3D< T, Descriptor >A generic interface for non-local data processors that invoke the NLD dynamics objects
plb::ExecutePlaneNLD_3D< T, Descriptor >Invoke NLD dynamics objects on a plane surface
plb::ExplicitThreadAttribution
plb::ExternalFieldArray< T, ExternalField >Helper class: allocation of memory for external fields in a cell
plb::ExternalFieldArray< T, descriptors::NoExternalField >Specialization of ExternalFieldArray, when no external field is present
plb::ExternalForceAccess< T, Descriptor, numForceComponents >Default implementation of ExternalForceAccess: return force from external scalar
plb::ExternalForceAccess< T, Descriptor, 0 >Specialization of ExternalForceAccess: return 0 if there is no external force
plb::ExternalForceDynamics< T, Descriptor >
plb::externalForceTemplates< T, Descriptor >
plb::externalForceTemplatesImpl< T, Descriptor >
plb::externalForceTemplatesImpl< T, descriptors::ForcedD2Q9Descriptor< T > >
plb::externalForceTemplatesImpl< T, descriptors::ForcedD3Q19Descriptor< T > >
plb::ExternalMomentBGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics, density and momentum taken from external scalars
plb::ExternalMomentRegularizedBGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics, density and momentum taken from external scalars
plb::descriptors::ExternalOmegaAndForceBase3d
plb::descriptors::ExternalOmegaAndForceDescriptor2d
plb::descriptors::ExternalOmegaAndForceDescriptor3d
plb::descriptors::ExternalOmegaBase3d
plb::descriptors::ExternalOmegaD2Q9Descriptor< T >
plb::descriptors::ExternalOmegaD3Q15Descriptor< T >
plb::descriptors::ExternalOmegaD3Q19Descriptor< T >
plb::descriptors::ExternalOmegaD3Q27Descriptor< T >
plb::descriptors::ExternalOmegaDescriptor2d
plb::descriptors::ExternalOmegaDescriptor3d
plb::ExternalOmegaDynamics< T, Descriptor >A dynamics which reads the relaxation parameter from external scalar before collision
plb::ExternalRhoJcollideAndStream2D< T, Descriptor >
plb::ExternalRhoJcollideAndStream3D< T, Descriptor >
plb::ExternalVelocityBGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics, velocity taken from external scalar
plb::ExternalVelocityIncMRTdynamics< T, Descriptor >Implementation of incompressible MRT dynamics, with velocity taken from an external scalar
plb::descriptors::ExternalVelocityMRTD2Q9Descriptor< T >
plb::descriptors::ExternalVelocityMRTD3Q19Descriptor< T >
plb::ExternalVelocityMRTdynamics< T, Descriptor >Implementation of the MRT collision step
plb::ExtractBottomMostDynamicsFunctional2D< T, Descriptor >
plb::ExtractBottomMostDynamicsFunctional3D< T, Descriptor >
plb::ExtractDynamicsChainFunctional2D< T, Descriptor >
plb::ExtractDynamicsChainFunctional3D< T, Descriptor >
plb::ExtractScalarSubDomainFunctional2D< T >
plb::ExtractScalarSubDomainFunctional3D< T >
plb::ExtractTensorComponentFunctional2D< T, nDim >
plb::ExtractTensorComponentFunctional3D< T, nDim >
plb::ExtractTensorSubDomainFunctional2D< T, nDim >
plb::ExtractTensorSubDomainFunctional3D< T, nDim >
plb::ExtractTopMostDynamicsFunctional2D< T, Descriptor >
plb::ExtractTopMostDynamicsFunctional3D< T, Descriptor >
plb::ExtrapolatedGeneralizedOffLatticeModel3D< T, Descriptor >
plb::ExtrapolateValue3D< T, Descriptor, ValueT >
plb::FileName
plb::FilteredCoarseGridInterfaceInstantiator< T, Descriptor >Create a coarse grid interface with filtering when copying from fine grid
plb::FineGridBoundaryDynamics< T, Descriptor >Dynamics attributed to boundary cell of fine lattice with grid refinement
plb::FineGridInterfaceInstantiator< T, Descriptor >Interface for the class that creates the fine grid interface
plb::FiniteDifference< T >
plb::FlagData2D
plb::FlagData3D
plb::FlatAdiabaticBoundaryFunctional2D< T, Descriptor, direction, orientation >
plb::FlatAdiabaticBoundaryFunctional3D< T, Descriptor, direction, orientation >
plb::FluidPressureOutlet3D< T, Descriptor, direction, orientation >Copy Unknown Populations Plus Impose Constant Pressure
plb::descriptors::Force2dDescriptor
plb::descriptors::Force2dDescriptorBase
plb::descriptors::Force3dDescriptor
plb::descriptors::Force3dDescriptorBase
plb::descriptors::ForcedD2Q37Descriptor< T >
plb::descriptors::ForcedD2Q9Descriptor< T >
plb::descriptors::ForcedD3Q121Descriptor< T >
plb::descriptors::ForcedD3Q13Descriptor< T >
plb::descriptors::ForcedD3Q15Descriptor< T >
plb::descriptors::ForcedD3Q19Descriptor< T >
plb::descriptors::ForcedD3Q27Descriptor< T >
plb::ForcedEntropicDynamics< T, Descriptor >Implementation of the forced entropic collision step
plb::descriptors::ForcedExternalOmegaD2Q9Descriptor< T >
plb::descriptors::ForcedExternalOmegaD3Q15Descriptor< T >
plb::descriptors::ForcedExternalOmegaD3Q19Descriptor< T >
plb::descriptors::ForcedExternalOmegaD3Q27Descriptor< T >
plb::descriptors::ForcedMRTD2Q9Descriptor< T >
plb::descriptors::ForcedMRTD3Q19Descriptor< T >
plb::descriptors::ForcedRhoBarJD3Q15Descriptor< T >
plb::descriptors::ForcedRhoBarJD3Q19Descriptor< T >
plb::descriptors::ForcedRhoBarJD3Q27Descriptor< T >
plb::descriptors::ForcedRhoBarJdescriptor2D
plb::descriptors::ForcedRhoBarJdescriptor3D
plb::descriptors::ForcedRhoBarJdescriptorBase2D
plb::descriptors::ForcedRhoBarJdescriptorBase3D
plb::descriptors::ForcedShanChenD2Q9Descriptor< T >D2Q9 lattice for Shan-Chen model with force
plb::descriptors::ForcedShanChenD3Q19Descriptor< T >D3Q19 lattice for Shan-Chen model with force
plb::descriptors::ForcedShanChenExternalBase2D
plb::descriptors::ForcedShanChenExternalBase3D
plb::FreeSlipProfile3D< T >
plb::FreeSurfaceAddSurfaceTension3D< T, Descriptor >Add the surface tension contribution
plb::FreeSurfaceCompletion3D< T, Descriptor >Completion scheme on the post-collide populations on interface cells
plb::FreeSurfaceCompletion3D_jonas< T, Descriptor >
plb::FreeSurfaceComputeCurvature3D< T, Descriptor >
plb::FreeSurfaceComputeInterfaceLists3D< T, Descriptor >
plb::FreeSurfaceComputeNormals3D< T, Descriptor >
plb::FreeSurfaceComputeStatistics3D< T, Descriptor >
plb::FreeSurfaceEqualMassExcessReDistribution3D< T, Descriptor >Enforce exact mass balance when interface cells become fluid or empty
plb::FreeSurfaceFadingArea3D< T, Descriptor >
plb::FreeSurfaceFields3D< T, Descriptor >
plb::FreeSurfaceGeometry3D< T, Descriptor >
plb::FreeSurfaceIniEmptyToInterfaceNodes3D< T, Descriptor >
plb::FreeSurfaceIniInterfaceToAnyNodes3D< T, Descriptor >
plb::FreeSurfaceMacroscopic3D< T, Descriptor >Compute and store mass-fraction and macroscopic variables
plb::FreeSurfaceMassChange3D< T, Descriptor >Compute the mass balance on every node in the domain, and store in mass matrix
plb::FreeSurfaceProcessorParam3D< T, Descriptor >
plb::FreeSurfaceRemoveFalseInterfaceCells3D< T, Descriptor >
plb::freeSurfaceTemplates< T, Descriptor >
plb::freeSurfaceTemplates< T, descriptors::ForcedD3Q19Descriptor >
plb::FS_AverageDensityFunctional3D< T, Descriptor >
plb::FS_AverageHeightFunctional3D< T, Descriptor >
plb::FS_AverageMassFunctional3D< T, Descriptor >
plb::FS_AverageMomentumFunctional3D< T, Descriptor >
plb::FS_AverageVolumeFractionFunctional3D< T, Descriptor >
plb::FS_TotalMassFunctional3D< T, Descriptor >
plb::meta::FunctionalFactory2D< FunctionalT >
plb::meta::FunctionalFactory3D< FunctionalT >
plb::GaussSeidelDefect2D< T >
plb::GaussSeidelIteration2D< T >
plb::GaussSeidelMaxDefectFunctional2D< T >
plb::meta::GeneralDynamicsGenerator< T, Descriptor, GeneralDynamics >
plb::GeneralizedBoundaryManager2D< T, Descriptor >
plb::GeneralizedBoundaryManager3D< T, Descriptor >
plb::GeneralizedBoundarySolver< T, Descriptor >
plb::generalizedComprTempBoundaryTemplates< T, Descriptor >
plb::GeneralizedDensityBoundaryDynamics< T, Descriptor, direction, orientation >Generic density Dirichlet boundary dynamics for a straight wall
plb::generalizedIncomprBoundaryTemplates< T, Descriptor >
plb::GeneralizedLinearBoundarySolver< T, Descriptor >
plb::GeneralizedMassConservingVelocityBoundaryDynamics< T, Descriptor >Mass Conserving Generic velocity boundary dynamics for a straight wall
plb::GeneralizedNextToBoundaryDynamics< T, Descriptor >Generic velocity and temperature boundary dynamics for a straight wall
plb::GeneralizedNonLinearBoundarySolver< T, Descriptor >
plb::GeneralizedVelocityBoundaryDynamics< T, Descriptor >Generic velocity boundary dynamics for a straight wall
plb::GeneralizedVelocityTemperatureBoundaryDynamics< T, Descriptor >Generic velocity and temperature boundary dynamics for a straight wall
plb::GenericIndexedLatticeFunctional2D< T, Descriptor >
plb::GenericIndexedLatticeFunctional3D< T, Descriptor >
plb::GenericLatticeFunctional2D< T, Descriptor >
plb::GenericLatticeFunctional3D< T, Descriptor >
plb::GetForceOnObjectFunctional3D< T, SurfaceData >
plb::GetThreadNumFunctional3D
plb::GetWaterLevelAtxyFunctional3D< T, Descriptor >
plb::GuoAdvDiffOffLatticeModel3D< T, Descriptor >
plb::GuoExternalForceBGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics with an external force (Guo approach)
plb::GuoExternalForceMRTdynamics< T, Descriptor >Implementation of the MRT collision step
plb::GuoExternalForceSmagorinskyBGKdynamics< T, Descriptor >
plb::GuoExternalForceSmagorinskyMRTdynamics< T, Descriptor >Implementation of the MRT collision step
plb::GuoOffLatticeModel3D< T, Descriptor >
plb::HeExternalForceBGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics with an external force (He et al. approach)
plb::HeLeeCollisionProcessor< T, Descriptor >
plb::HermiteTemplate< T, Descriptor >
plb::HermiteTemplateImpl< T, Descriptor, 2 >
plb::HermiteTemplateImpl< T, Descriptor, 3 >
plb::HierarchicSerializer
plb::HierarchicUnserializer
plb::IdentifyPureDynamics3D< T, Descriptor >
plb::ImageWriter< T >
plb::ImplicitOmega< T, N >
plb::ImplicitOmega< T, 0 >
plb::InamuroAnalyticalPressureDynamics< T, Descriptor, direction, orientation >
plb::InamuroAnalyticalVelocityDynamics< T, Descriptor, direction, orientation >
plb::InamuroBoundaryManager2D< T, Descriptor >
plb::IncAsinariDynamics< T, Descriptor >First part of collision in Asinari's LW-ACM model, with incompressible equilibrium
plb::IncBGKdynamics< T, Descriptor >Implementation of incompressible BGK dynamics
plb::IncGuoExternalForceBGKdynamics< T, Descriptor >Incompressible version of the Guo external forcing
plb::IncGuoExternalForceSmagorinskyBGKdynamics< T, Descriptor >
plb::IncMRTdynamics< T, Descriptor >Implementation of incompressible MRT dynamics
plb::IncomprFlowParam< T >Numeric parameters for isothermal, incompressible flow
plb::IncreasingPoiseuilleProfile3D< T, Descriptor >
plb::IncreasingVelocityProfile3D< T, Descriptor >
plb::IncRegularizedBGKdynamics< T, Descriptor >Implementation of O(Ma^2) Regularized BGK dynamics without the 1/rho in front of the non-linear term
plb::Index< T, Descriptor >
plb::IndexCollection
plb::IndexContraction_SymmetricTensor_A_SymmetricTensor_B_functional3D< T, nDim >
plb::IniConstEquilibriumFunctional2D< T, Descriptor >
plb::IniConstEquilibriumFunctional3D< T, Descriptor >
plb::IniConstScalarFunctional2D< T >
plb::IniConstScalarFunctional3D< T >
plb::IniConstTensorFunctional2D< T, nDim >
plb::IniConstTensorFunctional3D< T, nDim >
plb::IniCustomEquilibriumFunctional2D< T, Descriptor, RhoUFunction >
plb::IniCustomEquilibriumFunctional3D< T, Descriptor, RhoUFunction >
plb::IniCustomThermalEquilibriumFunctional2D< T, Descriptor, RhoVelThetaFunction >
plb::IniCustomThermalEquilibriumFunctional3D< T, Descriptor, RhoVelTempFunction >
plb::InitializeDotMomentumExchangeFunctional2D< T, Descriptor >
plb::InitializeDotMomentumExchangeFunctional3D< T, Descriptor >
plb::InitializeInterfaceLists3D< T, Descriptor >
plb::InitializeMomentumExchangeFunctional2D< T, Descriptor >
plb::InitializeMomentumExchangeFunctional3D< T, Descriptor >
plb::inletConstVolumeFraction3D< T, Descriptor >
plb::InletOutletProperty3D< T >
plb::InstantiateComplexDomainDynamicsFunctional2D< T, Descriptor >
plb::InstantiateComplexDomainDynamicsFunctional3D< T, Descriptor >
plb::InstantiateCompositeDynamicsFunctional2D< T, Descriptor >
plb::InstantiateCompositeDynamicsFunctional3D< T, Descriptor >
plb::InstantiateDotDynamicsFunctional2D< T, Descriptor >
plb::InstantiateDotDynamicsFunctional3D< T, Descriptor >
plb::InstantiateDynamicsFunctional2D< T, Descriptor >
plb::InstantiateDynamicsFunctional3D< T, Descriptor >
plb::InstantiateNLDdynamicsFunctional3D< T, Descriptor >
plb::InterfaceLists< T, Descriptor >Data structure for holding lists of cells along the free surface in an AtomicContainerBlock
plb::InterpolateCoarseToFineBoundaryDynamics3D< T, Descriptor1, Descriptor2 >
plb::InterpolateCoarseToFineCornerDynamics3D< T, Descriptor1, Descriptor2 >
plb::InterpolateCoarseToFineDynamics3D< T, Descriptor1, Descriptor2 >
plb::InterpolatedGeneralizedOffLatticeModel3D< T, Descriptor >
plb::InterpolatePopulationsFunctional3D< T, Descriptor >
plb::InterpolationBoundaryManager2D< T, Descriptor >
plb::InterpolationBoundaryManager3D< T, Descriptor >
plb::global::IOpolicyClass
plb::IsoSurfaceDefinition3D< T >
plb::IsoThermalBulkDynamics< T, Descriptor >Common base iso-thermal (or athermal) bulk dynamics
plb::IterateDynamicsFunctional2D
plb::IterateDynamicsFunctional3D
plb::JacobiIteration2D< T >
plb::LatticeBoxProcessingFunctional2D< T, Descriptor >Easy instantiation of boxed data processor for multiple lattices
plb::LatticeBoxProcessingFunctional3D< T, Descriptor >Easy instantiation of boxed data processor for multiple lattices
plb::LatticeCopyAllFunctional2D< T, Descriptor >
plb::LatticeCopyAllFunctional3D< T, Descriptor >
plb::LatticeCopyFineToCoarseNoScale3D< T, Descriptor >Copy data from a fine to a coarse ScalarField3D
plb::LatticeCopyFineToCoarseZerothOrder2D< T, Descriptor >Copy data from a fine to a coarse ScalarField2D
plb::LatticeCopyFineToCoarseZerothOrder3D< T, Descriptor >Copy data from a fine to a coarse ScalarField3D
plb::LatticeDotProcessingFunctional2D< T, Descriptor >Easy instantiation of dotted data processor for multiple lattices
plb::LatticeDotProcessingFunctional3D< T, Descriptor >Easy instantiation of dotted data processor for multiple lattices
plb::LatticeInterpolateCoarseToFine2D< T, Descriptor >Copy data from a coarse to a fine BlockLattice, using bilinear interpolation
plb::LatticeInterpolateCoarseToFine3D< T, Descriptor >Copy data from a coarse to a fine BlockLattice, using bilinear interpolation
plb::LatticeRegenerateFunctional2D< T, Descriptor >
plb::LatticeRegenerateFunctional3D< T, Descriptor >
plb::latticeTemplates< T, Descriptor >Helper functions with full-lattice access
plb::latticeTemplates< T, descriptors::D2Q9Descriptor >
plb::latticeTemplates< T, descriptors::D3Q15Descriptor >
plb::latticeTemplates< T, descriptors::D3Q19Descriptor >
plb::latticeTemplates< T, descriptors::ForcedD2Q9Descriptor >
plb::latticeTemplates< T, descriptors::ForcedD3Q15Descriptor >
plb::latticeTemplates< T, descriptors::ForcedD3Q19Descriptor >
plb::LatticeToPassiveAdvDiff2D< T, FluidDescriptor, ScalarDescriptor >
plb::LatticeToPassiveAdvDiff3D< T, FluidDescriptor, ScalarDescriptor >
plb::LBMcomputeDivergence3D< T, Descriptor >
plb::LBMcomputeGradient3D< T, Descriptor >
plb::LBMsmoothen3D< T, Descriptor >
plb::LBMsmoothenTensor3D< T, nDim, Descriptor >
plb::Lid
plb::LidLessThan< T >
plb::LinearFunction
plb::LinearInterpolationFineGridInterfaceInstantiator< T, Descriptor >Create a fine grid interface with linear interpolation
plb::LinearRoundOffPolicy< T >
plb::LocalMultiBlockInfo2D
plb::LocalMultiBlockInfo3D
plb::global::LogFileCollection
plb::global::MainArgs
plb::global::MainArgv
plb::MarchingCubeConstants
plb::MarchingCubeSurfaces3D< T >
plb::MaskedBoxProcessingFunctional2D_L< T, Descriptor >Easy instantiation of boxed data processor for a single lattice with bool mask
plb::MaskedBoxProcessingFunctional2D_LN< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-NTensorField coupling with mask
plb::MaskedBoxProcessingFunctional2D_N< T >Easy instantiation of boxed data processor for a single n-tensor field with bool mask
plb::MaskedBoxProcessingFunctional2D_NN< T1, T2 >Easy instantiation of boxed data processor for NTensorField-NTensorField coupling
plb::MaskedBoxProcessingFunctional3D_L< T, Descriptor >Easy instantiation of boxed data processor for a single lattice with bool mask
plb::MaskedBoxProcessingFunctional3D_LN< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-NTensorField coupling with bool mask
plb::MaskedBoxProcessingFunctional3D_N< T >Easy instantiation of boxed data processor for a single n-tensor field with bool mask
plb::MaskedBoxProcessingFunctional3D_NN< T1, T2 >Easy instantiation of boxed data processor for NTensorField-NTensorField coupling with bool mask
plb::MaskedBoxScalarAverageFunctional2D< T >
plb::MaskedBoxScalarAverageFunctional3D< T >
plb::MaskedCountBBNeighbors_NTensor3D< T, Descriptor >
plb::MaskedIniConstScalarFunctional2D< T >
plb::MaskedIniConstScalarFunctional3D< T >
plb::MaskedIniConstTensorFunctional2D< T, nDim >
plb::MaskedIniConstTensorFunctional3D< T, nDim >
plb::MaskedNTensorFieldBoxProcessingFunctional2D< T >Easy instantiation of boxed data processor for multiple n-tensorFields
plb::MaskedNTensorFieldBoxProcessingFunctional3D< T >Easy instantiation of boxed data processor for multiple n-tensorFields
plb::MaskedReductiveBoxProcessingFunctional2D_LN< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-NTensorField coupling
plb::MaskedReductiveBoxProcessingFunctional2D_N< T >Easy instantiation of boxed data processor for a single n-tensor field
plb::MaskedReductiveBoxProcessingFunctional2D_NN< T1, T2 >Easy instantiation of boxed data processor for NTensorField-NTensorField coupling
plb::MaskedReductiveBoxProcessingFunctional3D_LN< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-NTensorField coupling
plb::MaskedReductiveBoxProcessingFunctional3D_N< T >Easy instantiation of boxed data processor for a single n-tensor field
plb::MaskedReductiveBoxProcessingFunctional3D_NN< T1, T2 >Easy instantiation of boxed data processor for NTensorField-NTensorField coupling
plb::MassConservingGeneralizedBoundaryManager2D< T, Descriptor >
plb::momentTemplates< T, Descriptor >
plb::momentTemplatesImpl< T, Descriptor >
plb::momentTemplatesImpl< T, descriptors::D2Q9DescriptorBase< T > >
plb::momentTemplatesImpl< T, descriptors::D3Q15DescriptorBase< T > >
plb::momentTemplatesImpl< T, descriptors::D3Q19DescriptorBase< T > >
plb::momentTemplatesImpl< T, descriptors::D3Q27DescriptorBase< T > >
plb::MomentumExchangeBounceBack< T, Descriptor >Implementation of "full-way bounce-back" dynamics which computes momentum exchange
plb::MomentumExchangeComplexDomainFunctional2D< T, Descriptor >
plb::MomentumExchangeComplexDomainFunctional3D< T, Descriptor >
plb::global::MpiManager
plb::descriptors::MRTD2Q9Descriptor< T >
plb::descriptors::MRTD2Q9DescriptorBase< T >
plb::descriptors::MRTD3Q19Descriptor< T >
plb::descriptors::MRTD3Q19DescriptorBase< T >
plb::MRTdynamics< T, Descriptor >Implementation of the MRT collision step
plb::MRTparam< T, Descriptor >
plb::MRTparamList< T, Descriptor >
plb::mrtTemplates< T, Descriptor >All helper functions are inside this structure
plb::mrtTemplatesImpl< T, Descriptor >
plb::mrtTemplatesImpl< T, descriptors::MRTD2Q9DescriptorBase< T > >
plb::mrtTemplatesImpl< T, descriptors::MRTD3Q19DescriptorBase< T > >
plb::MultiBlock2D
plb::MultiBlock3D
plb::MultiBlockFastSerializer2D
plb::MultiBlockFastSerializer3D
plb::MultiBlockFastUnSerializer2D
plb::MultiBlockFastUnSerializer3D
plb::meta::MultiBlockGenerator2D
plb::meta::MultiBlockGenerator3D
plb::MultiBlockLattice2D< T, Descriptor >A complex LatticeBase, itself decomposed into smaller components
plb::MultiBlockLattice3D< T, Descriptor >A complex LatticeBase, itself decomposed into smaller components
plb::MultiBlockManagement2D
plb::MultiBlockManagement3D
plb::MultiBlockRedistribute3D
plb::meta::MultiBlockRegistration2D
plb::MultiBlockRegistration2D
plb::meta::MultiBlockRegistration3D
plb::MultiBlockRegistration3D
plb::MultiBlockSerializer2D
plb::MultiBlockSerializer3D
plb::MultiBlockUnSerializer2D
plb::MultiBlockUnSerializer3D
plb::MultiCellAccess2D< T, Descriptor >
plb::MultiCellAccess3D< T, Descriptor >
plb::MultiContainerBlock2D
plb::MultiContainerBlock3D
plb::MultiFreeSurfaceComplexCoupling3D< T, Descriptor >
plb::MultiFreeSurfaceFields3D< T, Descriptor >
plb::MultiFreeSurfaceOneWayCoupling3D< T, Descriptor >
plb::MultiFreeSurfaceRepellingForceCoupling3D< T, Descriptor >
plb::MultiFreeSurfaceVelocityContinuityCoupling3D< T, Descriptor >
plb::MultiGrid2DBase non-typed object that represents a multigrid
plb::MultiGrid3DBase non-typed object that represents a multigrid
plb::MultiGridGenerator2D< T, Descriptor >Factory class to create several different refined grids
plb::MultiGridLattice2D< T, Descriptor >Main class when dealing with grid refinement
plb::MultiGridLattice3D< T, Descriptor >
plb::MultiGridManagement2D
plb::MultiGridManagement3D
plb::MultiGridPeriodicitySwitch2DClass that allows periodicity to be toggled on/off in the multigrid
plb::MultiGridPeriodicitySwitch3DClass that allows periodicity to be toggled on/off in the multigrid
plb::MultiGridScalarField2D< T >
plb::MultiGridScalarField3D< T >
plb::MultiGridStatSubscriber2DHandles statistics subscriptions for the MultiGridLattice2D
plb::MultiGridStatSubscriber3DHandles statistics subscriptions for the MultiGridLattice3D
plb::MultiGridTensorField2D< T, nDim >
plb::MultiGridTensorField3D< T, nDim >
plb::MultiNTensorAccess2D< T >
plb::MultiNTensorAccess3D< T >
plb::MultiNTensorField2D< T >
plb::MultiNTensorField3D< T >
plb::multiPhaseHelpers2D< T, Descriptor >
plb::multiPhaseTemplates2D< T, Descriptor >Helper functions with full-lattice access
plb::multiPhaseTemplates2D< T, descriptors::ForcedShanChenD2Q9Descriptor >
plb::multiPhaseTemplates3D< T, Descriptor >Helper functions with full-lattice access
plb::multiPhaseTemplates3D< T, descriptors::ForcedShanChenD3Q19Descriptor >
plb::MultiProcessing2D< OriginalGenerator, MutableGenerator >
plb::MultiProcessing3D< OriginalGenerator, MutableGenerator >
plb::MultiScalarAccess2D< T >
plb::MultiScalarAccess3D< T >
plb::MultiScalarField2D< T >
plb::MultiScalarField3D< T >
plb::MultiScaleManager
plb::MultiStatSubscriber2DHandles statistics subscriptions for the MultiBlockLattice2D
plb::MultiStatSubscriber3DHandles statistics subscriptions for the MultiBlockLattice3D
plb::MultiTensorAccess2D< T, nDim >
plb::MultiTensorAccess3D< T, nDim >
plb::MultiTensorField2D< T, nDim >
plb::MultiTensorField3D< T, nDim >
plb::N_VelocityToPassiveAdvDiff3D< T, TemperatureDescriptor >
plb::NaiveExternalForceBGKdynamics< T, Descriptor >Implementation BGK dynamics with a simple, linear external force
plb::NaiveExternalForcePrecondBGKdynamics< T, Descriptor >Implementation BGK dynamics with a simple, linear external force
plb::NativeType< T >
plb::NativeTypeConstructor
plb::NaturalCubicSpline< T >
plb::neqPiD2Q9< T >Compute Pi tensor efficiently on D2Q9 lattice
plb::neqPiD3Q15< T >Compute Pi tensor efficiently on D3Q15 lattice
plb::neqPiD3Q19< T >
plb::neqPiD3Q27< T >
plb::NeumannBoundaryProfile3D< T >
plb::NextNeighbor< T >
plb::NextNeighborPop< T, Descriptor >
plb::NLD_AD_DirichletDynamics3D< T, Descriptor >Dirichlet version of the generic NLD boundary class for advection-diffusion
plb::NLD_AD_NeumannBoundaryDynamics3D< T, Descriptor >Neumann version of the generic NLD boundary class
plb::NLD_OutflowBoundaryDynamics3D< T, Descriptor >NLD boundary class for outflows: fixed density, extrapolate unknown populations
plb::NLD_VelocityBoundaryDynamics3D< T, Descriptor >Dirichlet version of the generic NLD boundary class
plb::NLD_VelocityCornerUtil3D< T, Descriptor >
plb::NLD_VelocityEdgeUtil3D< T, Descriptor >
plb::NLD_VelocityNeumannBoundaryDynamics3D< T, Descriptor >Neumann version of the generic NLD boundary class
plb::NLD_VelocityPlaneUtil3D< T, Descriptor >
plb::NoDynamics< T, Descriptor >Implementation of "dead dynamics" which does nothing
plb::descriptors::NoExternalField
plb::descriptors::NoExternalFieldBase
plb::NonLocalBoundaryDynamics2D< T, Descriptor >
plb::NonLocalBoundaryDynamics3D< T, Descriptor >
plb::NonLocalDynamics2D< T, Descriptor >
plb::NonLocalDynamics3D< T, Descriptor >
plb::NoOptimizationRoundOffPolicy< T >
plb::meta::NoParamDynamicsGenerator< T, Descriptor, NoParamDynamics >
plb::Normalize_Tensor_functional3D< T, nDim >
plb::Normalize_Tensor_inplace_functional3D< T, nDim >
plb::NoScalingEngine< T, Descriptor >Perform no rescaling
plb::noSlipMaximumVolumeFraction3D< T, Descriptor >
plb::NoSlipProfile3D< T >
plb::NTensorField2D< T >
plb::NTensorField3D< T >
plb::NTensorFieldBase2D< T >Interface for the variants of generic-sized 2D vector and tensor fields
plb::NTensorFieldBase3D< T >Interface for the variants of generic-sized 2D vector and tensor fields
plb::NTensorFieldBoxProcessingFunctional2D< T >Easy instantiation of boxed data processor for multiple n-tensorFields
plb::NTensorFieldBoxProcessingFunctional3D< T >Easy instantiation of boxed data processor for multiple n-tensorFields
plb::NTensorFieldDataTransfer2D< T >
plb::NTensorFieldDataTransfer3D< T >
plb::NTensorFieldDotProcessingFunctional2D< T >Easy instantiation of dotted data processor for multiple n-tensorFields
plb::NTensorFieldDotProcessingFunctional3D< T >Easy instantiation of dotted data processor for multiple n-tensorFields
plb::OffBoundary
plb::offEquilibriumAdvectionDiffusionTemplates< T, Descriptor >General first-order functions
plb::offEquilibriumAdvectionDiffusionTemplatesImpl< T, Descriptor >
plb::offEquilibriumTemplates< T, Descriptor >General first-order functions
plb::offEquilibriumTemplatesImpl< T, Descriptor >
plb::OffLatticeBoundaryCondition3D< T, Descriptor, BoundaryType >
plb::OffLatticeCompletionFunctional3D< T, Descriptor, SurfaceData >
plb::OffLatticeModel3D< T, SurfaceData >
plb::OffLatticePatternFunctional3D< T, SurfaceData >
plb::OmegaFromPiDynamics< T, Descriptor >A dynamics for relaxation parameter dependent on off-equilibrium stress, generic with respect to base dynamics
plb::OneCellFunctional2D< T, Descriptor >
plb::OneCellFunctional3D< T, Descriptor >
plb::OneCellIndexedFunctional2D< T, Descriptor >
plb::OneCellIndexedFunctional3D< T, Descriptor >
plb::MarchingCubeSurfaces3D< T >::EdgeOrientedTriangleSetData::OnEdgeTriangle
plb::meta::OneParamDynamicsGenerator< T, Descriptor, OneParamDynamics >
plb::OneToOneThreadAttribution
plb::OnLatticeAdvectionDiffusionBoundaryCondition2D< T, Descriptor >
plb::OnLatticeAdvectionDiffusionBoundaryCondition3D< T, Descriptor >
plb::OnLatticeBoundaryCondition2D< T, Descriptor >
plb::OnLatticeBoundaryCondition3D< T, Descriptor >
plb::OnLinkExternalRhoJcollideAndStream3D< T, Descriptor >
plb::Order2RoundOffPolicy< T >
plb::Order3RoundOffPolicy< T >
plb::OscillatingPoiseuilleProfile3D< T, Descriptor >
plb::OuterVelocityCornerFunctional2D< T, Descriptor, xNormal, yNormal >
plb::OuterVelocityCornerFunctional3D< T, Descriptor, xNormal, yNormal, zNormal >
plb::OuterVelocityEdgeFunctional3D< T, Descriptor, plane, normal1, normal2 >
plb::outletMaximumVolumeFraction3D< T, Descriptor >
plb::Overlap2D
plb::Overlap3D
plb::PackedExternalRhoJcollideAndStream3D< T, Descriptor >
plb::PackedRhoBarJfunctional2D< T, Descriptor >
plb::PackedRhoBarJfunctional3D< T, Descriptor >
plb::Parallel_istream
plb::Parallel_ostream
plb::Parallel_referring_istream
plb::Parallel_referring_ostream
plb::Parallelizer2D
plb::Parallelizer3D
plb::ParallellizeByCubes3DParallelize by making an approximative load balancing
plb::ParallellizeBySquares2DParallelize by making an approximative load balancing
plb::PartiallyDefaultInitializeFreeSurface3D< T, Descriptor >
plb::PeriodicitySwitch2D
plb::PeriodicitySwitch3D
plb::PeriodicOverlap2DThis structure holds both overlap information and orientation of the boundary
plb::PeriodicOverlap3DThis structure holds both overlap information and orientation of the boundary
plb::Piece
plb::PiecewiseFunction
plb::PlainReductiveBoxProcessingFunctional2DReductiveBoxProcessingFunctional2D which instantiates its own statistics object
plb::PlainReductiveBoxProcessingFunctional3DReductiveBoxProcessingFunctional3D which instantiates its own statistics object
plb::PlainReductiveDotProcessingFunctional2DReductiveDotProcessingFunctional2D which instantiates its own statistics object
plb::PlainReductiveDotProcessingFunctional3DReductiveDotProcessingFunctional3D which instantiates its own statistics object
plb::Plane< T >Definition of a 3D unbounded plane
plb::PlaneFdBoundaryFunctional3D< T, Descriptor, direction, orientation >
plb::BoundedBoxProcessingFunctional3D::PlaneWrapperFunctional
plb::BoundedReductiveBoxProcessingFunctional3D::PlaneWrapperFunctional
plb::plb_ifstream
plb::plb_ofstream
plb::global::PlbCounter
plb::PlbException
plb::PlbIOException
plb::global::PlbLogFileA globally accessible log file
plb::PlbLogicException
plb::PlbMemoryException
plb::PlbNetworkException
plb::PlbOutOfRangeException
plb::global::PlbRandom< T >
plb::global::PlbTimerA cumulative timer for benchmarking program parts and summing up the times
plb::PoiseuilleProfile3D< T >
plb::PouringLiquid3D< T, Descriptor >
plb::PowerLawFunction
plb::PowerTwoMultiScaleManager
plb::PrecondBGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics with preconditioning
plb::PreparePopulationsDynamics< T, Descriptor >Base class for composite dynamics which pre-attributes values to distribution functions
plb::meta::ProcessorFactory2D
plb::meta::ProcessorFactory3D
plb::meta::ProcessorRegistration2D
plb::meta::ProcessorRegistration3D
plb::MultiBlock2D::ProcessorStorage2D
plb::MultiBlock3D::ProcessorStorage3D
plb::global::Profiler
plb::interparticlePotential::PsiFunction< T >Interface for the interaction potential ("psi function") for single-component multi-phase Shan/Chen
plb::interparticlePotential::PsiIsRho< T >
plb::interparticlePotential::PsiQian95< T >Qian e.a. 1995:

\[ \Psi = g\rho_0^2\rho^2/(2(\rho_0+\rho)^2) \]

plb::interparticlePotential::PsiShanChen93< T >Shan, Chen 1993: /f[ = (1-(-/)) /f]
plb::interparticlePotential::PsiShanChen94< T >Shan, Chen 1994: /f[ = (-/) /f]
plb::PureDynamics< T >
plb::QuasiIncBGKdynamics< T, Descriptor >Implementation of quasi-incompressible BGK dynamics
plb::RandomRedistribute3D
plb::RayleighBenardFlowParam< T, nsDescriptor, adDescriptor >A useful class for the conversion between dimensionless and lattice units
plb::ReadFromSerialArray< T >
plb::ReAssignTriangleHash< T, ParticleFieldT >
plb::RecomposeFromFlowVariablesFunctional2D< T, Descriptor >
plb::RecomposeFromFlowVariablesFunctional3D< T, Descriptor >
plb::ReductiveBoxProcessingFunctional2DEasy instantiation of reductive boxed data processor (general case)
plb::ReductiveBoxProcessingFunctional2D_L< T, Descriptor >Easy instantiation of boxed data processor for a single lattice
plb::ReductiveBoxProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of boxed data processor for lattice-lattice coupling
plb::ReductiveBoxProcessingFunctional2D_LN< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-NTensorField coupling
plb::ReductiveBoxProcessingFunctional2D_LS< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-ScalarField coupling
plb::ReductiveBoxProcessingFunctional2D_LT< T1, Descriptor, T2, nDim >Easy instantiation of boxed data processor for Lattice-NTensorField coupling
plb::ReductiveBoxProcessingFunctional2D_N< T >Easy instantiation of boxed data processor for a single n-tensor field
plb::ReductiveBoxProcessingFunctional2D_NN< T1, T2 >Easy instantiation of boxed data processor for NTensorField-NTensorField coupling
plb::ReductiveBoxProcessingFunctional2D_S< T >Easy instantiation of boxed data processor for a single scalar field
plb::ReductiveBoxProcessingFunctional2D_SN< T1, T2 >Easy instantiation of boxed data processor for ScalarField-NTensorField coupling
plb::ReductiveBoxProcessingFunctional2D_SS< T1, T2 >Easy instantiation of boxed data processor for ScalarField-ScalarField coupling
plb::ReductiveBoxProcessingFunctional2D_ST< T1, T2, nDim >Easy instantiation of boxed data processor for ScalarField-TensorField coupling
plb::ReductiveBoxProcessingFunctional2D_T< T, nDim >Easy instantiation of boxed data processor for a single tensor field
plb::ReductiveBoxProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 >Easy instantiation of boxed data processor for TensorField-TensorField coupling
plb::ReductiveBoxProcessingFunctional3DEasy instantiation of reductive boxed data processor (general case)
plb::ReductiveBoxProcessingFunctional3D_L< T, Descriptor >Easy instantiation of boxed data processor for a single lattice
plb::ReductiveBoxProcessingFunctional3D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of boxed data processor for lattice-lattice coupling
plb::ReductiveBoxProcessingFunctional3D_LN< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-NTensorField coupling
plb::ReductiveBoxProcessingFunctional3D_LS< T1, Descriptor, T2 >Easy instantiation of boxed data processor for Lattice-ScalarField coupling
plb::ReductiveBoxProcessingFunctional3D_LT< T1, Descriptor, T2, nDim >Easy instantiation of boxed data processor for Lattice-TensorField coupling
plb::ReductiveBoxProcessingFunctional3D_N< T >Easy instantiation of boxed data processor for a single n-tensor field
plb::ReductiveBoxProcessingFunctional3D_NN< T1, T2 >Easy instantiation of boxed data processor for NTensorField-NTensorField coupling
plb::ReductiveBoxProcessingFunctional3D_S< T >Easy instantiation of boxed data processor for a single scalar field
plb::ReductiveBoxProcessingFunctional3D_SN< T1, T2 >Easy instantiation of boxed data processor for ScalarField-NTensorField coupling
plb::ReductiveBoxProcessingFunctional3D_SS< T1, T2 >Easy instantiation of boxed data processor for ScalarField-ScalarField coupling
plb::ReductiveBoxProcessingFunctional3D_ST< T1, T2, nDim >Easy instantiation of boxed data processor for ScalarField-TensorField coupling
plb::ReductiveBoxProcessingFunctional3D_T< T, nDim >Easy instantiation of boxed data processor for a single tensor field
plb::ReductiveBoxProcessingFunctional3D_TT< T1, nDim1, T2, nDim2 >Easy instantiation of boxed data processor for TensorField-TensorField coupling
plb::ReductiveBoxProcessor2DA reductive boxed data processor, automatically generated from a ReductiveBoxProcessingFunctional2D
plb::ReductiveBoxProcessor3DA reductive boxed data processor, automatically generated from a ReductiveBoxProcessingFunctional3D
plb::ReductiveBoxProcessorGenerator2DAn automatically created generator for the ReductiveBoxProcessor2D
plb::ReductiveBoxProcessorGenerator3DAn automatically created generator for the ReductiveBoxProcessor3D
plb::ReductiveDataProcessorGenerator2D
plb::ReductiveDataProcessorGenerator3D
plb::ReductiveDotProcessingFunctional2DEasy instantiation of reductive boxed data processor (general case)
plb::ReductiveDotProcessingFunctional2D_L< T, Descriptor >Easy instantiation of dotted data processor for a single lattice
plb::ReductiveDotProcessingFunctional2D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of dotted data processor for lattice-lattice coupling
plb::ReductiveDotProcessingFunctional2D_LN< T1, Descriptor, T2 >Easy instantiation of dotted data processor for Lattice-NTensorField coupling
plb::ReductiveDotProcessingFunctional2D_LS< T1, Descriptor, T2 >Easy instantiation of dotted data processor for Lattice-ScalarField coupling
plb::ReductiveDotProcessingFunctional2D_LT< T1, Descriptor, T2, nDim >Easy instantiation of dotted data processor for Lattice-TensorField coupling
plb::ReductiveDotProcessingFunctional2D_N< T >Easy instantiation of dotted data processor for a single n-tensor field
plb::ReductiveDotProcessingFunctional2D_NN< T1, T2 >Easy instantiation of dotted data processor for NTensorField-NTensorField coupling
plb::ReductiveDotProcessingFunctional2D_S< T >Easy instantiation of dotted data processor for a single scalar field
plb::ReductiveDotProcessingFunctional2D_SN< T1, T2 >Easy instantiation of dotted data processor for ScalarField-NTensorField coupling
plb::ReductiveDotProcessingFunctional2D_SS< T1, T2 >Easy instantiation of dotted data processor for ScalarField-ScalarField coupling
plb::ReductiveDotProcessingFunctional2D_ST< T1, T2, nDim >Easy instantiation of dotted data processor for ScalarField-TensorField coupling
plb::ReductiveDotProcessingFunctional2D_T< T, nDim >Easy instantiation of dotted data processor for a single tensor field
plb::ReductiveDotProcessingFunctional2D_TT< T1, nDim1, T2, nDim2 >Easy instantiation of dotted data processor for TensorField-TensorField coupling
plb::ReductiveDotProcessingFunctional3DEasy instantiation of reductive boxed data processor (general case)
plb::ReductiveDotProcessingFunctional3D_L< T, Descriptor >Easy instantiation of dotted data processor for a single lattice
plb::ReductiveDotProcessingFunctional3D_LL< T1, Descriptor1, T2, Descriptor2 >Easy instantiation of dotted data processor for lattice-lattice coupling
plb::ReductiveDotProcessingFunctional3D_LN< T1, Descriptor, T2 >Easy instantiation of dotted data processor for Lattice-NTensorField coupling
plb::ReductiveDotProcessingFunctional3D_LS< T1, Descriptor, T2 >Easy instantiation of dotted data processor for Lattice-ScalarField coupling
plb::ReductiveDotProcessingFunctional3D_LT< T1, Descriptor, T2, nDim >Easy instantiation of dotted data processor for Lattice-TensorField coupling
plb::ReductiveDotProcessingFunctional3D_N< T >Easy instantiation of dotted data processor for a single n-tensor field
plb::ReductiveDotProcessingFunctional3D_NN< T1, T2 >Easy instantiation of dotted data processor for NTensorField-NTensorField coupling
plb::ReductiveDotProcessingFunctional3D_S< T >Easy instantiation of dotted data processor for a single scalar field
plb::ReductiveDotProcessingFunctional3D_SN< T1, T2 >Easy instantiation of dotted data processor for ScalarField-NTensorField coupling
plb::ReductiveDotProcessingFunctional3D_SS< T1, T2 >Easy instantiation of dotted data processor for ScalarField-ScalarField coupling
plb::ReductiveDotProcessingFunctional3D_ST< T1, T2, nDim >Easy instantiation of dotted data processor for ScalarField-TensorField coupling
plb::ReductiveDotProcessingFunctional3D_T< T, nDim >Easy instantiation of dotted data processor for a single tensor field
plb::ReductiveDotProcessingFunctional3D_TT< T1, nDim1, T2, nDim2 >Easy instantiation of dotted data processor for TensorField-TensorField coupling
plb::ReductiveDotProcessor2DA ReductiveDotted data processor, automatically generated from a ReductiveDotProcessingFunctional2D
plb::ReductiveDotProcessor3DA ReductiveDotted data processor, automatically generated from a ReductiveDotProcessingFunctional3D
plb::ReductiveDotProcessorGenerator2DAn automatically created generator for the ReductiveDotProcessor2D
plb::ReductiveDotProcessorGenerator3DAn automatically created generator for the ReductiveDotProcessor3D
plb::ReductiveLatticeBoxProcessingFunctional2D< T, Descriptor >Easy instantiation of boxed data processor for multiple lattices
plb::ReductiveLatticeBoxProcessingFunctional3D< T, Descriptor >Easy instantiation of boxed data processor for multiple lattices
plb::ReductiveLatticeDotProcessingFunctional2D< T, Descriptor >Easy instantiation of dotted data processor for multiple lattices
plb::ReductiveLatticeDotProcessingFunctional3D< T, Descriptor >Easy instantiation of dotted data processor for multiple lattices
plb::ReductiveNTensorFieldBoxProcessingFunctional2D< T >Easy instantiation of boxed data processor for multiple n-tensorFields
plb::ReductiveNTensorFieldBoxProcessingFunctional3D< T >Easy instantiation of boxed data processor for multiple n-tensorFields
plb::ReductiveNTensorFieldDotProcessingFunctional2D< T >Easy instantiation of dotted data processor for multiple n-tensorFields
plb::ReductiveNTensorFieldDotProcessingFunctional3D< T >Easy instantiation of dotted data processor for multiple n-tensorFields
plb::ReductiveScalarFieldBoxProcessingFunctional2D< T >Easy instantiation of boxed data processor for multiple scalarFields
plb::ReductiveScalarFieldBoxProcessingFunctional3D< T >Easy instantiation of boxed data processor for multiple scalarFields
plb::ReductiveScalarFieldDotProcessingFunctional2D< T >Easy instantiation of dotted data processor for multiple scalarFields
plb::ReductiveScalarFieldDotProcessingFunctional3D< T >Easy instantiation of dotted data processor for multiple scalarFields
plb::ReductiveTensorFieldBoxProcessingFunctional2D< T, nDim >Easy instantiation of boxed data processor for multiple tensorFields
plb::ReductiveTensorFieldBoxProcessingFunctional3D< T, nDim >Easy instantiation of boxed data processor for multiple tensorFields
plb::ReductiveTensorFieldDotProcessingFunctional2D< T, nDim >Easy instantiation of dotted data processor for multiple tensorFields
plb::ReductiveTensorFieldDotProcessingFunctional3D< T, nDim >Easy instantiation of dotted data processor for multiple tensorFields
plb::RefinementParameters< T >Interface for a wrapper of refinement parameters (each level posseses specific parameters)
plb::RegularizedAdvectionDiffusionBoundaryDynamics< T, Descriptor, direction, orientation >Advection-diffusion dynamics on flat boundaries
plb::RegularizedAdvectionDiffusionBoundaryManager2D< T, Descriptor >
plb::RegularizedBGKCarreauDynamics< T, Descriptor, N >Implementation of O(Ma^2) BGK dynamics with constant average density
plb::RegularizedBGKdynamics< T, Descriptor >Implementation of O(Ma^2) regularized BGK dynamics
plb::RegularizedBoundaryManager2D< T, Descriptor >
plb::RegularizedBoundaryManager3D< T, Descriptor >
plb::RegularizedDensityBoundaryDynamics< T, Descriptor, direction, orientation >Regularized density Dirichlet boundary dynamics for a straight wall
plb::RegularizedVelocityBoundaryDynamics< T, Descriptor, direction, orientation >Regularized velocity boundary dynamics for a straight wall
plb::RegularizedVelocityInnerCornerDynamics2D< T, Descriptor, normalX, normalY >Regularized boundary dynamics for an inner corner
plb::RegularizedVelocityInnerCornerDynamics3D< T, Descriptor, normalX, normalY, normalZ >
plb::RegularizedVelocityInnerEdgeDynamics3D< T, Descriptor, plane, normal1, normal2 >
plb::RemoveMass3D< T, Descriptor >
plb::RescaleEngine< T, Descriptor >A policy for scaling the data between the cells of a coarse and a fine grid
plb::rgb
plb::RhoBarJAccess< T, Descriptor, ExternalField >
plb::RhoBarJAccess< T, Descriptor, descriptors::RhoBarJdescriptor2D >
plb::RhoBarJAccess< T, Descriptor, descriptors::RhoBarJdescriptor3D >
plb::descriptors::RhoBarJD2Q9Descriptor< T >
plb::descriptors::RhoBarJD3Q15Descriptor< T >
plb::descriptors::RhoBarJD3Q19Descriptor< T >
plb::descriptors::RhoBarJD3Q27Descriptor< T >
plb::descriptors::RhoBarJdescriptor2D
plb::descriptors::RhoBarJdescriptor3D
plb::descriptors::RhoBarJdescriptorBase2D
plb::descriptors::RhoBarJdescriptorBase3D
plb::RigidWallProperty3D< T >
plb::RLBdynamics< T, Descriptor >Generic implementation of the Regularized BGK dynamics
plb::parallelIO::SavedFullMultiBlockSerializer2D
plb::parallelIO::SavedFullMultiBlockSerializer3D
plb::Scalar_A_times_Tensor_B_functional3D< T, nDim >
plb::ScalarCopyFineToCoarseZerothOrder2D< T >Copy data from a fine to a coarse ScalarField2D
plb::ScalarCopyFineToCoarseZerothOrder3D< T >Copy data from a fine to a coarse ScalarField3D
plb::ScalarCubicInterpolationXY< T, Descriptor >Bulk interpolation
plb::ScalarCubicInterpolationXYCorner3D< T, Descriptor >The corners
plb::ScalarCubicInterpolationXYLineX3D< T, Descriptor >The edges
plb::ScalarCubicInterpolationXYLineY3D< T, Descriptor >
plb::ScalarCubicInterpolationXZ< T, Descriptor >Bulk interpolation
plb::ScalarCubicInterpolationXZCorner3D< T, Descriptor >The corners
plb::ScalarCubicInterpolationXZLineX3D< T, Descriptor >The edges
plb::ScalarCubicInterpolationXZLineZ3D< T, Descriptor >
plb::ScalarCubicInterpolationYZ< T, Descriptor >Bulk interpolation
plb::ScalarCubicInterpolationYZCorner3D< T, Descriptor >The corners
plb::ScalarCubicInterpolationYZLineY3D< T, Descriptor >The edges
plb::ScalarCubicInterpolationYZLineZ3D< T, Descriptor >
plb::ScalarDirichletProfile3D< T >
plb::ScalarField2D< T >
plb::ScalarField3D< T >
plb::ScalarFieldBase2D< T >Interface for the variants of 2D scalar fields
plb::ScalarFieldBase3D< T >Interface for the variants of 3D scalar fields
plb::ScalarFieldBoxProcessingFunctional2D< T >Easy instantiation of boxed data processor for multiple scalarFields
plb::ScalarFieldBoxProcessingFunctional3D< T >Easy instantiation of boxed data processor for multiple scalarFields
plb::ScalarFieldDataTransfer2D< T >
plb::ScalarFieldDataTransfer3D< T >
plb::ScalarFieldDotProcessingFunctional2D< T >Easy instantiation of dotted data processor for multiple scalarFields
plb::ScalarFieldDotProcessingFunctional3D< T >Easy instantiation of dotted data processor for multiple scalarFields
plb::ScalarFieldIsoSurface3D< T >
plb::ScalarFluxProfile3D< T >
plb::ScalarFunction
plb::ScalarInterpolateCoarseToFine2D< T >Copy data from a coarse to a fine ScalarField2D, using bilinear interpolation
plb::ScalarInterpolateCoarseToFine3D< T >Copy data from a coarse to a fine ScalarField3D, using bilinear interpolation
plb::ScalarIsolationProfile3D< T >Implements the condition grad(rho) = kappa(asymptoticRho-rho)
plb::ScalarNeumannProfile3D< T >
plb::SecuredRegularizedBGKdynamics< T, Descriptor >Implementation of O(Ma^2) regularized BGK dynamics
plb::util::SelectConstInt
plb::util::SelectInt
plb::util::SelectLargerEqualInt
plb::SerialBlockCommunicator2D
plb::SerialBlockCommunicator3D
plb::SerialCellAccess2D< T, Descriptor >
plb::SerialCellAccess3D< T, Descriptor >
plb::SerialCombinedStatistics
plb::SerializedReader
plb::SerializedWriter
plb::SerialNTensorAccess2D< T >
plb::SerialNTensorAccess3D< T >
plb::SerialScalarAccess2D< T >
plb::SerialScalarAccess3D< T >
plb::SerialTensorAccess2D< T, nDim >
plb::SerialTensorAccess3D< T, nDim >
plb::SerialThreadAttribution
plb::SetConstBoundaryDensityFunctional2D< T, Descriptor >
plb::SetConstBoundaryDensityFunctional3D< T, Descriptor >
plb::SetConstBoundaryTemperatureFunctional2D< T, Descriptor >
plb::SetConstBoundaryVelocityFunctional2D< T, Descriptor >
plb::SetConstBoundaryVelocityFunctional3D< T, Descriptor >
plb::SetCustomBoundaryDensityFunctional2D< T, Descriptor, DensityFunction >
plb::SetCustomBoundaryDensityFunctional3D< T, Descriptor, DensityFunction >
plb::SetCustomBoundaryTemperatureFunctional2D< T, Descriptor, TemperatureFunction >
plb::SetCustomBoundaryVelocityFunctional2D< T, Descriptor, VelocityFunction >
plb::SetCustomBoundaryVelocityFunctional3D< T, Descriptor, VelocityFunction >
plb::SetCustomExternalVectorFunctional2D< T, Descriptor, VectorFunction >
plb::SetExternalScalarFromScalarFieldFunctional2D< T, Descriptor >
plb::SetExternalScalarFunctional2D< T, Descriptor >
plb::SetExternalScalarFunctional3D< T, Descriptor >
plb::SetExternalVectorFromTensorFieldFunctional2D< T, Descriptor, nDim >
plb::SetExternalVectorFromTensorFieldFunctional3D< T, Descriptor, nDim >
plb::SetExternalVectorFunctional2D< T, Descriptor >
plb::SetExternalVectorFunctional3D< T, Descriptor >
plb::SetGenericExternalScalarFunctional3D< T, Descriptor, Functional >
plb::SetTensorComponentFunctional2D< T, nDim >
plb::SetTensorComponentFunctional3D< T, nDim >
plb::SetToCoordinateFunctional2D< T >
plb::SetToCoordinateFunctional3D< T >
plb::SetToCoordinatesFunctional2D< T >
plb::SetToCoordinatesFunctional3D< T >
plb::SetToScalarFunctionFunctional2D< T, Function >
plb::SetToScalarFunctionFunctional3D< T, Function >
plb::SetToTensorFunctionFunctional2D< T, nDim, Function >
plb::SetToTensorFunctionFunctional3D< T, nDim, Function >
plb::descriptors::ShanChenD2Q9Descriptor< T >D2Q9 lattice for Shan-Chen model
plb::descriptors::ShanChenD3Q19Descriptor< T >D3Q19 lattice for Shan-Chen model
plb::descriptors::ShanChenExternalBase2D
plb::descriptors::ShanChenExternalBase3D
plb::ShanChenExternalForceBGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics with an external force (Shan/Chen approach)
plb::ShanChenExternalForceRegularizedBGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics with an external force (Guo approach)
plb::ShanChenMultiComponentProcessor2D< T, Descriptor >Shan-Chen coupling for multi-component flow with or without external force
plb::ShanChenMultiComponentProcessor3D< T, Descriptor >Shan-Chen coupling for multi-component flow with or without external force
plb::ShanChenSingleComponentProcessor2D< T, Descriptor >Shan-Chen coupling for single-component flow with or without external force
plb::ShanChenSingleComponentProcessor3D< T, Descriptor >Shan-Chen coupling for single-component flow with or without external force
plb::ShortenBounceBack3D< T, Descriptor >
plb::SmagoOperations< T, Descriptor >
plb::SmagorinskyAdvectionDiffusionRLBdynamics< T, Descriptor >Regularized Advection-Diffusion dynamics with artificial diffusivity as in the Smagorinsky model
plb::SmagorinskyBGKdynamics< T, Descriptor >
plb::SmagorinskyDynamics< T, Descriptor >
plb::SmagorinskyIncBGKdynamics< T, Descriptor >
plb::SmagorinskyRegularizedDynamics< T, Descriptor >
plb::SmartBulk2DCompute envelope and things alike
plb::SmartBulk3DCompute envelope and things alike
plb::Smoothen3D< T >
plb::SmoothenTensor3D< T, nDim >
plb::SparseBlockStructure2D
plb::SparseBlockStructure3D
plb::meta::SpecificMultiBlockGenerator2D< MultiBlockGenT >
plb::meta::SpecificMultiBlockGenerator3D< MultiBlockGenT >
plb::Spline< T >
plb::StaticSmagorinskyFunctional2D< T, Descriptor, SmagoFunction >
plb::StaticSmagorinskyFunctional3D< T, Descriptor, SmagoFunction >
plb::util::Stats
plb::StatSubscriberA polymorphic type to handle subscription to a BlockStatistics class
plb::StatSubscriber2DHandles statistics subscriptions for the BlockLattice2D
plb::StatSubscriber3DHandles statistics subscriptions for the BlockLattice3D
plb::StoreDensityAndVelocityDynamics< T, Descriptor >Density and Velocity are stored inside dynamics
plb::StoreDensityDynamics< T, Descriptor >Value of the density is stored inside Dynamics
plb::StoreDynamicsFunctional2D< T, Descriptor >
plb::StoreDynamicsFunctional3D< T, Descriptor >
plb::StoreDynamicsIDContainer object for StoreDynamicsFunctionalXD
plb::StoreRhoBarJBGKdynamics< T, Descriptor >
plb::StoreTemperatureAndVelocityDynamics< T, Descriptor >Temperature and Velocity are stored inside dynamics
plb::StoreVelocityDynamics< T, Descriptor >Value of the velocity is stored inside dynamics
plb::StraightFdBoundaryFunctional2D< T, Descriptor, direction, orientation >
plb::StripeOffDensityOffsetFunctional2D< T, Descriptor >
plb::StripeOffDensityOffsetFunctional3D< T, Descriptor >
plb::indexTemplates::SubIndex< Descriptor, index, value >
plb::indexTemplates::SubIndexIngoingCorner2D< Descriptor, xNormal, yNormal >Finds the indexes outgoing from a 2D corner
plb::utilAdvDiff::SubIndexOutgoing< Descriptor, direction, orientation >Finds the indexes outgoing from a 2D-3D flat wall (unknowns)
plb::indexTemplates::SubIndexOutgoing< Descriptor, direction, orientation >
plb::utilAdvDiff::SubIndexOutgoing2DonCorners< Descriptor, normalX, normalY >
plb::utilAdvDiff::SubIndexOutgoing3DonCorners< Descriptor, normalX, normalY, normalZ >
plb::utilAdvDiff::SubIndexOutgoing3DonEdges< Descriptor, plane, normal1, normal2 >
plb::indexTemplates::SubIndexOutgoingCorner2D< Descriptor, xNormal, yNormal >Finds the indexes outgoing from a 2D corner
plb::indexTemplates::SubIndexOutgoingExternalCorner3D< Descriptor, xNormal, yNormal, zNormal >Finds the indexes outgoing from a 3D corner
plb::indexTemplates::SubIndexOutgoingExternalEdge3D< Descriptor, plane, normal1, normal2 >Finds the indexes outgoing from a 3D edge
plb::indexTemplates::SubIndexOutgoingInternalCorner2D< Descriptor, xNormal, yNormal >Finds the indexes outgoing from a 2D corner
plb::indexTemplates::SubIndexOutgoingInternalCorner3D< Descriptor, xNormal, yNormal, zNormal >Finds the indexes outgoing from a 3D corner
plb::indexTemplates::SubIndexOutgoingInternalEdge3D< Descriptor, plane, normal1, normal2 >Finds the indexes outgoing from a 3D edge
plb::SurfaceDivision3DFragmentation of the surface of a block into bulk, edges, and corners
plb::SVGWriter2D
plb::SymmetricRankFourTensor< T, Descriptor >Operations on a symmetric tensor which stores only above-or-on-diagonal values
plb::SymmetricRankFourTensorImpl< T, d >
plb::SymmetricRankFourTensorImpl< T, 2 >
plb::SymmetricRankFourTensorImpl< T, 3 >
plb::SymmetricRankThreeTensor< T, Descriptor >Operations on a symmetric tensor which stores only above-or-on-diagonal values
plb::SymmetricRankThreeTensorImpl< T, d >
plb::SymmetricRankThreeTensorImpl< T, 2 >
plb::SymmetricRankThreeTensorImpl< T, 3 >
plb::SymmetricTensor< T, Descriptor >Operations on a symmetric tensor which stores only above-or-on-diagonal values
plb::SymmetricTensorImpl< T, d >
plb::SymmetricTensorImpl< T, 2 >
plb::SymmetricTensorImpl< T, 3 >
plb::descriptors::Tau1_D2Q9Descriptor< T >
plb::descriptors::Tau1_D2Q9DescriptorBase< T >
plb::Tau1CollideAndStream2D< T, Descriptor >
plb::Tensor_A_dividedBy_B_functional2D< T, nDim >
plb::Tensor_A_dividedBy_B_functional3D< T, nDim >
plb::Tensor_A_dividedBy_B_inplace_functional2D< T, nDim >
plb::Tensor_A_dividedBy_B_inplace_functional3D< T, nDim >
plb::Tensor_A_minus_B_functional2D< T, nDim >
plb::Tensor_A_minus_B_functional3D< T, nDim >
plb::Tensor_A_minus_B_inplace_functional2D< T, nDim >
plb::Tensor_A_minus_B_inplace_functional3D< T, nDim >
plb::Tensor_A_plus_B_functional2D< T, nDim >
plb::Tensor_A_plus_B_functional3D< T, nDim >
plb::Tensor_A_plus_B_inplace_functional2D< T, nDim >
plb::Tensor_A_plus_B_inplace_functional3D< T, nDim >
plb::Tensor_A_times_alpha_functional2D< T, nDim >
plb::Tensor_A_times_alpha_functional3D< T, nDim >
plb::Tensor_A_times_alpha_inplace_functional2D< T, nDim >
plb::Tensor_A_times_alpha_inplace_functional3D< T, nDim >
plb::Tensor_A_times_B_functional2D< T, nDim >
plb::Tensor_A_times_B_functional3D< T, nDim >
plb::Tensor_A_times_B_inplace_functional2D< T, nDim >
plb::Tensor_A_times_B_inplace_functional3D< T, nDim >
plb::TensorCopyFineToCoarseZerothOrder2D< T, nDim >Copy data from a fine to a coarse TensorField2D
plb::TensorCopyFineToCoarseZerothOrder3D< T, nDim >Copy data from a fine to a coarse TensorField3D
plb::TensorField2D< T, nDim >
plb::TensorField3D< T, nDim >
plb::TensorFieldBase2D< T, nDim >Interface for the variants of 2D vector and tensor fields
plb::TensorFieldBase3D< T, nDim >Interface for the variants of 3D vector and tensor fields
plb::TensorFieldBoxProcessingFunctional2D< T, nDim >Easy instantiation of boxed data processor for multiple tensorFields
plb::TensorFieldBoxProcessingFunctional3D< T, nDim >Easy instantiation of boxed data processor for multiple tensorFields
plb::TensorFieldDataTransfer2D< T, nDim >
plb::TensorFieldDataTransfer3D< T, nDim >
plb::TensorFieldDotProcessingFunctional2D< T, nDim >Easy instantiation of dotted data processor for multiple tensorFields
plb::TensorFieldDotProcessingFunctional3D< T, nDim >Easy instantiation of dotted data processor for multiple tensorFields
plb::TensorInterpolateCoarseToFine2D< T, nDim >Copy data from a coarse to a fine TensorField2D, using bilinear interpolation
plb::TensorInterpolateCoarseToFine3D< T, nDim >Copy data from a coarse to a fine TensorField3D, using bilinear interpolation
plb::TensorProduct_A_A_functional3D< T, nDim >
plb::TerminalExtrapolateValue3D< T, Descriptor, ValueT >
plb::ThermalBGKdynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics
plb::ThermalBulkDynamics< T, Descriptor >Common base iso-thermal (or athermal) bulk dynamics
plb::ThreadAttribution
plb::TimeCounterA counter for keeping track of discrete time evolution
plb::util::TimeDependentFunction< T, size >
plb::TimeDependentVelocityProfile3D< T, Descriptor >
plb::TimePeriodicSignal< T >
plb::TriangleBoundary3D< T >
plb::TriangleFlowShape3D< T, SurfaceData >
plb::TriangleHash< T >
plb::TriangleHashData
plb::TriangleSet< T >
plb::MarchingCubeSurfaces3D< T >::TriangleSetData
plb::TriangleToDef< T >
plb::TriangularSurfaceMesh< T >
plb::meta::TwoParamDynamicsGenerator< T, Descriptor, TwoParamDynamics >
plb::TypeInfoComparator
plb::UnfilteredCoarseGridInterfaceInstantiator< T, Descriptor >Create a coarse grid interface that performs only a simple copy from the fine grid
plb::UniformlyBoundScalarField3D< T >
plb::util::UniqueId
plb::util::ValueTracer< T >Check time-convergence of a scalar
plb::VariableOmegaDynamics< T, Descriptor >A dynamics for space-dependent relaxation parameter, generic with respect to base dynamics
plb::VectorIsLess
plb::VectorTemplate< T, Descriptor >
plb::VectorTemplateImpl< T, d >
plb::VectorTemplateImpl< T, 2 >
plb::VectorTemplateImpl< T, 3 >
plb::descriptors::Velocity2dDescriptor
plb::descriptors::Velocity2dDescriptorBase
plb::descriptors::Velocity3dBase
plb::descriptors::Velocity3dDescriptor
plb::descriptors::VelocityAndScalar3dBase
plb::descriptors::VelocityAndScalar3dDescriptor
plb::descriptors::VelocityD2Q9Descriptor< T >
plb::descriptors::VelocityD3Q19Descriptor< T >
plb::VelocityDirichletBoundaryDynamics< T, Descriptor, direction, orientation >Velocity Dirichlet boundary dynamics for a straight wall
plb::VelocityFromRhoBarJfunctional3D< T >
plb::VelocityPlugProfile3D< T >
plb::VelocitySingleProbe3D< T, Descriptor >
plb::VelocityToPassiveAdvDiff3D< T, TemperatureDescriptor >
plb::VertexProperty3D< T >
plb::VorticitySingleProbe3D< T, Descriptor >
plb::VoxelizedDomain3D< T >
plb::VoxelizeMeshFunctional3D< T >
plb::VtkDataWriter3D
plb::VtkImageOutput2D< T >
plb::VtkImageOutput3D< T >
plb::VtkStructuredImageOutput2D< T >
plb::VtkStructuredImageOutput3D< T >
plb::VtkStructuredWriter3D
plb::VtkTypeNames< T >
plb::WaveDynamics< T, Descriptor >Implementation of O(Ma^2) BGK dynamics with adjustable speed of sound
plb::WrappedGeneralizedBoundaryManager2D< T, Descriptor >
plb::WrappedGeneralizedBoundaryManager3D< T, Descriptor >
plb::WrappedInamuroBoundaryManager2D< T, Descriptor >
plb::WrappedLocalBoundaryFunctional2D< T, Descriptor >
plb::WrappedLocalBoundaryFunctional3D< T, Descriptor >
plb::WrappedMassConservingGeneralizedBoundaryManager2D< T, Descriptor >
plb::WrappedRegularizedBoundaryManager2D< T, Descriptor >
plb::WrappedRegularizedBoundaryManager3D< T, Descriptor >
plb::WrappedZouHeBoundaryManager2D< T, Descriptor >
plb::WrappedZouHeBoundaryManager3D< T, Descriptor >
plb::WriteToSerialArray< T >
plb::X_ExtrapolateValue3D< T, Descriptor, ValueT >
plb::XMLreader
plb::XMLreaderProxy
plb::XMLwriter
plb::ZouHeBoundaryManager2D< T, Descriptor >
plb::ZouHeBoundaryManager3D< T, Descriptor >
plb::ZouHePressureDynamics< T, Descriptor, direction, orientation >
plb::ZouHeVelocityDynamics< T, Descriptor, direction, orientation >
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines