| CAdaptiveSparseContacts< dim, PropertiesIndex > | Mechanism that disables contacts computation through mobility status of cells based on granular temperature |
| CDEM::dem_data_structures< dim >::adjacent_particle_pairs_value | |
| CParameters::ALE< dim > | An interface for all the common parameters required to consider a moving frame of reference in a simplified Arbitrary Lagrangian Eulerian (ALE) module |
| CAnalyticalSolutions::AnalyticalSolution< dim > | Implements analytical solutions for the Navier-Stokes equations and the other physics supported by lethe |
| CAutoDerivativeFunction | |
| CPeriodicHillsPullBack< dim, spacedim > | |
| CPeriodicHillsPushForward< dim, spacedim > | 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) |
| CShape< dim > | 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 |
| CCompositeShape< dim > | 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< dim > | |
| CCutHollowSphere< dim > | |
| CCylinder< dim > | |
| CCylindricalHelix< dim > | |
| CCylindricalTube< dim > | |
| CDeathStar< dim > | |
| CEllipsoid< dim > | |
| CHyperRectangle< dim > | |
| COpenCascadeShape< dim > | |
| CPlane< dim > | |
| CRBFShape< dim > | 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 |
| CSphere< dim > | |
| CSuperquadric< dim > | 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\) |
| CTorus< dim > | |
| CAverageScalar< dim > | Calculates the time-averaged scalar field |
| CAverageVelocities< dim, VectorType, DofsType > | 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)\) |
| Cbase_type | |
| CRayTracingSolver< dim >::neighbor_list_types::ghost | |
| CRayTracingSolver< dim >::neighbor_list_types::local | |
| CParameters::Lagrangian::BCDEM | Boundary conditions for DEM simulations |
| Cboundary_cells_info_struct< dim > | Handle the information related to the boundary cells which will be used for particle-wall contact detection |
| CIBParticlesDEM< dim >::BoundaryCellsInfo | |
| CBoundaryCellsInformation< dim > | 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 |
| CBoundaryConditions::BoundaryConditions< BoundaryType > | This class is the base class for all boundary conditions. It stores the general information that all boundary condition share. In Lethe, boundary conditions are identified with an id, a type and, in the special case of periodic boundary condition, a periodic matching id (periodic_id) and a periodic direction (0, 1 or 2) |
| CBoundaryConditions::BoundaryConditions< CahnHilliardBoundaryType > | |
| CBoundaryConditions::CahnHilliardBoundaryConditions< dim > | This class manages the boundary conditions for the Cahn-Hilliard solver It introduces the boundary functions and declares the boundary conditions coherently |
| CBoundaryConditions::BoundaryConditions< CLSBoundaryType > | |
| CBoundaryConditions::CLSBoundaryConditions< dim > | This class manages the boundary conditions for CLS solver It introduces the boundary functions and declares the boundary conditions coherently |
| CBoundaryConditions::BoundaryConditions< FluidDynamicsBoundaryType > | |
| CBoundaryConditions::FluidDynamicsBoundaryConditions< dim > | This class manages the boundary conditions forhe fluid dynamics solver It introduces the boundary functions and declares the boundary conditions coherently |
| CBoundaryConditions::BoundaryConditions< HeatTransferBoundaryType > | |
| CBoundaryConditions::HeatTransferBoundaryConditions< dim > | This class manages the boundary conditions for Heat-Transfer solver It introduces the boundary functions and declares the boundary conditions coherently. The members "value", "h" and "Tinf" contain double used for bc calculation: |
| CBoundaryConditions::BoundaryConditions< QMOMBoundaryType > | |
| CBoundaryConditions::QMOMBoundaryConditions< dim > | Boundary conditions of the QMOM physics. They apply to the advective flux of all the QMOM fields (scalars and moments), which is meant to be computed with an upwind numerical flux: |
| CBoundaryConditions::BoundaryConditions< TimeHarmonicMaxwellBoundaryType > | |
| CBoundaryConditions::TimeHarmonicMaxwellBoundaryConditions< dim > | This class manages the boundary conditions for Time Harmonic Maxwell solver. It introduces the boundary functions and declares the boundary conditions coherently |
| CBoundaryConditions::BoundaryConditions< TracerBoundaryType > | |
| CBoundaryConditions::TracerBoundaryConditions< dim > | This class manages the boundary conditions for Tracer solver It introduces the boundary functions and declares the boundary conditions coherently |
| CBufferRW< T > | Create a temporary vector where mortar evaluation data is stored before being passed to the system matrix |
| CParameters::CahnHilliard | |
| CParameters::CahnHilliard_PhaseFilter | CahnHilliard_PhaseFilter - Defines the parameters for the phase filtration of CahnHilliard physics |
| CBoundaryConditions::CahnHilliardBoundaryFunctions< dim > | This class manages the functions associated with function-type boundary conditions of the Cahn-Hilliard equations |
| CCahnHilliardFilterBase | Filter phase fraction according to the selected filtering method |
| 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 |
| CCahnHilliardNoFilter | Used as a default when no filter is applied to the phase fraction |
| CCahnHilliardTanhFilter | Calculate a filtered phase fraction for Cahn-Hilliard simulations |
| CParameters::CarreauParameters | Carreau model to solve for non-Newtonian flows |
| Ccell_comparison< dim > | Operator overloading to enable using triangulation cells as map keys |
| Ccell_line_info< dim > | Handle information related to the cell-line matching |
| Ccell_point_info< dim > | Handle information related to the cell-point matching |
| CParameters::CFDDEM | Parameters for the CFD-DEM coupled solver |
| CCFDDEMSimulationParameters< dim > | |
| CCheckpointControl | |
| CParameters::CLS | CLS - Defines the parameters for free surface simulations using the CLS method. Has to be declared before member creation in Multiphysics structure |
| CParameters::CLS_GeometricInterfaceReinitialization | Parameters for geometric reinitialization of the interface used with the CLS solver |
| CParameters::CLS_InterfaceSharpening | CLS_InterfaceSharpening - Defines the parameters for interface sharpening in the CLS solver |
| CParameters::CLS_PDEBasedInterfaceReinitialization | Parameters for PDE-based reinitialization of the interface used with the CLS solver |
| CParameters::CLS_PhaseFilter | Parameters for the phase filtration |
| CParameters::CLS_ReinitializationMethod | Parameters for interface reinitialization methods used within the CLS solver. It stores the parameters for the three available methods (projection-, PDE-, and geometric based reinitialization) |
| CParameters::CLS_SurfaceTensionForce | Parameters for the calculation of surface tension force in the CLS solver |
| CCLSSubequationsInterface< dim > | Interface for secondary equations (subequations) solved within the CLS auxiliary physics |
| Ccollision_event< dim > | Struct storing a full collision event (start and end) |
| Ccollision_log< dim > | Struct to store information about a particle-wall collision moment |
| CCompletedCollisionLog< dim > | Class that stores all the completed collision events |
| 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 |
| CParameters::ConstrainSolidDomain< dim > | Set of parameters constraining a certain portion of a fluid domain to null velocity and pressure fields to mimic a solid subdomain |
| CIBParticlesDEM< dim >::ContactInfo | Struct that contains history of the contact between two objects. This is the commonly used constructor since it houses all the information required to perform the contact calculation |
| 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 |
| CStabilizedDGMethodsCopyData::CopyDataFace | |
| CCouplingEvaluationBase< dim, Number > | Base class for coupling evaluation routines |
| CNavierStokesCouplingEvaluationSIPG< dim, Number > | |
| CScalarCouplingEvaluationSIPG< dim, n_components, Number > | |
| CCouplingEvaluationData< dim, Number > | |
| CCouplingOperator< dim, Number > | Base class for the Coupling Operator Base |
| Ccut_cell_comparison< dim > | |
| Ccut_cell_hash< dim > | 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 |
| Cdealii::DataOutInterface | |
| CFluidDynamicsSharp< dim >::Visualization_IB | Defines a struct with methods that allow the generation of a visualisation of the IB_particles. This is equivalent to the corresponding class in the DEM solver |
| CInterfaceTools::InterfaceReconstructionDataOut< dim > | Interface to build the patches of the interface reconstruction vertices for visualization. It reproduce the same structure as particle visualization |
| CQuadraturePointsDataOut< dim > | 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 |
| CVisualization< dim, PropertiesIndex > | Building patches of particle properties for visualization. This function is taken from Aspect and deal.ii and implemented here |
| CDataPostprocessorScalar | |
| CBoundaryPostprocessor< dim > | BoundaryPostprocessor Post-processor class used to attach the boundary id to the faces when outputting the surfaces within the domain |
| CDensityPostprocessor< dim > | Compute the density scalar field of a material within a domain |
| CDivergencePostprocessor< dim > | Compute the velocity divergence scalar field within a domain |
| CDynamicViscosityPostprocessor< dim > | Compute the dynamic viscosity scalar field of a fluid within a domain |
| CKinematicViscosityPostprocessor< dim > | Compute the kinematic viscosity scalar field of a fluid within a domain |
| CLevelsetPostprocessor< dim > | Compute level set field for a given shape within a domain |
| CQCriterionPostprocessor< dim > | Compute the Q-criterion scalar field within a domain |
| CScalarFunctionPostprocessor< dim > | Compute a scalar field for a given function within a domain |
| CShearRatePostprocessor< dim > | Compute the shear rate scalar field within a domain |
| CDataPostprocessorTensor | |
| CGradientPostprocessor< dim > | Return the velocity gradient field within a domain |
| CDataPostprocessorVector | |
| CHeatFluxPostprocessor< dim > | Compute the local heat flux vector field within a domain |
| CLevelsetGradientPostprocessor< dim > | Compute a level set gradient vector field for a given shape within a domain |
| CSRFPostprocessor< dim > | Compute the velocity field in the Eulerian frame of reference for simulations carried out in a single rotating frame (SRF) |
| CVorticityPostprocessor< dim > | Compute the vorticity vector field within a domain |
| CIBParticlesDEM< dim >::DefaultDBL_MAX | |
| CDEM::dem_data_structures< dim > | DEM data structure containers To improve readability of containers, there's a simple description above all declarations which follow these representation : <> : map or unordered map or unordered multimap () : tuple or pair [] : vector |
| CDEMActionManager | Manage the actions to be performed in the DEM solver and on the DEM part of the coupling CFD-DEM solver |
| CDEMContactManager< dim, PropertiesIndex > | Manage the numerous of contact detection search operations in the DEM |
| CParameters::DEMSolidObjects< dim > | Container class managing rigid solid objects for DEM simulations |
| CDEMSolver< dim, PropertiesIndex > | Solver using the soft-sphere model of the discrete element method (DEM) to simulate granular systems |
| CDEMSolverParameters< dim > | Handles all the parameters declared in the parameter handler file |
| CParameters::Dimensionality | Class used to rescale physical properties for cases where the main dimensions of the problems (Length, Mass, Time and Temperature) are not expressed in SI, but are expressed in another set of units. For example, this can be used to carry out a simulation where the mesh is expressed in millimeters instead of meters. This class is currently only used to rescale the physical properties in the FEM-based physics (e.g. all of those that are solvers). Support for DEM, CFD-DEM and rescaling of boundary conditions is planned in the midterm |
| CDistribution | |
| CCustomDistribution | |
| CLogNormalDistribution | |
| CNormalDistribution | |
| CUniformDistribution | |
| 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) |
| CParameters::DynamicFlowControl | FlowControl - Set average velocity on a boundary (CFD) or the domain (CFD-DEM) |
| CEnableObserverPointer | |
| CNavierStokesOperatorBase< dim, MGNumber > | |
| CPreconditionBase< MGVectorType > | |
| CBlockDiagPreconditioner< PreconditionerMp > | |
| CBlockSchurPreconditioner< BSPreconditioner > | |
| CNavierStokesOperatorBase< dim, number > | A class that serves as base for all the matrix-free Navier-Stokes operators |
| CNavierStokesNonNewtonianStabilizedOperator< dim, number > | Implements the matrix-free operator to solve steady/transient non-Newtonian Navier-Stokes equations using stabilization |
| CNavierStokesStabilizedOperator< dim, number > | Implements the matrix-free operator to solve steady/transient Navier-Stokes equations using stabilization |
| CVANSOperator< dim, number > | Implements the matrix-free operator for the VANS equations |
| CPreconditionBase< VectorType > | A base class of preconditioners used by the smoother |
| CMyDiagonalMatrix< VectorType > | A wrapper class around DiagonalMatrix class from deal.II |
| CPreconditionASM< VectorType > | An Additive Schwarz preconditioner |
| CPreconditionAdapter< VectorType, VectorTypePrecondition > | A wrapper class around a preconditioner to be able to handle vector types that are not supported by the preconditioner |
| CLetheGridTools::equal_cell< dim > | A functor that provides a way to check if two cells are the same cell. Used to store cells in hash sets |
| CParameters::Evaporation | Evaporation - Defines the subparameters for the evaporation cooling and recoil pressure at the free surface (air/metal interface) |
| 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 |
| CParameters::FEM | FEM - The finite element section controls the properties of the finite element method. This section controls the interpolation degree of polynomial integration and the number of quadrature points within the cells |
| CParameters::Lagrangian::FloatingGrid< dim > | Parameters for a floating grid in DEM simulations |
| CParameters::Lagrangian::FloatingWalls< dim > | Parameters for floating walls in DEM simulations |
| CFlowControl< dim > | Dynamic flow controller that drives the average velocity of the flow towards a target value |
| CParameters::Forces | Forces - Defines the parameters for the force calculation on boundaries of the domain |
| CParameters::Lagrangian::ForceTorqueOnWall< dim > | ForceTorqueOnWall - Defines the parameters for the force and torques calculation on boundaries of the domain |
| CFunction | |
| CCahnHilliardFunctionDefined< dim > | Class that implements a boundary conditions for the Cahn-Hilliard equation where the phase and chemical potential are defined using individual functions |
| CFluidDynamicsPressureFunctionDefined< dim > | This class implements a pressure boundary condition for the Navier-Stokes equations |
| CFluidDynamicsVelocityFunctionDefined< dim > | This class implements a boundary conditions for the fluid dynamics solver where the velocity component are defined using individual functions |
| CInterfaceTools::CellWiseFunction< dim, VectorType, FEType > | Scalar function defined by the DOF values of a single cell. Based on the CellWiseFunction and RefSpaceFEFieldFunction of dealii |
| CQMOMFieldFunction< dim > | Function of all the QMOM fields, built from the functions of the scalars and from the particle size distribution |
| CTimeHarmonicMaxwellElectricFieldDefined< dim > | This class implements a boundary condition type for the Time Harmonic Maxwell equation where the electric field components are defined using individual functions |
| CTimeHarmonicMaxwellMagneticFieldDefined< dim > | This class implements a boundary condition type for the Time Harmonic Maxwell equation where the magnetic field components are defined using individual functions |
| CGridBirminghamFluidizedBed< dim, spacedim > | Generates a 3D mesh for the Birmingham fluidized bed geometry |
| CGridCubeMerged< dim, spacedim > | Class that creates a custom geometry that combines an extruded plate with a hole and an inner cylinder to form a cube |
| CGridFicheraOven< dim, spacedim > | Generates a 3D Fichera oven mesh by removing cells from a subdivided hyper-rectangle |
| CGridImpingingJetMixer< dim, spacedim > | Generates a 3D mesh for an impinging-jet mixer geometry |
| CParameters::Lagrangian::GridMotion< dim > | Parameters for grid (mesh) motion in DEM simulations |
| CGridMotionBase< dim, spacedim > | Carries out motion of the triangulation, including rotational, translational and rotational-translational motions |
| CGridPeriodicHills< dim, spacedim > | 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< dim, spacedim > | Generates a 3D mesh of a waveguide embedded in a cylindrical cavity in which a liquid flows |
| CGridUniformChannelWithMeshedCylinder< dim, spacedim > | 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< dim, spacedim > | 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 |
| CLetheGridTools::hash_cell< dim > | A functor that provides a unique and uniformly distributed hash for a a cell. Used to store cells in hash sets |
| CIBParticle< dim > | Define the behavior of a specific particle for the sharp interface IB solver |
| CParameters::IBParticles< dim > | |
| CIBParticlesDEM< dim > | 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< dim > | Define where the sharp immersed-boundaries are imposed on Eulerian grid |
| CParameters::ImmersedSolidGaussianParameters | Gaussian-based physical properties model to handle properties at the interface of immersed solids and in the bulk of each phase |
| CParameters::ImmersedSolidTanhParameters | Tanh-based physical properties model to handle properties in/out of immersed solids |
| CParameters::InitialConditions< dim > | |
| CInsertion< dim, PropertiesIndex > | Base interface for classes that carry out the insertion of particles in the system |
| CInsertionFile< dim, PropertiesIndex > | |
| CInsertionList< dim, PropertiesIndex > | |
| CInsertionPacked< dim, PropertiesIndex > | |
| CInsertionPlane< dim, PropertiesIndex > | 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< dim, PropertiesIndex > | |
| CParameters::Lagrangian::InsertionInfo< dim > | Parameters controlling particle insertion in DEM simulations |
| CIntegrator< dim, PropertiesIndex > | Base interface for classes that carry out the integration of the velocity and position of particles with inertia |
| CExplicitEulerIntegrator< dim, PropertiesIndex > | 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 |
| CVelocityVerletIntegrator< dim, PropertiesIndex > | 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 |
| 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 |
| CMobilityCahnHilliardModel | Implementation of the computation of the mobility for Cahn-Hilliard equations |
| CMobilityCahnHilliardModelConstant | Constant mobility model |
| CMobilityCahnHilliardModelQuartic | Quartic mobility model |
| CSurfaceTensionModel | Abstract class that allows to calculate the surface tension coefficient |
| CSurfaceTensionConstant | Constant surface tension |
| CSurfaceTensionLinear | Linear surface tension. The surface tension is given by: sigma_0 + dsimga/dT * (T-T_0) |
| CSurfaceTensionPhaseChange | Linear surface tension with phase change. The surface tension is given by: alpha_l*(sigma_0 + dsigma/dT * (T-T_0)) |
| CParameters::PostProcessing< dim >::IsocontourBoundingBoxes::Isocontour | |
| CParameters::PostProcessing< dim >::IsocontourBoundingBoxes | Isocontour bounding box parameters. This is used to get the evolution of the bounding values (In 2D: \(x_\mathrm{min}\), \(x_\mathrm{max}\), \(y_\mathrm{min}\), and \(y_\mathrm{max}\); In 3D: \(x_\mathrm{min}\), \(x_\mathrm{max}\), \(y_\mathrm{min}\), \(y_\mathrm{max}\), \(z_\mathrm{min}\), and \(z_\mathrm{max}\)) of one or many specified isocontours. The data of each isocontour is written in a separate file |
| CInterfaceTools::IsocontourBoundingValues< dim > | Bounding values of an isocontour along each coordinate direction ( \(x\) and \(y\) in 2D; \(x\), \(y\), and \(z\) in 3D). A boolean flag also indicates whether the isocontour is present in the simulated domain or not |
| CParameters::IsothermalIdealGasDensityParameters | Isothermal ideal gas model to solve for isothermal weakly compressible fluid flows |
| CLagrangianLoadBalancing< dim, PropertiesIndex > | 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 |
| CParameters::Lagrangian::LagrangianPhysicalProperties | Physical properties of particles, walls, and interstitial gas for Lagrangian (DEM) simulations |
| CParameters::Lagrangian::LagrangianPostProcessing | Lagrangian Postprocessing - Defines the parameters for the Lagrangian post-processing |
| CParameters::Laser< dim > | Laser parameters - Defines the parameters for the laser heat source |
| CParameters::Laser_FreeSurfaceRadiation | Laser_FreeSurfaceRadiation - Defines the subparameters for the radiation sink at the free surface (air/metal interface) |
| CParameters::LinearSolver | LinearSolver - Parameters that control the solution of the linear system of equations that arise from the finite element problem for each of the physics available in Lethe |
| CParameters::Manifolds | Manifolds - This class manages attaching manifolds to faces when a manual attachment is required (for example if the mesh is coming from a GMSH file) |
| CParameters::Material | Material - Class that defines the physical property of a material. Generally a material will be a fluid, but for conjugated heat transfer, this may also be a solid |
| CParameters::MaterialInteractions | MaterialInteractions - Class that defines physical properties due to interactions between two different materials (either fluid-fluid or fluid-solid) |
| CParameters::Mesh< dim, spacedim > | Mesh - Parameters that control mesh reading and mesh generation |
| CParameters::MeshAdaptation | MeshAdaption - Parameters that control dynamic mesh adaptation. Dynamic mesh adaptation in Lethe is very flexible and can be both local and global |
| CParameters::MeshBoxRefinement< dim, spacedim > | |
| CMeshController | |
| CMFNavierStokesPreconditionGMGBase< dim > | A geometric multigrid preconditioner compatible with the matrix-free solver |
| CMFNavierStokesPreconditionGMG< dim > | A geometric multigrid preconditioner implementation for incompressible flow |
| CMFNavierStokesVANSPreconditionGMG< dim > | A geometric multigrid preconditioner implementation for incompressible VANS equations |
| CMGCoarseGridBase | |
| Cdealii::MGCoarseGridApplyPreconditioner< VectorType, PreconditionerType > | |
| CMGTransferBase | |
| CMGTransferMatrixFreeWrapper< dim, MGNumber > | |
| CMGTransferMatrixFreeWrapper< dim, Number > | |
| CMixerGeometry | Geometry dimensions of the impinging-jet mixer (SI units, metres) |
| CParameters::MobilityCahnHilliardParameters | MobilityCahnHilliardParameters - Defines parameters for the mobility models used in the Cahn-Hilliard equations |
| CParameters::Lagrangian::ModelParameters< dim > | Numerical model parameters for DEM simulations |
| CParameters::Mortar< dim > | Mortar - Defines parameters used to construct mortar elements |
| CMortarManagerBase< dim > | Base class for the mortar manager |
| CMortarManagerCircle< dim > | Mortar manager class for circular interface |
| CMortarManagerLinear< dim > | Mortar manager class for linear interface |
| CParameters::Multiphysics< dim > | Multiphysics - the parameters for multiphysics simulations and handles sub-physics parameters |
| CMultiphysicsInterface< dim > | |
| CParameters::MultipleAdaptationParameters | Mesh Adaptation Parameters that can differ for each refinement variable |
| CBoundaryConditions::NavierStokesBoundaryFunctions< dim > | This class manages the functions associated with function-type boundary conditions of the Navier-Stokes equations |
| CRayTracingSolver< dim >::neighbor_list_types | Container that shows the local/ghost neighbor cells of all local cells in the triangulation. Note that they are reciprocal |
| CParameters::Nitsche< dim > | Container class managing multiple Nitsche solid objects |
| CParameters::NitscheObject< dim, spacedim > | Parameters for a single solid object used with the Nitsche immersed boundary method |
| CParameters::NonLinearSolver | NonLinearSolver - Parameter that controls the solution of the non-linear problems |
| CParameters::NonNewtonian | Non-Newtonian - Defines the parameters for non-Newtonian flows according to the chosen rheological model |
| CIBParticlesDEM< dim >::ObjectProperties | Struct is used to reduce the number of parameters passed in the function calculate_force_model |
| COngoingCollisionLog< dim > | Class managing the ongoing collisions |
| 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< dim, VectorType > | 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< dim, VectorType > | 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 |
| Cparticle_comparison< dim > | Operator overloading to enable using particle iterators as map keys |
| Cparticle_line_contact_info< dim > | Handle information related to the calculation of the particle-line contact forces |
| Cparticle_particle_contact_info< dim > | 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 |
| Cperiodic_particle_particle_contact_info< dim > | 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 |
| Cparticle_point_contact_info< dim > | Handle information related to the calculation of the particle-point contact forces |
| CParticleWallContactForce< dim, PropertiesIndex, contact_model, rolling_friction_model >::particle_triangle_contact_candidate | Contact candidate between a particle and a triangle from a solid surface. Stores the required information to evaluate the contact |
| Cparticle_wall_contact_info< dim > | Handle the information related to the calculation of the particle-wall contact forces |
| CParticleFieldQCM< dim, n_components, property_start_index > | 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< dim, PropertiesIndex > | Interface for all assemblers of particle-fluid interactions in the VANS equations |
| CVANSAssemblerBeetstra< dim, PropertiesIndex > | Assembler for the drag force using the Beetstra model |
| CVANSAssemblerBuoyancy< dim, PropertiesIndex > | Assembler for the buoyancy force on particles in the VANS equations |
| CVANSAssemblerDallavalle< dim, PropertiesIndex > | Assembler for the drag force using the Dallavalle model |
| CVANSAssemblerDiFelice< dim, PropertiesIndex > | Assembler for the drag force using the Di Felice model |
| CVANSAssemblerGidaspow< dim, PropertiesIndex > | Assembler for the drag force using the Gidaspow model |
| CVANSAssemblerKochHill< dim, PropertiesIndex > | Assembler for the drag force using the Koch and Hill drag model |
| CVANSAssemblerMagnus< dim, PropertiesIndex > | Assembler for the lift force using the Magnus model |
| CVANSAssemblerPressureForce< dim, PropertiesIndex > | Assembler for the pressure force on particles |
| CVANSAssemblerRong< dim, PropertiesIndex > | Assembler for the drag force using the Rong model |
| CVANSAssemblerSaffmanMei< dim, PropertiesIndex > | Assembler for the lift force using the Saffman-Mei model |
| CVANSAssemblerShearForce< dim, PropertiesIndex > | Assembler for the shear force on particles |
| CVANSAssemblerViscousTorque< dim, PropertiesIndex > | Assembler for the viscous dissipative torque due to particle rotation as defined by Derksen (2004) |
| CVANSAssemblerVorticalTorque< dim, PropertiesIndex > | Assembler for the viscous dissipative torque due to fluid vorticity as defined by Derksen (2004) |
| CParticleInteractionOutcomes< PropertiesIndex > | Class where the outcomes of particle-particle interactions are stored |
| CParticleParticleContactForceBase< dim, PropertiesIndex > | 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 |
| CParticleParticleContactForce< dim, PropertiesIndex, force_model, rolling_friction_model > | |
| CParticlesForceChains< dim, PropertiesIndex, force_model, rolling_friction_model > | 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 |
| CParticleParticleContactForce< dim, PropertiesIndex, contact_model, rolling_friction_model > | Execute calculation of particle-particle contact forces including linear, non-linear contact models, and non-linear with cohesive forces |
| CParticlePointLineForce< dim, PropertiesIndex > | 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 |
| CDEM::ParticleProperties< dim, PropertiesIndex > | Controls the name of output variables for the vtu |
| CParameters::Lagrangian::ParticleRayTracing< dim > | Defines parameters used to construct particle ray tracing class |
| CParticlesForceChainsBase< dim, PropertiesIndex > | 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 |
| CParticlesForceChains< dim, PropertiesIndex, force_model, rolling_friction_model > | 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 |
| CParticleWallContactForceBase< dim, PropertiesIndex > | 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 |
| CParticleWallContactForce< dim, PropertiesIndex, contact_model, rolling_friction_model > | Execute calculation of particle-wall contacts |
| CDEM::dem_data_structures< dim >::periodic_adjacent_particle_pairs_value | |
| Cperiodic_boundaries_cells_info_struct< dim > | Handle the information related to the periodic boundary cells which will be used for particle-wall contact detection |
| CPeriodicBoundariesManipulator< dim > | |
| CParameters::PeriodicBoundary | A periodic boundary pair, keyed elsewhere by its principal boundary id |
| CParameters::PhaseChange | Phase change model for melting/freezing liquids The model assumes that the phase change occurs between a solidus and liquidus temperature. This defines a solidification interval which is used to smooth the non-linearity of the melting problem or to fit the real thermodynamics of the melting process |
| CEffectiveMediumModel::PhaseModels | Models of the property of a phase. The effective property of the phase can be complex and builded from the sum of the real part models plus i times the sum of the imaginary part models (e.g., eps_eff = eps' + i (eps'' + sigma) for the permittivity) |
| CParameters::PhysicalProperties | PhysicalProperties - Define the possible physical properties. All continuum equations share the same physical properties object but only take the subset of properties they require Defined as a class with public attributes in order to use a non-static declare_parameters methods (useful for multiple fluid simulations) |
| 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 |
| CDensityModel | Abstract class for calculating the density of materials |
| CDensityConstant | Constant density model |
| CDensityIsothermalIdealGas | Isothermal ideal gas density |
| 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) |
| 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 |
| 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 |
| CElectricConductivityModel | Abstract class that allows to calculate the electric conductivity on each quadrature point |
| CConstantElectricConductivity | Constant electric conductivity |
| CPolynomialElectricConductivity | Polynomial electric conductivity |
| CElectricPermittivityModel | Abstract class that allows to calculate the electric permittivity real and imaginary part on each quadrature point |
| CConstantElectricPermittivity | Constant electric permittivity |
| CPolynomialElectricPermittivity | Polynomial electric permittivity |
| CMagneticPermeabilityModel | Abstract class that allows to calculate the magnetic permeability on each quadrature point |
| CConstantMagneticPermeability | Constant magnetic permeability |
| CPolynomialMagneticPermeability | Polynomial magnetic permeability |
| CRheologicalModel | Abstract class that allows to calculate the non-Newtonian viscosity on each quadrature point and the shear rate magnitude |
| CCarreau | |
| CNewtonian | |
| CPhaseChangeRheology | |
| CPowerLaw | |
| CSpecificHeatModel | Abstract class for calculating the specific heat of materials on quadrature points using the temperature of the fluid |
| CConstantSpecificHeat | Constant specific heat model |
| CPhaseChangeSpecificHeat | Phase change specific heat model |
| CThermalConductivityModel | Abstract class that allows to calculate the thermal conductivity on each quadrature point using the temperature of the fluid |
| CConstantThermalConductivity | Constant thermal conductivity |
| CThermalConductivityLinear | Implements a linear temperature-dependent thermal conductivity of the form k = A + BT |
| CThermalConductivityPhaseChange | Implements a phase-dependent thermal conductivity |
| CThermalExpansionModel | Abstract class that allows to calculate the thermal expansion coefficient (with unit of inverse temperature) |
| CConstantThermalExpansion | Constant thermal expansion coefficient |
| CThermalExpansionPhaseChange | Implements a phase-dependent thermal expansion coefficient |
| CTracerDiffusivityModel | Abstract class that allows to calculates the tracer diffusivity |
| CConstantTracerDiffusivity | Constant tracer diffusivity |
| CGaussianLevelsetTracerDiffusivity | Diffusivity that depends on the Gaussian of the level set |
| CTanhLevelsetTracerDiffusivity | Diffusivity that depends on the tanh of the level set |
| CTracerReactionPrefactorModel | Abstract class to calculate the tracer reaction prefactor |
| CConstantTracerReactionPrefactor | Constant tracer reaction prefactor |
| CGaussianLevelsetTracerReactionPrefactor | Reaction prefactor that depends on the Gaussian of the level set |
| CNoneTracerReactionPrefactor | Dummy tracer reaction prefactor model |
| CTanhLevelsetTracerReactionPrefactor | Tanh level-set-dependent tracer reaction prefactor |
| CPhysicsAssemblerBase< ScratchDataType, CopyDataType > | Base class for assembler objects of physics and subequations |
| CPhysicsAssemblerBase< CahnHilliardScratchData< dim >, StabilizedMethodsCopyData > | |
| CCahnHilliardAssemblerAngleOfContact< dim > | Class that assembles the boundary condition on the angle of contact in the Cahn-Hilliard equations |
| CCahnHilliardAssemblerBDF< dim > | 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< dim > | 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< dim > | Class that assembles the boundary condition that allows a free angle of contact, thus adding a degree of freedom to the problem |
| CPhysicsAssemblerBase< CLSScratchData< dim >, StabilizedMethodsCopyData > | |
| CCLSAssemblerBDF< dim > | 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< dim > | 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< dim > | Assemble the Discontinuity-Capturing Directional Dissipation (DCDD) stabilization term for the CLS phase indicator |
| CCLSAssemblerDGCore< dim > | 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 \) |
| CPhysicsAssemblerBase< HeatTransferScratchData< dim >, StabilizedMethodsCopyData > | |
| CHeatTransferAssemblerBDF< dim > | Class that assembles the transient time arising from BDF time integration for the heat transfer solver |
| CHeatTransferAssemblerCLSEvaporation< dim > | Class that assembles the evaporation sink for the heat transfer solver at the free surface (air/metal interface) when CLS is enabled |
| CHeatTransferAssemblerCore< dim > | 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< dim > | 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< dim > | 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< dim > | 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< dim > | 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< dim > | 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< dim > | 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< dim > | 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< dim > | Class that assembles the Robin boundary condition for the heat transfer solver |
| CHeatTransferAssemblerViscousDissipation< dim > | Class that assembles the viscous dissipation for the heat transfer solver |
| CHeatTransferAssemblerViscousDissipationCLS< dim > | 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 |
| CPhysicsAssemblerBase< NavierStokesScratchData< dim >, StabilizedMethodsTensorCopyData< dim > > | |
| CBlockNavierStokesAssemblerCore< dim > | 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< dim > | |
| CGLSIsothermalCompressibleNavierStokesAssemblerBDF< dim > | 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< dim > | 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< dim > | |
| CGLSIsothermalCompressibleNavierStokesCLSAssemblerCore< dim > | 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< dim > | 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< dim > | 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< dim > | Class that assembles the core of the Navier-Stokes equation using a Rheological model to predict non-Newtonian behaviors |
| CGLSNavierStokesAssemblerSDIRK< dim > | Class that assembles the transient term arising from SDIRK time integration for the Navier Stokes equations. For a given stage |
| CGLSNavierStokesAssemblerSRF< dim > | 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 |
| CGLSNavierStokesCLSAssemblerBDF< dim > | 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< dim > | 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< dim > | Assembles the Marangoni effect for the Navier-Stokes equations according to the following equation: |
| CGLSNavierStokesCLSAssemblerNonNewtonianCore< dim > | Assembles the core of the Navier-Stokes equation using a Rheological model to predict non-Newtonian behaviors |
| CGLSNavierStokesCLSAssemblerSTF< dim > | Assembles the Surface Tension Force (STF) for the Navier-Stokes equations according to the following equation: |
| CGLSNavierStokesCahnHilliardAssemblerBDF< dim > | 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< dim > | 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 |
| CLaplaceAssembly< dim > | 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 |
| CNavierStokesCLSAssemblerEvaporation< dim > | Assembles the momentum source due to evaporation for the Navier-Stokes equations |
| CNeumannTractionBoundaryCondition< dim > | 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 |
| COutletBoundaryCondition< dim > | 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 |
| CPSPGSUPGNavierStokesAssemblerCore< dim > | 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 |
| CPartialSlipDirichletBoundaryCondition< dim > | 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) |
| CPhaseChangeCarmanKozenyAssembler< dim > | Assembler of the non-linear Carman-Kozeny permeability model for simulations with phase change |
| CPhaseChangeCarmanKozenyCLSAssembler< dim > | Assembler of the non-linear Carman-Kozeny permeability model for CLS simulations with phase change |
| CPhaseChangeDarcyAssembly< dim > | 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< dim > | 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 |
| CPressureBoundaryCondition< dim > | Class that assembles a Neumann boundary condition. According to the following weak form: (p-mu*grad_u)*n at the boundary |
| CThermalBuoyancyAssembly< dim > | 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< dim > | 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} = ... \) |
| CVANSAssemblerBDF< dim > | Assembler for the transient term arising from BDF time integration for the VANS equations |
| CVANSAssemblerCoreModelA< dim > | Assembler for the core of Model A of the Volume-Averaged Navier-Stokes (VANS) equations |
| CVANSAssemblerCoreModelB< dim > | Assembler for the core of Model B of the Volume-Averaged Navier-Stokes (VANS) equations |
| CVANSAssemblerFPI< dim > | Assembler for the fluid-particle interactions (FPI) in the VANS equations, such as the drag force |
| CVANSAssemblerFPIProjection< dim > | Assembler for the fluid-particle interactions (FPI) in the VANS equations when the forces are projected from the particles to the fluid grid |
| CWeakDirichletBoundaryCondition< dim > | 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) |
| CPhysicsAssemblerBase< TimeHarmonicMaxwellScratchData< dim >, DPGCopyData > | |
| CTimeHarmonicMaxwellAssemblerCore< dim > | 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: |
| CPhysicsAssemblerBase< TracerScratchData< dim >, StabilizedMethodsCopyData > | |
| CTracerAssemblerBDF< dim > | 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}\) |
| CTracerAssemblerCore< dim > | 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< dim > | 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< dim > | 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 \) |
| CPhysicsFaceAssemblerBase< ScratchDataType, CopyDataType > | Base class for assembler objects of physics and subequations that require a face assembly. This type of assembler is generally used for DG equations |
| CPhysicsFaceAssemblerBase< CLSScratchData< dim >, StabilizedDGMethodsCopyData > | |
| CCLSAssemblerSIPG< dim > | 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 |
| CPhysicsFaceAssemblerBase< TimeHarmonicMaxwellScratchData< dim >, DPGCopyData > | |
| CTimeHarmonicMaxwellAssemblerRobinBC< dim > | 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< dim > | 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) |
| CPhysicsFaceAssemblerBase< TracerScratchData< dim >, StabilizedDGMethodsCopyData > | |
| CTracerAssemblerBoundaryNitsche< dim > | 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 |
| CTracerAssemblerSIPG< dim > | 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 |
| CPhysicsScratchDataBase | Base class for scratch data objects of physics and subequations |
| CCLSScratchData< dim > | 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 |
| CCahnHilliardScratchData< dim > | 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 |
| CHeatTransferScratchData< dim > | 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 |
| CNavierStokesScratchData< dim > | 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 |
| CTimeHarmonicMaxwellScratchData< dim > | 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 |
| CTracerScratchData< dim > | 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 |
| CPhysicsSolver< VectorType > | 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 |
| CAuxiliaryPhysics< dim, VectorType > | |
| CTimeHarmonicMaxwell< dim > | |
| CNavierStokesBase< dim, VectorType, DofsType > | |
| CPhysicsNonlinearSubequationsSolver< dim, VectorType > | Non-linear subequations solved inside a physics (or auxiliary physics) that are not part of the main set of equations |
| CPhysicsSolver< GlobalBlockVectorType > | |
| CNavierStokesBase< dim, GlobalBlockVectorType, std::vector< IndexSet > > | |
| CFluidDynamicsBlock< dim > | |
| CPhysicsSolver< GlobalVectorType > | |
| CAuxiliaryPhysics< dim, GlobalVectorType > | |
| CCahnHilliard< dim > | |
| CConservativeLevelSet< dim > | |
| CContinuumSolidDynamics< dim > | Solid phase of the Euler-Euler model, solved as an auxiliary physics coupled to the VANS fluid dynamics solver |
| CHeatTransfer< dim > | 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 \) |
| CTracer< dim > | |
| CNavierStokesBase< dim, GlobalVectorType, IndexSet > | |
| CFluidDynamicsMatrixBased< dim > | A solver class for the Navier-Stokes equation using GLS stabilization |
| CFluidDynamicsNitsche< dim, spacedim > | |
| CFluidDynamicsSharp< dim > | |
| CFluidDynamicsVANS< dim, PropertiesIndex > | Solver class for Volume-Averaged Navier-Stokes (VANS) equations with GLS stabilization |
| CCFDDEMSolver< dim, PropertiesIndex > | Solver class for coupled Computational Fluid Dynamics and Discrete Element Method (CFD-DEM) simulations |
| CPhysicsNonlinearSubequationsSolver< dim, GlobalVectorType > | |
| CCLSPDEBasedInterfaceReinitialization< dim > | CLS PDE-based reinitialization solver |
| CPhysicsSolver< LinearAlgebra::distributed::Vector< double > > | |
| CNavierStokesBase< dim, LinearAlgebra::distributed::Vector< double >, IndexSet > | |
| CFluidDynamicsMatrixFree< dim > | A solver for the incompressible Navier-Stokes equations implemented in a matrix-free fashion |
| CFluidDynamicsVANSMatrixFree< dim, PropertiesIndex > | A solver for the Volume-Averaged incompressible Navier-Stokes equations implemented in a matrix-free fashion |
| CCFDDEMMatrixFree< dim, PropertiesIndex > | Solver class for coupled Computational Fluid Dynamics and Discrete Element Method (CFD-DEM) simulations using a matrix-free formulation |
| CPhysicsSolverStrategy< VectorType > | Base class that works as an interface for all solver strategies (either non-linear or linear) for all systems of equations |
| CInexactNewtonNonLinearSolverStrategy< VectorType > | 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 |
| CKinsolNewtonNonLinearSolverStrategy< VectorType > | 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 |
| CLinearSolverStrategy< VectorType > | The linear solver strategy class is used to solve the physics as a linear problem |
| CNewtonNonLinearSolverStrategy< VectorType > | 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 |
| 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 |
| CPhysicsNonlinearSubequationsSolver< dim, GlobalVectorType > | |
| CPhysicsLinearSubequationsSolver | Linear subequations solved inside a physics (or auxiliary physics) that are not part of the main set of equations |
| CCLSLinearSubequationsSolver< dim > | Generalized solver for CLS linear subequations |
| CCLSCurvatureProjection< dim > | CLS curvature L2 projection solver |
| CCLSPhaseGradientProjection< dim > | CLS phase indicator gradient L2 projection solver |
| CParticleProjector< dim, PropertiesIndex > | 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 |
| CPhysicsNonlinearSubequationsSolver< dim, VectorType > | Non-linear subequations solved inside a physics (or auxiliary physics) that are not part of the main set of equations |
| CParameters::PostProcessing< dim > | Postprocessing - Defines the parameters for the post-processing. In Lethe, post-processing implies the calculation of quantities derived from the principal variables. For example, the integral kinetic energy or the integral enstrophy |
| CPostprocessingProbes< dim > | |
| CParameters::PowerLawParameters | Power-law rheological model to solve for non-Newtonian flows |
| CParameters::PostProcessing< dim >::ProbingPoints | Probing points parameters. This is used to monitor the evolution of variables (e.g., temperature) at specified points in the domain |
| CParameters::PostProcessing< dim >::ProbingPoints::ProbingPointsPerVariable | IDs and locations associated with probe points of a given variable |
| 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 |
| CParameters::QMOM | Parameters of the quadrature method of moments (QMOM) physics, declared in the "QMOM" subsection |
| CParameters::QMOMFunctions< dim > | Functions of space and time prescribing the fields of the QMOM physics. They are used for the initial conditions, the Dirichlet boundary conditions, the analytical solution and the source terms |
| CParameters::QMOMLipidNanoparticleProduction | Process parameters of the lipid nanoparticle (LNP) production simulated with the QMOM physics: operating conditions, properties of the aqueous and organic phases and shape factor of the particles. All of them are in SI units |
| CParameters::QMOMPhaseEvolution | Parameters of the phase-space evolution of the QMOM moments, which is delegated to QMOMKit |
| CParameters::QMOMPhysicalConstants | Physical constants used by the QMOM physics, in SI units. Their default values are the exact values of the 2019 redefinition of the SI base units and the CODATA 2022 value of the vacuum permittivity |
| CParameters::Ramp | |
| CParameters::Ramp_n | |
| CParameters::Ramp_viscosity | |
| CRayTracingSolver< dim > | Solver that uses ray tracing to find intersection points between photons and particles |
| CRayTracingSolverParameters< dim > | Handles all the parameters declared in the parameter handler file |
| CParameters::Restart | Restart - Controls writing and reading simulation checkpoints |
| CParameters::RigidSolidObject< dim, spacedim > | Parameters for a single rigid solid object used in DEM simulations |
| CSDIRKStageData | |
| CSDIRKTable | Structure representing a Butcher tableau for a SDIRK method |
| CNavierStokesBase< dim, VectorType, DofsType >::SDIRKVectors | Structure that stores all SDIRK-related vectors used during the time integration process |
| CSerialSolid< dim, spacedim > | |
| CInterfaceTools::SignedDistanceSolver< dim, VectorType > | Solver to compute the signed distance from a given level of a level-set field. It is based on the method proposed in the following article: Ausas, R.F., Dari, E.A. and Buscaglia, G.C. (2011), A geometric mass-preserving redistancing scheme for the level set function. Int. J. Numer. Meth. Fluids, 65: 989-1010. https://doi.org/10.1002/fld.2227 |
| 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 |
| CParameters::SimulationControl | SimulationControl - Defines the parameter that control the flow of the simulation as well as the frequency of the output of the solutions |
| CSimulationControl | Base class for controlling steady-state and transient simulations in Lethe |
| CSimulationControlRayTracing | Simulation control for ray tracing simulations |
| CSimulationControlSteady | Simulation control for steady-state simulations |
| CSimulationControlTransient | Simulation control for transient simulations |
| CSimulationControlAdjointSteady | Simulation control for adjoint steady-state simulations |
| CSimulationControlTransientDEM | Transient simulation control tailored for the Discrete Element Method (DEM) |
| CSimulationParameters< dim > | |
| CParameters::SizeOfSubsections | |
| CSolidBase< dim, spacedim > | |
| CSourceTerms::SourceTerm< dim > | |
| CParameters::Stabilization | Stabilization - Defines parameters for an advanced control over the stabilization strategy used by the solvers |
| 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> |
| 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 |
| CStabilizedMethodsTensorCopyData< dim > | 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 |
| CAverageVelocities< dim, VectorType, DofsType >::SupportPointDoFs | Global indices of the degrees of freedom located at one velocity support point |
| CParameters::SurfaceTensionParameters | SurfaceTensionParameters - Defines parameters for surface tension models |
| CParameters::Testing | Testing - Some solvers have a specific testing mode that can be enabled to output more variables to the terminal. This is enabled using the Testing parameters |
| CParameters::TimeHarmonicMaxwell< dim > | TimeHarmonicMaxwell - Defines the parameters for time-harmonic Maxwell simulations |
| CBoundaryConditions::TimeHarmonicMaxwellBoundaryFunctions< dim > | This class manages the functions associated with both imposed electric and magnetic fields boundary conditions of the Time Harmonic Maxwell equations |
| CParameters::Timer | Timer - Defines the parameters that control the timing of the simulation. Lethe supports advanced timing features which supports the monitoring of specific subsections of the software to evaluate the relative workload |
| 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 |
| CParameters::TracerDriftVelocity< dim > | Implements a drift velocity function to account for simplified multiphase flows |
| CLetheGridTools::TriangleProjectionData< dim > | Particle-independent geometric data of a triangle (its first vertex, edge vectors, unit normal, and the coefficients of its first fundamental form), precomputed once by prepare_triangle_projection_data so that repeated find_particle_triangle_projection queries against the same triangle (e.g. for several nearby particles) do not recompute it. This data is defined "Geometric Tools for Computer Graphics, Eberly 2003
Chapter 10.3.2 - Point to triangle." |
| CParameters::VelocitySource | VelocitySource - Adds velocity-dependent source term to the Navier-Stokes equations with the appropriate jacobian matrix. Currently only a change to a rotating frame is supported, but additional terms such as a Darcy force or similar could be easily added |
| CParameters::VoidFractionParameters< dim > | Parameters controlling the void fraction computation in CFD-DEM simulations |