Lethe Open-Source Library version 1.2.0
Developer Guide
Loading...
Searching...
No Matches
Class List
Here are the classes, structs, unions and interfaces with brief descriptions:
[detail level 1234]
 NAnalyticalSolutionsContains all the classes related to the calculation of the analytical solutions for the various physics
 NBoundaryConditions
 Ndealii
 NDEMThis namespace defines all the data containers and required operations on these containers for the DEM solver. At the moment, only overloaded operators are here, but eventually all the data containers of the DEM solver will be moved here
 NInterfaceTools
 NLetheGridTools
 NParameters
 NSourceTerms
 CAdaptiveSparseContactsMechanism that disables contacts computation through mobility status of cells based on granular temperature
 CAuxiliaryPhysics
 CAverageScalarCalculates the time-averaged scalar field
 CAverageVelocitiesCalculates the time-averaged velocities and pressure \((\langle u \rangle, \langle v \rangle, \langle w \rangle, \langle p \rangle)\) and the independent components of the Reynolds stresses tensor \((\langle u'u' \rangle, \langle v'v' \rangle, \langle w'w' \rangle, \langle u'v' \rangle, \langle v'w' \rangle, \langle w'u' \rangle)\)
 CBlockDiagPreconditioner
 CBlockNavierStokesAssemblerCoreClass that assembles the core of the Navier-Stokes equation. According to the following weak form: \(\mathbf{u} \cdot \nabla \mathbf{u} - \nabla p - \nu \nabla^2 \mathbf{u} =0 \) with a grad-div stabilization
 CBlockNavierStokesAssemblerNonNewtonianCore
 CBlockSchurPreconditioner
 Cboundary_cells_info_structHandle the information related to the boundary cells which will be used for particle-wall contact detection
 CBoundaryCellsInformationFinds all the boundary cells and faces in the triangulation, for each cell the boundary face is specified and the normal vector as well as a point on the boundary face are obtained
 CBoundaryPostprocessorBoundaryPostprocessor Post-processor class used to attach the boundary id to the faces when outputting the surfaces within the domain
 CBruggemanEffectiveMediumModelTwo-phase Bruggeman effective medium approximation for spherical inclusions. With the void fraction \(\epsilon\) (volume fraction of phase 1), the mixture property \(\alpha_\mathrm{eff}\) is the root of \(\epsilon\frac{\alpha_1 - \alpha_\mathrm{eff}}{\alpha_1 + 2\alpha_\mathrm{eff}} + (1-\epsilon)\frac{\alpha_2 - \alpha_\mathrm{eff}}{\alpha_2 + 2\alpha_\mathrm{eff}} = 0\), a quadratic equation. The root with a positive real part and a non-negative imaginary part is kept
 CBufferRWCreate a temporary vector where mortar evaluation data is stored before being passed to the system matrix
 CCahnHilliard
 CCahnHilliardAssemblerAngleOfContactClass that assembles the boundary condition on the angle of contact in the Cahn-Hilliard equations
 CCahnHilliardAssemblerBDFClass that assembles the transient time arising from BDF time integration for the Cahn-Hilliard equations. For example, if a BDF1 scheme is chosen, the following is assembled \(\frac{\mathbf{T}^{t+\Delta t}-\mathbf{T}^{t}}{\Delta t}\)
 CCahnHilliardAssemblerCoreClass that assembles the core of the Cahn-Hilliard equation : \( \frac{d \phi}{dt} + (u \cdot \nabla) \phi - \nabla \cdot (M(\phi)\nabla \eta) = 0 \\ \eta - \frac{\lambda}{\epsilon^2}(\phi^3 - \phi) + \lambda \nabla^2 \phi + \xi \nabla^2 \eta = 0 \)
 CCahnHilliardAssemblerFreeAngleClass that assembles the boundary condition that allows a free angle of contact, thus adding a degree of freedom to the problem
 CCahnHilliardClipFilterCalculate a filtered phase fraction for Cahn-Hilliard simulations. In this case, a simple clamping is performed on the phase fraction parameter for it to remain in the [-1,1] interval
 CCahnHilliardFilterBaseFilter phase fraction according to the selected filtering method
 CCahnHilliardFunctionDefinedClass that implements a boundary conditions for the Cahn-Hilliard equation where the phase and chemical potential are defined using individual functions
 CCahnHilliardNoFilterUsed as a default when no filter is applied to the phase fraction
 CCahnHilliardScratchDataClass that stores the information required by the assembly procedure for the Cahn-Hilliard equations. Consequently, this class calculates the phase field parameter Phi (values, gradients, laplacians), the chemical potential eta (values, gradients, laplacians) and the shape function (values, gradients, laplacians) at all the Gauss points for all degrees of freedom and stores it into arrays. Additionally, the user can request that this class gathers additional fields for physics which are coupled to the Cahn-Hilliard equations, such as the velocity which is required. This class serves as a separation between the evaluation at the Gauss point of the variables of interest and their use in the assembly, which is carried out by the assembler functions. For more information on this design, the reader can consult deal.II step-9 "https://www.dealii.org/current/doxygen/deal.II/step_9.html". In this latter example, the scratch is a struct instead of a templated class because of the simplicity of step-9
 CCahnHilliardTanhFilterCalculate a filtered phase fraction for Cahn-Hilliard simulations
 CCarreau
 Ccell_comparisonOperator overloading to enable using triangulation cells as map keys
 Ccell_line_infoHandle information related to the cell-line matching
 Ccell_point_infoHandle information related to the cell-point matching
 CCFDDEMMatrixFreeSolver class for coupled Computational Fluid Dynamics and Discrete Element Method (CFD-DEM) simulations using a matrix-free formulation
 CCFDDEMSimulationParameters
 CCFDDEMSolverSolver class for coupled Computational Fluid Dynamics and Discrete Element Method (CFD-DEM) simulations
 CCheckpointControl
 CCLSAssemblerBDFClass that assembles the transient time arising from BDF time integration for the CLS equation. For example, if a BDF1 scheme is chosen, the following is assembled \(\frac{\mathbf{T}^{t+\Delta t}-\mathbf{T}^{t}}{\Delta t}\)
 CCLSAssemblerCoreClass that assembles the core of the CLS solver. According to the following weak form: \(\mathbf{u} \cdot T \cdot \nabla T =0 \) with an SUPG stabilization
 CCLSAssemblerDCDDStabilizationAssemble the Discontinuity-Capturing Directional Dissipation (DCDD) stabilization term for the CLS phase indicator
 CCLSAssemblerDGCoreClass that assembles the core (cells) of the CLS equation for DG elements. This class assembles the weak form of: \(\mathbf{u} \cdot \nabla \phi = 0 \)
 CCLSAssemblerSIPGAssembles the symmetric interior penalty Galerkin (SIPG) method (or Nitsche's method) for internal faces. This assembler is only required when solving the CLS equation using a discontinuous Galerkin discretization
 CCLSCurvatureProjectionCLS curvature L2 projection solver
 CCLSLinearSubequationsSolverGeneralized solver for CLS linear subequations
 CCLSPDEBasedInterfaceReinitializationCLS PDE-based reinitialization solver
 CCLSPhaseGradientProjectionCLS phase indicator gradient L2 projection solver
 CCLSScratchDataStore the information required by the assembly procedure for a CLS free surface equation. Consequently, this class calculates the phase values (values, gradients, laplacians) and the shape method (values, gradients, laplacians) at all the gauss points for all degrees of freedom and stores it into arrays. This class serves as a separation between the evaluation at the gauss point of the variables of interest and their use in the assembly, which is carried out by the assembler methods
 CCLSSubequationsInterfaceInterface for secondary equations (subequations) solved within the CLS auxiliary physics
 Ccollision_eventStruct storing a full collision event (start and end)
 Ccollision_logStruct to store information about a particle-wall collision moment
 CCompletedCollisionLogClass that stores all the completed collision events
 CCompositeShapeThis class was designed so that specific composite shapes could be defined through the parameter file. Boolean operations such as union, difference, and intersection are allowed
 CCone
 CConservativeLevelSet
 CConservativeLevelSetFilterBaseAbstract class for filtering phase indicator in Conservative Level Set (CLS) simulations
 CConservativeLevelSetNoFilterDefault filter applied to phase indicator. The ConservativeLevelSetNoFilter filter does not modify the phase indicator value and returns it as it is
 CConservativeLevelSetTanhFilterFilter phase indicator with a hyperbolic tangent function for CLS simulations
 CConstantElectricConductivityConstant electric conductivity
 CConstantElectricPermittivityConstant electric permittivity
 CConstantMagneticPermeabilityConstant magnetic permeability
 CConstantSpecificHeatConstant specific heat model
 CConstantThermalConductivityConstant thermal conductivity
 CConstantThermalExpansionConstant thermal expansion coefficient
 CConstantTracerDiffusivityConstant tracer diffusivity
 CConstantTracerReactionPrefactorConstant tracer reaction prefactor
 CContinuumSolidDynamicsSolid phase of the Euler-Euler model, solved as an auxiliary physics coupled to the VANS fluid dynamics solver
 CCopyDataClass responsible for storing the information calculated using the assembly of regular (meaning non-stabilized) equations. It is also used to initialize, zero (reset) and store the cell_matrix, the cell_rhs and the dof indices associated with the dofs of the cell
 CCouplingEvaluationBaseBase class for coupling evaluation routines
 CCouplingEvaluationData
 CCouplingOperatorBase class for the Coupling Operator Base
 CCustomDistribution
 Ccut_cell_comparison
 Ccut_cell_hashHash functor to enable using cut-cell (embedded triangulation) active cell iterators as keys of an unordered associative container, for example std::unordered_map. Pairs with cut_cell_comparison, which orders the same iterators for ordered associative containers
 CCutHollowSphere
 CCylinder
 CCylindricalHelix
 CCylindricalTube
 CDeathStar
 CDEMActionManagerManage the actions to be performed in the DEM solver and on the DEM part of the coupling CFD-DEM solver
 CDEMContactManagerManage the numerous of contact detection search operations in the DEM
 CDEMSolverSolver using the soft-sphere model of the discrete element method (DEM) to simulate granular systems
 CDEMSolverParametersHandles all the parameters declared in the parameter handler file
 CDensityConstantConstant density model
 CDensityIsothermalIdealGasIsothermal ideal gas density
 CDensityModelAbstract class for calculating the density of materials
 CDensityPostprocessorCompute the density scalar field of a material within a domain
 CDistribution
 CDivergencePostprocessorCompute the velocity divergence scalar field within a domain
 CDPGCopyDataClass responsible for storing the local system of an ultraweak Discontinuous Petrov-Galerkin (DPG) discretization. The assemblers fill the uncondensed local system: the Gram matrix of the test space \(G\), the matrices of the bilinear form in the cell interior \(B\) and on the skeleton \(\hat{B}\), and the load vector \(l\). The solver then condenses this system on the skeleton unknowns using the operators \(M_1 = B^\dagger G^{-1} B\), \(M_2 = B^\dagger G^{-1} \hat{B}\), \(M_3 = \hat{B}^\dagger G^{-1} *\hat{B}\), and the vectors \(M_4 l = B^\dagger G^{-1} l\) and \(M_5 l = *\hat{B}^\dagger G^{-1} l\), and stores either the condensed skeleton system (assembly) or the reconstructed interior solution (interior reconstruction)
 CDynamicViscosityPostprocessorCompute the dynamic viscosity scalar field of a fluid within a domain
 CEffectiveMediumModelEffective medium model for the calculation of a physical property of a mixture of two phases. The mixture and its two phases are defined by a material interaction. The property of each phase is calculated with the physical property models of its material. The mixing is done with complex values to allow for the calculation of complex properties, such as the complex permittivity or permeability. The mixture property depends on the fields on which the models of the phases used by the mixing law depend, and on the fields required by the mixing law itself (e.g., the void fraction)
 CElectricConductivityModelAbstract class that allows to calculate the electric conductivity on each quadrature point
 CElectricPermittivityModelAbstract class that allows to calculate the electric permittivity real and imaginary part on each quadrature point
 CEllipsoid
 CEvaporationModelEvaporationModel. Abstract class that allows to calculate the evaporation mass, heat and momentum fluxes. This model computes all the terms required for the assembly of the governing equations, i.e., Navier-Stokes momentum and energy, when evaporation is considered. The former terms are the momentum flux (i.e., pressure) acting on the evaporative front in the normal direction, the heat flux, acting at the same location as a cooling term, and the fluxes' jacobian, if required
 CEvaporationModelConstantEvaporationModelConstant. Class that allows to calculate the evaporation mass, heat, and momentum fluxes when a constant mass flux is considered
 CEvaporationModelTemperatureEvaporationModelTemperature. Class that allows to calculate the evaporation mass, heat, and momentum fluxes when a temperature-dependent mass flux is considered
 CExplicitEulerIntegratorImplementation of a classical explicit euler scheme for the integration of the particle motion. Note that reinitialization of force and torque is also integrated into integration class
 CFlowControlDynamic flow controller that drives the average velocity of the flow towards a target value
 CFluidDynamicsBlock
 CFluidDynamicsMatrixBasedA solver class for the Navier-Stokes equation using GLS stabilization
 CFluidDynamicsMatrixFreeA solver for the incompressible Navier-Stokes equations implemented in a matrix-free fashion
 CFluidDynamicsNitsche
 CFluidDynamicsPressureFunctionDefinedThis class implements a pressure boundary condition for the Navier-Stokes equations
 CFluidDynamicsSharp
 CFluidDynamicsVANSSolver class for Volume-Averaged Navier-Stokes (VANS) equations with GLS stabilization
 CFluidDynamicsVANSMatrixFreeA solver for the Volume-Averaged incompressible Navier-Stokes equations implemented in a matrix-free fashion
 CFluidDynamicsVelocityFunctionDefinedThis class implements a boundary conditions for the fluid dynamics solver where the velocity component are defined using individual functions
 CGaussianLevelsetTracerDiffusivityDiffusivity that depends on the Gaussian of the level set
 CGaussianLevelsetTracerReactionPrefactorReaction prefactor that depends on the Gaussian of the level set
 CGLSIsothermalCompressibleNavierStokesAssemblerBDFClass that assembles the transient time arising from BDF time integration for the isothermal compressible Navier Stokes equations. For example, if a BDF1 scheme is chosen, the following is assembled \(\frac{(\rho \mathbf{u})^{t+\Delta t}-(\rho \mathbf{u})^{t}}{\Delta t} + \frac{(\psi \mathbf{p})^{t+\Delta t}-(\psi \mathbf{p})^{t}}{\Delta t} \)
 CGLSIsothermalCompressibleNavierStokesAssemblerCoreClass that assembles the core of the isothermal compressible Navier-Stokes equations. According to the following weak form: \(\nabla \cdot (\rho \mathbf{u}) + \rho \mathbf{u} \cdot \nabla \mathbf{u} - \nabla p - \mu \nabla^2 \mathbf{u} = 0\) with a full GLS stabilization including the laplacian of the test function
 CGLSIsothermalCompressibleNavierStokesCLSAssemblerBDF
 CGLSIsothermalCompressibleNavierStokesCLSAssemblerCoreClass that assembles the core of the Navier-Stokes equation with free surface using CLS modeling. According to the following weak form: \(\nabla \cdot (\rho \mathbf{u}) + \rho \mathbf{u} \cdot \nabla \mathbf{u} - \nabla p - \mu \nabla\cdot (\nabla \mathbf{u} + (\nabla \mathbf{u})^T) = 0 \) with a full GLS stabilization
 CGLSNavierStokesAssemblerBDFClass that assembles the transient time arising from BDF time integration for the Navier Stokes equations. For example, if a BDF1 scheme is chosen, the following is assembled \(\frac{\mathbf{u}^{t+\Delta t}-\mathbf{u}^{t}}{\Delta t}\)
 CGLSNavierStokesAssemblerCoreClass that assembles the core of the Navier-Stokes equation. According to the following weak form: \(\mathbf{u} \cdot \nabla \mathbf{u} - \nabla p - \nu \nabla^2 \mathbf{u} =0 \) with a full GLS stabilization including the laplacian of the test function
 CGLSNavierStokesAssemblerNonNewtonianCoreClass that assembles the core of the Navier-Stokes equation using a Rheological model to predict non-Newtonian behaviors
 CGLSNavierStokesAssemblerSDIRKClass that assembles the transient term arising from SDIRK time integration for the Navier Stokes equations. For a given stage
 CGLSNavierStokesAssemblerSRFClass that assembles the coriolis and the centrifugal if a simulation is carried out in a rotating frame of reference according to the following term: \(2\mathbf{\omega} \times \mathbf{u} + \mathbf{\omega}\times (\mathbf{\omega} \times \mathbf{r})\) Where $\mathbf{\omega}$ is the rotation vector of the frame of reference and $\mathbf{r}$ is the position vector (e.g. a vector between a point on the rotation axis and the gauss point) By default, it is assumed that the rotation vector passes through the point (0,0) in 2D or (0,0,0) in 3D
 CGLSNavierStokesCahnHilliardAssemblerBDFClass that assembles the transient time arising from BDF time integration for the Navier-Stokes equation with free surface using Cahn-Hilliard modeling. For example, if a BDF1 scheme is chosen, the following is assembled \(\frac{(\rho \mathbf{u})^{t+\Delta t}-(\rho \mathbf{u})^{t}}{\Delta t} \)
 CGLSNavierStokesCahnHilliardAssemblerCoreClass that assembles the core of the Navier-Stokes equation with free surface using Cahn-Hilliard modeling. According to the following weak form: \( \nabla \cdot \mathbf{u} + \rho \mathbf{u} \cdot \nabla \mathbf{u} + \nabla p - \mu \nabla\cdot (\nabla \mathbf{u} + (\nabla \mathbf{u})^T)=0 \) with an SUPG and PSPG stabilization
 CGLSNavierStokesCLSAssemblerBDFAssembles the transient time arising from BDF time integration for the Navier-Stokes equation with free surface using CLS modeling. For example, if a BDF1 scheme is chosen, the following is assembled \(\frac{(\rho \mathbf{u})^{t+\Delta t}-(\rho \mathbf{u})^{t}}{\Delta t} \)
 CGLSNavierStokesCLSAssemblerCoreAssembles the core of the Navier-Stokes equation with free surface using CLS modeling. According to the following weak form: \( \nabla \cdot \mathbf{u} + \rho \mathbf{u} \cdot \nabla \mathbf{u} + \nabla p - \mu \nabla\cdot (\nabla \mathbf{u} + (\nabla \mathbf{u})^T) = 0 \) with an SUPG and PSPG stabilization
 CGLSNavierStokesCLSAssemblerMarangoniAssembles the Marangoni effect for the Navier-Stokes equations according to the following equation:
 CGLSNavierStokesCLSAssemblerNonNewtonianCoreAssembles the core of the Navier-Stokes equation using a Rheological model to predict non-Newtonian behaviors
 CGLSNavierStokesCLSAssemblerSTFAssembles the Surface Tension Force (STF) for the Navier-Stokes equations according to the following equation:
 CGradientPostprocessorReturn the velocity gradient field within a domain
 CGridBirminghamFluidizedBedGenerates a 3D mesh for the Birmingham fluidized bed geometry
 CGridCubeMergedClass that creates a custom geometry that combines an extruded plate with a hole and an inner cylinder to form a cube
 CGridFicheraOvenGenerates a 3D Fichera oven mesh by removing cells from a subdivided hyper-rectangle
 CGridImpingingJetMixerGenerates a 3D mesh for an impinging-jet mixer geometry
 CGridMotionBaseCarries out motion of the triangulation, including rotational, translational and rotational-translational motions
 CGridPeriodicHillsClass that creates a hyper_rectangle and transforms it to obtain the hill geometry with the hill_geometry function. It also attaches a manifold to the geometry
 CGridPipeAndWaveguideGenerates a 3D mesh of a waveguide embedded in a cylindrical cavity in which a liquid flows
 CGridUniformChannelWithMeshedCylinderGenerates a rectangular channel mesh with a meshed cylinder obstacle. By default, this geometry defines two material IDs. The obstacle is assigned the material_id = 1 and the remaining domain is assigned material_id = 0. The obstacle can be optionally removed by setting mesh_obstacle to false, in which case the entire domain is assigned material_id = 0
 CGridUniformChannelWithMeshedSquarePrismGenerates a rectangular channel mesh with a meshed square obstacle in 2D (extruded to a square prism in 3D). By default, this geometry defines two material IDs. The obstacle is assigned the material_id = 1 and the remaining domain is assigned material_id = 0
 CHeatFluxPostprocessorCompute the local heat flux vector field within a domain
 CHeatTransferImplementation of heat transfer as an auxiliary physics. The heat equation is weakly coupled to the velocity field. Equation solved: \( \rho C_p \cdot \left( \frac{dT}{dt} + u \cdot \nabla T \right) = k \cdot \nabla^2 T + \tau : \nabla u \)
 CHeatTransferAssemblerBDFClass that assembles the transient time arising from BDF time integration for the heat transfer solver
 CHeatTransferAssemblerCLSEvaporationClass that assembles the evaporation sink for the heat transfer solver at the free surface (air/metal interface) when CLS is enabled
 CHeatTransferAssemblerCoreClass that assembles the core of the heat transfer equation. This class assembles the weak form of: \( - k * \nabla^2 T + \rho * cp * \mathbf{u} * \nabla T - f - \tau : \nabla \mathbf{u} =0 \)
 CHeatTransferAssemblerDCDDstabilizationClass that assembles the Discontinuity-Capturing Directional Dissipation stabilization term for the heat transfer solver. For more information see Tezduyar, T. E. (2003). Computation of moving boundaries and interfaces and stabilization parameters. International Journal for Numerical Methods in Fluids, 43(5), 555-575. The implementation is based on equations (70) and (79), which are adapted for the heat transfer solver
 CHeatTransferAssemblerFreeSurfaceRadiationCLSClass that assembles the radiation sink for the heat transfer solver at the free surface (air/metal interface) when CLS and the laser are active. The phase gradient of the CLS solver is used to transform radiative boundary condition at free surface into a volumetric sink at the air/metal interface: "Tao Yu, Jidong Zhao,Semi-coupled resolved CFD–DEM simulation of powder-based selective laser melting for additive manufacturing, Computer Methods in Applied Mechanics and Engineering, Volume 377, 2021, 113707, ISSN 0045-7825, https://doi.org/10.1016/j.cma.2021.113707."
 CHeatTransferAssemblerLaserExponentialDecayClass that assembles the laser heating as a volumetric source for the heat transfer solver. Exponentially decaying model is used to simulate the laser heat source: "Liu, S., Zhu, H., Peng, G., Yin, J. and Zeng, X.,
 CHeatTransferAssemblerLaserExponentialDecayCLSClass that assembles the laser heating as a volumetric source for the heat transfer solver when CLS is enabled. Exponentially decaying model is used to simulate the laser heat source: "Liu, S., Zhu, H., Peng, G., Yin, J. and Zeng, X., 2018. Microstructure prediction of selective laser melting AlSi10Mg using finite element analysis. Materials & Design, 142, pp.319-328." The laser heat source is only applied in the metal (when phase value is non-null) using the phase value alpha as a multiplying factor on the laser heat source
 CHeatTransferAssemblerLaserGaussianHeatFluxCLSInterfaceClass that assembles the laser heating as a surface flux for the heat transfer solver when CLS is enabled. The laser heat flux is applied at the CLS interface (where the phase gradient is non-null)
 CHeatTransferAssemblerLaserUniformHeatFluxCLSInterfaceClass that assembles the laser heating as a uniform surface flux for the heat transfer solver when CLS is enabled. The laser heat flux is applied at the CLS interface (where the phase gradient is non-null)
 CHeatTransferAssemblerMicrowaveHeatingTimeHarmonicMaxwellClass that assembles the time average electromagnetic heating for the heat transfer solver when the time-harmonic Maxwell solver is enabled. The electromagnetic heating is applied as a volumetric source term in the heat equation, and is calculated as \( Q = 1/2(\sigma |E|^2 + \omega \varepsilon_0 \varepsilon_i |E|^2 + \omega \mu_0 \mu_i |H|^2 ) \)
 CHeatTransferAssemblerRobinBCClass that assembles the Robin boundary condition for the heat transfer solver
 CHeatTransferAssemblerViscousDissipationClass that assembles the viscous dissipation for the heat transfer solver
 CHeatTransferAssemblerViscousDissipationCLSClass that assembles the viscous dissipation for the heat transfer solver, for the specific case of CLS simulations. The only difference compared to the regular one is that the viscous dissipation can be applied in one of the fluids rather than both, through the viscous_dissipative_fluid parameter
 CHeatTransferScratchDataClass that stores the information required by the assembly procedure for a heat transfer advection-diffusion equation. Consequently, this class calculates the heat transfer (values, gradients, laplacians) and the shape function (values, gradients, laplacians) at all the gauss points for all degrees of freedom and stores it into arrays. Additionally, the user can request that this class gathers additional fields for physics which are coupled to the heat transfer equation, such as the velocity which is required. This class serves as a separation between the evaluation at the gauss point of the variables of interest and their use in the assembly, which is carried out by the assembler methods. For more information on this design, the reader can consult deal.II step-9 "https://www.dealii.org/current/doxygen/deal.II/step_9.html". In this latter example, the scratch is a struct instead of a templated class because of the simplicity of step-9
 CHyperRectangle
 CIBParticleDefine the behavior of a specific particle for the sharp interface IB solver
 CIBParticlesDEMA solver class for the DEM used in conjunction with IB particles and fluid_dynamics_sharp. This class defines and uses some functions of the DEM class that have been modified and simplified to be compatible with IB_particles
 CIBStencilDefine where the sharp immersed-boundaries are imposed on Eulerian grid
 CInexactNewtonNonLinearSolverStrategyNon-linear solver for non-linear systems of equations which uses an inexact Newton method with \(\alpha\) relaxation to ensure that the residual is monotonically decreasing. It allows to reuse the matrix and avoid its reassembly for every Newton step
 CInsertionBase interface for classes that carry out the insertion of particles in the system
 CInsertionFile
 CInsertionList
 CInsertionPacked
 CInsertionPlaneInsertion of particles using cells cut by a plane. Particle insertion using cells cut by a plane. Locally owned cells that are cut by the plane are flagged. From those flagged cells, we insert a particle at their centroids if they are individually empty (contain no particle). This way, no significant overlap is occurring on the insertion of new particle which can occur with other insertion method
 CInsertionVolume
 CIntegratorBase interface for classes that carry out the integration of the velocity and position of particles with inertia
 CInterfacePropertyModelAbstract class that defines the interface for a interface property model. Interface property model provides an abstract interface to calculate the value of an interface property or a vector of interface property value for given field value. By default, the interface does not require that all (or any) fields be specified. This is why a map is used to pass the dependent variable. To allow for the calculation of the appropriate jacobian matrix (when that is necessary) the interface also provides a jacobian function, which must provide the derivative with respect to the field specified as an argument
 CKinematicViscosityPostprocessorCompute the kinematic viscosity scalar field of a fluid within a domain
 CKinsolNewtonNonLinearSolverStrategyNon-linear Newton solver for non-linear systems of equations implemented in the SUNDIALS suite, specifically the KINSOL package. This solver has internal algorithms to determine the time step and decide whether to reassemble the Jacobian matrix or not
 CLagrangianLoadBalancingManages the load balancing (repartitioning), of the domain according to the computational load of the cells and the particles. It is used by the DEM and the coupling CFD-DEM solvers
 CLaplaceAssemblyClass that assembles a Poisson problem for all velocity components and pressure variables. According to the following weak form: d^2 U/dx^2=0 and d^2 P/dx^2=0
 CLevelsetGradientPostprocessorCompute a level set gradient vector field for a given shape within a domain
 CLevelsetPostprocessorCompute level set field for a given shape within a domain
 CLinearSolverStrategyThe linear solver strategy class is used to solve the physics as a linear problem
 CLogNormalDistribution
 CMagneticPermeabilityModelAbstract class that allows to calculate the magnetic permeability on each quadrature point
 CMeshController
 CMFNavierStokesPreconditionGMGA geometric multigrid preconditioner implementation for incompressible flow
 CMFNavierStokesPreconditionGMGBaseA geometric multigrid preconditioner compatible with the matrix-free solver
 CMFNavierStokesVANSPreconditionGMGA geometric multigrid preconditioner implementation for incompressible VANS equations
 CMGTransferMatrixFreeWrapper
 CMixerGeometryGeometry dimensions of the impinging-jet mixer (SI units, metres)
 CMobilityCahnHilliardModelImplementation of the computation of the mobility for Cahn-Hilliard equations
 CMobilityCahnHilliardModelConstantConstant mobility model
 CMobilityCahnHilliardModelQuarticQuartic mobility model
 CMortarManagerBaseBase class for the mortar manager
 CMortarManagerCircleMortar manager class for circular interface
 CMortarManagerLinearMortar manager class for linear interface
 CMultiphysicsInterface
 CMyDiagonalMatrixA wrapper class around DiagonalMatrix class from deal.II
 CNavierStokesBase
 CNavierStokesCLSAssemblerEvaporationAssembles the momentum source due to evaporation for the Navier-Stokes equations
 CNavierStokesCouplingEvaluationSIPG
 CNavierStokesNonNewtonianStabilizedOperatorImplements the matrix-free operator to solve steady/transient non-Newtonian Navier-Stokes equations using stabilization
 CNavierStokesOperatorBaseA class that serves as base for all the matrix-free Navier-Stokes operators
 CNavierStokesScratchDataClass that stores the information required by the assembly procedure for a Navier-Stokes equation. Consequently, this class calculates the velocity (values, gradients, laplacians) and the shape function (values, gradients, laplacians) at all the gauss points for all degrees of freedom and stores it into arrays. Additionally, the use can request that this class gathers additional fields for physics which are coupled to the Navier-Stokes equation, such as the CLS. This class serves as a separation between the evaluation at the gauss point of the variables of interest and their use in the assembly, which is carried out by the assembler functions. For more information on this design, the reader can consult deal.II step-9 "https://www.dealii.org/current/doxygen/deal.II/step_9.html". In this latter example, the scratch is a struct instead of a templated class because of the simplicity of step-9
 CNavierStokesStabilizedOperatorImplements the matrix-free operator to solve steady/transient Navier-Stokes equations using stabilization
 CNeumannTractionBoundaryConditionClass that assembles a Neumann traction boundary condition. According to the following weak form: \((p-\mu\nabla \mathbf{u})\cdot \mathbf{n}\) at the boundary
 CNewtonian
 CNewtonNonLinearSolverStrategyNon-linear solver for non-linear systems of equations which uses a Newton method with \(\alpha\) relaxation to ensure that the residual is monotonically decreasing
 CNoEffectiveMediumModelMixture without effective medium model: the mixture property is the property of phase 1. It is used when one of the phases has no impact on the mixture property
 CNoneTracerReactionPrefactorDummy tracer reaction prefactor model
 CNormalDistribution
 COngoingCollisionLogClass managing the ongoing collisions
 COpenCascadeShape
 COutletBoundaryConditionClass that assembles the weak formulation of an outlet boundary condition according to the following equation: (nu grad(u) * grad(v) + pI - (beta * u)_ * n. See the paper by Arndt, Braack and Lube https://www.mathsim.eu/~darndt/files/ENUMATH_2015.pdf
 COutputStructCellVectorStruct containing information about the solution output. It is used to pass all the information required upon calling add_data_vector() for the DataOut instance without losing track of its attributes such as name and data component interpretation. This version of the struct uses a cell-based field parsed as a Vector and the solution name
 COutputStructPostprocessorStruct containing information about the solution output. It is used to pass the information required upon calling add_data_vector() for the DataOut instance without losing track of its attributes such as name and data component interpretation. This version of the struct uses Postprocessors
 COutputStructSolutionStruct containing information about the solution output. It is used to pass all the information required upon calling add_data_vector() for the DataOut instance without losing track of its attributes such as name and data component interpretation. This version of the struct uses the DoF handler, the present solution field, and the data component interpretation vector
 COutputStructTableHandlerStruct containing information about the table handlers to be written/read. It is used to pass a vector of references to TableHandler objects that should be serialized/deserialized at the writing/reading of a checkpoint by the solver used, and a vector of references to strings containing the names of the corresponding files
 CPartialSlipDirichletBoundaryConditionClass that assembles the special case of partial slip condition using the weak formulation of a Dirichlet boundary condition using the Nitsche method. According to the following weak form: beta n(nu-nv) + mu/boundary_layer_thickness t(tu-tv)
 Cparticle_comparisonOperator overloading to enable using particle iterators as map keys
 Cparticle_line_contact_infoHandle information related to the calculation of the particle-line contact forces
 Cparticle_particle_contact_infoHandle the information related to the calculation of the particle-particle contact force. Notably it is responsible for storing information that has to be preserved over multiple iterations of a contact, namely everything related to tangential displacements
 Cparticle_point_contact_infoHandle information related to the calculation of the particle-point contact forces
 Cparticle_wall_contact_infoHandle the information related to the calculation of the particle-wall contact forces
 CParticleFieldQCMParticleFieldQCM calculator. This class stores the required information for the calculation of a field or a particle-fluid interaction onto a mesh. This class does not solve any equation, but compartmentalize the necessary information for the projection of the particle field or interaction onto a mesh. Multiple instances of this function can be called to establish new projections.In the case of a particle-fluid interaction, there is no particle field to project and, consequently, the property_start_index parameter is given an invalid default value (-1)
 CParticleFluidAssemblerBaseInterface for all assemblers of particle-fluid interactions in the VANS equations
 CParticleInteractionOutcomesClass where the outcomes of particle-particle interactions are stored
 CParticleParticleContactForceExecute calculation of particle-particle contact forces including linear, non-linear contact models, and non-linear with cohesive forces
 CParticleParticleContactForceBaseBase class for the particle-particle contact force models This class does not implement any of the models but ensures that an interface without template specialization is available. All the actual implementations of the models are carried out in the ParticleParticleContactForce class, which is templated by the contact model type
 CParticlePointLineForceCalculate the non-linear particle-point and particle-line contact force using the information obtained from the fine search and physical properties of particles and walls. Since the inputs and the calculation method of particle-point and particle-line contact forces are similar, we only used one function for both tasks
 CParticleProjectorParticle information projection. This class manages the calculation of the projection of the particle fields onto a triangulation. Its main use is the calculation of the void fraction which is used as an auxiliary field for the solvers that solve the Volume-Averaged Navier-Stokes equations. The present architecture of the class support all of the different void fraction calculation methods within a single class instead of building a class hierarchy. This is because there are only a few void fraction calculation strategies
 CParticlesForceChainsClass that carries out the calculation of particle-particle contact force and the visualization of force chains by writing vtu files, pvtu files and a pvd file. Instead of using an inheritance hierarchy to distinguish between the contact model, the class is templated with the type of force model and rolling friction model. Consequently, the code for each combination of force model is generated at compile time
 CParticlesForceChainsBaseBase class for the particles force chains contact force models. This class does not implement any of the models, but ensures that an interface without template specialization is available. Every model implementation are carried out in the ParticlesForceChains class which is templated by the contact model type
 CParticleWallContactForceExecute calculation of particle-wall contacts
 CParticleWallContactForceBaseBase class for the particle-wall contact force models This class does not implement any of the models, but ensures that an interface without template specialization is available. All the actual implementation of the models are carried out in the ParticleWallContactForce class which is templated by the contact model type
 Cperiodic_boundaries_cells_info_structHandle the information related to the periodic boundary cells which will be used for particle-wall contact detection
 Cperiodic_particle_particle_contact_infoDerived struct of the base struct particle_particle_contact_info for periodic particle-particle contacts. Adds a translation vector that brings particle_two into contact with particle_one
 CPeriodicBoundariesManipulator
 CPeriodicHillsPullBack
 CPeriodicHillsPushForwardThe push_forward & the pull_back classes create the vector_value functions gradient function and because it inherits from Function<spacedim>. (formula is currently Euler and can be changed. See AutoDerivativeFunction documentation)
 CPhaseChangeCarmanKozenyAssemblerAssembler of the non-linear Carman-Kozeny permeability model for simulations with phase change
 CPhaseChangeCarmanKozenyCLSAssemblerAssembler of the non-linear Carman-Kozeny permeability model for CLS simulations with phase change
 CPhaseChangeDarcyAssemblyClass that assembles a phase change Darcy forcing term. This term adds \(-\beta_D \mathbf{u} \) to the right hand-side of the Navier-Stokes equations to prohibit the motion of a material. In the phase change model, the value of the \( \beta_D \) coefficient depends on the temperature field. Generally, this is used to prohibit fluid motion in the solid phase within phase change problem. This generally leads to a better conditioning of the linear system than increasing the viscosity of the solid phase
 CPhaseChangeDarcyCLSAssemblerAssembles a phase change Darcy forcing term for a CLS two-fluid simulation. The term \(-\phi \beta_D \mathbf{u} \) is added to the right hand-side of the Navier-Stokes equations to prohibit the motion of a material. In the phase change model, the value of the \( \beta_D \) coefficient depends on the temperature field and the material (fluid) properties. Generally, this is used to impose the stasis in the solid phase. This generally leads to a better conditioning of the linear system than increasing the viscosity of the solid phase
 CPhaseChangeRheology
 CPhaseChangeSpecificHeatPhase change specific heat model
 CPhysicalPropertiesManagerClass that manages the physical properties model which are required to calculate the various physical properties This centralizes the place where the models are created. The class can be constructed empty and initialized from parameters or it can be constructed directly with a Parameters section. The architecture of the PhysicalPropertiesManager is made to ensure that it can store as many physical properties models as required. It first stores the physical properties of the fluids, which are always assumed to lie in material_id=0, and then stores the physical properties of the solid, which may be in cells for which material_id>0
 CPhysicalPropertyModelAbstract class that defines the interface for a physical property model Physical property model provides an abstract interface to calculate the value of a physical property or a vector of physical property value for given field value. By default, the interface does not require that all (or any) fields be specified. This is why a map is used to pass the dependent variable. To allow for the calculation of the appropriate jacobian matrix (when that is necessary) the interface also provides a jacobian function, which must provide the derivative with respect to the field specified as an argument
 CPhysicsAssemblerBaseBase class for assembler objects of physics and subequations
 CPhysicsFaceAssemblerBaseBase class for assembler objects of physics and subequations that require a face assembly. This type of assembler is generally used for DG equations
 CPhysicsLinearSubequationsSolverLinear subequations solved inside a physics (or auxiliary physics) that are not part of the main set of equations
 CPhysicsNonlinearSubequationsSolverNon-linear subequations solved inside a physics (or auxiliary physics) that are not part of the main set of equations
 CPhysicsScratchDataBaseBase class for scratch data objects of physics and subequations
 CPhysicsSolverContain all the common elements of a physics solver. It creates the non-linear solver as specified by the user using the parameters file and provides all the necessary elements needed by the solver to solve a physics problem
 CPhysicsSolverStrategyBase class that works as an interface for all solver strategies (either non-linear or linear) for all systems of equations
 CPhysicsSubequationsSolverBaseBase class to solve subequations solved inside a physics (or auxiliary physics) that are not part of the main equations set. It contains all the common elements of a subequation solver
 CPlane
 CPolynomialElectricConductivityPolynomial electric conductivity
 CPolynomialElectricPermittivityPolynomial electric permittivity
 CPolynomialMagneticPermeabilityPolynomial magnetic permeability
 CPostprocessingProbes
 CPowerLaw
 CPreconditionAdapterA wrapper class around a preconditioner to be able to handle vector types that are not supported by the preconditioner
 CPreconditionASMAn Additive Schwarz preconditioner
 CPreconditionBaseA base class of preconditioners used by the smoother
 CPressureBoundaryConditionClass that assembles a Neumann boundary condition. According to the following weak form: (p-mu*grad_u)*n at the boundary
 CPSPGSUPGNavierStokesAssemblerCoreClass that assembles the core of the Navier-Stokes equation. According to the following weak form: \(\mathbf{u} \cdot \nabla \mathbf{u} - \nabla p - \nu \nabla^2 \mathbf{u} =0 \) with an SUPG and PSPG stabilization
 CPVDHandlerManages the storage of the information required to write pvd file. It is particularly necessary for simulations which must be restarted from checkpoint since it manages the continuity of the pvd output
 CQCriterionPostprocessorCompute the Q-criterion scalar field within a domain
 CQMOMFieldFunctionFunction of all the QMOM fields, built from the functions of the scalars and from the particle size distribution
 CQuadraturePointsDataOutBuild point patches located at quadrature points for visualization, for example to display the QCM filter spheres centered at each quadrature point. Each quadrature point stores its filter radius, filter diameter and the global active index of the cell it belongs to
 CRayTracingSolverSolver that uses ray tracing to find intersection points between photons and particles
 CRayTracingSolverParametersHandles all the parameters declared in the parameter handler file
 CRBFShapeRBF Shapes express the signed distance function as a linear combination of Radial Basis Functions (RBF), which have a defined support radius and basis function. A collection of nodes and weights compose the object. Outside of the domain covered by the nodes, the distance is computed by using the distance to a bounding box instead
 CRheologicalModelAbstract class that allows to calculate the non-Newtonian viscosity on each quadrature point and the shear rate magnitude
 CScalarCouplingEvaluationSIPG
 CScalarFunctionPostprocessorCompute a scalar field for a given function within a domain
 CSDIRKStageData
 CSDIRKTableStructure representing a Butcher tableau for a SDIRK method
 CSerialSolid
 CShapeA base class used to represent geometrical entities. Its main uses are to return signed distance and its gradient. It inherits AutoDerivativeFunction so that it can evaluate gradients even when they are not implemented analytically
 CShearRatePostprocessorCompute the shear rate scalar field within a domain
 CSignedDistanceTransformationBaseAbstract class for the transformation of the signed distance to the phase indicator for the CLS solver when geometric redistanciation is used
 CSignedDistanceTransformationPiecewisePolynomialTransforms the signed distance to the phase indicator with a piecewise polynomial function (degree 4)
 CSignedDistanceTransformationTanhTransforms the signed distance to the phase indicator with a hyperbolic tangent function
 CSimulationControlBase class for controlling steady-state and transient simulations in Lethe
 CSimulationControlAdjointSteadySimulation control for adjoint steady-state simulations
 CSimulationControlRayTracingSimulation control for ray tracing simulations
 CSimulationControlSteadySimulation control for steady-state simulations
 CSimulationControlTransientSimulation control for transient simulations
 CSimulationControlTransientDEMTransient simulation control tailored for the Discrete Element Method (DEM)
 CSimulationParameters
 CSolidBase
 CSpecificHeatModelAbstract class for calculating the specific heat of materials on quadrature points using the temperature of the fluid
 CSphere
 CSRFPostprocessorCompute the velocity field in the Eulerian frame of reference for simulations carried out in a single rotating frame (SRF)
 CStabilizedDGMethodsCopyDataResponsible for storing the information calculated using the discontinuous galerkin (DG) assembly of stabilized scalar equations. Like the StabilizedCopyData class, this class is used to initialize, zero (reset) and store the cell_matrix and the cell_rhs while having support for stabilized terms. However, it also has to support the storage of information at internal faces. This is required for the DG methods
 CStabilizedMethodsCopyDataClass responsible for storing the information calculated using the assembly of stabilized scalar equations. Like the CopyData class, this class is used to initialize, zero (reset) and store the cell_matrix and the cell_rhs. Contrary to the regular CopyData class, this class also stores the strong_residual and the strong_jacobian of the equation being assembled. This is useful for equations that implement residual-based stabilization such as SUPG. This class is specialized for single component equations because the strong jacobian is stored using a Vector<double>
 CStabilizedMethodsTensorCopyDataClass responsible for storing the information calculated using the assembly of stabilized Tensor<1,dim> equations. Like the CopyData class, this class is used to initialize, zero (reset) and store the cell_matrix and the cell_rhs. Contrary to the regular CopyData class, this class also stores the strong_residual and the strong_jacobian of the equation being assembled. This is useful for equations that implement residual-based stabilization such as SUPG. This class is specialized for Tensor<1,dim> equations because the strong jacobian is stored using a Tensor<1,dim>
 CStasisConstraintWithTemperatureStruct containing fluid id, temperature and phase indicator range information, and flag containers for DOFs used in temperature-dependent stasis constraints
 CstatisticsA simple container for storing basic statistical values
 CSubSimulationControlDEMControls DEM sub iteration logic
 CSuperquadricThis class defines superquadric shapes. Their signed distance function is: \(\left|\frac{x}{a}\right|^r + \left|\frac{y}{b}\right|^s + \left|\frac{z}{c}\right|^t - 1 = 0\)
 CSurfaceTensionConstantConstant surface tension
 CSurfaceTensionLinearLinear surface tension. The surface tension is given by: sigma_0 + dsimga/dT * (T-T_0)
 CSurfaceTensionModelAbstract class that allows to calculate the surface tension coefficient
 CSurfaceTensionPhaseChangeLinear surface tension with phase change. The surface tension is given by: alpha_l*(sigma_0 + dsigma/dT * (T-T_0))
 CTanhLevelsetTracerDiffusivityDiffusivity that depends on the tanh of the level set
 CTanhLevelsetTracerReactionPrefactorTanh level-set-dependent tracer reaction prefactor
 CThermalBuoyancyAssemblyClass that assembles a thermal buoyancy forcing term using the Boussinesq approximation. For more information, read Chapter 10 of Transport phenomena by Bird et al., or "Boussinesq approximation (buoyancy)" page on Wikipedia
 CThermalBuoyancyAssemblyCLSAssembles the thermal buoyancy source term for CLS simulations. This assembler includes density explicitly in the buoyancy term since the CLS momentum equation is written as: \( \rho \frac{\partial \mathbf{u}}{\partial t} + \rho \mathbf{u} \cdot \nabla \mathbf{u} = ... \)
 CThermalConductivityLinearImplements a linear temperature-dependent thermal conductivity of the form k = A + BT
 CThermalConductivityModelAbstract class that allows to calculate the thermal conductivity on each quadrature point using the temperature of the fluid
 CThermalConductivityPhaseChangeImplements a phase-dependent thermal conductivity
 CThermalExpansionModelAbstract class that allows to calculate the thermal expansion coefficient (with unit of inverse temperature)
 CThermalExpansionPhaseChangeImplements a phase-dependent thermal expansion coefficient
 CTimeHarmonicMaxwell
 CTimeHarmonicMaxwellAssemblerCoreClass that assembles the cell terms of the ultraweak DPG formulation of the time-harmonic Maxwell equations. With the test functions \(\mathbf{F}\) (electric) and \(\mathbf{I}\) (magnetic), it assembles:
 CTimeHarmonicMaxwellAssemblerRobinBCClass that assembles the Robin boundary conditions of the time-harmonic Maxwell equations (silver_muller, impedance_boundary and waveguide_port). On these faces, the magnetic trace is expressed from the electric trace with the surface admittance \(Y\) and the excitation \(\mathbf{g}\), which gives the terms \(-\langle Y \hat{\mathbf{E}}, \mathbf{F} \rangle\) in \(\hat{B}\) and \(-\langle \mathbf{g}, \mathbf{F} \rangle\) in \(l\), where only the tangential component of \(\mathbf{g}\) is used since the left-hand side of the Robin boundary condition is tangential. Since the energy norm that is minimized is also modified on these faces, it also assembles the boundary terms of the Gram matrix \(G\):
 CTimeHarmonicMaxwellAssemblerSkeletonClass that assembles the skeleton terms of the ultraweak DPG formulation of the time-harmonic Maxwell equations. On every face, it assembles \(\langle \mathbf{n} \times \hat{\mathbf{E}}, \mathbf{I} \rangle\) in the matrix \(\hat{B}\) and, except on the faces where a Robin boundary condition is applied, it assembles \(\langle \mathbf{n} \times \hat{\mathbf{H}}, \mathbf{F} \rangle\). On Robin faces, the latter term is replaced by the Robin boundary condition (see TimeHarmonicMaxwellAssemblerRobinBC)
 CTimeHarmonicMaxwellElectricFieldDefinedThis class implements a boundary condition type for the Time Harmonic Maxwell equation where the electric field components are defined using individual functions
 CTimeHarmonicMaxwellMagneticFieldDefinedThis class implements a boundary condition type for the Time Harmonic Maxwell equation where the magnetic field components are defined using individual functions
 CTimeHarmonicMaxwellScratchDataClass that stores the information required by the assembly of the Discontinuous Petrov-Galerkin (DPG) ultraweak formulation of the time-harmonic Maxwell equations. For each cell, it evaluates the base functions of the test space ( \(\mathbf{F}\) and \(\mathbf{I}\)) with their curls, the base functions of the interior trial space ( \(\mathbf{E}\) and \(\mathbf{H}\)) and the effective material properties at the quadrature points. Additionally, for each face of the cell, it evaluates the base functions of the tangential traces of the test space and the base functions of the skeleton trial space ( \(\hat{\mathbf{E}}\) and \(\hat{\mathbf{H}}\)), with their cross products with the normal. Since the Nedelec base functions whose degrees of freedom are not located on a face have a zero tangential trace on this face, only the base functions associated with the face are evaluated
 CTimeSteppingDataData structure to store time-stepping data in the matrix-free operator. This is a very small structure that is used to simplify the operator process instead of relying on function calls to the SimulationControl object. It should not be used outside of the operator
 CTorus
 CTracer
 CTracerAssemblerBDFClass that assembles the transient time arising from BDF time integration for the Tracer equations. For example, if a BDF1 scheme is chosen, the following is assembled \(\frac{\mathbf{T}^{t+\Delta t}-\mathbf{T}^{t}}{\Delta t}\)
 CTracerAssemblerBoundaryNitscheAssembles Nitsche's method for boundary faces. This assembler is only required when solving the Tracer equation using a discontinuous Galerkin discretization since the boundary conditions have to be weakly imposed
 CTracerAssemblerCoreClass that assembles the core of the Tracer equation. This class assembles the weak form of: \(\mathbf{u} \cdot \nabla T - D \nabla^2T = S \) with an SUPG stabilization
 CTracerAssemblerDGCoreClass that assembles the core (cells) of the Tracer equation for DG elements. This class assembles the weak form of: \(\mathbf{u} \cdot \nabla T - D \nabla^2T =S \)
 CTracerAssemblerReactionClass that assembles the reaction source term of the Tracer equation. It assembles the term: \( S = - R \= - k C \) Where C is the tracer concentration and k is a reaction rate prefactor that changes depending on the underlying model. For power law of base rate $\alpha$ and order $n$, the model is: \( S = - R \= - (\alpha C^(n-1)) C \)
 CTracerAssemblerSIPGAssembles the symmetric interior penalty (SIPG) method (or Nitsche's method) for internal faces. This assembler is only required when solving the Tracer equation using a discontinuous Galerkin discretization
 CTracerDiffusivityModelAbstract class that allows to calculates the tracer diffusivity
 CTracerReactionPrefactorModelAbstract class to calculate the tracer reaction prefactor
 CTracerScratchDataClass that stores the information required by the assembly procedure for a Tracer advection-diffusion equation. Consequently, this class calculates the tracer (values, gradients, laplacians) and the shape function (values, gradients, laplacians) at all the gauss points for all degrees of freedom and stores it into arrays. Additionnaly, the use can request that this class gathers additional fields for physics which are coupled to the Tracer equation, such as the velocity which is required. This class serves as a seperation between the evaluation at the gauss point of the variables of interest and their use in the assembly, which is carried out by the assembler functions. For more information on this design, the reader can consult deal.II step-9 "https://www.dealii.org/current/doxygen/deal.II/step_9.html". In this latter example, the scratch is a struct instead of a templated class because of the simplicity of step-9
 CUniformDistribution
 CVANSAssemblerBDFAssembler for the transient term arising from BDF time integration for the VANS equations
 CVANSAssemblerBeetstraAssembler for the drag force using the Beetstra model
 CVANSAssemblerBuoyancyAssembler for the buoyancy force on particles in the VANS equations
 CVANSAssemblerCoreModelAAssembler for the core of Model A of the Volume-Averaged Navier-Stokes (VANS) equations
 CVANSAssemblerCoreModelBAssembler for the core of Model B of the Volume-Averaged Navier-Stokes (VANS) equations
 CVANSAssemblerDallavalleAssembler for the drag force using the Dallavalle model
 CVANSAssemblerDiFeliceAssembler for the drag force using the Di Felice model
 CVANSAssemblerFPIAssembler for the fluid-particle interactions (FPI) in the VANS equations, such as the drag force
 CVANSAssemblerFPIProjectionAssembler for the fluid-particle interactions (FPI) in the VANS equations when the forces are projected from the particles to the fluid grid
 CVANSAssemblerGidaspowAssembler for the drag force using the Gidaspow model
 CVANSAssemblerKochHillAssembler for the drag force using the Koch and Hill drag model
 CVANSAssemblerMagnusAssembler for the lift force using the Magnus model
 CVANSAssemblerPressureForceAssembler for the pressure force on particles
 CVANSAssemblerRongAssembler for the drag force using the Rong model
 CVANSAssemblerSaffmanMeiAssembler for the lift force using the Saffman-Mei model
 CVANSAssemblerShearForceAssembler for the shear force on particles
 CVANSAssemblerViscousTorqueAssembler for the viscous dissipative torque due to particle rotation as defined by Derksen (2004)
 CVANSAssemblerVorticalTorqueAssembler for the viscous dissipative torque due to fluid vorticity as defined by Derksen (2004)
 CVANSOperatorImplements the matrix-free operator for the VANS equations
 CVelocityVerletIntegratorImplementation of a classical velocity verlet scheme for the integration of the particle motion. Note that reinitialization of force and torque is also integrated into integration class
 CVisualizationBuilding patches of particle properties for visualization. This function is taken from Aspect and deal.ii and implemented here
 CVorticityPostprocessorCompute the vorticity vector field within a domain
 CWeakDirichletBoundaryConditionClass that assembles the weak formulation of a Dirichlet boundary condition using the Nitsche method. According to the following weak form: (u_ib-u)-(u,grad v)