Lethe Open-Source Library version 1.2.0
Developer Guide
Loading...
Searching...
No Matches
Class Hierarchy

Go to the graphical class hierarchy

This inheritance list is sorted roughly, but not completely, alphabetically:
[detail level 12345]
 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
 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
 CParameters::Lagrangian::BCDEMBoundary 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::BoundaryConditions< CLSBoundaryType >
 CBoundaryConditions::BoundaryConditions< FluidDynamicsBoundaryType >
 CBoundaryConditions::BoundaryConditions< HeatTransferBoundaryType >
 CBoundaryConditions::BoundaryConditions< QMOMBoundaryType >
 CBoundaryConditions::BoundaryConditions< TimeHarmonicMaxwellBoundaryType >
 CBoundaryConditions::BoundaryConditions< TracerBoundaryType >
 CBufferRW< T >Create a temporary vector where mortar evaluation data is stored before being passed to the system matrix
 CParameters::CahnHilliard
 CParameters::CahnHilliard_PhaseFilterCahnHilliard_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
 CCahnHilliardFilterBaseFilter phase fraction according to the selected filtering method
 CParameters::CarreauParametersCarreau 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::CFDDEMParameters for the CFD-DEM coupled solver
 CCFDDEMSimulationParameters< dim >
 CCheckpointControl
 CParameters::CLSCLS - Defines the parameters for free surface simulations using the CLS method. Has to be declared before member creation in Multiphysics structure
 CParameters::CLS_GeometricInterfaceReinitializationParameters for geometric reinitialization of the interface used with the CLS solver
 CParameters::CLS_InterfaceSharpeningCLS_InterfaceSharpening - Defines the parameters for interface sharpening in the CLS solver
 CParameters::CLS_PDEBasedInterfaceReinitializationParameters for PDE-based reinitialization of the interface used with the CLS solver
 CParameters::CLS_PhaseFilterParameters for the phase filtration
 CParameters::CLS_ReinitializationMethodParameters 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_SurfaceTensionForceParameters 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
 CConservativeLevelSetFilterBaseAbstract class for filtering phase indicator in Conservative Level Set (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 >::ContactInfoStruct 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
 CCopyDataClass responsible for storing the information calculated using the assembly of regular (meaning non-stabilized) equations. It is also used to initialize, zero (reset) and store the cell_matrix, the cell_rhs and the dof indices associated with the dofs of the cell
 CStabilizedDGMethodsCopyData::CopyDataFace
 CCouplingEvaluationBase< dim, Number >Base class for coupling evaluation routines
 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
 CDataPostprocessorScalar
 CDataPostprocessorTensor
 CDataPostprocessorVector
 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
 CDEMActionManagerManage 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::DimensionalityClass 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
 CDPGCopyDataClass responsible for storing the local system of an ultraweak Discontinuous Petrov-Galerkin (DPG) discretization. The assemblers fill the uncondensed local system: the Gram matrix of the test space \(G\), the matrices of the bilinear form in the cell interior \(B\) and on the skeleton \(\hat{B}\), and the load vector \(l\). The solver then condenses this system on the skeleton unknowns using the operators \(M_1 = B^\dagger G^{-1} B\), \(M_2 = B^\dagger G^{-1} \hat{B}\), \(M_3 = \hat{B}^\dagger G^{-1} *\hat{B}\), and the vectors \(M_4 l = B^\dagger G^{-1} l\) and \(M_5 l = *\hat{B}^\dagger G^{-1} l\), and stores either the condensed skeleton system (assembly) or the reconstructed interior solution (interior reconstruction)
 CParameters::DynamicFlowControlFlowControl - Set average velocity on a boundary (CFD) or the domain (CFD-DEM)
 CEnableObserverPointer
 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::EvaporationEvaporation - Defines the subparameters for the evaporation cooling and recoil pressure at the free surface (air/metal interface)
 CEvaporationModelEvaporationModel. Abstract class that allows to calculate the evaporation mass, heat and momentum fluxes. This model computes all the terms required for the assembly of the governing equations, i.e., Navier-Stokes momentum and energy, when evaporation is considered. The former terms are the momentum flux (i.e., pressure) acting on the evaporative front in the normal direction, the heat flux, acting at the same location as a cooling term, and the fluxes' jacobian, if required
 CParameters::FEMFEM - 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::ForcesForces - 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
 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::ImmersedSolidGaussianParametersGaussian-based physical properties model to handle properties at the interface of immersed solids and in the bulk of each phase
 CParameters::ImmersedSolidTanhParametersTanh-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
 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
 CInterfacePropertyModelAbstract class that defines the interface for a interface property model. Interface property model provides an abstract interface to calculate the value of an interface property or a vector of interface property value for given field value. By default, the interface does not require that all (or any) fields be specified. This is why a map is used to pass the dependent variable. To allow for the calculation of the appropriate jacobian matrix (when that is necessary) the interface also provides a jacobian function, which must provide the derivative with respect to the field specified as an argument
 CParameters::PostProcessing< dim >::IsocontourBoundingBoxes::Isocontour
 CParameters::PostProcessing< dim >::IsocontourBoundingBoxesIsocontour 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::IsothermalIdealGasDensityParametersIsothermal 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::LagrangianPhysicalPropertiesPhysical properties of particles, walls, and interstitial gas for Lagrangian (DEM) simulations
 CParameters::Lagrangian::LagrangianPostProcessingLagrangian Postprocessing - Defines the parameters for the Lagrangian post-processing
 CParameters::Laser< dim >Laser parameters - Defines the parameters for the laser heat source
 CParameters::Laser_FreeSurfaceRadiationLaser_FreeSurfaceRadiation - Defines the subparameters for the radiation sink at the free surface (air/metal interface)
 CParameters::LinearSolverLinearSolver - 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::ManifoldsManifolds - 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::MaterialMaterial - 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::MaterialInteractionsMaterialInteractions - 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::MeshAdaptationMeshAdaption - 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
 CMGCoarseGridBase
 CMGTransferBase
 CMixerGeometryGeometry dimensions of the impinging-jet mixer (SI units, metres)
 CParameters::MobilityCahnHilliardParametersMobilityCahnHilliardParameters - 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
 CParameters::Multiphysics< dim >Multiphysics - the parameters for multiphysics simulations and handles sub-physics parameters
 CMultiphysicsInterface< dim >
 CParameters::MultipleAdaptationParametersMesh 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_typesContainer 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::NonLinearSolverNonLinearSolver - Parameter that controls the solution of the non-linear problems
 CParameters::NonNewtonianNon-Newtonian - Defines the parameters for non-Newtonian flows according to the chosen rheological model
 CIBParticlesDEM< dim >::ObjectPropertiesStruct is used to reduce the number of parameters passed in the function calculate_force_model
 COngoingCollisionLog< dim >Class managing the ongoing collisions
 COutputStructCellVectorStruct containing information about the solution output. It is used to pass all the information required upon calling add_data_vector() for the DataOut instance without losing track of its attributes such as name and data component interpretation. This version of the struct uses a cell-based field parsed as a Vector and the solution name
 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
 COutputStructTableHandlerStruct containing information about the table handlers to be written/read. It is used to pass a vector of references to TableHandler objects that should be serialized/deserialized at the writing/reading of a checkpoint by the solver used, and a vector of references to strings containing the names of the corresponding files
 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
 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_candidateContact 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
 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
 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
 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
 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::PeriodicBoundaryA periodic boundary pair, keyed elsewhere by its principal boundary id
 CParameters::PhaseChangePhase 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::PhaseModelsModels 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::PhysicalPropertiesPhysicalProperties - 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)
 CPhysicalPropertiesManagerClass that manages the physical properties model which are required to calculate the various physical properties This centralizes the place where the models are created. The class can be constructed empty and initialized from parameters or it can be constructed directly with a Parameters section. The architecture of the PhysicalPropertiesManager is made to ensure that it can store as many physical properties models as required. It first stores the physical properties of the fluids, which are always assumed to lie in material_id=0, and then stores the physical properties of the solid, which may be in cells for which material_id>0
 CPhysicalPropertyModelAbstract class that defines the interface for a physical property model Physical property model provides an abstract interface to calculate the value of a physical property or a vector of physical property value for given field value. By default, the interface does not require that all (or any) fields be specified. This is why a map is used to pass the dependent variable. To allow for the calculation of the appropriate jacobian matrix (when that is necessary) the interface also provides a jacobian function, which must provide the derivative with respect to the field specified as an argument
 CPhysicsAssemblerBase< ScratchDataType, CopyDataType >Base class for assembler objects of physics and subequations
 CPhysicsAssemblerBase< CahnHilliardScratchData< dim >, StabilizedMethodsCopyData >
 CPhysicsAssemblerBase< CLSScratchData< dim >, StabilizedMethodsCopyData >
 CPhysicsAssemblerBase< HeatTransferScratchData< dim >, StabilizedMethodsCopyData >
 CPhysicsAssemblerBase< NavierStokesScratchData< dim >, StabilizedMethodsTensorCopyData< dim > >
 CPhysicsAssemblerBase< TimeHarmonicMaxwellScratchData< dim >, DPGCopyData >
 CPhysicsAssemblerBase< TracerScratchData< dim >, StabilizedMethodsCopyData >
 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 >
 CPhysicsFaceAssemblerBase< TimeHarmonicMaxwellScratchData< dim >, DPGCopyData >
 CPhysicsFaceAssemblerBase< TracerScratchData< dim >, StabilizedDGMethodsCopyData >
 CPhysicsScratchDataBaseBase class for scratch data objects of physics and subequations
 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
 CPhysicsSolver< GlobalBlockVectorType >
 CPhysicsSolver< GlobalVectorType >
 CPhysicsSolver< LinearAlgebra::distributed::Vector< double > >
 CPhysicsSolverStrategy< VectorType >Base class that works as an interface for all solver strategies (either non-linear or linear) for all systems of equations
 CPhysicsSubequationsSolverBaseBase class to solve subequations solved inside a physics (or auxiliary physics) that are not part of the main equations set. It contains all the common elements of a subequation solver
 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::PowerLawParametersPower-law rheological model to solve for non-Newtonian flows
 CParameters::PostProcessing< dim >::ProbingPointsProbing points parameters. This is used to monitor the evolution of variables (e.g., temperature) at specified points in the domain
 CParameters::PostProcessing< dim >::ProbingPoints::ProbingPointsPerVariableIDs and locations associated with probe points of a given variable
 CPVDHandlerManages the storage of the information required to write pvd file. It is particularly necessary for simulations which must be restarted from checkpoint since it manages the continuity of the pvd output
 CParameters::QMOMParameters 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::QMOMLipidNanoparticleProductionProcess 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::QMOMPhaseEvolutionParameters of the phase-space evolution of the QMOM moments, which is delegated to QMOMKit
 CParameters::QMOMPhysicalConstantsPhysical 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::RestartRestart - Controls writing and reading simulation checkpoints
 CParameters::RigidSolidObject< dim, spacedim >Parameters for a single rigid solid object used in DEM simulations
 CSDIRKStageData
 CSDIRKTableStructure representing a Butcher tableau for a SDIRK method
 CNavierStokesBase< dim, VectorType, DofsType >::SDIRKVectorsStructure 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
 CSignedDistanceTransformationBaseAbstract class for the transformation of the signed distance to the phase indicator for the CLS solver when geometric redistanciation is used
 CParameters::SimulationControlSimulationControl - Defines the parameter that control the flow of the simulation as well as the frequency of the output of the solutions
 CSimulationControlBase class for controlling steady-state and transient simulations in Lethe
 CSimulationParameters< dim >
 CParameters::SizeOfSubsections
 CSolidBase< dim, spacedim >
 CSourceTerms::SourceTerm< dim >
 CParameters::StabilizationStabilization - Defines parameters for an advanced control over the stabilization strategy used by the solvers
 CStabilizedMethodsCopyDataClass responsible for storing the information calculated using the assembly of stabilized scalar equations. Like the CopyData class, this class is used to initialize, zero (reset) and store the cell_matrix and the cell_rhs. Contrary to the regular CopyData class, this class also stores the strong_residual and the strong_jacobian of the equation being assembled. This is useful for equations that implement residual-based stabilization such as SUPG. This class is specialized for single component equations because the strong jacobian is stored using a Vector<double>
 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>
 CStasisConstraintWithTemperatureStruct containing fluid id, temperature and phase indicator range information, and flag containers for DOFs used in temperature-dependent stasis constraints
 CstatisticsA simple container for storing basic statistical values
 CSubSimulationControlDEMControls DEM sub iteration logic
 CAverageVelocities< dim, VectorType, DofsType >::SupportPointDoFsGlobal indices of the degrees of freedom located at one velocity support point
 CParameters::SurfaceTensionParametersSurfaceTensionParameters - Defines parameters for surface tension models
 CParameters::TestingTesting - 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::TimerTimer - 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
 CTimeSteppingDataData structure to store time-stepping data in the matrix-free operator. This is a very small structure that is used to simplify the operator process instead of relying on function calls to the SimulationControl object. It should not be used outside of the operator
 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::VelocitySourceVelocitySource - 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