![]() |
Lethe Open-Source Library version 1.2.0
Developer Guide
|
| NAnalyticalSolutions | Contains all the classes related to the calculation of the analytical solutions for the various physics |
| NBoundaryConditions | |
| Ndealii | |
| NDEM | This 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 | |
| CAdaptiveSparseContacts | Mechanism that disables contacts computation through mobility status of cells based on granular temperature |
| CAuxiliaryPhysics | |
| CAverageScalar | Calculates the time-averaged scalar field |
| CAverageVelocities | Calculates 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 | |
| CBlockNavierStokesAssemblerCore | Class 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_struct | Handle the information related to the boundary cells which will be used for particle-wall contact detection |
| CBoundaryCellsInformation | Finds 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 |
| CBoundaryPostprocessor | BoundaryPostprocessor Post-processor class used to attach the boundary id to the faces when outputting the surfaces within the domain |
| CBruggemanEffectiveMediumModel | Two-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 |
| CBufferRW | Create a temporary vector where mortar evaluation data is stored before being passed to the system matrix |
| CCahnHilliard | |
| CCahnHilliardAssemblerAngleOfContact | Class that assembles the boundary condition on the angle of contact in the Cahn-Hilliard equations |
| CCahnHilliardAssemblerBDF | Class 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}\) |
| CCahnHilliardAssemblerCore | Class 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 \) |
| CCahnHilliardAssemblerFreeAngle | Class that assembles the boundary condition that allows a free angle of contact, thus adding a degree of freedom to the problem |
| CCahnHilliardClipFilter | Calculate 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 |
| CCahnHilliardFilterBase | Filter phase fraction according to the selected filtering method |
| CCahnHilliardFunctionDefined | Class that implements a boundary conditions for the Cahn-Hilliard equation where the phase and chemical potential are defined using individual functions |
| CCahnHilliardNoFilter | Used as a default when no filter is applied to the phase fraction |
| CCahnHilliardScratchData | Class 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 |
| CCahnHilliardTanhFilter | Calculate a filtered phase fraction for Cahn-Hilliard simulations |
| CCarreau | |
| Ccell_comparison | Operator overloading to enable using triangulation cells as map keys |
| Ccell_line_info | Handle information related to the cell-line matching |
| Ccell_point_info | Handle information related to the cell-point matching |
| CCFDDEMMatrixFree | Solver class for coupled Computational Fluid Dynamics and Discrete Element Method (CFD-DEM) simulations using a matrix-free formulation |
| CCFDDEMSimulationParameters | |
| CCFDDEMSolver | Solver class for coupled Computational Fluid Dynamics and Discrete Element Method (CFD-DEM) simulations |
| CCheckpointControl | |
| CCLSAssemblerBDF | Class 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}\) |
| CCLSAssemblerCore | Class 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 |
| CCLSAssemblerDCDDStabilization | Assemble the Discontinuity-Capturing Directional Dissipation (DCDD) stabilization term for the CLS phase indicator |
| CCLSAssemblerDGCore | Class 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 \) |
| CCLSAssemblerSIPG | Assembles 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 |
| CCLSCurvatureProjection | CLS curvature L2 projection solver |
| CCLSLinearSubequationsSolver | Generalized solver for CLS linear subequations |
| CCLSPDEBasedInterfaceReinitialization | CLS PDE-based reinitialization solver |
| CCLSPhaseGradientProjection | CLS phase indicator gradient L2 projection solver |
| CCLSScratchData | Store 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 |
| CCLSSubequationsInterface | Interface for secondary equations (subequations) solved within the CLS auxiliary physics |
| Ccollision_event | Struct storing a full collision event (start and end) |
| Ccollision_log | Struct to store information about a particle-wall collision moment |
| CCompletedCollisionLog | Class that stores all the completed collision events |
| CCompositeShape | This 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 | |
| CConservativeLevelSetFilterBase | Abstract class for filtering phase indicator in Conservative Level Set (CLS) simulations |
| CConservativeLevelSetNoFilter | Default filter applied to phase indicator. The ConservativeLevelSetNoFilter filter does not modify the phase indicator value and returns it as it is |
| CConservativeLevelSetTanhFilter | Filter phase indicator with a hyperbolic tangent function for CLS simulations |
| CConstantElectricConductivity | Constant electric conductivity |
| CConstantElectricPermittivity | Constant electric permittivity |
| CConstantMagneticPermeability | Constant magnetic permeability |
| CConstantSpecificHeat | Constant specific heat model |
| CConstantThermalConductivity | Constant thermal conductivity |
| CConstantThermalExpansion | Constant thermal expansion coefficient |
| CConstantTracerDiffusivity | Constant tracer diffusivity |
| CConstantTracerReactionPrefactor | Constant tracer reaction prefactor |
| CContinuumSolidDynamics | Solid phase of the Euler-Euler model, solved as an auxiliary physics coupled to the VANS fluid dynamics solver |
| CCopyData | Class 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 |
| CCouplingEvaluationBase | Base class for coupling evaluation routines |
| CCouplingEvaluationData | |
| CCouplingOperator | Base class for the Coupling Operator Base |
| CCustomDistribution | |
| Ccut_cell_comparison | |
| Ccut_cell_hash | Hash 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 | |
| CDEMActionManager | Manage the actions to be performed in the DEM solver and on the DEM part of the coupling CFD-DEM solver |
| CDEMContactManager | Manage the numerous of contact detection search operations in the DEM |
| CDEMSolver | Solver using the soft-sphere model of the discrete element method (DEM) to simulate granular systems |
| CDEMSolverParameters | Handles all the parameters declared in the parameter handler file |
| CDensityConstant | Constant density model |
| CDensityIsothermalIdealGas | Isothermal ideal gas density |
| CDensityModel | Abstract class for calculating the density of materials |
| CDensityPostprocessor | Compute the density scalar field of a material within a domain |
| CDistribution | |
| CDivergencePostprocessor | Compute the velocity divergence scalar field within a domain |
| CDPGCopyData | Class 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) |
| CDynamicViscosityPostprocessor | Compute the dynamic viscosity scalar field of a fluid within a domain |
| CEffectiveMediumModel | Effective 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) |
| CElectricConductivityModel | Abstract class that allows to calculate the electric conductivity on each quadrature point |
| CElectricPermittivityModel | Abstract class that allows to calculate the electric permittivity real and imaginary part on each quadrature point |
| CEllipsoid | |
| CEvaporationModel | EvaporationModel. 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 |
| CEvaporationModelConstant | EvaporationModelConstant. Class that allows to calculate the evaporation mass, heat, and momentum fluxes when a constant mass flux is considered |
| CEvaporationModelTemperature | EvaporationModelTemperature. Class that allows to calculate the evaporation mass, heat, and momentum fluxes when a temperature-dependent mass flux is considered |
| CExplicitEulerIntegrator | Implementation 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 |
| CFlowControl | Dynamic flow controller that drives the average velocity of the flow towards a target value |
| CFluidDynamicsBlock | |
| CFluidDynamicsMatrixBased | A solver class for the Navier-Stokes equation using GLS stabilization |
| CFluidDynamicsMatrixFree | A solver for the incompressible Navier-Stokes equations implemented in a matrix-free fashion |
| CFluidDynamicsNitsche | |
| CFluidDynamicsPressureFunctionDefined | This class implements a pressure boundary condition for the Navier-Stokes equations |
| CFluidDynamicsSharp | |
| CFluidDynamicsVANS | Solver class for Volume-Averaged Navier-Stokes (VANS) equations with GLS stabilization |
| CFluidDynamicsVANSMatrixFree | A solver for the Volume-Averaged incompressible Navier-Stokes equations implemented in a matrix-free fashion |
| CFluidDynamicsVelocityFunctionDefined | This class implements a boundary conditions for the fluid dynamics solver where the velocity component are defined using individual functions |
| CGaussianLevelsetTracerDiffusivity | Diffusivity that depends on the Gaussian of the level set |
| CGaussianLevelsetTracerReactionPrefactor | Reaction prefactor that depends on the Gaussian of the level set |
| CGLSIsothermalCompressibleNavierStokesAssemblerBDF | Class 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} \) |
| CGLSIsothermalCompressibleNavierStokesAssemblerCore | Class 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 | |
| CGLSIsothermalCompressibleNavierStokesCLSAssemblerCore | Class 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 |
| CGLSNavierStokesAssemblerBDF | Class 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}\) |
| CGLSNavierStokesAssemblerCore | Class 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 |
| CGLSNavierStokesAssemblerNonNewtonianCore | Class that assembles the core of the Navier-Stokes equation using a Rheological model to predict non-Newtonian behaviors |
| CGLSNavierStokesAssemblerSDIRK | Class that assembles the transient term arising from SDIRK time integration for the Navier Stokes equations. For a given stage |
| CGLSNavierStokesAssemblerSRF | Class 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 |
| CGLSNavierStokesCahnHilliardAssemblerBDF | Class 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} \) |
| CGLSNavierStokesCahnHilliardAssemblerCore | Class 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 |
| CGLSNavierStokesCLSAssemblerBDF | Assembles 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} \) |
| CGLSNavierStokesCLSAssemblerCore | Assembles 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 |
| CGLSNavierStokesCLSAssemblerMarangoni | Assembles the Marangoni effect for the Navier-Stokes equations according to the following equation: |
| CGLSNavierStokesCLSAssemblerNonNewtonianCore | Assembles the core of the Navier-Stokes equation using a Rheological model to predict non-Newtonian behaviors |
| CGLSNavierStokesCLSAssemblerSTF | Assembles the Surface Tension Force (STF) for the Navier-Stokes equations according to the following equation: |
| CGradientPostprocessor | Return the velocity gradient field within a domain |
| CGridBirminghamFluidizedBed | Generates a 3D mesh for the Birmingham fluidized bed geometry |
| CGridCubeMerged | Class that creates a custom geometry that combines an extruded plate with a hole and an inner cylinder to form a cube |
| CGridFicheraOven | Generates a 3D Fichera oven mesh by removing cells from a subdivided hyper-rectangle |
| CGridImpingingJetMixer | Generates a 3D mesh for an impinging-jet mixer geometry |
| CGridMotionBase | Carries out motion of the triangulation, including rotational, translational and rotational-translational motions |
| CGridPeriodicHills | Class 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 |
| CGridPipeAndWaveguide | Generates a 3D mesh of a waveguide embedded in a cylindrical cavity in which a liquid flows |
| CGridUniformChannelWithMeshedCylinder | Generates 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 |
| CGridUniformChannelWithMeshedSquarePrism | Generates 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 |
| CHeatFluxPostprocessor | Compute the local heat flux vector field within a domain |
| CHeatTransfer | Implementation 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 \) |
| CHeatTransferAssemblerBDF | Class that assembles the transient time arising from BDF time integration for the heat transfer solver |
| CHeatTransferAssemblerCLSEvaporation | Class that assembles the evaporation sink for the heat transfer solver at the free surface (air/metal interface) when CLS is enabled |
| CHeatTransferAssemblerCore | Class 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 \) |
| CHeatTransferAssemblerDCDDstabilization | Class 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 |
| CHeatTransferAssemblerFreeSurfaceRadiationCLS | Class 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." |
| CHeatTransferAssemblerLaserExponentialDecay | Class 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., |
| CHeatTransferAssemblerLaserExponentialDecayCLS | Class 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 |
| CHeatTransferAssemblerLaserGaussianHeatFluxCLSInterface | Class 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) |
| CHeatTransferAssemblerLaserUniformHeatFluxCLSInterface | Class 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) |
| CHeatTransferAssemblerMicrowaveHeatingTimeHarmonicMaxwell | Class 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 ) \) |
| CHeatTransferAssemblerRobinBC | Class that assembles the Robin boundary condition for the heat transfer solver |
| CHeatTransferAssemblerViscousDissipation | Class that assembles the viscous dissipation for the heat transfer solver |
| CHeatTransferAssemblerViscousDissipationCLS | Class 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 |
| CHeatTransferScratchData | Class 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 | |
| CIBParticle | Define the behavior of a specific particle for the sharp interface IB solver |
| CIBParticlesDEM | A 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 |
| CIBStencil | Define where the sharp immersed-boundaries are imposed on Eulerian grid |
| CInexactNewtonNonLinearSolverStrategy | Non-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 |
| CInsertion | Base interface for classes that carry out the insertion of particles in the system |
| CInsertionFile | |
| CInsertionList | |
| CInsertionPacked | |
| CInsertionPlane | Insertion 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 | |
| CIntegrator | Base interface for classes that carry out the integration of the velocity and position of particles with inertia |
| CInterfacePropertyModel | Abstract 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 |
| CKinematicViscosityPostprocessor | Compute the kinematic viscosity scalar field of a fluid within a domain |
| CKinsolNewtonNonLinearSolverStrategy | Non-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 |
| CLagrangianLoadBalancing | Manages 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 |
| CLaplaceAssembly | Class 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 |
| CLevelsetGradientPostprocessor | Compute a level set gradient vector field for a given shape within a domain |
| CLevelsetPostprocessor | Compute level set field for a given shape within a domain |
| CLinearSolverStrategy | The linear solver strategy class is used to solve the physics as a linear problem |
| CLogNormalDistribution | |
| CMagneticPermeabilityModel | Abstract class that allows to calculate the magnetic permeability on each quadrature point |
| CMeshController | |
| CMFNavierStokesPreconditionGMG | A geometric multigrid preconditioner implementation for incompressible flow |
| CMFNavierStokesPreconditionGMGBase | A geometric multigrid preconditioner compatible with the matrix-free solver |
| CMFNavierStokesVANSPreconditionGMG | A geometric multigrid preconditioner implementation for incompressible VANS equations |
| CMGTransferMatrixFreeWrapper | |
| CMixerGeometry | Geometry dimensions of the impinging-jet mixer (SI units, metres) |
| CMobilityCahnHilliardModel | Implementation of the computation of the mobility for Cahn-Hilliard equations |
| CMobilityCahnHilliardModelConstant | Constant mobility model |
| CMobilityCahnHilliardModelQuartic | Quartic mobility model |
| CMortarManagerBase | Base class for the mortar manager |
| CMortarManagerCircle | Mortar manager class for circular interface |
| CMortarManagerLinear | Mortar manager class for linear interface |
| CMultiphysicsInterface | |
| CMyDiagonalMatrix | A wrapper class around DiagonalMatrix class from deal.II |
| CNavierStokesBase | |
| CNavierStokesCLSAssemblerEvaporation | Assembles the momentum source due to evaporation for the Navier-Stokes equations |
| CNavierStokesCouplingEvaluationSIPG | |
| CNavierStokesNonNewtonianStabilizedOperator | Implements the matrix-free operator to solve steady/transient non-Newtonian Navier-Stokes equations using stabilization |
| CNavierStokesOperatorBase | A class that serves as base for all the matrix-free Navier-Stokes operators |
| CNavierStokesScratchData | Class 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 |
| CNavierStokesStabilizedOperator | Implements the matrix-free operator to solve steady/transient Navier-Stokes equations using stabilization |
| CNeumannTractionBoundaryCondition | Class 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 | |
| CNewtonNonLinearSolverStrategy | Non-linear solver for non-linear systems of equations which uses a Newton method with \(\alpha\) relaxation to ensure that the residual is monotonically decreasing |
| CNoEffectiveMediumModel | Mixture 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 |
| CNoneTracerReactionPrefactor | Dummy tracer reaction prefactor model |
| CNormalDistribution | |
| COngoingCollisionLog | Class managing the ongoing collisions |
| COpenCascadeShape | |
| COutletBoundaryCondition | Class 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 |
| COutputStructCellVector | Struct 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 |
| COutputStructPostprocessor | Struct 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 |
| COutputStructSolution | Struct 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 |
| COutputStructTableHandler | Struct 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 |
| CPartialSlipDirichletBoundaryCondition | Class 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_comparison | Operator overloading to enable using particle iterators as map keys |
| Cparticle_line_contact_info | Handle information related to the calculation of the particle-line contact forces |
| Cparticle_particle_contact_info | Handle 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_info | Handle information related to the calculation of the particle-point contact forces |
| Cparticle_wall_contact_info | Handle the information related to the calculation of the particle-wall contact forces |
| CParticleFieldQCM | ParticleFieldQCM 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) |
| CParticleFluidAssemblerBase | Interface for all assemblers of particle-fluid interactions in the VANS equations |
| CParticleInteractionOutcomes | Class where the outcomes of particle-particle interactions are stored |
| CParticleParticleContactForce | Execute calculation of particle-particle contact forces including linear, non-linear contact models, and non-linear with cohesive forces |
| CParticleParticleContactForceBase | Base 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 |
| CParticlePointLineForce | Calculate 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 |
| CParticleProjector | Particle 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 |
| CParticlesForceChains | Class 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 |
| CParticlesForceChainsBase | Base 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 |
| CParticleWallContactForce | Execute calculation of particle-wall contacts |
| CParticleWallContactForceBase | Base 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_struct | Handle the information related to the periodic boundary cells which will be used for particle-wall contact detection |
| Cperiodic_particle_particle_contact_info | Derived 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 | |
| CPeriodicHillsPushForward | The 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) |
| CPhaseChangeCarmanKozenyAssembler | Assembler of the non-linear Carman-Kozeny permeability model for simulations with phase change |
| CPhaseChangeCarmanKozenyCLSAssembler | Assembler of the non-linear Carman-Kozeny permeability model for CLS simulations with phase change |
| CPhaseChangeDarcyAssembly | Class 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 |
| CPhaseChangeDarcyCLSAssembler | Assembles 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 | |
| CPhaseChangeSpecificHeat | Phase change specific heat model |
| CPhysicalPropertiesManager | Class 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 |
| CPhysicalPropertyModel | Abstract 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 |
| CPhysicsAssemblerBase | Base class for assembler objects of physics and subequations |
| CPhysicsFaceAssemblerBase | Base class for assembler objects of physics and subequations that require a face assembly. This type of assembler is generally used for DG equations |
| CPhysicsLinearSubequationsSolver | Linear subequations solved inside a physics (or auxiliary physics) that are not part of the main set of equations |
| CPhysicsNonlinearSubequationsSolver | Non-linear subequations solved inside a physics (or auxiliary physics) that are not part of the main set of equations |
| CPhysicsScratchDataBase | Base class for scratch data objects of physics and subequations |
| CPhysicsSolver | Contain 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 |
| CPhysicsSolverStrategy | Base class that works as an interface for all solver strategies (either non-linear or linear) for all systems of equations |
| CPhysicsSubequationsSolverBase | Base 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 | |
| CPolynomialElectricConductivity | Polynomial electric conductivity |
| CPolynomialElectricPermittivity | Polynomial electric permittivity |
| CPolynomialMagneticPermeability | Polynomial magnetic permeability |
| CPostprocessingProbes | |
| CPowerLaw | |
| CPreconditionAdapter | A wrapper class around a preconditioner to be able to handle vector types that are not supported by the preconditioner |
| CPreconditionASM | An Additive Schwarz preconditioner |
| CPreconditionBase | A base class of preconditioners used by the smoother |
| CPressureBoundaryCondition | Class that assembles a Neumann boundary condition. According to the following weak form: (p-mu*grad_u)*n at the boundary |
| CPSPGSUPGNavierStokesAssemblerCore | Class 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 |
| CPVDHandler | Manages 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 |
| CQCriterionPostprocessor | Compute the Q-criterion scalar field within a domain |
| CQMOMFieldFunction | Function of all the QMOM fields, built from the functions of the scalars and from the particle size distribution |
| CQuadraturePointsDataOut | Build 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 |
| CRayTracingSolver | Solver that uses ray tracing to find intersection points between photons and particles |
| CRayTracingSolverParameters | Handles all the parameters declared in the parameter handler file |
| CRBFShape | RBF 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 |
| CRheologicalModel | Abstract class that allows to calculate the non-Newtonian viscosity on each quadrature point and the shear rate magnitude |
| CScalarCouplingEvaluationSIPG | |
| CScalarFunctionPostprocessor | Compute a scalar field for a given function within a domain |
| CSDIRKStageData | |
| CSDIRKTable | Structure representing a Butcher tableau for a SDIRK method |
| CSerialSolid | |
| CShape | A 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 |
| CShearRatePostprocessor | Compute the shear rate scalar field within a domain |
| CSignedDistanceTransformationBase | Abstract class for the transformation of the signed distance to the phase indicator for the CLS solver when geometric redistanciation is used |
| CSignedDistanceTransformationPiecewisePolynomial | Transforms the signed distance to the phase indicator with a piecewise polynomial function (degree 4) |
| CSignedDistanceTransformationTanh | Transforms the signed distance to the phase indicator with a hyperbolic tangent function |
| CSimulationControl | Base class for controlling steady-state and transient simulations in Lethe |
| CSimulationControlAdjointSteady | Simulation control for adjoint steady-state simulations |
| CSimulationControlRayTracing | Simulation control for ray tracing simulations |
| CSimulationControlSteady | Simulation control for steady-state simulations |
| CSimulationControlTransient | Simulation control for transient simulations |
| CSimulationControlTransientDEM | Transient simulation control tailored for the Discrete Element Method (DEM) |
| CSimulationParameters | |
| CSolidBase | |
| CSpecificHeatModel | Abstract class for calculating the specific heat of materials on quadrature points using the temperature of the fluid |
| CSphere | |
| CSRFPostprocessor | Compute the velocity field in the Eulerian frame of reference for simulations carried out in a single rotating frame (SRF) |
| CStabilizedDGMethodsCopyData | Responsible 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 |
| CStabilizedMethodsCopyData | Class 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> |
| CStabilizedMethodsTensorCopyData | Class 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> |
| CStasisConstraintWithTemperature | Struct containing fluid id, temperature and phase indicator range information, and flag containers for DOFs used in temperature-dependent stasis constraints |
| Cstatistics | A simple container for storing basic statistical values |
| CSubSimulationControlDEM | Controls DEM sub iteration logic |
| CSuperquadric | This 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\) |
| CSurfaceTensionConstant | Constant surface tension |
| CSurfaceTensionLinear | Linear surface tension. The surface tension is given by: sigma_0 + dsimga/dT * (T-T_0) |
| CSurfaceTensionModel | Abstract class that allows to calculate the surface tension coefficient |
| CSurfaceTensionPhaseChange | Linear surface tension with phase change. The surface tension is given by: alpha_l*(sigma_0 + dsigma/dT * (T-T_0)) |
| CTanhLevelsetTracerDiffusivity | Diffusivity that depends on the tanh of the level set |
| CTanhLevelsetTracerReactionPrefactor | Tanh level-set-dependent tracer reaction prefactor |
| CThermalBuoyancyAssembly | Class 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 |
| CThermalBuoyancyAssemblyCLS | Assembles 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} = ... \) |
| CThermalConductivityLinear | Implements a linear temperature-dependent thermal conductivity of the form k = A + BT |
| CThermalConductivityModel | Abstract class that allows to calculate the thermal conductivity on each quadrature point using the temperature of the fluid |
| CThermalConductivityPhaseChange | Implements a phase-dependent thermal conductivity |
| CThermalExpansionModel | Abstract class that allows to calculate the thermal expansion coefficient (with unit of inverse temperature) |
| CThermalExpansionPhaseChange | Implements a phase-dependent thermal expansion coefficient |
| CTimeHarmonicMaxwell | |
| CTimeHarmonicMaxwellAssemblerCore | Class 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: |
| CTimeHarmonicMaxwellAssemblerRobinBC | Class 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\): |
| CTimeHarmonicMaxwellAssemblerSkeleton | Class 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) |
| CTimeHarmonicMaxwellElectricFieldDefined | This class implements a boundary condition type for the Time Harmonic Maxwell equation where the electric field components are defined using individual functions |
| CTimeHarmonicMaxwellMagneticFieldDefined | This class implements a boundary condition type for the Time Harmonic Maxwell equation where the magnetic field components are defined using individual functions |
| CTimeHarmonicMaxwellScratchData | Class 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 |
| CTimeSteppingData | Data 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 | |
| CTracerAssemblerBDF | Class 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}\) |
| CTracerAssemblerBoundaryNitsche | Assembles 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 |
| CTracerAssemblerCore | Class 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 |
| CTracerAssemblerDGCore | Class 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 \) |
| CTracerAssemblerReaction | Class 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 \) |
| CTracerAssemblerSIPG | Assembles 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 |
| CTracerDiffusivityModel | Abstract class that allows to calculates the tracer diffusivity |
| CTracerReactionPrefactorModel | Abstract class to calculate the tracer reaction prefactor |
| CTracerScratchData | Class 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 | |
| CVANSAssemblerBDF | Assembler for the transient term arising from BDF time integration for the VANS equations |
| CVANSAssemblerBeetstra | Assembler for the drag force using the Beetstra model |
| CVANSAssemblerBuoyancy | Assembler for the buoyancy force on particles in the VANS equations |
| CVANSAssemblerCoreModelA | Assembler for the core of Model A of the Volume-Averaged Navier-Stokes (VANS) equations |
| CVANSAssemblerCoreModelB | Assembler for the core of Model B of the Volume-Averaged Navier-Stokes (VANS) equations |
| CVANSAssemblerDallavalle | Assembler for the drag force using the Dallavalle model |
| CVANSAssemblerDiFelice | Assembler for the drag force using the Di Felice model |
| CVANSAssemblerFPI | Assembler for the fluid-particle interactions (FPI) in the VANS equations, such as the drag force |
| CVANSAssemblerFPIProjection | Assembler for the fluid-particle interactions (FPI) in the VANS equations when the forces are projected from the particles to the fluid grid |
| CVANSAssemblerGidaspow | Assembler for the drag force using the Gidaspow model |
| CVANSAssemblerKochHill | Assembler for the drag force using the Koch and Hill drag model |
| CVANSAssemblerMagnus | Assembler for the lift force using the Magnus model |
| CVANSAssemblerPressureForce | Assembler for the pressure force on particles |
| CVANSAssemblerRong | Assembler for the drag force using the Rong model |
| CVANSAssemblerSaffmanMei | Assembler for the lift force using the Saffman-Mei model |
| CVANSAssemblerShearForce | Assembler for the shear force on particles |
| CVANSAssemblerViscousTorque | Assembler for the viscous dissipative torque due to particle rotation as defined by Derksen (2004) |
| CVANSAssemblerVorticalTorque | Assembler for the viscous dissipative torque due to fluid vorticity as defined by Derksen (2004) |
| CVANSOperator | Implements the matrix-free operator for the VANS equations |
| CVelocityVerletIntegrator | Implementation 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 |
| CVisualization | Building patches of particle properties for visualization. This function is taken from Aspect and deal.ii and implemented here |
| CVorticityPostprocessor | Compute the vorticity vector field within a domain |
| CWeakDirichletBoundaryCondition | Class 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) |