 |
3.4
DUNE for Multi-{Phase, Component, Scale, Physics, ...} flow and transport in porous media
|
| |
3.4
DUNE for Multi-{Phase, Component, Scale, Physics, ...} flow and transport in porous media
|
| ►NDumux | |
| ►NBinaryCoeff | |
| CAir_Mesitylene | Binary coefficients for water and mesitylene |
| CAir_Xylene | Binary coefficients for air and xylene |
| CBrine_CO2 | Binary coefficients for brine and CO2 |
| CBrine_CO2_Old | Old version of binary coefficients for CO2 and brine. Calculates molfraction of CO2 in brine according to Duan and Sun 2003 molfraction of H2O has been assumed to be a constant value For use with the actual brine_co2_system this class still needs to be adapted |
| CH2O_Air | Binary coefficients for water and air |
| CH2O_CH4 | Binary coefficients for water and methane |
| CH2O_Component | Binary coefficients for water and another component |
| CH2O_Component< Scalar, Components::Constant< id, Scalar > > | Binary coefficients for water and a constant component |
| CH2O_HeavyOil | Binary coefficients for water and heavy oil as in SAGD processes |
| CH2O_Mesitylene | Binary coefficients for water and mesitylene |
| CH2O_N2 | Binary coefficients for water and nitrogen |
| CH2O_O2 | Binary coefficients for water and oxygen |
| CH2O_Xylene | Binary coefficients for water and xylene |
| CN2_O2 | Binary coefficients for nitrogen and oxygen |
| NCCMpfa | |
| ►NCCMpfaDataHandleBases | |
| CSystemMatricesHandle | Common base class to all handles. Stores arrays of the matrices involved in the interaction volume-local systems of equations. Apart from the transmissibility matrix we store those matrices that are needed e.g. for later face pressure reconstruction. The fluxes as well as the local systems of equations can be expressed as functions of the intermediate unknown face face values \(\bar{\mathbf{u}}\) and the known cell/Dirichlet values \(\mathbf{u}\) using the matrices \(\mathbf{A}\), \(\mathbf{B}\), \(\mathbf{C}\), \(\mathbf{D}\) and the vector of Neumann fluxes \(\mathbf{N}\) as follows: |
| CSystemVectorsHandle | Common base class to all handles. Stores arrays of the vectors involved in the interaction volume-local systems of equations |
| ►NComponents | |
| CAir | A class for the air fluid properties |
| CAmmonia | A class for the Ammonia (NH3) component properties |
| CBase | Base class for all components Components provide the thermodynamic relations for the liquid, gaseous and/or solid state of a single chemical species or a fixed mixture of species. Fluid systems use components to compute thermodynamic quantities of phases |
| CBenzene | A simple benzene component (LNAPL) |
| CBrine | A class for the brine fluid properties |
| CCalcite | A class for the CaCO3 mineral phase properties |
| CCalciumIon | A class for the Ca2+ (Calcium ion) component properties |
| CCaO | A class for the CaO properties |
| CCaO2H2 | A class for the CaO2H2 properties |
| CCarbonateIon | A class for the CO3 fluid properties |
| CCH4 | Properties of pure molecular methane \(CH_4\) |
| CChlorideIon | A class for the Cl- (Chloride ion) component properties |
| CCO2 | A class for the CO2 fluid properties |
| CConstant | A component which returns run time specified values for all fluid properties |
| CGas | Interface for components that have a gas state |
| CGlucose | A class for the Glucose component properties |
| CGranite | Properties of granite |
| CH2 | Properties of pure molecular hydrogen \(H_2\) |
| CH2O | Material properties of pure water \(H_2O\) |
| CHeavyOil | Properties of the component heavyoil |
| CIon | Interface for components that are ions |
| CIsAqueous | IsAqueous struct |
| CIsAqueous< Brine< Scalar, H2O > > | |
| CIsAqueous< H2O< Scalar > > | |
| CIsAqueous< SimpleH2O< Scalar > > | |
| CIsAqueous< TabulatedComponent< RawComponent, useVaporPressure > > | |
| CLiquid | Interface for components that have a liquid state |
| CMesitylene | Mesitylene |
| CN2 | Properties of pure molecular nitrogen \(N_2\) |
| CNaCl | A class for the NaCl properties |
| CO2 | Properties of pure molecular oxygen \(O_2\) |
| CSimpleH2O | A simple version of pure water |
| CSodiumIon | A class for the Na+ (Sodium ion) component properties |
| CSolid | Interface for components that have a solid state |
| CTabulatedComponent | Tabulates all thermodynamic properties of a given untabulated chemical species |
| CTrichloroethene | A simple implementation of TCE as exemplary component for a dense NAPL |
| CUrea | A class for the Urea component properties |
| CXylene | Properties of xylene |
| ►NDetail | |
| ►NStaggered | |
| CJacobianTypeImpl | |
| CSubDomainFVGridGeometryImpl | |
| CSubDomainFVGridGeometryImpl< SubDomainTypeTag, 0 > | |
| CSubDomainFVGridGeometryImpl< SubDomainTypeTag, 1 > | |
| CSubDomainGridVariablesImpl | |
| CSubDomainGridVariablesImpl< SubDomainTypeTag, 0 > | |
| CSubDomainGridVariablesImpl< SubDomainTypeTag, 1 > | |
| CSubDomainJacobianMatrixImpl | |
| CSubDomainJacobianMatrixImpl< SubDomainTypeTag, 0 > | |
| CSubDomainJacobianMatrixImpl< SubDomainTypeTag, 1 > | |
| CSubDomainPrimaryVariablesImpl | |
| CSubDomainPrimaryVariablesImpl< SubDomainTypeTag, 0 > | |
| CSubDomainPrimaryVariablesImpl< SubDomainTypeTag, 1 > | |
| CSubDomainSolutionVectorImpl | |
| CSubDomainSolutionVectorImpl< SubDomainTypeTag, 0 > | |
| CSubDomainSolutionVectorImpl< SubDomainTypeTag, 1 > | |
| CAxisData | In Axis Data stored per sub face |
| CAxisData< GridView, 1 > | In Axis Data stored per sub face for first-order scheme |
| CBlockTypeHelper | |
| CBlockTypeHelper< S, true > | |
| CConcatSeq | |
| CConcatSeq< std::index_sequence< Is1... >, offset, std::index_sequence< Is2... > > | |
| CcreateMultiTypeBlockMatrixType | Helper class to create a multitype matrix given the diagonal matrix blocks |
| CGeometryDistance | |
| CGeometryDistance< Geo1, Geo2, dimWorld, 0, 0 > | |
| CGeometryDistance< Geo1, Geo2, dimWorld, 0, 1 > | |
| CGeometryDistance< Geo1, Geo2, dimWorld, 1, 0 > | |
| ChasState | Helper struct detecting if a PrimaryVariables object has a state() function |
| CInAxisVelocities | |
| CInAxisVelocities< Scalar, 1 > | |
| CisParallelAMGBackend | |
| CisParallelAMGBackend< Dumux::AMGBiCGSTABBackend< T > > | |
| CisUG | |
| CMax | |
| CMin | |
| CMultiDomainMatrixType | Helper alias to create the JacobianMatrix type |
| CMultiDomainTupleSharedPtr | Helper alias to create a tuple of shared_ptr<...> from an indexed type |
| CMultiDomainTupleSharedPtrConst | Helper alias to create a tuple of shared_ptr<const ...> from an indexed type |
| CPairData | Parallel Data stored per sub face |
| CPriVarSwitchVariablesType | |
| CPriVarSwitchVariablesType< Assembler, false > | |
| CProblemTraits | |
| CProblemTraits< Problem, DiscretizationMethod::box > | |
| CProblemTraits< Problem, DiscretizationMethod::ccmpfa > | |
| CProblemTraits< Problem, DiscretizationMethod::cctpfa > | |
| CProblemTraits< Problem, DiscretizationMethod::staggered > | |
| CSetEqual | |
| CSum | |
| CsupportsPartialReassembly | Helper struct detecting if an assembler supports partial reassembly |
| CValidityTestFunctor | |
| CVariablesBackend | |
| CVariablesBackend< Vars, false > | Class providing operations for primary variable vector/scalar types |
| CVariablesBackend< Vars, true > | |
| CVariablesChooser | |
| CVariablesChooser< A, false > | |
| CVariablesChooser< A, true > | |
| CVolVarsWithOutPVSwitch | |
| CVolVarsWithPVSwitch | Helper structs to conditionally use a primary variable switch or not |
| ►NEmbedded1d3dCouplingMode | |
| CAverage | |
| CKernel | |
| CLine | |
| CSurface | |
| ►NEmbeddedCoupling | |
| NDetail | |
| CCylinderIntegration | Helper class to integrate over a cylinder domain |
| CEllipseIntegration | Helper class to integrate over an elliptic domain |
| CEllipticCylinderIntegration | Helper class to integrate over an elliptic cylinder domain |
| CExtendedSourceStencil | A class managing an extended source stencil |
| ►NExperimental | |
| ►NMultiStage | Multi-stage time stepping scheme implementations |
| CExplicitEuler | An explicit Euler time stepping scheme |
| CImplicitEuler | An implicit Euler time stepping scheme |
| CRungeKuttaExplicitFourthOrder | Classical explicit fourth order Runge-Kutta scheme |
| CTheta | A theta time stepping scheme theta=1.0 is an implicit Euler scheme, theta=0.0 an explicit Euler scheme, theta=0.5 is a Cranck-Nicholson scheme |
| CFVGridVariables | The grid variable class for finite volume schemes, storing variables on scv and scvf (volume and flux variables) |
| CFVGridVariablesLocalView | Finite volume-specific local view on grid variables |
| CGridVariables | Base class for grid variables |
| CMultiStageMethod | Abstract interface for one-step multi-stage method parameters in Shu/Osher form |
| CMultiStageParams | Data object for the parameters of a given stage |
| CMultiStageTimeStepper | Time stepping with a multi-stage method |
| CTimeLevel | Class that represents a time level during time integration |
| CVariables | Class that represents the variables of a model. We assume that models are formulated on the basis of primary and possibly secondary variables, where the latter may non-linearly depend on the former. Variables in Dumux represent the state of a numerical solution of a model, consisting of all primary/secondary variables and, if a transient problem is modeled, time information |
| NFacetCoupling | |
| ►NFCGridManagerChecks | |
| CFulfillConditions | |
| CFulfillConditions< checkDimWorld, G1, G2 > | |
| CFulfillConditions< checkDimWorld, G1, Gs... > | |
| ►NFluidMatrix | |
| CAdapter | Adapter to inherit from, allowing the inheriting class to be wrapped by the makeFluidMatrixInteraction function |
| CAdsorption | Wrapper type for adsorption laws |
| ►CBrooksCorey | Implementation of the Brooks-Corey capillary pressure <-> saturation relation. This class bundles the "raw" curves as static members and doesn't concern itself converting absolute to effective saturations and vice versa |
| CParams | The parameter type |
| ►CBrooksCoreyRegularization | A regularization for the BrooksCorey material law |
| CParams | Regularization parameters |
| CDataSplineTwoPMaterialLaw | Pc- and Kr-sw curves based on monotone splines through given data points |
| ►CHeatPipeLaw | Implementation of the capillary pressure <-> saturation relation for the heatpipe problem |
| CParams | The parameter type |
| CInterfacialArea | Wrapper class to implement regularized laws (pc-sw-a) with a conversion policy between absolution and effective saturations |
| ►CInterfacialAreaExponential | Implementation of the exponential function relating specific interfacial area to wetting phase saturation and capillary pressure as suggested by Nuske(2009) (Diploma thesis) [45] |
| CParams | |
| ►CInterfacialAreaExponentialCubic | Implementation of a exponential function relating specific interfacial area to wetting phase saturation and capillary pressure |
| CParams | |
| ►CInterfacialAreaolynomialEdgeZero2ndOrder | Implementation of the polynomial of second order relating specific interfacial area to wetting phase saturation and capillary pressure |
| CParams | |
| ►CInterfacialAreaPcMax | Implementation of the polynomial of second order relating specific interfacial area to wetting phase saturation and capillary pressure |
| CParams | |
| ►CInterfacialAreaPolynomialSecondOrder | Implementation of the polynomial of second order relating specific interfacial area to wetting phase saturation and capillary pressure as suggested by Joekar-Niasar(2008) [33] |
| CParams | |
| ►CLinearMaterial | Linear capillary pressure and relative permeability <-> saturation relations |
| CParams | The parameter type |
| CMPAdapter | An adapter for mpnc to use the capillary pressure-saturation relationships |
| CMPAdapter< MaterialLaw, 2 > | |
| CMPLinearMaterial | Implements a linear saturation-capillary pressure relation |
| CMultiPhasePcKrSw | Wrapper type for multiphase interface laws providing pc-S and kr-S rules |
| CNonwettingSolidInterfacialAreaPcSw | Wrapper type for laws providing rules for the nonwetting-solid interfacial area |
| ►CNoRegularization | A tag to turn off regularization and it's overhead |
| CParams | Empty parameter structure |
| ►CParkerVanGenuchten3P | Implementation of Parker/vanGenuchten's capillary pressure <-> saturation relation for three phases. This class bundles the "raw" curves as static members and doesn't concern itself converting absolute to effective saturations and vince versa |
| CParams | The parameter type |
| ►CParkerVanGenuchten3PEffToAbsPolicy | |
| CParams | The parameter type |
| ►CParkerVanGenuchten3PRegularization | A regularization for the ParkerVanGenuchten3PRegularization material law |
| CParams | Regularization parameters |
| CParkerVanGenuchtenMaterialLaw | |
| CPcKrSw | Wrapper type for laws providing pc-Sw and kr-Sw rules |
| ►CSmoothedLinearLaw | Implements a linear saturation-capillary pressure relation |
| CParams | The parameter type |
| CSplineTwoPMaterialLaw | A spline approximation wrapper for 2p material laws |
| CThreePhasePcKrSw | Wrapper type for 3p interface laws providing pc-S and kr-S rules |
| ►CThreePNAPLAdsorption | |
| CParams | |
| ►CTwoPEffToAbsDefaultPolicy | This is a policy for 2p material laws how to convert absolute to relative saturations and vice versa |
| CParams | The parameter type |
| CTwoPMaterialLaw | Wrapper class to implement regularized material laws (pc-sw, kr-sw) with a conversion policy between absolution and effective saturations |
| ►CVanGenuchten | Implementation of the van Genuchten capillary pressure <-> saturation relation, and relative permeability |
| CParams | The parameter type |
| ►CVanGenuchtenRegularization | A regularization for the VanGenuchten material law |
| CParams | Regularization parameters |
| CWettingNonwettingInterfacialAreaPcSw | Wrapper type for laws providing rules for the wetting-nonwetting interfacial area |
| CWettingSolidInterfacialAreaPcSw | Wrapper type for laws providing rules for the wetting-solid interfacial area |
| ►NFluidSystems | |
| ►NDetail | |
| CBrineCO2Indices | Class that exports some indices that should be provided by the BrineAir fluid system. The indices are chosen dependent on the policy, i.e. if a simplified pseudo component Brine is used or salt is considered an individual component |
| CBrineCO2Indices< false > | Specialization for the case of brine being a fluid system with NaCl as individual component |
| CBrineCO2Indices< true > | Specialization for the case of brine being a pseudo component with a constant salinity |
| CBase | Fluid system base class |
| CBrine | A compositional single phase fluid system consisting of two components, which are H2O and NaCl |
| CBrineAir | A compositional two-phase fluid system with a liquid and a gaseous phase and \(H_2O\), \(Air\) and \(S\) (dissolved minerals) as components |
| CBrineAirDefaultPolicy | Policy for the brine-air fluid system |
| CBrineCO2 | A compositional fluid with brine (H2O & NaCl) and carbon dioxide as components in both the liquid and the gas (supercritical) phase |
| CBrineCO2DefaultPolicy | Default policy for the Brine-CO2 fluid system |
| CH2OAir | A compositional two-phase fluid system with water and air as components in both, the liquid and the gas phase |
| CH2OAirDefaultPolicy | Policy for the H2O-air fluid system |
| CH2OAirMesitylene | A three-phase fluid system featuring gas, NAPL and water as phases and distilled water \((\mathrm{H_2O})\) and air (Pseudo component composed of \(\mathrm{79\%\;N_2}\), \(\mathrm{20\%\;O_2}\) and Mesitylene \((\mathrm{C_6H_3(CH_3)_3})\) as components |
| CH2OAirXylene | A three-phase fluid system featuring gas, NAPL and water as phases and distilled water \((\mathrm{H_2O})\) and air (Pseudo component composed of \(\mathrm{79\%\;N_2}\), \(\mathrm{20\%\;O_2}\) and Mesitylene \((\mathrm{C_8H_{10}})\) as components |
| CH2OHeavyOil | A compositional fluid system with water and heavy oil components in both the liquid and the gas phase |
| CH2ON2 | A two-phase fluid system with two components water \((\mathrm{H_2O})\) Nitrogen \((\mathrm{N_2})\) for non-equilibrium models |
| CH2ON2DefaultPolicy | Policy for the H2O-N2 fluid system |
| CH2ON2Kinetic | A two-phase fluid system with two components water \((\mathrm{H_2O})\) Nitrogen \((\mathrm{N_2})\) for non-equilibrium models. TODO: Is this fluid system necessary?? |
| CH2ON2O2 | A two-phase (water and air) fluid system with water, nitrogen and oxygen as components |
| CH2ON2O2DefaultPolicy | Policy for the H2O-N2-O2 fluid system |
| CLiquidPhaseTwoC | A liquid phase consisting of a two components, a main component and a conservative tracer component |
| COnePAdapter | An adapter for multi-phase fluid systems to be used with (compositional) one-phase models |
| COnePGas | A gaseous phase consisting of a single component |
| COnePLiquid | A liquid phase consisting of a single component |
| CSpe5 | The fluid system for the SPE-5 benchmark problem |
| CThreePImmiscible | A fluid system for three-phase models assuming immiscibility and thermodynamic equilibrium |
| CTwoPImmiscible | A fluid system for two-phase models assuming immiscibility and thermodynamic equilibrium |
| CTwoPOneC | A two-phase fluid system with only one component |
| ►NFluxVariablesCaching | |
| CEmptyAdvectionCache | Empty caches to use in a constitutive flux law/process, e.g. Darcy's law |
| CEmptyCache | An empty flux variables cache |
| CEmptyCacheFiller | The empty filler class corresponding to EmptyCache |
| CEmptyDiffusionCache | |
| CEmptyHeatConductionCache | |
| NFmt | Formatting tools in the style of std::format (C++20) |
| NGnuplot | Helper functions related to gnuplot |
| ►NIAPWS | |
| CCommon | Implements relations which are common for all regions of the IAPWS '97 formulation |
| CRegion1 | Implements the equations for region 1 of the IAPWS '97 formulation |
| CRegion2 | Implements the equations for region 2 of the IAPWS '97 formulation |
| CRegion4 | Implements the equations for region 4 of the IAPWS '97 formulation |
| ►NInterpolationPolicy | Forward declaration of the linear interpolation policy (default) |
| CLinear | Interpolate linearly between two given values |
| CLinearTable | Interpolate linearly in a piecewise linear function (tabularized function) |
| ►NIntersectionPolicy | |
| CDefaultPolicyChooser | Default policy chooser class |
| CPointPolicy | Policy structure for point-like intersections |
| CPolygonPolicy | Policy structure for polygon-like intersections |
| CPolyhedronPolicy | Policy structure for polyhedron-like intersections |
| CSegmentPolicy | Policy structure for segment-like intersections |
| NIOName | |
| ►NPoreNetwork | |
| ►NDetail | |
| CNoDiffusionType | |
| CTransmissibility | |
| ►NFluidMatrix | |
| CLocalRulesTraits | |
| ►CMultiShapeTwoPLocalRules | |
| CBasicParams | |
| CPlatonicBodyParams | The parameter type |
| CSingleShapeTwoPLocalRules | Base class for all standard pore-local pc-Sw curves |
| CTwoPLocalRulesPlatonicBody | Implementation of the simplified pore-local capillary pressure-saturation curve for platonic bodies (tetrahedron, cube, octahedron, dodecahedron, icosahedron) |
| ►CTwoPLocalRulesPlatonicBodyRegularization | |
| CParams | |
| ►NNonWettingPhaseTransmissibility | |
| CBakkeOren | |
| CMogensen | TODO: evalute and maybe remove |
| CValvatne | TODO: evalute and maybe remove |
| NPore | |
| NThroat | |
| ►NWettingLayerTransmissibility | |
| CCreviceResistanceFactorZhou | |
| ►CRansohoffRadke | |
| CWettingLayerCache | |
| CAveragedValues | Calculates averaged values of the network solution |
| CBaseSpatialParams | The base class for spatial parameters for pore-network models |
| CBoundaryFlux | Class for the calculation of fluxes at the boundary of pore-network models |
| CCommonIOFields | Adds output fields specific to all pore-network models |
| CCreepingFlow | |
| CDefaultPNMData | Base class for geometry data extraction from the grid data format |
| CEmptyCache | |
| CGridData | Class for grid data attached to dgf or gmsh grid files |
| CGridGeometry | Base class for the finite volume geometry for porenetwork models |
| CGridGeometry< Scalar, GV, false, Traits > | Base class for the finite volume geometry for porenetwork models |
| CGridGeometry< Scalar, GV, true, Traits > | Base class for the finite volume geometry for porenetwork models |
| CLabels | Labels for pores and throats |
| ►CNonCreepingFlow | |
| ►CTransmissibility | Inherit transmissibility from creeping flow transmissibility law to cache non-creeping flow-related parameters |
| CSinglePhaseCache | |
| COnePDefaultSpatialParams | The default class for spatial parameters for single-phase pore-network models |
| COnePFluxVariablesCache | Flux variables cache for the single-phase-flow PNM Store data required for flux calculation |
| COnePIOFields | Adds output fields specific to the PNM 1p model |
| COnePNCIOFields | Adds output fields specific to the PNM 1pnc model |
| COnePNCVolumeVariables | Contains the quantities which are are constant within a finite volume in the one-phase, n-component model |
| COnePVolumeVariables | Contains the quantities which are constant within a finite volume (the pore body) in the one-phase model |
| CParametersForGeneratedGrid | Helper class to assign parameters to a generated grid |
| CPNMDefaultGridGeometryTraits | The default traits |
| CPNMDefaultScvfGeometryTraits | Default traits class |
| CPNMDefaultScvGeometryTraits | Default traits class |
| CPNMFicksLaw | Specialization of Fick's Law for the pore-network model |
| CPNMFouriersLaw | Specialization of Fourier's Law for the pore-network model |
| CPNMFVElementGeometry | Base class for the local geometry for porenetworks |
| CPNMFVElementGeometry< GG, false > | Specialization in case the FVElementGeometries are not stored |
| CPNMFVElementGeometry< GG, true > | Specialization in case the FVElementGeometries are stored |
| CPNMSubControlVolume | Sub control volume for porenetworks |
| CPNMSubControlVolumeFace | Class for a sub control volume face for porenetworks |
| CPNMTwoPDefaultGridFVCTraits | Flux variable caches traits |
| CPNMTwoPElementFluxVariablesCache | The flux variables caches for an element |
| CPNMTwoPElementFluxVariablesCache< GFVC, false > | The flux variables caches for an element with caching disabled |
| CPNMTwoPElementFluxVariablesCache< GFVC, true > | The flux variables caches for an element with caching enabled |
| CPNMTwoPGridFluxVariablesCache | Flux variable caches on a gridview |
| CPNMTwoPGridFluxVariablesCache< P, FVC, false, Traits > | The grid flux variables cache for the two-phase PNM hodling the invasion state of the throats |
| CPNMTwoPGridFluxVariablesCache< P, FVC, true, Traits > | The grid flux variables cache for the two-phase PNM hodling the invasion state of the throats |
| CSubGridData | Wrapper for subgrid data |
| CThresholdCapillaryPressures | |
| CTransmissibilityAzzamDullien | Used by Joeakar-Niasar |
| CTransmissibilityBruus | Collection of single-phase flow throat transmissibilities based on Bruus, H. (2011). Acoustofluidics 1: Governing equations in microfluidics. Lab on a Chip, 11(22), 3742-3751. https://backend.orbit.dtu.dk/ws/portalfiles/portal/5900070/rsc%5B1%5D.pdf |
| CTransmissibilityPatzekSilin | Single-phase flow throat transmissibility based on Patzek & Silin (2001) https://doi.org/10.1006/jcis.2000.7413 |
| CTwoPBaseSpatialParams | The base class for spatial parameters for pore-network models |
| CTwoPDefaultSpatialParams | |
| CTwoPFluxVariablesCache | Flux variables cache for the two-phase-flow PNM Store data required for flux calculation |
| CTwoPInvasionState | This class updates the invasion state for the two-phase PNM |
| CTwoPIOFields | Adds output fields specific to the PNM 2p model |
| CTwoPNewtonConsistencyChecks | Consistency checks for the PNM two-phase model |
| CTwoPNewtonSolver | A two-phase PNM specific newton solver |
| CTwoPStaticDrainage | A (quasi-) static two-phase pore-network model for drainage processes. This assumes that there are no pressure gradients within the phases and thus, no flow |
| CTwoPVolumeVariables | Contains the quantities which are are constant within a finite volume (the pore body) in the two-phase model |
| CVelocityOutput | Velocity output for pore-network models |
| CVtkOutputModule | Adds vtk output fields specific to pore-network models |
| ►NProperties | |
| ►NDetail | Implementation details for template meta programming |
| CGetDefined | Helper struct to get the first property that is defined in the TypeTag hierarchy |
| CGetDefined< TypeTag, Property, std::tuple< FirstTypeTag, Args... > > | |
| CGetDefined< TypeTag, Property, std::tuple< LastTypeTag > > | |
| CGetNextTypeTag | Helper struct to iteratre over the TypeTag hierarchy |
| CGetNextTypeTag< TypeTag, Property, std::tuple< FirstTypeTag, Args... >, std::enable_if_t< hasParentTypeTag< FirstTypeTag >(int{}), void > > | |
| CGetNextTypeTag< TypeTag, Property, std::tuple< FirstTypeTag, Args... >, std::enable_if_t<!hasParentTypeTag< FirstTypeTag >(int{}), void > > | |
| CGetNextTypeTag< TypeTag, Property, std::tuple< LastTypeTag >, std::enable_if_t< hasParentTypeTag< LastTypeTag >(int{}), void > > | |
| CGetNextTypeTag< TypeTag, Property, std::tuple< LastTypeTag >, std::enable_if_t<!hasParentTypeTag< LastTypeTag >(int{}), void > > | |
| CGetPropImpl | Helper struct to extract get the Property specilization given a TypeTag, asserts that the property is defined |
| ►NTTag | Type tag for numeric models |
| CBoxDfmModel | |
| CBoxFacetCouplingModel | |
| CBoxModel | |
| CCCMpfaFacetCouplingModel | |
| CCCMpfaModel | |
| CCCTpfaFacetCouplingModel | |
| CCCTpfaModel | |
| CElastic | |
| CFiniteVolumeModel | |
| CFreeFlow | |
| CFvMpfaL2dPressureTwoP | |
| CFvMpfaL2dPressureTwoPAdaptive | |
| CFvMpfaL3dPressureTwoP | |
| CFvMpfaL3dPressureTwoPAdaptive | |
| CFvMpfaO2dPressureTwoP | |
| CFVPressureOneP | |
| CFVPressureTwoP | |
| CFVPressureTwoPAdaptive | |
| CFVTransportTwoP | |
| CGeomechanics | |
| CGridAdapt | |
| CGridProperties | Type tag for numeric models |
| CIMPESTwoP | |
| CIMPESTwoPAdaptive | |
| CIMPET | |
| CKEpsilon | The type tag for the single-phase, isothermal k-epsilon model |
| CKEpsilonNC | The type tags for the single-phase, multi-component isothermal k-epsilon model |
| CKEpsilonNCNI | The type tags for the single-phase, multi-component non-isothermal k-epsilon models |
| CKEpsilonNI | The type tag for the single-phase, non-isothermal k-epsilon model |
| CKOmega | The type tag for the single-phase, isothermal k-omega model |
| CKOmegaNC | The type tags for the single-phase, multi-component isothermal k-omega model |
| CKOmegaNCNI | The type tags for the single-phase, multi-component non-isothermal k-omega models |
| CKOmegaNI | The type tag for the single-phase, non-isothermal k-omega 2-Eq. model |
| CLowReKEpsilon | The type tag for the single-phase, isothermal low-Reynolds k-epsilon model |
| CLowReKEpsilonNC | The type tags for the single-phase, multi-component isothermal low-Re k-epsilon model |
| CLowReKEpsilonNCNI | The type tags for the single-phase, multi-component non-isothermal low-Re k-epsilon models |
| CLowReKEpsilonNI | The type tag for the single-phase, non-isothermal low-Reynolds k-epsilon model |
| CMimetic | |
| CMimeticPressureTwoP | |
| CMimeticPressureTwoPAdaptive | |
| CModelProperties | |
| CMPFAProperties | |
| CMPNC | |
| CMPNCNI | |
| CMPNCNonequil | |
| CNavierStokes | The type tag for the single-phase, isothermal Navier-Stokes model |
| CNavierStokesNC | The type tag for the single-phase, multi-component isothermal free-flow model |
| CNavierStokesNCNI | The type tag for the single-phase, multi-component non-isothermal free-flow model |
| CNavierStokesNI | The type tag for the corresponding non-isothermal model |
| CNonEquilibrium | |
| COneEq | The type tag for the single-phase, isothermal Spalart-Allmaras model |
| COneEqNC | The type tags for the single-phase, multi-component isothermal one-equation model |
| COneEqNCNI | The type tags for the single-phase, multi-component non-isothermal one-equation models |
| COneEqNI | The type tag for the single-phase, non-isothermal Spalart-Allmaras model |
| COneP | The type tags for the isothermal single phase model |
| COnePNC | |
| COnePNCMin | |
| COnePNCMinNI | |
| COnePNCNI | |
| COnePNCNonEquil | |
| COnePNI | The type tags for the non-isothermal single phase model |
| CPNMOneP | |
| CPNMOnePNC | |
| CPNMOnePNCNI | The type tags for the corresponding non-isothermal problems |
| CPNMOnePNI | The type tags for the corresponding non-isothermal problems |
| CPNMTwoP | |
| CPNMTwoPNI | The type tags for the corresponding non-isothermal problems |
| CPoreNetworkModel | |
| CPoroElastic | |
| CPorousMediumFlow | |
| CPressure | |
| CPressureOneP | |
| CPressureTwoP | |
| CRANS | The type tag for the single-phase, isothermal Reynolds-Averaged Navier-Stokes model |
| CRANSNI | The type tag for the single-phase, isothermal Reynolds-Averaged Navier-Stokes model |
| CRichards | |
| CRichardsNC | |
| CRichardsNCNI | |
| CRichardsNI | |
| CSequentialModel | |
| CSequentialOneP | |
| CSequentialTwoP | |
| CSequentialTwoPTwoC | |
| CSequentialTwoPTwoCAdaptive | |
| CShallowWater | |
| CSolidEnergy | |
| CStaggeredFreeFlowModel | |
| CStaggeredModel | |
| CThreeP | The type tags for the isothermal three-phase model |
| CThreePNI | The type tags for the non-isothermal three-phase model |
| CThreePThreeC | The type tags for the isothermal three-phase three-component model |
| CThreePThreeCNI | The type tags for the non-isothermal three-phase three-component model |
| CThreePWaterOilNI | |
| CTracer | |
| CTransport | |
| CTransportTwoP | |
| CTwoP | The type tag for the isothermal two-phase model |
| CTwoPNC | |
| CTwoPNCMin | |
| CTwoPNCMinNI | |
| CTwoPNCNI | |
| CTwoPNI | The type tag for the non-isothermal two-phase model |
| CTwoPOneCNI | |
| CTwoPTwoC | |
| CTwoPTwoCCO2 | |
| CTwoPTwoCCO2NI | |
| CTwoPTwoCNI | |
| CTwoPTwoCNINonEquil | |
| CTwoPTwoCNonEquil | |
| CZeroEq | The type tag for the single-phase, isothermal Reynolds-Averaged Navier-Stokes 0-Eq. model |
| CZeroEqNC | The type tags for the single-phase, multi-component isothermal ZeroEq model |
| CZeroEqNCNI | The type tags for the single-phase, multi-component non-isothermal ZeroEq models |
| CZeroEqNI | The type tag for the single-phase, non-isothermal Reynolds-Averaged Navier-Stokes model |
| CAdaptionIndicator | Class defining the refinement/coarsening indicator |
| CAdaptionIndicator< TypeTag, TTag::IMPESTwoPAdaptive > | Set the standard indicator class of two-phase models for adaption or coarsening |
| CAdaptionInitializationIndicator | Class defining the refinement/coarsening indicator for grid initialization |
| CAdaptionInitializationIndicator< TypeTag, TTag::GridAdapt > | |
| CAdaptionInitializationIndicator< TypeTag, TTag::IMPESTwoPAdaptive > | Set default class for adaptation initialization indicator |
| CAdaptiveGrid | Defines if the grid is h-adaptive |
| CAdaptiveGrid< TypeTag, TTag::GridAdapt > | |
| CAdaptiveGrid< TypeTag, TTag::IMPESTwoPAdaptive > | Enable adaptive grid |
| CAdaptiveGrid< TypeTag, TTag::SequentialTwoPTwoCAdaptive > | |
| CAdvectionType | The type for the calculation the advective fluxes |
| CAdvectionType< TypeTag, TTag::BoxFacetCouplingModel > | Use the box facet coupling-specific Darcy's law |
| CAdvectionType< TypeTag, TTag::CCTpfaFacetCouplingModel > | Use the tpfa facet coupling-specific Darcy's law |
| CAdvectionType< TypeTag, TTag::PNMOneP > | The advection type |
| CAdvectionType< TypeTag, TTag::PNMOnePNC > | The advection type |
| CAdvectionType< TypeTag, TTag::PNMTwoP > | The advection type |
| CAdvectionType< TypeTag, TTag::PorousMediumFlow > | By default, we use darcy's law for the advective fluxes |
| CAdvectionType< TypeTag, TTag::ShallowWater > | |
| CAdvectionType< TypeTag, TTag::Tracer > | We use darcy's law as the default for the advective fluxes |
| CAdvectionType< TypeTag, TTag::TwoPOneCNI > | Use a modified version of Darcy's law which allows for blocking of spurious flows |
| CBalanceEqOpts | A class that collects options for the evaluation of the balance equations |
| CBalanceEqOpts< TypeTag, TTag::ModelProperties > | Set the default class for the balance equation options |
| CBaseEpsilon | A base epsilon for numerical differentiation, can contain multiple values |
| CBaseLocalResidual | The type of the base class of the local residual (specific to a discretization scheme) |
| CBaseLocalResidual< TypeTag, TTag::BoxFacetCouplingModel > | Use the box local residual for models with facet coupling |
| CBaseLocalResidual< TypeTag, TTag::BoxModel > | Set the BaseLocalResidual to BoxLocalResidual |
| CBaseLocalResidual< TypeTag, TTag::CCMpfaFacetCouplingModel > | Use the cc local residual for models with facet coupling |
| CBaseLocalResidual< TypeTag, TTag::CCMpfaModel > | Set the BaseLocalResidual to CCLocalResidual |
| CBaseLocalResidual< TypeTag, TTag::CCTpfaFacetCouplingModel > | Use the cc local residual for models with facet coupling |
| CBaseLocalResidual< TypeTag, TTag::CCTpfaModel > | Set the BaseLocalResidual to CCLocalResidual |
| CBaseLocalResidual< TypeTag, TTag::StaggeredModel > | Set the BaseLocalResidual to StaggeredLocalResidual |
| CBaseModelTraits | Model traits to be used as a base for nonisothermal, mineralization ... models |
| CBaseModelTraits< TypeTag, TTag::OneP > | States some specifics of the one-phase model |
| CBaseModelTraits< TypeTag, TTag::OnePNC > | The base model traits. Per default, we use the number of components of the fluid system |
| CBaseModelTraits< TypeTag, TTag::RichardsNC > | Set the model traits class |
| CBaseModelTraits< TypeTag, TTag::ThreePThreeC > | Set the model traits |
| CBaseModelTraits< TypeTag, TTag::TwoP > | The base model traits class |
| CBaseModelTraits< TypeTag, TTag::TwoPNC > | Set the base model traits |
| CBaseModelTraits< TypeTag, TTag::TwoPTwoC > | Set the model traits property |
| CBoundaryMobility | |
| CBoundaryMobility< TypeTag, TTag::SequentialTwoPTwoC > | < Saturation scales flux on Dirichlet B.C |
| CBoundaryValues | Class containing local boundary data |
| CCapillaryFlux | The type of the diffusive part in a transport equation |
| CCapillaryFlux< TypeTag, TTag::FVTransportTwoP > | Set the default implementation of a diffusive flux -> diffusive flux dissabled |
| CCellCenterPrimaryVariables | The primary variables container type for cell-centered dofs |
| CCellCenterPrimaryVariables< TypeTag, TTag::StaggeredModel > | The cell center primary variables |
| CCellCenterSolutionVector | The solution vector type for cell-centered dofs |
| CCellCenterSolutionVector< TypeTag, TTag::StaggeredModel > | The type of a solution for the whole grid at a fixed time TODO: move to LinearAlgebra traits |
| CCellData | Defines data object to be stored |
| CCellData< TypeTag, TTag::IMPESTwoPAdaptive > | Set cell data class for adaptive two-phase IMPES schemes |
| CCellData< TypeTag, TTag::SequentialOneP > | Set standart CellData of immiscible one-phase models as default |
| CCellData< TypeTag, TTag::SequentialTwoP > | Set standart CellData of immiscible two-phase models as default |
| CCellData< TypeTag, TTag::SequentialTwoPTwoC > | |
| CCellData< TypeTag, TTag::SequentialTwoPTwoCAdaptive > | |
| CChemistry | The chemistry class with which solves equlibrium reactions |
| CCouplingManager | |
| CDiscretizationMethod | The type of discretization method |
| CDualGridNodalIndexSet | The type used for the nodal index sets of the dual grid |
| CDualGridNodalIndexSet< TypeTag, TTag::CCMpfaModel > | Set the index set type used on the dual grid nodes |
| CEffectiveDiffusivityModel | The employed model for the computation of the effective diffusivity |
| CEffectiveDiffusivityModel< TypeTag, TTag::MPNC > | Use the model after Millington (1961) for the effective diffusivity |
| CEffectiveDiffusivityModel< TypeTag, TTag::OnePNC > | Use the model after Millington (1961) for the effective diffusivity |
| CEffectiveDiffusivityModel< TypeTag, TTag::Richards > | Use the model after Millington (1961) for the effective diffusivity |
| CEffectiveDiffusivityModel< TypeTag, TTag::RichardsNC > | The model after Millington (1961) is used for the effective diffusivity |
| CEffectiveDiffusivityModel< TypeTag, TTag::ThreePThreeC > | The model after Millington (1961) is used for the effective diffusivity |
| CEffectiveDiffusivityModel< TypeTag, TTag::ThreePWaterOilNI > | Use the model after Millington (1961) for the effective diffusivity |
| CEffectiveDiffusivityModel< TypeTag, TTag::Tracer > | Use simple model with constant tortuosity as pm diffusivity model |
| CEffectiveDiffusivityModel< TypeTag, TTag::TwoPNC > | Use the model after Millington (1961) for the effective diffusivity |
| CElementBoundaryTypes | Stores the boundary types on an element |
| CElementBoundaryTypes< TypeTag, TTag::BoxModel > | Set the default for the ElementBoundaryTypes |
| CElementBoundaryTypes< TypeTag, TTag::CCMpfaModel > | Set the default for the ElementBoundaryTypes |
| CElementBoundaryTypes< TypeTag, TTag::CCTpfaModel > | Set the default for the ElementBoundaryTypes |
| CElementBoundaryTypes< TypeTag, TTag::StaggeredModel > | Use the cell center element boundary types per default |
| CEnableBoxInterfaceSolver | |
| CEnableBoxInterfaceSolver< TypeTag, TTag::PorousMediumFlow > | Per default, we disable the box interface solver |
| CEnableCapillarity | Returns whether capillarity is regarded |
| CEnableCapillarity< TypeTag, TTag::SequentialTwoPTwoC > | Capillarity is enabled |
| CEnableChemicalNonEquilibrium | |
| CEnableChemicalNonEquilibrium< TypeTag, TTag::NonEquilibrium > | |
| CEnableChemicalNonEquilibrium< TypeTag, TTag::OnePNCNonEquil > | |
| CEnableCompressibility | Returns whether compressibility is allowed |
| CEnableCompressibility< TypeTag, TTag::SequentialTwoP > | Disable compressibility by default |
| CEnableCompressibility< TypeTag, TTag::SequentialTwoPTwoC > | Compositional models are very likely compressible |
| CEnableGridFaceVariablesCache | Switch on/off caching of face variables |
| CEnableGridFaceVariablesCache< TypeTag, TTag::StaggeredModel > | Cache the face variables per default |
| CEnableGridFluxVariablesCache | If data on flux vars should be saved (faster, but more memory consuming) |
| CEnableGridFluxVariablesCache< TypeTag, TTag::FiniteVolumeModel > | Disable flux variables data caching by default |
| CEnableGridGeometryCache | |
| CEnableGridGeometryCache< TypeTag, TTag::FiniteVolumeModel > | We do not store the FVGeometry by default |
| CEnableGridVolumeVariablesCache | If disabled, the volume variables are not stored (reduces memory, but is slower) |
| CEnableGridVolumeVariablesCache< TypeTag, TTag::FiniteVolumeModel > | We do not store the volume variables by default |
| CEnableThermalNonEquilibrium | |
| CEnableThermalNonEquilibrium< TypeTag, TTag::NonEquilibrium > | Per default, we consider both thermal and chemical non-equilibrium |
| CEnableThermalNonEquilibrium< TypeTag, TTag::PoreNetworkModel > | |
| CEnableThermalNonEquilibrium< TypeTag, TTag::PorousMediumFlow > | |
| CEnableWaterDiffusionInAir | Property for turning Richards into extended Richards |
| CEnableWaterDiffusionInAir< TypeTag, TTag::Richards > | |
| CEnableWaterDiffusionInAir< TypeTag, TTag::RichardsNC > | |
| CEnergyLocalResidual | The local residual of the energy equation |
| CEnergyLocalResidual< TypeTag, TTag::NonEquilibrium > | |
| CEnergyLocalResidual< TypeTag, TTag::PNMTwoP > | |
| CEnergyLocalResidual< TypeTag, TTag::PorousMediumFlow > | The default implementation of the energy balance equation for flow problems in porous media |
| CEquilibriumIndices | |
| CEquilibriumIOFields | |
| CEquilibriumIOFields< TypeTag, TTag::MPNCNonequil > | Set the vtk output fields specific to this model |
| CEquilibriumIOFields< TypeTag, TTag::OnePNCNonEquil > | Set the vtk output fields specific to this model |
| CEquilibriumIOFields< TypeTag, TTag::TwoPTwoCNINonEquil > | Set the equilibrium IO fields which are in that case the nonisothermal io fields |
| CEquilibriumIOFields< TypeTag, TTag::TwoPTwoCNonEquil > | Set the vtk output fields specific to this model |
| CEquilibriumLocalResidual | |
| CEquilibriumLocalResidual< TypeTag, TTag::MPNCNonequil > | |
| CEquilibriumLocalResidual< TypeTag, TTag::OnePNCNonEquil > | |
| CEquilibriumLocalResidual< TypeTag, TTag::TwoPTwoCNonEquil > | |
| CEquilibriumModelTraits | Formulation of the pressure e.g most wetting first |
| CEquilibriumModelTraits< TypeTag, TTag::MPNCNonequil > | Set equilibrium model traits |
| CEquilibriumModelTraits< TypeTag, TTag::OnePNCNonEquil > | Set equilibrium model traits |
| CEquilibriumModelTraits< TypeTag, TTag::TwoPTwoCNonEquil > | Set equilibrium model traits |
| CEvalCflFluxFunction | Type of the evaluation of the CFL-condition |
| CEvalCflFluxFunction< TypeTag, TTag::FVTransportTwoP > | Set the default implementation of the cfl-condition |
| CFacePrimaryVariables | The primary variables container type for face dofs |
| CFacePrimaryVariables< TypeTag, TTag::StaggeredModel > | The face primary variables |
| CFaceSolutionVector | The solution vector type for face dofs |
| CFaceSolutionVector< TypeTag, TTag::StaggeredModel > | The type of a solution for the whole grid at a fixed time TODO: move to LinearAlgebra traits |
| CFaceVariables | Class containing local face-related data |
| CFaceVariables< TypeTag, TTag::StaggeredFreeFlowModel > | The variables living on the faces |
| CFluid | |
| CFluidState | The type of the fluid state to use |
| CFluidState< TypeTag, TTag::MPNC > | This model uses the compositional fluid state |
| CFluidState< TypeTag, TTag::NavierStokes > | The fluid state which is used by the volume variables to store the thermodynamic state. This should be chosen appropriately for the model ((non-)isothermal, equilibrium, ...). This can be done in the problem |
| CFluidState< TypeTag, TTag::NavierStokesNC > | The fluid state which is used by the volume variables to store the thermodynamic state. This should be chosen appropriately for the model ((non-)isothermal, equilibrium, ...). This can be done in the problem |
| CFluidState< TypeTag, TTag::NonEquilibrium > | |
| CFluidState< TypeTag, TTag::OneP > | The fluid state which is used by the volume variables to store the thermodynamic state |
| CFluidState< TypeTag, TTag::OnePNC > | The fluid state which is used by the volume variables to store the thermodynamic state |
| CFluidState< TypeTag, TTag::Richards > | The fluid state which is used by the volume variables to store the thermodynamic state. This should be chosen appropriately for the model ((non-)isothermal, equilibrium, ...). This can be done in the problem |
| CFluidState< TypeTag, TTag::RichardsNC > | The fluid state which is used by the volume variables to store the thermodynamic state. This should be chosen appropriately for the model ((non-)isothermal, equilibrium, ...). This can be done in the problem |
| CFluidState< TypeTag, TTag::SequentialTwoP > | Set default fluid state |
| CFluidState< TypeTag, TTag::SequentialTwoPTwoC > | |
| CFluidState< TypeTag, TTag::ThreeP > | The fluid state which is used by the volume variables to store the thermodynamic state |
| CFluidState< TypeTag, TTag::ThreePThreeC > | The fluid state which is used by the volume variables to store the thermodynamic state. This should be chosen appropriately for the model ((non-)isothermal, equilibrium, ...). This can be done in the problem |
| CFluidState< TypeTag, TTag::ThreePWaterOilNI > | The fluid state which is used by the volume variables to store the thermodynamic state. This should be chosen appropriately for the model ((non-)isothermal, equilibrium, ...). This can be done in the problem |
| CFluidState< TypeTag, TTag::TwoP > | The two-phase model uses the immiscible fluid state |
| CFluidState< TypeTag, TTag::TwoPNC > | This model uses the compositional fluid state |
| CFluidState< TypeTag, TTag::TwoPOneCNI > | The fluid state which is used by the volume variables to store the thermodynamic state. This should be chosen appropriately for the model ((non-)isothermal, equilibrium, ...). This can be done in the problem |
| CFluidSystem | The type of the fluid system to use |
| CFluidSystem< TypeTag, TTag::Richards > | The fluid system used by the model |
| CFluidSystem< TypeTag, TTag::RichardsNC > | The fluid system used by the model |
| CFluxVariables | Container storing the different types of flux variables |
| CFluxVariables< TypeTag, TTag::BoxFacetCouplingModel > | Per default, use the porous medium flow flux variables with the modified upwind scheme |
| CFluxVariables< TypeTag, TTag::CCMpfaFacetCouplingModel > | Per default, use the porous medium flow flux variables with the modified upwind scheme |
| CFluxVariables< TypeTag, TTag::CCTpfaFacetCouplingModel > | Per default, use the porous medium flow flux variables with the modified upwind scheme |
| CFluxVariables< TypeTag, TTag::KEpsilon > | The flux variables |
| CFluxVariables< TypeTag, TTag::KEpsilonNC > | The flux variables |
| CFluxVariables< TypeTag, TTag::KEpsilonNCNI > | The flux variables |
| CFluxVariables< TypeTag, TTag::KOmega > | The flux variables |
| CFluxVariables< TypeTag, TTag::KOmegaNC > | The flux variables |
| CFluxVariables< TypeTag, TTag::KOmegaNCNI > | The flux variables |
| CFluxVariables< TypeTag, TTag::LowReKEpsilon > | The flux variables |
| CFluxVariables< TypeTag, TTag::LowReKEpsilonNC > | The flux variables |
| CFluxVariables< TypeTag, TTag::LowReKEpsilonNCNI > | The flux variables |
| CFluxVariables< TypeTag, TTag::NavierStokes > | The flux variables |
| CFluxVariables< TypeTag, TTag::NavierStokesNC > | The flux variables |
| CFluxVariables< TypeTag, TTag::OneEq > | The flux variables |
| CFluxVariables< TypeTag, TTag::OneEqNC > | The flux variables |
| CFluxVariables< TypeTag, TTag::OneEqNCNI > | The flux variables |
| CFluxVariables< TypeTag, TTag::PorousMediumFlow > | The flux variables for models involving flow in porous media |
| CFluxVariables< TypeTag, TTag::ShallowWater > | |
| CFluxVariablesCache | Stores data associated with flux vars |
| CFluxVariablesCache< TypeTag, TTag::BoxDfmModel > | The flux variables cache class specific to box-dfm porous medium flow models |
| CFluxVariablesCache< TypeTag, TTag::FreeFlow > | The flux variables cache class, by default the one for free flow |
| CFluxVariablesCache< TypeTag, TTag::Geomechanics > | The flux variables cache class for models involving flow in porous media |
| CFluxVariablesCache< TypeTag, TTag::PNMTwoP > | The flux variables cache |
| CFluxVariablesCache< TypeTag, TTag::PoreNetworkModel > | The flux variables cache |
| CFluxVariablesCache< TypeTag, TTag::PorousMediumFlow > | The flux variables cache class for models involving flow in porous media |
| CFluxVariablesCache< TypeTag, TTag::ShallowWater > | |
| CFluxVariablesCacheFiller | The engine behind the global flux cache (how to fill caches for the stencil) |
| CFluxVariablesCacheFiller< TypeTag, TTag::FreeFlow > | |
| CFluxVariablesCacheFiller< TypeTag, TTag::PorousMediumFlow > | |
| CFluxVariablesCacheFiller< TypeTag, TTag::ShallowWater > | |
| CFormulation | The formulation of the model |
| CFormulation< TypeTag, TTag::SequentialTwoP > | Set \(p_w\)- \(S_w\) formulation as default two-phase formulation |
| CFormulation< TypeTag, TTag::TwoP > | < Set the default formulation to pwsn |
| CFormulation< TypeTag, TTag::TwoPNC > | Default formulation is pw-Sn, overwrite if necessary |
| CFormulation< TypeTag, TTag::TwoPOneCNI > | Set the default formulation to pw-sn |
| CGravityFlux | The type of a convective part in a transport equation |
| CGravityFlux< TypeTag, TTag::FVTransportTwoP > | Set the default implementation of an additional convective flux -> additional convective flux dissabled |
| CGrid | The DUNE grid type |
| CGridAdaptCoarsenThreshold | Tolerance for coarsening |
| CGridAdaptCoarsenThreshold< TypeTag, TTag::GridAdapt > | |
| CGridAdaptModel | The type of grid adaptation |
| CGridAdaptModel< TypeTag, TTag::GridAdapt > | |
| CGridAdaptRefineThreshold | Tolerance for refinement |
| CGridAdaptRefineThreshold< TypeTag, TTag::GridAdapt > | |
| CGridFaceVariables | Global vector containing face-related data |
| CGridFaceVariables< TypeTag, TTag::StaggeredModel > | Set the default global face variables cache vector class |
| CGridFluxVariablesCache | The global vector of flux variable containers |
| CGridFluxVariablesCache< TypeTag, TTag::BoxModel > | The grid flux variables cache vector class |
| CGridFluxVariablesCache< TypeTag, TTag::CCMpfaModel > | The grid volume variables vector class |
| CGridFluxVariablesCache< TypeTag, TTag::CCTpfaModel > | The grid flux variables cache vector class |
| CGridFluxVariablesCache< TypeTag, TTag::PNMTwoP > | The grid flux variables cache vector class |
| CGridFluxVariablesCache< TypeTag, TTag::StaggeredModel > | Set the global flux variables cache vector class |
| CGridGeometry | |
| CGridGeometry< TypeTag, TTag::BoxDfmModel > | Set the default for the grid geometry |
| CGridGeometry< TypeTag, TTag::BoxFacetCouplingModel > | Set the default for the grid finite volume geometry |
| CGridGeometry< TypeTag, TTag::BoxModel > | Set the default for the grid geometry |
| CGridGeometry< TypeTag, TTag::CCMpfaModel > | Set the default for the grid geometry |
| CGridGeometry< TypeTag, TTag::CCTpfaModel > | Set the default for the grid geometry |
| CGridGeometry< TypeTag, TTag::PoreNetworkModel > | Set the default for the grid geometry |
| ►CGridGeometry< TypeTag, TTag::SequentialModel > | A simplified grid geometry for compatibility with new style models |
| CMockFVGridGeometry | |
| CGridGeometry< TypeTag, TTag::StaggeredFreeFlowModel > | The default grid geometry |
| CGridImplementation | Gives kind of grid implementation in form of a GridType |
| CGridTypeIndices | The grid type indices to decide which grid is used |
| CGridTypeIndices< TypeTag, TTag::MPFAProperties > | Set grid type indices |
| CGridTypeIndices< TypeTag, TTag::SequentialTwoPTwoCAdaptive > | Property not used but default necessary for mpfa2p |
| CGridVariables | The grid variables object managing variable data on the grid (volvars/fluxvars cache) |
| CGridVariables< TypeTag, TTag::FiniteVolumeModel > | The grid variables |
| CGridVariables< TypeTag, TTag::NonEquilibrium > | The grid variables |
| CGridVariables< TypeTag, TTag::StaggeredModel > | Set the grid variables (volume, flux and face variables) |
| CGridVolumeVariables | The type for a global container for the volume variables |
| CGridVolumeVariables< TypeTag, TTag::BoxModel > | The grid volume variables vector class |
| CGridVolumeVariables< TypeTag, TTag::CCMpfaModel > | The grid volume variables vector class |
| CGridVolumeVariables< TypeTag, TTag::CCTpfaModel > | The grid volume variables vector class |
| CGridVolumeVariables< TypeTag, TTag::StaggeredFreeFlowModel > | Set the default global volume variables cache vector class |
| CHeatConductionType | The type for the calculation of the heat conduction fluxes |
| CHeatConductionType< TypeTag, TTag::BoxFacetCouplingModel > | Use the box facet coupling-specific Fourier's law |
| CHeatConductionType< TypeTag, TTag::CCTpfaFacetCouplingModel > | Use the tpfa facet coupling-specific Ficks's law |
| CHeatConductionType< TypeTag, TTag::FreeFlow > | Use Fourier's Law as default heat conduction type |
| CHeatConductionType< TypeTag, TTag::NavierStokesNCNI > | Use Fourier's Law as default heat conduction type |
| CHeatConductionType< TypeTag, TTag::NonEquilibrium > | |
| CHeatConductionType< TypeTag, TTag::PoreNetworkModel > | |
| CHeatConductionType< TypeTag, TTag::PorousMediumFlow > | By default, we use fourier's law as the default for heat conduction fluxes |
| CHeatConductionType< TypeTag, TTag::RANSNI > | Use Fourier's Law as default heat conduction type |
| CIndices | |
| CIndices< TypeTag, TTag::SequentialOneP > | Chose the set of indices for the one-phase formulation |
| CIndices< TypeTag, TTag::SequentialTwoP > | Chose the set of indices depending on the chosen formulation |
| CIndices< TypeTag, TTag::SequentialTwoPTwoC > | |
| CIndices< TypeTag, TTag::SequentialTwoPTwoCAdaptive > | |
| CIntersectionMapper | Specifies the intersection mapper |
| CIOFields | A class helping models to define input and output fields |
| CIOFields< TypeTag, TTag::KEpsilon > | The specific I/O fields |
| CIOFields< TypeTag, TTag::KEpsilonNC > | The specific I/O fields |
| CIOFields< TypeTag, TTag::KEpsilonNCNI > | The specific I/O fields |
| CIOFields< TypeTag, TTag::KEpsilonNI > | The specific non-isothermal I/O fields |
| CIOFields< TypeTag, TTag::KOmega > | The specific I/O fields |
| CIOFields< TypeTag, TTag::KOmegaNC > | The specific I/O fields |
| CIOFields< TypeTag, TTag::KOmegaNCNI > | The specific I/O fields |
| CIOFields< TypeTag, TTag::KOmegaNI > | The specific non-isothermal I/O fields |
| CIOFields< TypeTag, TTag::LowReKEpsilon > | The specific I/O fields |
| CIOFields< TypeTag, TTag::LowReKEpsilonNC > | The specific I/O fields |
| CIOFields< TypeTag, TTag::LowReKEpsilonNCNI > | The specific I/O fields |
| CIOFields< TypeTag, TTag::LowReKEpsilonNI > | The specific non-isothermal I/O fields |
| CIOFields< TypeTag, TTag::ModelProperties > | Set the default to an implementation throwing a NotImplemented error |
| CIOFields< TypeTag, TTag::MPNC > | Set the vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::NavierStokes > | The specific I/O fields |
| CIOFields< TypeTag, TTag::NavierStokesNC > | The specific I/O fields |
| CIOFields< TypeTag, TTag::NavierStokesNCNI > | The non-isothermal I/O fields |
| CIOFields< TypeTag, TTag::NavierStokesNI > | The specific non-isothermal I/O fields |
| CIOFields< TypeTag, TTag::NonEquilibrium > | Indices for non-isothermal models |
| CIOFields< TypeTag, TTag::OneEq > | The specific I/O fields |
| CIOFields< TypeTag, TTag::OneEqNC > | The specific I/O fields |
| CIOFields< TypeTag, TTag::OneEqNCNI > | The specific I/O fields |
| CIOFields< TypeTag, TTag::OneEqNI > | The specific non-isothermal I/O fields |
| CIOFields< TypeTag, TTag::OneP > | Default I/O fields specific to this model |
| CIOFields< TypeTag, TTag::OnePNC > | Set the vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::OnePNCMin > | Use the mineralization vtk output fields |
| CIOFields< TypeTag, TTag::OnePNCMinNI > | Non-isothermal vtk output |
| CIOFields< TypeTag, TTag::OnePNCNI > | The non-isothermal vtk output fields |
| CIOFields< TypeTag, TTag::OnePNI > | Add temperature to the output |
| CIOFields< TypeTag, TTag::PNMOneP > | Default I/O fields specific to this model |
| CIOFields< TypeTag, TTag::PNMOnePNC > | |
| CIOFields< TypeTag, TTag::PNMOnePNCNI > | |
| CIOFields< TypeTag, TTag::PNMOnePNI > | Add temperature to the output |
| CIOFields< TypeTag, TTag::PNMTwoP > | |
| CIOFields< TypeTag, TTag::PNMTwoPNI > | Set the vtk output fields specific to the non-isothermal two-phase model |
| CIOFields< TypeTag, TTag::PoroElastic > | Default vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::RANS > | The specific I/O fields |
| CIOFields< TypeTag, TTag::RANSNI > | The specific non-isothermal I/O fields |
| CIOFields< TypeTag, TTag::Richards > | Set the vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::RichardsNC > | Set the vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::RichardsNI > | Set the vtk output fields specific to th non-isothermal model |
| CIOFields< TypeTag, TTag::ShallowWater > | |
| CIOFields< TypeTag, TTag::SolidEnergy > | Set the vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::ThreeP > | Set the vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::ThreePNI > | Set non-isothermal output fields |
| CIOFields< TypeTag, TTag::ThreePThreeC > | Set the vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::ThreePThreeCNI > | Set the non-isothermal vktoutputfields |
| CIOFields< TypeTag, TTag::ThreePWaterOilNI > | Set the non-isothermal vkt output fields |
| CIOFields< TypeTag, TTag::Tracer > | Set the vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::TwoP > | Set the vtk output fields specific to the twop model |
| CIOFields< TypeTag, TTag::TwoPNC > | Set the vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::TwoPNCMin > | Set the vtk output fields specific to this model |
| CIOFields< TypeTag, TTag::TwoPNCMinNI > | Non-isothermal vtkoutput |
| CIOFields< TypeTag, TTag::TwoPNCNI > | Set non-isothermal output fields |
| CIOFields< TypeTag, TTag::TwoPNI > | Set the vtk output fields specific to the non-isothermal twop model |
| CIOFields< TypeTag, TTag::TwoPOneCNI > | The non-isothermal vtk output fields |
| CIOFields< TypeTag, TTag::TwoPTwoCNI > | Set non-isothermal output fields |
| CIOFields< TypeTag, TTag::ZeroEqNC > | The specific I/O fields |
| CIOFields< TypeTag, TTag::ZeroEqNCNI > | The specific I/O fields |
| CJacobianMatrix | Type of the global jacobian matrix |
| CJacobianMatrix< TypeTag, TTag::FiniteVolumeModel > | Set the type of a global jacobian matrix from the solution types TODO: move to LinearAlgebra traits |
| CJacobianMatrix< TypeTag, TTag::SequentialModel > | Type of the jacobian matrix needed for compatibility with implicit models for the amg backend |
| CJacobianMatrix< TypeTag, TTag::StaggeredModel > | Set the type of a global jacobian matrix from the solution types TODO: move to LinearAlgebra traits |
| CKEpsilonModelTraits | Traits for the k-epsilon model |
| CKEpsilonNCModelTraits | Traits for the low-Reynolds k-epsilon multi-component model states some specifics of the isothermal multi-component low-Reynolds k-epsilon model |
| CKOmegaModelTraits | Traits for the k-omega model |
| CKOmegaNCModelTraits | Traits for the k-omega multi-component modelstates some specifics of the isothermal multi-component k-omega model |
| CLabels | The pore/throat labels |
| CLabels< TypeTag, TTag::PoreNetworkModel > | The labels |
| CLinearSolver | TODO: Remove this property as soon as the decoupled models are integrated |
| CLinearSolver< TypeTag, TTag::Pressure > | |
| CLocalResidual | |
| CLocalResidual< TypeTag, TTag::Elastic > | Use the local residual of the elastic model |
| CLocalResidual< TypeTag, TTag::KEpsilon > | The local residual |
| CLocalResidual< TypeTag, TTag::KEpsilonNC > | The local residual |
| CLocalResidual< TypeTag, TTag::KEpsilonNCNI > | The local residual |
| CLocalResidual< TypeTag, TTag::KOmega > | The local residual |
| CLocalResidual< TypeTag, TTag::KOmegaNC > | The local residual |
| CLocalResidual< TypeTag, TTag::KOmegaNCNI > | The local residual |
| CLocalResidual< TypeTag, TTag::LowReKEpsilon > | The local residual |
| CLocalResidual< TypeTag, TTag::LowReKEpsilonNC > | The local residual |
| CLocalResidual< TypeTag, TTag::LowReKEpsilonNCNI > | The local residual |
| CLocalResidual< TypeTag, TTag::MPNC > | Use the MpNc local residual for the MpNc model |
| CLocalResidual< TypeTag, TTag::NavierStokes > | The local residual |
| CLocalResidual< TypeTag, TTag::NavierStokesNC > | The local residual |
| CLocalResidual< TypeTag, TTag::NonEquilibrium > | |
| CLocalResidual< TypeTag, TTag::OneEq > | The local residual |
| CLocalResidual< TypeTag, TTag::OneEqNC > | The local residual |
| CLocalResidual< TypeTag, TTag::OneEqNCNI > | The local residual |
| CLocalResidual< TypeTag, TTag::OneP > | Local residual function |
| CLocalResidual< TypeTag, TTag::OnePNC > | The local residual function |
| CLocalResidual< TypeTag, TTag::OnePNCMin > | |
| CLocalResidual< TypeTag, TTag::PoroElastic > | Use the local residual of the poro-elastic model |
| CLocalResidual< TypeTag, TTag::Richards > | The local residual operator |
| CLocalResidual< TypeTag, TTag::RichardsNC > | Use the dedicated local residual |
| CLocalResidual< TypeTag, TTag::ShallowWater > | |
| CLocalResidual< TypeTag, TTag::SolidEnergy > | Set the local residual |
| CLocalResidual< TypeTag, TTag::ThreeP > | The local residual function of the conservation equations |
| CLocalResidual< TypeTag, TTag::ThreePThreeC > | The local residual function of the conservation equations |
| CLocalResidual< TypeTag, TTag::ThreePWaterOilNI > | The local residual function of the conservation equations |
| CLocalResidual< TypeTag, TTag::Tracer > | Use the tracer local residual function for the tracer model |
| CLocalResidual< TypeTag, TTag::TwoP > | Use the immiscible local residual operator for the 2p model |
| CLocalResidual< TypeTag, TTag::TwoPNC > | Use the compositional local residual |
| CLocalResidual< TypeTag, TTag::TwoPNCMin > | |
| CLocalResidual< TypeTag, TTag::TwoPOneCNI > | The specific local residual (i.e. balance equations) |
| CLocalStiffness | |
| CLocalStiffness< TypeTag, TTag::MimeticPressureTwoP > | |
| CLocalStiffness< TypeTag, TTag::MimeticPressureTwoPAdaptive > | |
| CLowReKEpsilonModelTraits | Traits for the low-Reynolds k-epsilon model |
| CLowReKEpsilonNCModelTraits | Traits for the low-Reynolds k-epsilon multi-component modelstates some specifics of the isothermal multi-component low-Reynolds k-epsilon model |
| CMaxIntersections | Gives maximum number of intersections of an element and neighboring elements |
| CMaxIntersections< TypeTag, TTag::SequentialModel > | Default number of intersections for quadrilaterals |
| CModel | The type of the mode |
| CModel< TypeTag, TTag::IMPET > | |
| CModel< TypeTag, TTag::PressureOneP > | |
| CModel< TypeTag, TTag::PressureTwoP > | |
| CModel< TypeTag, TTag::TransportTwoP > | |
| CModelDefaultParameters | Property which defines the group that is queried for parameters by default |
| CModelDefaultParameters< TypeTag, TTag::ModelProperties > | Do not specific any model-specific default parameters here |
| CModelDefaultParameters< TypeTag, TTag::SequentialModel > | Do not specific any model-specific default parameters here |
| CModelTraits | Traits class encapsulating model specifications |
| CModelTraits< TypeTag, TTag::Elastic > | The model traits of the elastic model |
| CModelTraits< TypeTag, TTag::KEpsilon > | < states some specifics of the isothermal k-epsilon model |
| CModelTraits< TypeTag, TTag::KEpsilonNC > | |
| CModelTraits< TypeTag, TTag::KEpsilonNCNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::KEpsilonNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::KOmega > | States some specifics of the isothermal k-omega model |
| CModelTraits< TypeTag, TTag::KOmegaNC > | |
| CModelTraits< TypeTag, TTag::KOmegaNCNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::KOmegaNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::LowReKEpsilon > | < states some specifics of the isothermal low-Reynolds k-epsilon model |
| CModelTraits< TypeTag, TTag::LowReKEpsilonNC > | |
| CModelTraits< TypeTag, TTag::LowReKEpsilonNCNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::LowReKEpsilonNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::MPNC > | Set the model traits property |
| CModelTraits< TypeTag, TTag::MPNCNI > | Set the non-isothermal model traits |
| CModelTraits< TypeTag, TTag::MPNCNonequil > | |
| CModelTraits< TypeTag, TTag::NavierStokes > | |
| CModelTraits< TypeTag, TTag::NavierStokesNC > | < states some specifics of the free-flow model |
| CModelTraits< TypeTag, TTag::NavierStokesNCNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::NavierStokesNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::NonEquilibrium > | Set the model traits |
| CModelTraits< TypeTag, TTag::OneEq > | < states some specifics of the isothermal Spalart-Allmaras model |
| CModelTraits< TypeTag, TTag::OneEqNC > | |
| CModelTraits< TypeTag, TTag::OneEqNCNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::OneEqNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::OneP > | Default the actually used traits to the base traits |
| CModelTraits< TypeTag, TTag::OnePNC > | Default the actually used traits to the base traits |
| CModelTraits< TypeTag, TTag::OnePNCMin > | Use non-mineralization model traits with 1pnc traits |
| CModelTraits< TypeTag, TTag::OnePNCMinNI > | The non-isothermal model traits |
| CModelTraits< TypeTag, TTag::OnePNCNI > | Model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::OnePNCNonEquil > | |
| CModelTraits< TypeTag, TTag::OnePNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::PNMOnePNCNI > | Model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::PNMOnePNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::PNMTwoPNI > | Model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::PoroElastic > | The deault model traits of the poro-elastic model |
| CModelTraits< TypeTag, TTag::RANS > | The model traits of the isothermal model |
| CModelTraits< TypeTag, TTag::RANSNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::Richards > | The model traits |
| CModelTraits< TypeTag, TTag::RichardsNC > | |
| CModelTraits< TypeTag, TTag::RichardsNCNI > | Set non-isothermal model traits |
| CModelTraits< TypeTag, TTag::RichardsNI > | Set non-isothermal model traits |
| CModelTraits< TypeTag, TTag::SequentialModel > | |
| CModelTraits< TypeTag, TTag::ShallowWater > | |
| CModelTraits< TypeTag, TTag::SolidEnergy > | Set the model traits |
| CModelTraits< TypeTag, TTag::ThreeP > | Set the model traits |
| CModelTraits< TypeTag, TTag::ThreePNI > | Set non-isothermal model traits |
| CModelTraits< TypeTag, TTag::ThreePThreeC > | |
| CModelTraits< TypeTag, TTag::ThreePThreeCNI > | Set non-isothermal NumEq |
| CModelTraits< TypeTag, TTag::ThreePWaterOilNI > | Set the non-isothermal model traits property |
| CModelTraits< TypeTag, TTag::Tracer > | Set the model traits |
| CModelTraits< TypeTag, TTag::TwoP > | Default the actually used traits to the base traits |
| CModelTraits< TypeTag, TTag::TwoPNC > | Default the actually used traits to the base traits |
| CModelTraits< TypeTag, TTag::TwoPNCMin > | The 2pnc model traits define the non-mineralization part |
| CModelTraits< TypeTag, TTag::TwoPNCMinNI > | Set non-isothermal model traits |
| CModelTraits< TypeTag, TTag::TwoPNCNI > | Set the non-isothermal model traits |
| CModelTraits< TypeTag, TTag::TwoPNI > | The non-isothermal model traits class |
| CModelTraits< TypeTag, TTag::TwoPOneCNI > | Set the non-isothermal model traits |
| CModelTraits< TypeTag, TTag::TwoPTwoC > | |
| CModelTraits< TypeTag, TTag::TwoPTwoCNI > | Set the non-isothermal model traits |
| CModelTraits< TypeTag, TTag::TwoPTwoCNINonEquil > | Set the non-isothermal model traits with the nonequilibrium model traits as isothermal traits |
| CModelTraits< TypeTag, TTag::TwoPTwoCNonEquil > | |
| CModelTraits< TypeTag, TTag::ZeroEq > | |
| CModelTraits< TypeTag, TTag::ZeroEqNC > | The model traits of the isothermal model |
| CModelTraits< TypeTag, TTag::ZeroEqNCNI > | The model traits of the non-isothermal model |
| CModelTraits< TypeTag, TTag::ZeroEqNI > | The model traits of the non-isothermal model |
| CMolecularDiffusionType | The type for the calculation of the molecular diffusion fluxes |
| CMolecularDiffusionType< TypeTag, TTag::BoxFacetCouplingModel > | Use the box facet coupling-specific Ficks's law |
| CMolecularDiffusionType< TypeTag, TTag::CCTpfaFacetCouplingModel > | Use the tpfa facet coupling-specific Ficks's law |
| CMolecularDiffusionType< TypeTag, TTag::NavierStokesNC > | Use Fick's law for molecular diffusion per default |
| CMolecularDiffusionType< TypeTag, TTag::PNMOnePNC > | We use fick's law as the default for the diffusive fluxes |
| CMolecularDiffusionType< TypeTag, TTag::PorousMediumFlow > | By default, we use fick's law for the diffusive fluxes |
| CMPFAInteractionVolume | Type of the data container for one interaction volume |
| CMPFAInteractionVolume< TypeTag, TTag::FvMpfaL3dPressureTwoP > | |
| CMPFAInteractionVolume< TypeTag, TTag::FvMpfaL3dPressureTwoPAdaptive > | |
| CMPFAInteractionVolume< TypeTag, TTag::SequentialTwoPTwoCAdaptive > | |
| CMPFAInteractionVolumeContainer | Type of the data container for one interaction volume |
| CMPFAInteractionVolumeContainer< TypeTag, TTag::FvMpfaL3dPressureTwoP > | |
| CMPFAInteractionVolumeContainer< TypeTag, TTag::FvMpfaL3dPressureTwoPAdaptive > | |
| CMPFAInteractionVolumeContainer< TypeTag, TTag::SequentialTwoPTwoCAdaptive > | |
| CMPFATransmissibilityCalculator | Type defining the transmissibility calculation |
| CNormalizePressure | Returns whether to normalize the pressure term in the momentum balance or not |
| CNormalizePressure< TypeTag, TTag::NavierStokes > | Normalize the pressure term in the momentum balance by default |
| CNormalizePressure< TypeTag, TTag::NavierStokesNC > | Normalize the pressure term in the momentum balance by default |
| CNumComponents | Number of components in the system |
| CNumComponents< TypeTag, TTag::SequentialOneP > | Each phase consists of 1 pure component |
| CNumComponents< TypeTag, TTag::SequentialTwoP > | Set number of components to 1 for immiscible two-phase models Each phase consists of 1 pure component |
| CNumComponents< TypeTag, TTag::SequentialTwoPTwoC > | < The number of components in the 2p2c model is 2 |
| CNumEnergyEqFluid | |
| CNumEnergyEqFluid< TypeTag, TTag::NonEquilibrium > | |
| CNumEnergyEqSolid | |
| CNumEnergyEqSolid< TypeTag, TTag::NonEquilibrium > | Default values for the number of energy balance equations |
| CNumEq | Number of equations in the system of PDEs |
| CNumEq< TypeTag, TTag::SequentialOneP > | Set number of equations to 1 for isothermal one-phase models |
| CNumEq< TypeTag, TTag::SequentialTwoP > | Set number of equations to 2 for isothermal two-phase models |
| CNumEq< TypeTag, TTag::SequentialTwoPTwoC > | |
| CNumEqBalance | |
| CNumEqCellCenter | The number of equations for cell-centered dofs |
| CNumEqCellCenter< TypeTag, TTag::StaggeredFreeFlowModel > | For free flow models, we take the number of "physical" equations (e.g. 4 for a 3D NavierStokes problem, 3 velocity components and pressure) and substract the number of dimensions. This yields the number of equations to be solved on the cell centers. Works also for non-isothermal models |
| CNumEqFace | The number of equations for face dofs |
| CNumEqFace< TypeTag, TTag::StaggeredFreeFlowModel > | Set the number of equations on the faces to 1. We only consider scalar values because the velocity vector is normal to the face |
| CNumEqVector | A vector of size number equations that can be used for Neumann fluxes, sources, residuals, .. |
| CNumEqVector< TypeTag, TTag::ModelProperties > | Set the default vector with size number of equations to a field vector |
| CNumPhases | Number of phases in the system |
| CNumPhases< TypeTag, TTag::SequentialOneP > | Set number of phases to 1 for one-phase models |
| CNumPhases< TypeTag, TTag::SequentialTwoP > | Set number of phases to 2 for two-phase models The number of phases in the 2p model is 2 |
| CNumPhases< TypeTag, TTag::SequentialTwoPTwoC > | < The number of phases in the 2p2c model is 2 |
| CNusseltFormulation | |
| CNusseltFormulation< TypeTag, TTag::NonEquilibrium > | |
| COneEqModelTraits | Traits for the Spalart-Allmaras model |
| COneEqNCModelTraits | Traits for the one-equation multi-component modelstates some specifics of the isothermal multi-component one-equation model |
| COnlyGasPhaseCanDisappear | Reduces the phasestates to threePhases and wnPhaseOnly |
| COnlyGasPhaseCanDisappear< TypeTag, TTag::ThreePWaterOilNI > | Determines whether a constraint solver should be used explicitly |
| CPointSource | Property defining the type of point source used |
| CPointSource< TypeTag, TTag::GridProperties > | Use the minimal point source implementation as default |
| CPointSourceHelper | Property defining the class that computes which sub control volume point sources belong to |
| CPointSourceHelper< TypeTag, TTag::GridProperties > | Use the point source helper using the bounding box tree as a default |
| CPrecomputedConstRels | |
| CPrecomputedConstRels< TypeTag, TTag::FVTransportTwoP > | Set PrecomputedConstRels flag true as default |
| CPressureCoefficientMatrix | Gives maximum number of intersections of an element and neighboring elements |
| CPressureCoefficientMatrix< TypeTag, TTag::Pressure > | |
| CPressureFormulation | |
| CPressureFormulation< TypeTag, TTag::MPNC > | Set the default pressure formulation to the pressure of the (most) wetting phase |
| CPressureFormulation< TypeTag, TTag::SequentialTwoP > | Set the default pressure formulation according to the chosen two-phase formulation |
| CPressureFormulation< TypeTag, TTag::SequentialTwoPTwoC > | Set the default formulation Compositional models are very likely compressible |
| CPressureModel | The type of the discretization of a pressure model |
| CPressureModel< TypeTag, TTag::FvMpfaL2dPressureTwoP > | |
| CPressureModel< TypeTag, TTag::FvMpfaL2dPressureTwoPAdaptive > | |
| CPressureModel< TypeTag, TTag::FvMpfaL3dPressureTwoP > | |
| CPressureModel< TypeTag, TTag::FvMpfaL3dPressureTwoPAdaptive > | |
| CPressureModel< TypeTag, TTag::FvMpfaO2dPressureTwoP > | |
| CPressureModel< TypeTag, TTag::FVPressureOneP > | Set finite volume implementation of the one-phase pressure equation as default pressure model |
| CPressureModel< TypeTag, TTag::FVPressureTwoP > | Set finite volume implementation of the two-phase pressure equation as default pressure model |
| CPressureModel< TypeTag, TTag::FVPressureTwoPAdaptive > | Set finite volume implementation of the two-phase pressure equation which allows hanging nodes as default pressure model |
| CPressureModel< TypeTag, TTag::MimeticPressureTwoP > | |
| CPressureModel< TypeTag, TTag::MimeticPressureTwoPAdaptive > | |
| CPressureModel< TypeTag, TTag::SequentialTwoPTwoCAdaptive > | |
| CPressureRHSVector | Type of the right hand side vector given to the linear solver |
| CPressureRHSVector< TypeTag, TTag::Pressure > | |
| CPressureSolutionVector | |
| CPressureSolutionVector< TypeTag, TTag::Pressure > | |
| CPrimaryInteractionVolume | The primary interaction volume type |
| CPrimaryInteractionVolume< TypeTag, TTag::CCMpfaFacetCouplingModel > | Use the facet coupling-specific mpfa-o interaction volume |
| CPrimaryInteractionVolume< TypeTag, TTag::CCMpfaModel > | Per default, we use the dynamic mpfa-o interaction volume |
| CPrimaryVariables | A vector of primary variables |
| CPrimaryVariables< TypeTag, TTag::ModelProperties > | |
| CPrimaryVariables< TypeTag, TTag::Richards > | The primary variables vector for the richards model |
| CPrimaryVariables< TypeTag, TTag::SequentialModel > | |
| CPrimaryVariables< TypeTag, TTag::ThreePThreeC > | The primary variables vector for the 3p3c model |
| CPrimaryVariables< TypeTag, TTag::ThreePWaterOilNI > | The primary variables vector for the 3p3c model |
| CPrimaryVariables< TypeTag, TTag::TwoPNC > | The primary variables vector for the 2pnc model |
| CPrimaryVariables< TypeTag, TTag::TwoPOneCNI > | The primary variables vector for the 2p1cni model |
| CProblem | Property to specify the type of a problem which has to be solved |
| CRANSModelTraits | Traits for the Reynolds-averaged Navier-Stokes model |
| CRegulateBoundaryPermeability | A minimum permeability can be assigned via the runtime-Parameter SpatialParams.minBoundaryPermeability |
| CRegulateBoundaryPermeability< TypeTag, TTag::SequentialTwoPTwoC > | Switch off permeability regularization at Dirichlet boundaries by default |
| CReplaceCompEqIdx | The component balance index that should be replaced by the total mass/mole balance |
| CReplaceCompEqIdx< TypeTag, TTag::MPNC > | Per default, no component mass balance is replaced |
| CReplaceCompEqIdx< TypeTag, TTag::NavierStokesNC > | |
| CReplaceCompEqIdx< TypeTag, TTag::OnePNC > | Set as default that no component mass balance is replaced by the total mass balance |
| CReplaceCompEqIdx< TypeTag, TTag::PNMOnePNC > | Set as default that no component mass balance is replaced by the total mass balance |
| CReplaceCompEqIdx< TypeTag, TTag::RichardsNC > | |
| CReplaceCompEqIdx< TypeTag, TTag::ThreePThreeC > | Set as default that no component mass balance is replaced by the total mass balance |
| CReplaceCompEqIdx< TypeTag, TTag::ThreePWaterOilNI > | Set as default that no component mass balance is replaced by the total mass balance |
| CReplaceCompEqIdx< TypeTag, TTag::TwoPNC > | Per default, no component mass balance is replaced |
| CSaturationFormulation | The formulation of the saturation model |
| CSaturationFormulation< TypeTag, TTag::SequentialTwoP > | Set the default saturation formulation according to the chosen two-phase formulation |
| CSaturationFormulation< TypeTag, TTag::SequentialTwoPTwoC > | Compositional models are very likely compressible |
| CScalar | Property to specify the type of scalar values |
| CScalar< TypeTag, TTag::ModelProperties > | Set the default type of scalar values to double |
| CSecondaryInteractionVolume | The secondary interaction volume type used e.g. on the boundaries |
| CSecondaryInteractionVolume< TypeTag, TTag::CCMpfaFacetCouplingModel > | Use the facet coupling-specific mpfa-o interaction volume |
| CSecondaryInteractionVolume< TypeTag, TTag::CCMpfaModel > | Per default, we use the dynamic mpfa-o interaction volume on boundaries |
| CSequentialBoundaryTypes | |
| CSequentialBoundaryTypes< TypeTag, TTag::SequentialModel > | Boundary types at a single degree of freedom |
| CSetMoleFractionsForFirstPhase | Set the mole fraction in the wetting or nonwetting phase |
| CSetMoleFractionsForFirstPhase< TypeTag, TTag::TwoPNC > | Set the primary variables mole fractions for the wetting or nonwetting phase |
| CSherwoodFormulation | |
| CSherwoodFormulation< TypeTag, TTag::NonEquilibrium > | Set the default formulation for the sherwood correlation Other possible parametrizations can be found in the dimensionlessnumbers |
| CSolidState | The type of the solid state to use |
| CSolidState< TypeTag, TTag::Geomechanics > | The solid state must be inert |
| CSolidState< TypeTag, TTag::OnePNCMin > | The two-phase model uses the immiscible fluid state |
| CSolidState< TypeTag, TTag::PorousMediumFlow > | Per default solid state is inert |
| CSolidState< TypeTag, TTag::TwoPNCMin > | The two-phase model uses the immiscible fluid state |
| CSolidSystem | The type of the solid system to use |
| CSolidSystem< TypeTag, TTag::Geomechanics > | Per default we use one constant component in the inert solid system |
| CSolidSystem< TypeTag, TTag::PorousMediumFlow > | |
| CSolutionDependentAdvection | If the parameters for the advective fluxes depend on the solution |
| CSolutionDependentAdvection< TypeTag, TTag::PorousMediumFlow > | By default, parameters are solution-dependent |
| CSolutionDependentHeatConduction | If the parameters for the heat conduction fluxes depend on the solution |
| CSolutionDependentHeatConduction< TypeTag, TTag::PorousMediumFlow > | |
| CSolutionDependentMolecularDiffusion | If the parameters for the diffusive fluxes depend on the solution |
| CSolutionDependentMolecularDiffusion< TypeTag, TTag::PorousMediumFlow > | |
| CSolutionTypes | |
| CSolutionTypes< TypeTag, TTag::SequentialModel > | Specifies the types which are assoicated with a solution |
| CSolutionVector | Vector containing all primary variable vector of the grid |
| CSolutionVector< TypeTag, TTag::FiniteVolumeModel > | The type of a solution for the whole grid at a fixed time TODO: move to LinearAlgebra traits |
| CSolutionVector< TypeTag, TTag::SequentialModel > | For compatibility with new style models we need a solution vector type |
| CSolutionVector< TypeTag, TTag::StaggeredModel > | Default property value for the solution vector only used for monolithic solver TODO: move to LinearAlgebra traits |
| CSpatialParams | The type of the spatial parameters object |
| CSpatialParams< TypeTag, TTag::PNMOneP > | |
| CSpatialParams< TypeTag, TTag::PNMOnePNC > | |
| CSpatialParams< TypeTag, TTag::PNMTwoP > | |
| CSpatialParams< TypeTag, TTag::SequentialOneP > | The spatial parameters to be employed. Use BoxSpatialParams by default |
| CSpatialParams< TypeTag, TTag::SequentialTwoP > | The spatial parameters to be employed. Use SequentialFVSpatialParams by default |
| CSpatialParams< TypeTag, TTag::SequentialTwoPTwoC > | The spatial parameters to be employed |
| CStaggeredFaceSolution | A vector containing the solution for a face (similar to ElementSolution) |
| CStaggeredFaceSolution< TypeTag, TTag::StaggeredModel > | Set the face solution type |
| CStaggeredPrimaryVariables | The hybrid primary variables container type |
| CStressType | The type used for the evaluation of stress tensors and forces |
| CStressType< TypeTag, TTag::Elastic > | By default, we use hooke's law for stress evaluations |
| CStressType< TypeTag, TTag::PoroElastic > | Per default, we use effective stresses on the basis of Hooke's Law |
| CThermalConductivityModel | Model to be used for the calculation of the effective conductivity |
| CThermalConductivityModel< TypeTag, TTag::MPNCNI > | Somerton is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::MPNCNonequil > | In case we do not assume full non-equilibrium one needs a thermal conductivity |
| CThermalConductivityModel< TypeTag, TTag::OnePNCMinNI > | Use the average for effective conductivities |
| CThermalConductivityModel< TypeTag, TTag::OnePNCNI > | Use the average for effective conductivities |
| CThermalConductivityModel< TypeTag, TTag::OnePNCNonEquil > | In case we do not assume full non-equilibrium one needs a thermal conductivity |
| CThermalConductivityModel< TypeTag, TTag::OnePNI > | Use the average for effective conductivities |
| CThermalConductivityModel< TypeTag, TTag::PNMOnePNCNI > | Use the average for effective conductivities |
| CThermalConductivityModel< TypeTag, TTag::PNMOnePNI > | Use the average for effective conductivities |
| CThermalConductivityModel< TypeTag, TTag::PNMTwoPNI > | Use the average for effective conductivities |
| CThermalConductivityModel< TypeTag, TTag::RichardsNCNI > | Average is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::RichardsNI > | Somerton is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::SolidEnergy > | Use the average for effective conductivities |
| CThermalConductivityModel< TypeTag, TTag::ThreePNI > | Somerton is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::ThreePThreeCNI > | Somerton is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::ThreePWaterOilNI > | Somerton is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::TwoPNCMinNI > | Use the effective thermal conductivities calculated using the Somerton method |
| CThermalConductivityModel< TypeTag, TTag::TwoPNCNI > | Somerton is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::TwoPNI > | Somerton is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::TwoPOneCNI > | Somerton is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::TwoPTwoCNI > | Somerton is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::TwoPTwoCNINonEquil > | Somerton is used as default model to compute the effective thermal heat conductivity |
| CThermalConductivityModel< TypeTag, TTag::TwoPTwoCNonEquil > | |
| CTimeManager | |
| CTimeManager< TypeTag, TTag::SequentialModel > | Set the default type for the time manager |
| CTransportModel | The type of the discretization of a transport model |
| CTransportModel< TypeTag, TTag::FVTransportTwoP > | Set finite volume implementation of the two-phase saturation equation as default saturation model |
| CTransportModel< TypeTag, TTag::SequentialTwoPTwoCAdaptive > | |
| CTransportSolutionType | |
| CTransportSolutionType< TypeTag, TTag::SequentialTwoPTwoC > | |
| CTransportSolutionType< TypeTag, TTag::Transport > | Default implementation for the Vector of the transportet quantity |
| CUndefinedProperty | Tag to mark properties as undefined |
| CUpwindSchemeOrder | Specifies the order of the upwinding scheme (1 == first order, 2 == second order(tvd methods)) |
| CUpwindSchemeOrder< TypeTag, TTag::StaggeredFreeFlowModel > | Set the order of the upwinding scheme to 1 by default |
| CUseBlockingOfSpuriousFlow | Determines whether blocking of spurious flow is used or not |
| CUseBlockingOfSpuriousFlow< TypeTag, TTag::TwoPOneCNI > | Do not block spurious flows by default |
| CUseConstraintSolver | Whether to use a contraint solver for computing the secondary variables |
| CUseConstraintSolver< TypeTag, TTag::ThreePThreeC > | Determines whether a constraint solver should be used explicitly |
| CUseConstraintSolver< TypeTag, TTag::TwoPTwoC > | Determines whether the constraint solver is used |
| CUseMoles | Property whether to use moles or kg as amount unit for balance equations |
| CUseMoles< TypeTag, TTag::MPNC > | Use mole fractions in the balance equations by default |
| CUseMoles< TypeTag, TTag::NavierStokesNC > | Defines whether molar (true) or mass (false) density is used |
| CUseMoles< TypeTag, TTag::OnePNC > | Use mole fractions in the balance equations by default |
| CUseMoles< TypeTag, TTag::PNMOnePNC > | |
| CUseMoles< TypeTag, TTag::RichardsNC > | Define that per default mole fractions are used in the balance equations |
| CUseMoles< TypeTag, TTag::ThreePThreeC > | Use mole fractions in the balance equations by default |
| CUseMoles< TypeTag, TTag::ThreePWaterOilNI > | |
| CUseMoles< TypeTag, TTag::Tracer > | Define that mole fractions are used in the balance equations |
| CUseMoles< TypeTag, TTag::TwoPNC > | Use mole fractions in the balance equations by default |
| CVariables | The type of the container of global variables |
| CVariables< TypeTag, TTag::IMPESTwoPAdaptive > | Set variable class for adaptive impet schemes |
| CVariables< TypeTag, TTag::SequentialModel > | |
| CVariables< TypeTag, TTag::SequentialOneP > | Set general sequential VariableClass as default |
| CVariables< TypeTag, TTag::SequentialTwoP > | Set general sequential VariableClass as default |
| CVariables< TypeTag, TTag::SequentialTwoPTwoC > | |
| CVariables< TypeTag, TTag::SequentialTwoPTwoCAdaptive > | |
| CVelocity | The type velocity reconstruction |
| CVelocity< TypeTag, TTag::FvMpfaL2dPressureTwoP > | Set velocity reconstruction implementation standard cell centered finite volume schemes as default |
| CVelocity< TypeTag, TTag::FvMpfaL2dPressureTwoPAdaptive > | Set velocity reconstruction implementation standard cell centered finite volume schemes as default |
| CVelocity< TypeTag, TTag::FvMpfaL3dPressureTwoP > | |
| CVelocity< TypeTag, TTag::FvMpfaL3dPressureTwoPAdaptive > | |
| CVelocity< TypeTag, TTag::FvMpfaO2dPressureTwoP > | Set velocity reconstruction implementation standard cell centered finite volume schemes as default |
| CVelocity< TypeTag, TTag::FVPressureOneP > | Set velocity reconstruction implementation standard cell centered finite volume schemes as default |
| CVelocity< TypeTag, TTag::FVPressureTwoP > | Set velocity reconstruction implementation standard cell centered finite volume schemes as default |
| CVelocity< TypeTag, TTag::FVPressureTwoPAdaptive > | Set velocity reconstruction implementation for grid-adaptive cell centered finite volume schemes as default |
| CVelocity< TypeTag, TTag::Pressure > | |
| CVelocity< TypeTag, TTag::TransportTwoP > | |
| CVelocityFormulation | The type of velocity reconstructed for the transport model |
| CVelocityFormulation< TypeTag, TTag::SequentialTwoP > | Set the default velocity formulation according to the chosen two-phase formulation |
| CVelocityFormulation< TypeTag, TTag::SequentialTwoPTwoC > | Compositional models are very likely compressible |
| CVelocityOutput | Velocity calculation module to be used |
| CVelocityOutput< TypeTag, TTag::Geomechanics > | The (currently empty) velocity output |
| CVelocityOutput< TypeTag, TTag::PoreNetworkModel > | |
| CVelocityOutput< TypeTag, TTag::PorousMediumFlow > | Velocity output |
| CVelocityOutput< TypeTag, TTag::StaggeredFreeFlowModel > | The velocity output |
| CViscousFluxType | The type for the calculation of the (turbulent) viscous (momentum) fluxes |
| CViscousFluxType< TypeTag, TTag::ShallowWater > | |
| CVisitFacesOnlyOnce | Type of solution vector or pressure system Indicates if faces are only regarded from one side |
| CVisitFacesOnlyOnce< TypeTag, TTag::FVPressureOneP > | Allow assembling algorithm for the pressure matrix to assemble only from one side of a cell-cell interface |
| CVisitFacesOnlyOnce< TypeTag, TTag::FVPressureTwoP > | Allow assembling algorithm for the pressure matrix to assemble only from one side of a cell-cell interface |
| CVisitFacesOnlyOnce< TypeTag, TTag::FVPressureTwoPAdaptive > | Allow assembling algorithm for the pressure matrix to assemble only from one side of a cell-cell interface |
| CVisitFacesOnlyOnce< TypeTag, TTag::Pressure > | Faces are only regarded from one side and not from both cells |
| CVisitFacesOnlyOnce< TypeTag, TTag::SequentialTwoPTwoC > | Faces are regarded from both sides |
| CVolumeVariables | The secondary variables within a sub-control volume |
| CVolumeVariables< TypeTag, TTag::Elastic > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::KEpsilon > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::KEpsilonNC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::KEpsilonNCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::KEpsilonNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::KOmega > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::KOmegaNC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::KOmegaNCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::KOmegaNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::LowReKEpsilon > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::LowReKEpsilonNC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::LowReKEpsilonNCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::LowReKEpsilonNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::MPNC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::MPNCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::MPNCNonequil > | Use the mineralization volume variables together with the 2pnc vol vars |
| CVolumeVariables< TypeTag, TTag::NavierStokes > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::NavierStokesNC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::OneEq > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::OneEqNC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::OneEqNCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::OneEqNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::OneP > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::OnePNC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::OnePNCMin > | Use the mineralization volume variables together with the 1pnc vol vars |
| CVolumeVariables< TypeTag, TTag::OnePNCMinNI > | Use the mineralization volume variables together with the 1pnc vol vars |
| CVolumeVariables< TypeTag, TTag::OnePNCNI > | |
| CVolumeVariables< TypeTag, TTag::OnePNCNonEquil > | Use the mineralization volume variables together with the 2pnc vol vars |
| CVolumeVariables< TypeTag, TTag::OnePNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::PNMOneP > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::PNMOnePNC > | Set the volume variables property Set the vtk output fields specific to this model |
| CVolumeVariables< TypeTag, TTag::PNMOnePNCNI > | |
| CVolumeVariables< TypeTag, TTag::PNMOnePNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::PNMTwoP > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::PNMTwoPNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::PoroElastic > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::Richards > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::RichardsNC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::RichardsNCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::RichardsNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::ShallowWater > | |
| CVolumeVariables< TypeTag, TTag::SolidEnergy > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::ThreeP > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::ThreePNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::ThreePThreeC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::ThreePThreeCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::ThreePWaterOilNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::Tracer > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::TwoP > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::TwoPNC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::TwoPNCMin > | Use the mineralization volume variables together with the 2pnc vol vars |
| CVolumeVariables< TypeTag, TTag::TwoPNCMinNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::TwoPNCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::TwoPNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::TwoPOneCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::TwoPTwoC > | Use the 2p2c VolumeVariables |
| CVolumeVariables< TypeTag, TTag::TwoPTwoCCO2 > | Co2 volume variables use the same traits as the 2p2c model |
| CVolumeVariables< TypeTag, TTag::TwoPTwoCCO2NI > | |
| CVolumeVariables< TypeTag, TTag::TwoPTwoCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::TwoPTwoCNINonEquil > | Use the nonequilibrium volume variables together with the 2p2c vol vars |
| CVolumeVariables< TypeTag, TTag::TwoPTwoCNonEquil > | Use the nonequilibrium volume variables together with the 2p2c vol vars |
| CVolumeVariables< TypeTag, TTag::ZeroEq > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::ZeroEqNC > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::ZeroEqNCNI > | Set the volume variables property |
| CVolumeVariables< TypeTag, TTag::ZeroEqNI > | Set the volume variables property |
| CZeroEqModelTraits | Traits for the ZeroEq model |
| CZeroEqNCModelTraits | Traits for the Reynolds-averaged Navier-Stokes 0-Eq. model |
| ►NPython | |
| CFVProblem | A C++ wrapper for a Python problem |
| ►NShallowWater | |
| CRiemannSolution | |
| ►NSolidSystems | |
| CCompositionalSolidPhase | A solid phase consisting of multiple inert solid components |
| COneCSolid | The simplest solid phase consisting of a single solid component |
| ►NTemp | |
| ►NCapabilities | |
| CcanCommunicate | |
| ►NTriangulationPolicy | |
| CDelaunayPolicy | Delaunay-type triangulations |
| CMidPointPolicy | |
| ►NUtility | |
| NDetail | |
| CTag | Helper class to create (named and comparable) tagged types Tags any given type. The tagged type is equality comparable and can be written to streams. A custom name can be provided by implementing the name() member function |
| ►NVtk | |
| NDetail | |
| CField | Struct that can hold any field that fulfills the VTKFunction interface |
| CVectorP0VTKFunction | VTK function that supports both scalar and vector values for each element |
| CVectorP1NonConformingVTKFunction | A VTK function that supports both scalar and vector values for each vertex. This expects the data to be organized by a two-dimensional field storing for each element the element-local nodal values. This can be used for the output of fields that are non-conforming due to e.g. constitutive relationships and where no extra degrees of freedom exist to disply the discontinuities |
| CVectorP1VTKFunction | VTK function that supports both scalar and vector values for each vertex |
| CAdaptiveGridRestart | Indices denoting the different grid types |
| CAdaptiveGridRestart< Grid, true > | Provides a restart functionality for adaptive grids |
| CAdvectionCacheChooser | |
| CAdvectionCacheChooser< TypeTag, true > | |
| CAdvectionDataHandle | Data handle for quantities related to advection |
| CAdvectionDataHandle< MatVecTraits, PhysicsTraits, false > | Process-dependent data handles when related process is disabled |
| CAlwaysFalse | Template which always yields a false value |
| CAMGBiCGSTABBackend | A linear solver based on the ISTL AMG preconditioner and the ISTL BiCGSTAB solver |
| CBalanceEquationOptions | Traits class to set options used by the local residual when when evaluating the balance equations |
| CBaseGridGeometry | Base class for all finite volume grid geometries |
| CBaseStaggeredGeometryHelper | Base class for a staggered grid geometry helper |
| CBlockDiagAMGBiCGSTABSolver | A simple ilu0 block diagonal preconditioned BiCGSTABSolver |
| CBlockDiagAMGPreconditioner | A simple ilu0 block diagonal preconditioner |
| CBlockDiagILU0BiCGSTABSolver | A simple ilu0 block diagonal preconditioned BiCGSTABSolver |
| CBlockDiagILU0Preconditioner | A simple ilu0 block diagonal preconditioner |
| CBlockDiagILU0RestartedGMResSolver | A simple ilu0 block diagonal preconditioned RestartedGMResSolver |
| CBoundaryConditions | Define a class containing boundary condition flags |
| CBoundaryFlag | |
| CBoundarySegmentIndexFlag | Class for accessing boundary flags |
| ►CBoundaryTypes | Class to specify the type of a boundary |
| CBoundaryInfo | Use bitfields to minimize the size |
| CBoundingBoxTree | An axis-aligned bounding box volume tree implementation |
| CBoundingBoxTreePointSourceHelper | A helper class calculating a sub control volume to point source map This class uses the bounding box tree implementation to indentify in which sub control volume(s) a point source falls |
| CBoxDarcysLaw | Darcy's law for the box scheme |
| CBoxDefaultGridFVCTraits | Flux variable caches traits |
| CBoxDefaultGridGeometryTraits | The default traits for the box finite volume grid geometry Defines the scv and scvf types and the mapper types |
| CBoxDefaultGridVolumeVariablesTraits | |
| ►CBoxDefaultScvfGeometryTraits | Default traits class to be used for the sub-control volume faces for the box scheme |
| ►CScvfMLGTraits | |
| CCornerStorage | |
| ChasSingleGeometryType | |
| ►CBoxDefaultScvGeometryTraits | Default traits class to be used for the sub-control volumes for the box scheme |
| ►CScvMLGTraits | |
| CCornerStorage | |
| ChasSingleGeometryType | |
| CBoxDfmDefaultGridGeometryTraits | The default traits for the box finite volume grid geometry |
| ►CBoxDfmDefaultScvfGeometryTraits | Default traits class to be used for the sub-control volume faces for the box discrete fracture scheme |
| ►CScvfMLGTraits | |
| CCornerStorage | |
| ChasSingleGeometryType | |
| ►CBoxDfmDefaultScvGeometryTraits | Default traits class to be used for the sub-control volumes for the box discrete fracture scheme |
| ►CScvMLGTraits | |
| CCornerStorage | |
| ChasSingleGeometryType | |
| CBoxDfmFluxVariablesCache | We only store discretization-related quantities for the box method. However, we cannot reuse the cache of the standard box method as we have to take into account the scvs that lie on fracture facets |
| CBoxDfmFVElementGeometry | Base class for the finite volume geometry vector for box discrete fracture model |
| CBoxDfmFVElementGeometry< GG, false > | Specialization in case the FVElementGeometries are not stored |
| CBoxDfmFVElementGeometry< GG, true > | Specialization in case the FVElementGeometries are stored |
| CBoxDfmFVGridGeometry | Base class for the finite volume geometry vector for box schemes |
| CBoxDfmFVGridGeometry< Scalar, GV, false, Traits > | Base class for the finite volume geometry vector for box schemes This builds up the sub control volumes and sub control volume faces |
| CBoxDfmFVGridGeometry< Scalar, GV, true, Traits > | Base class for the finite volume geometry vector for box schemes that consider extra connectivity between grid vertices on marked codim one entities |
| CBoxDfmGeometryHelper | Create sub control volumes and sub control volume face geometries |
| CBoxDfmGeometryHelper< GridView, 2, ScvType, ScvfType > | A class to create sub control volume and sub control volume face geometries per element |
| CBoxDfmGeometryHelper< GridView, 3, ScvType, ScvfType > | A class to create sub control volume and sub control volume face geometries per element |
| CBoxDfmSubControlVolume | Sub control volume for the box discrete fracture scheme |
| CBoxDfmSubControlVolumeFace | Class for a sub control volume face in the box discrete fracture method, i.e a part of the boundary of a sub control volume we compute fluxes on |
| CBoxDfmVtkOutputModule | A VTK output module to simplify writing dumux simulation data to VTK format |
| CBoxElementBoundaryTypes | This class stores an array of BoundaryTypes objects |
| CBoxElementFluxVariablesCache | The flux variables caches for an element |
| CBoxElementFluxVariablesCache< GFVC, false > | The flux variables caches for an element with caching disabled |
| CBoxElementFluxVariablesCache< GFVC, true > | The flux variables caches for an element with caching enabled |
| CBoxElementSolution | The element solution vector |
| CBoxElementVolumeVariables | The local (stencil) volume variables class for box models |
| CBoxElementVolumeVariables< GVV, false > | The local (stencil) volume variables class for box models without caching |
| CBoxElementVolumeVariables< GVV, true > | The local (stencil) volume variables class for box models with caching |
| CBoxFacetCouplingDarcysLaw | Darcy's law for the box scheme in the context of coupled models where coupling occurs across the facets of the bulk domain elements with a lower-dimensional domain living on these facets |
| CBoxFacetCouplingDefaultGridGeometryTraits | The default traits for the finite volume grid geometry of the box scheme with coupling occuring across the element facets. Defines the scv and scvf types and the mapper types |
| CBoxFacetCouplingFicksLaw | Ficks's law for the box scheme in the context of coupled models where coupling occurs across the facets of the bulk domain elements with a lower-dimensional domain living on these facets |
| CBoxFacetCouplingFouriersLaw | Fourier's law for the box scheme in the context of coupled models where coupling occurs across the facets of the bulk domain elements with a lower-dimensional domain living on these facets |
| CBoxFacetCouplingFVElementGeometry | Base class for the element-local finite volume geometry for box models in the context of models considering coupling of different domains across the bulk grid facets. This builds up the sub control volumes and sub control volume faces for an element |
| CBoxFacetCouplingFVElementGeometry< GG, false > | Specialization in case the geometries are not stored grid-wide |
| CBoxFacetCouplingFVElementGeometry< GG, true > | Specialization in case the FVElementGeometries are stored |
| CBoxFacetCouplingFVGridGeometry | Base class for the finite volume geometry vector for box schemes in the context of coupled models where the coupling occurs across the element facets. This builds up the sub control volumes and sub control volume faces |
| CBoxFacetCouplingFVGridGeometry< Scalar, GV, false, Traits > | Base class for the finite volume geometry vector for box schemes This builds up the sub control volumes and sub control volume faces |
| CBoxFacetCouplingFVGridGeometry< Scalar, GV, true, Traits > | Base class for the finite volume geometry vector for box schemes in the context of coupled models where the coupling occurs across the element facets. This builds up the sub control volumes and sub control volume faces |
| CBoxFacetCouplingLocalResidual | The element-wise residual for the box scheme |
| CBoxFacetCouplingSubControlVolumeFace | Class for a sub control volume face in the box method, i.e a part of the boundary of a sub control volume we compute fluxes on. This is a specialization for models considering coupling of different domains across the bulk grid facets |
| CBoxFacetCouplingUpwindScheme | The upwind scheme used for the advective fluxes. This is a modified scheme for models involving coupling with a lower-dimensional domain across the element facets |
| CBoxFluxVariablesCache | Flux variables cache class for the box scheme. For the box scheme, this class does not contain any physics-/process-dependent data. It solely stores disretization-/grid-related data |
| CBoxFVElementGeometry | Base class for the finite volume geometry vector for box models This builds up the sub control volumes and sub control volume faces for each element |
| CBoxFVElementGeometry< GG, false > | Specialization in case the FVElementGeometries are not stored |
| CBoxFVElementGeometry< GG, true > | Specialization in case the FVElementGeometries are stored |
| CBoxFVGridGeometry | Base class for the finite volume geometry vector for box schemes This builds up the sub control volumes and sub control volume faces |
| CBoxFVGridGeometry< Scalar, GV, false, Traits > | Base class for the finite volume geometry vector for box schemes This builds up the sub control volumes and sub control volume faces |
| CBoxFVGridGeometry< Scalar, GV, true, Traits > | Base class for the finite volume geometry vector for box schemes This builds up the sub control volumes and sub control volume faces |
| CBoxGeometryHelper | Create sub control volumes and sub control volume face geometries |
| CBoxGeometryHelper< GridView, 1, ScvType, ScvfType > | A class to create sub control volume and sub control volume face geometries per element |
| CBoxGeometryHelper< GridView, 2, ScvType, ScvfType > | A class to create sub control volume and sub control volume face geometries per element |
| CBoxGeometryHelper< GridView, 3, ScvType, ScvfType > | A class to create sub control volume and sub control volume face geometries per element |
| CBoxGridFluxVariablesCache | Flux variable caches on a gridview |
| CBoxGridFluxVariablesCache< P, FVC, false, Traits > | Flux variable caches on a gridview with grid caching disabled |
| CBoxGridFluxVariablesCache< P, FVC, true, Traits > | Flux variable caches on a gridview with grid caching enabled |
| CBoxGridVolumeVariables | Base class for the grid volume variables |
| CBoxGridVolumeVariables< P, VV, false, Traits > | |
| CBoxGridVolumeVariables< P, VV, true, Traits > | |
| CBoxLocalAssembler | An assembler for Jacobian and residual contribution per element (box methods) |
| CBoxLocalAssembler< TypeTag, Assembler, DiffMethod::analytic, false > | Box local assembler using analytic differentiation and explicit time discretization |
| CBoxLocalAssembler< TypeTag, Assembler, DiffMethod::analytic, true > | Box local assembler using analytic differentiation and implicit time discretization |
| CBoxLocalAssembler< TypeTag, Assembler, DiffMethod::numeric, false > | Box local assembler using numeric differentiation and explicit time discretization |
| CBoxLocalAssembler< TypeTag, Assembler, DiffMethod::numeric, true > | Box local assembler using numeric differentiation and implicit time discretization |
| CBoxLocalAssemblerBase | A base class for all local box assemblers |
| CBoxLocalResidual | The element-wise residual for the box scheme |
| CBoxMaterialInterfaces | Class that determines the material with the lowest capillary pressure (under fully water-saturated conditions) around the nodes of a grid |
| CBoxSubControlVolume | Sub control volume for the box scheme |
| CBoxSubControlVolumeFace | Class for a sub control volume face in the box method, i.e a part of the boundary of a sub control volume we compute fluxes on. We simply use the base class here |
| CCakeGridManager | Provides a grid manager with a method for creating creating vectors with polar Coordinates and one for creating a Cartesian grid from these polar coordinates |
| CCapillaryDiffusion | Class for defining the diffusive capillary pressure term of a saturation equation |
| CCCDefaultScvGeometryTraits | Default traits class to be used for the sub-control volumes for the cell-centered finite volume scheme using TPFA |
| CCCElementBoundaryTypes | Boundary types gathered on an element |
| CCCElementSolution | The element solution vector |
| CCCFacetCouplingLocalResidual | Calculates the element-wise residual for cell-centered discretization schemes in models where coupling occurs across the element facets. We only overwrite the function for the computation of a flux across a single sub-control volume face, as we need to additionally check if a boundary face couples to a facet element |
| CCCFacetCouplingUpwindScheme | The upwind scheme used for the advective fluxes. This is a modified scheme for models involving coupling with a lower-dimensional domain across the element facets |
| CCCGridVolumeVariables | Base class for the grid volume variables |
| CCCGridVolumeVariables< Traits, false > | Specialization when the current volume variables are not stored globally |
| CCCGridVolumeVariables< Traits, true > | Specialization in case of storing the volume variables |
| CCCLocalAssembler | An assembler for Jacobian and residual contribution per element (cell-centered methods) |
| CCCLocalAssembler< TypeTag, Assembler, DiffMethod::analytic, false > | Cell-centered scheme local assembler using analytic (hand-coded) differentiation and explicit time discretization |
| CCCLocalAssembler< TypeTag, Assembler, DiffMethod::analytic, true > | Cell-centered scheme local assembler using analytic (hand-coded) differentiation and implicit time discretization |
| CCCLocalAssembler< TypeTag, Assembler, DiffMethod::numeric, false > | Cell-centered scheme local assembler using numeric differentiation and explicit time discretization |
| CCCLocalAssembler< TypeTag, Assembler, DiffMethod::numeric, true > | Cell-centered scheme local assembler using numeric differentiation and implicit time discretization |
| CCCLocalAssemblerBase | A base class for all local cell-centered assemblers |
| CCCLocalResidual | Calculates the element-wise residual for the cell-centered discretization schemes |
| CCCMpfaConnectivityMap | Forward declaration of method specific implementation of the assembly map |
| CCCMpfaConnectivityMap< GridGeometry, MpfaMethods::oMethod > | The o-method can use the simple (symmetric) assembly map |
| CCCMpfaDefaultGridFluxVariablesCacheTraits | Data handle physics traits |
| CCCMpfaDefaultGridVolumeVariablesTraits | |
| ►CCCMpfaDefaultScvfGeometryTraits | Default traits class to be used for the sub-control volume faces for the cell-centered finite volume scheme using MPFA |
| ►CScvfMLGTraits | |
| CCornerStorage | |
| ChasSingleGeometryType | |
| CCCMpfaDualGridIndexSet | Class for the index sets of the dual grid in mpfa schemes |
| CCCMpfaDualGridNodalIndexSet | Nodal index set for mpfa schemes, constructed around grid vertices |
| CCCMpfaElementFluxVariablesCache | The flux variables caches for an element |
| CCCMpfaElementFluxVariablesCache< GFVC, false > | The flux variables caches for an element with caching disabled |
| CCCMpfaElementFluxVariablesCache< GFVC, true > | The flux variables caches for an element with caching enabled |
| CCCMpfaElementVolumeVariables | The local (stencil) volume variables class for cell centered mpfa models |
| CCCMpfaElementVolumeVariables< GVV, false > | The local (stencil) volume variables class for cell centered tpfa models with caching |
| CCCMpfaElementVolumeVariables< GVV, true > | The local (stencil) volume variables class for cell centered mpfa models with caching |
| CCCMpfaFVElementGeometry | Stencil-local finite volume geometry (scvs and scvfs) for cell-centered mpfa models This builds up the sub control volumes and sub control volume faces for each element in the local scope we are restricting to, e.g. stencil or element |
| CCCMpfaFVElementGeometry< GG, false > | Stencil-local finite volume geometry (scvs and scvfs) for cell-centered TPFA models Specialization for grid caching disabled |
| CCCMpfaFVElementGeometry< GG, true > | Stencil-local finite volume geometry (scvs and scvfs) for cell-centered mpfa models Specialization for grid caching enabled |
| CCCMpfaFVGridGeometry | The finite volume geometry (scvs and scvfs) for cell-centered mpfa models on a grid view This builds up the sub control volumes and sub control volume faces |
| CCCMpfaFVGridGeometry< GV, Traits, false > | The finite volume geometry (scvs and scvfs) for cell-centered mpfa models on a grid view This builds up the sub control volumes and sub control volume faces |
| CCCMpfaFVGridGeometry< GV, Traits, true > | The finite volume geometry (scvs and scvfs) for cell-centered mpfa models on a grid view This builds up the sub control volumes and sub control volume faces |
| CCCMpfaFVGridGeometryTraits | Traits class to be used for the CCMpfaFVGridGeometry |
| CCCMpfaGridFluxVariablesCache | Flux variable caches on a gridview |
| CCCMpfaGridFluxVariablesCache< TheTraits, false > | Flux variable caches on a gridview with grid caching disabled |
| CCCMpfaGridFluxVariablesCache< TheTraits, true > | Flux variable caches on a gridview with grid caching enabled |
| CCCMpfaGridInteractionVolumeIndexSets | Class that holds all interaction volume index sets on a grid view |
| CCCMpfaGridVolumeVariables | Base class for the grid volume variables |
| CCCMpfaHelper | Helper class to get the required information on an interaction volume |
| CCCMpfaInteractionVolumeBase | Base class for the interaction volumes of mpfa methods. It defines the interface and actual implementations should derive from this class |
| CCCMpfaODefaultInteractionVolumeTraits | The default interaction volume traits class for the mpfa-o method. This uses dynamic types types for matrices/vectors in order to work on general grids. For interaction volumes known at compile time use the static interaction volume implementation |
| CCCMpfaODefaultStaticInteractionVolumeTraits | The default interaction volume traits class for the mpfa-o method with known size of the interaction volumes at compile time. It uses statically sized containers for the iv-local data structures and static matrices and vectors |
| CCCMpfaOFacetCouplingDefaultInteractionVolumeTraits | The default interaction volume traits class for the mpfa-o method in the context of facet coupling. This uses dynamic types types for matrices/vectors in order to work on general grids |
| ►CCCMpfaOFacetCouplingInteractionVolume | Forward declaration of the facet coupling MPFA-O interaction volume |
| CInteriorBoundaryData | Define data structure to store which scvfs lie on interior boundaries |
| CCCMpfaOFacetCouplingInteractionVolumeLocalScv | Class for the interaction volume-local sub-control volume used in the mpfa-o scheme in the context of facet coupling |
| CCCMpfaOFacetCouplingInteractionVolumeLocalScvf | Class for the interaction volume-local sub-control volume face used in the mpfa-o scheme in the context of facet coupling |
| ►CCCMpfaOInteractionVolume | Forward declaration of the o-method's interaction volume |
| CDirichletData | |
| CCCMpfaOInteractionVolumeIndexSet | The interaction volume index set class for the mpfa-o scheme |
| CCCMpfaOInteractionVolumeLocalScv | Class for the interaction volume-local sub-control volume used in the mpfa-o scheme |
| CCCMpfaOInteractionVolumeLocalScvf | Class for the interaction volume-local sub-control volume face used in the mpfa-o scheme |
| CCCMpfaOScvGeometryHelper | Helper class providing functionality to compute the geometry of the interaction-volume local sub-control volumes of mpfa-o type |
| ►CCCMpfaOStaticInteractionVolume | Forward declaration of the o-method's static interaction volume |
| CDirichletData | This does not work on surface grids |
| CCCMpfaScvGradients | Class roviding functionality for the reconstruction of the gradients in the sub-control volumes involved in mpfa schemes |
| CCCMpfaSubControlVolumeFace | Class for a sub control volume face in mpfa methods, i.e a part of the boundary of a control volume we compute fluxes on |
| CCCSimpleConnectivityMap | A simple version of the connectivity map for cellcentered schemes. This implementation works for schemes in which for a given cell I only those cells J have to be prepared in whose stencil the cell I appears. This means that for the flux calculations in the cells J (in order to compute the derivatives with respect to cell I), we do not need data on any additional cells J to compute these fluxes. The same holds for scvfs in the cells J, i.e. we need only those scvfs in the cells J in which the cell I is in the stencil |
| CCCSubControlVolume | Sub control volumes for cell-centered discretization schemes |
| CCCTpfaDarcysLaw | Darcy's law for cell-centered finite volume schemes with two-point flux approximation |
| CCCTpfaDarcysLaw< ScalarType, GridGeometry, false > | Specialization of the CCTpfaDarcysLaw grids where dim=dimWorld |
| CCCTpfaDarcysLaw< ScalarType, GridGeometry, true > | Specialization of the CCTpfaDarcysLaw grids where dim < dimWorld (network/surface grids) |
| CCCTpfaDefaultGridFVCTraits | Flux variable caches traits |
| CCCTpfaDefaultGridGeometryTraits | The default traits for the tpfa finite volume grid geometry Defines the scv and scvf types and the mapper types |
| CCCTpfaDefaultGridVolumeVariablesTraits | |
| ►CCCTpfaDefaultScvfGeometryTraits | Default traits class to be used for the sub-control volume faces for the cell-centered finite volume scheme using TPFA |
| ►CScvfMLGTraits | |
| CCornerStorage | |
| CCCTpfaElementFluxVariablesCache | The flux variables caches for an element |
| CCCTpfaElementFluxVariablesCache< GFVC, false > | The flux variables caches for an element with caching disabled |
| CCCTpfaElementFluxVariablesCache< GFVC, true > | The flux variables caches for an element with caching enabled |
| CCCTpfaElementVolumeVariables | The local (stencil) volume variables class for cell centered tpfa models |
| CCCTpfaElementVolumeVariables< GVV, false > | The local (stencil) volume variables class for cell centered tpfa models with caching |
| CCCTpfaElementVolumeVariables< GVV, true > | The local (stencil) volume variables class for cell centered tpfa models with caching |
| CCCTpfaFacetCouplingDarcysLawCache | The cache corresponding to tpfa Darcy's Law with facet coupling |
| CCCTpfaFacetCouplingDarcysLawCache< AdvectionType, GridGeometry, false > | Specialization of FacetCouplingTpfaDarcysLawCache for non-network grids |
| CCCTpfaFacetCouplingDarcysLawCache< AdvectionType, GridGeometry, true > | Specialization of FacetCouplingTpfaDarcysLawCache for network grids |
| CCCTpfaFacetCouplingDarcysLawImpl | Forward declaration of the implementation |
| CCCTpfaFacetCouplingDarcysLawImpl< ScalarType, GridGeometry, false > | Specialization of CCTpfaFacetCouplingDarcysLawImpl for dim=dimWorld |
| CCCTpfaFacetCouplingDarcysLawImpl< ScalarType, GridGeometry, true > | Specialization of CCTpfaFacetCouplingDarcysLawImpl for dim<dimWorld |
| CCCTpfaFacetCouplingFicksLawImpl | Forward declaration of the implementation |
| CCCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem, false > | Specialization of CCTpfaFacetCouplingFicksLawImpl for dim=dimWorld |
| CCCTpfaFacetCouplingFicksLawImpl< TypeTag, referenceSystem, true > | Specialization of CCTpfaFacetCouplingFicksLawImpl for dim<dimWorld |
| CCCTpfaFacetCouplingFouriersLawImpl | Forward declaration of the implementation |
| CCCTpfaFacetCouplingFouriersLawImpl< TypeTag, false > | Specialization of CCTpfaFacetCouplingFouriersLawImpl for dim=dimWorld |
| CCCTpfaFacetCouplingFouriersLawImpl< TypeTag, true > | Specialization of CCTpfaFacetCouplingFouriersLawImpl for dim<dimWorld |
| CCCTpfaForchheimersLaw | Forchheimer's law for cell-centered finite volume schemes with two-point flux approximation |
| CCCTpfaForchheimersLaw< ScalarType, GridGeometry, UpwindScheme, false > | Specialization of the CCTpfaForchheimersLaw grids where dim=dimWorld |
| CCCTpfaForchheimersLaw< ScalarType, GridGeometry, UpwindScheme, true > | Specialization of the CCTpfaForchheimersLaw grids where dim<dimWorld |
| CCCTpfaFVElementGeometry | Stencil-local finite volume geometry (scvs and scvfs) for cell-centered TPFA models This builds up the sub control volumes and sub control volume faces for each element in the local scope we are restricting to, e.g. stencil or element |
| CCCTpfaFVElementGeometry< GG, false > | Stencil-local finite volume geometry (scvs and scvfs) for cell-centered TPFA models Specialization for grid caching disabled |
| CCCTpfaFVElementGeometry< GG, true > | Stencil-local finite volume geometry (scvs and scvfs) for cell-centered TPFA models Specialization for grid caching enabled |
| CCCTpfaFVGridGeometry | The finite volume geometry (scvs and scvfs) for cell-centered TPFA models on a grid view This builds up the sub control volumes and sub control volume faces |
| CCCTpfaFVGridGeometry< GV, false, Traits > | The finite volume geometry (scvs and scvfs) for cell-centered TPFA models on a grid view This builds up the sub control volumes and sub control volume faces |
| CCCTpfaFVGridGeometry< GV, true, Traits > | The finite volume geometry (scvs and scvfs) for cell-centered TPFA models on a grid view This builds up the sub control volumes and sub control volume faces |
| CCCTpfaGridFluxVariablesCache | Flux variable caches on a gridview |
| CCCTpfaGridFluxVariablesCache< P, FVC, FVCF, false, TheTraits > | Flux variable caches on a gridview with grid caching disabled |
| CCCTpfaGridFluxVariablesCache< P, FVC, FVCF, true, TheTraits > | Flux variable caches on a gridview with grid caching enabled |
| CCCTpfaGridVolumeVariables | Base class for the grid volume variables |
| CCCTpfaSubControlVolumeFace | The sub control volume face |
| CCellCenterFVGridGeometry | Cell center specific auxiliary FvGridGeometry classes. Required for the Dumux multi-domain framework |
| CCellCenterGridVariablesView | Cell center specific auxiliary GridVariables classes. Required for the Dumux multi-domain framework |
| CCellData1P | Class including data of one grid cell |
| CCellData2P | Class including data of one grid cell |
| CCellData2P2C | Storage container for discretized data of the constitutive relations for one element |
| ►CCellData2P2CAdaptive | Class including the data of a grid cell needed if an adaptive grid is used |
| CAdaptedValues | A container for all necessary variables to map an old solution to a new grid If the primary variables (pressure, total concentrations) are mapped to a new grid, the secondary variables can be calulated. For the mapping between sons and father, it is in addition necessary to know about how many sons live in each father ("count"). While only one phase pressure is PV, the method updateMaterialLaws() that recalculates the secondary variables needs both phase pressures (initiated via the capillary pressure of the last time step) to start the iteration to determine appropriate phase composition and pc. Hence, both phase pressures are mapped to the new solution |
| CCellData2P2CMultiPhysics | Storage container for discretized data for multiphysics models |
| CCellData2P< TypeTag, false > | Class including the variables and data of discretized data of the constitutive relations for one grid cell |
| CCellData2P< TypeTag, true > | Class including the variables and data of discretized data of the constitutive relations for one grid cell |
| ►CCellData2PAdaptive | Class including the data of a grid cell needed if an adaptive grid is used |
| CAdaptedValues | Collection of variables that have to be mapped if the grid is adapted For an immiscible two-phase model, the following data has to be transferred to a new grid |
| CCheckOverlapSize | Check if the overlap size is valid for a given discretization method |
| CCheckOverlapSize< DiscretizationMethod::box > | Specialization for the box method which requires an overlap size of 0 |
| CCheckOverlapSize< DiscretizationMethod::fem > | |
| CCheckPointTimeLoop | A time loop with a check point mechanism |
| CCircleAveragePointSourceTraits | Point source traits for the circle average coupling mode |
| CCodimOneGridAdapter | Adapter that allows retrieving information on a d-dimensional grid for entities of a (d-1)-dimensional grid. This lower-dimensional grid is assumed to be facet-conforming to the d-dimensional grid. This class can be used in the context of models where a sub-domain lives on the facets of a bulk grid |
| CComponentTraits | Component traits, i.e. information extracted from components |
| CComponentTraits< Components::TabulatedComponent< RawComponent, useVaporPressure > > | Component traits for tabulated component |
| CCompositionalFlash | Flash calculation routines for compositional sequential models |
| CCompositionalFluidState | Represents all relevant thermodynamic quantities of a multi-phase, multi-component fluid system assuming thermodynamic equilibrium |
| CCompositionalLocalResidual | Element-wise calculation of the local residual for problems using compositional fully implicit model |
| CCompositionalSolidState | Represents all relevant thermodynamic quantities of a compositional solid system |
| CCompositionFromFugacities | Calculates the chemical equilibrium from the component fugacities \( f^\kappa \) in the phase \( \alpha \) |
| CComputeFromReferencePhase | Computes all quantities of a generic fluid state if a reference phase has been specified |
| CConformingGridIntersectionMapper | Defines a standard intersection mapper for mapping of global DOFs assigned to faces. It only works for conforming grids, without hanging nodes |
| CConstants | A central place for various physical constants occuring in some equations |
| CConvectivePart | Base class for defining a convective part of the saturation transport equation |
| CConvergenceWriterInterface | |
| CCouplingManager | |
| CCROperatorAssemblerTwoP | Extends CROperatorBase by a generic methods to assemble global stiffness matrix from local stiffness matrices |
| CCROperatorAssemblerTwoPAdaptive | Extends CROperatorBase by a generic methods to assemble global stiffness matrix from local stiffness matrices |
| CCubicSpline | A simple implementation of a natural cubic spline |
| CCubicSplineHermiteBasis | The cubic spline hermite basis |
| CDarcyDarcyBoundaryCouplingManager | Coupling manager for equal-dimension boundary coupling of darcy models |
| CDarcyDarcyBoundaryCouplingMapper | Default mapper for conforming equal dimension boundary coupling between two domains (box or cc) |
| CDarcysLawImplementation | Forward declaration of the method-specific implementation |
| CDarcysLawImplementation< TypeTag, DiscretizationMethod::box > | Specialization of Darcy's Law for the box method |
| CDarcysLawImplementation< TypeTag, DiscretizationMethod::ccmpfa > | Darcy's law for cell-centered finite volume schemes with multi-point flux approximation |
| CDarcysLawImplementation< TypeTag, DiscretizationMethod::cctpfa > | Darcy's law for cell-centered finite volume schemes with two-point flux approximation |
| CDefaultFEGridGeometryTraits | Default Traits class for the fem grid geometry |
| CDefaultIOFields | Adds output fields to a given output module |
| CDefaultMapperTraits | |
| CDefaultPartialReassembler | |
| CDefaultPointSourceTraits | Default point source traits |
| CDiffusionCacheChooser | |
| CDiffusionCacheChooser< TypeTag, true > | |
| CDiffusionDataHandle | Data handle for quantities related to diffusion |
| CDiffusionDataHandle< MatVecTraits, PhysicsTraits, false > | |
| CDiffusionProblem1P | Base class for all single phase diffusion problems |
| CDiffusionProblem2P | Base class for stationary solution of a two-phase diffusion/pressure equation |
| CDiffusivePart | Base class for defining the diffusive part of the saturation transport equation |
| CDiffusivityConstantTortuosity | Relation for the saturation-dependent effective diffusion coefficient |
| CDiffusivityMillingtonQuirk | Relation for the saturation-dependent effective diffusion coefficient |
| CDimensionlessNumbers | Collection of functions which calculate dimensionless numbers. Each number has it's own function. All the parameters for the calculation have to be handed over. Rendering this collection generic in the sense that it can be used by any model |
| CDofBackend | Class providing operations with primary variable vectors |
| CDofBackend< Dune::MultiTypeBlockVector< Blocks... >, false > | Specialization providing operations for multitype block vectors |
| CDofBackend< Scalar, true > | Specialization providing operations for scalar/number types |
| CDofBackend< Vector, false > | Specialization providing operations for block vectors |
| CDoubleExponentialIntegrator | Numerical integration in one dimension using the double exponential method of M. Mori |
| CDumuxMessage | DuMux start and end message |
| CEffectiveStressLaw | This computes the stress tensor and surface forces resulting from poro-mechanical deformation |
| CEffectiveStressLaw< StressType, GridGeometry, DiscretizationMethod::box > | Effective stress law for box scheme |
| CElasticIndices | The indices for the linear elasticity model |
| CElasticLocalResidual | Element-wise calculation of the local residual for problems using the elastic model considering linear elasticity |
| CElasticModelTraits | Specifies a number properties of the elastic model |
| CElasticVolumeVariables | Contains the quantities which are constant within a finite volume in the elastic model |
| CElasticVolumeVariablesTraits | Traits class for the volume variables of the elastic model |
| CElectroChemistry | This class calculates source terms and current densities for fuel cells with the electrochemical models suggested by Ochs (2008) [47] or Acosta et al. (2006) [2] |
| CElectroChemistryNI | Class calculating source terms and current densities for fuel cells with the electrochemical models suggested by Ochs (2008) [47] or Acosta (2006) [2] for the non-isothermal case |
| CEmbedded1d3dCouplingManager | Manages the coupling between bulk elements and lower dimensional elements Point sources on each integration point are computed by an AABB tree |
| CEmbedded1d3dCouplingManager< MDTraits, Embedded1d3dCouplingMode::Average > | Manages the coupling between bulk elements and lower dimensional elements Point sources on each integration point are computed by an AABB tree |
| CEmbedded1d3dCouplingManager< MDTraits, Embedded1d3dCouplingMode::Kernel > | Manages the coupling between bulk elements and lower dimensional elements Point sources on each integration point are computed by an AABB tree |
| CEmbedded1d3dCouplingManager< MDTraits, Embedded1d3dCouplingMode::Line > | Manages the coupling between bulk elements and lower dimensional elements Point sources on each integration point are computed by an AABB tree |
| CEmbedded1d3dCouplingManager< MDTraits, Embedded1d3dCouplingMode::Surface > | Manages the coupling between bulk elements and lower dimensional elements Point sources on each integration point are computed by an AABB tree |
| CEmbeddedCouplingManager2d3d | Coupling manager for embedded fractures |
| CEmbeddedCouplingManagerBase | Manages the coupling between bulk elements and lower dimensional elements Point sources on each integration point are computed by an AABB tree |
| CEmptyDataHandle | Empty data handle class |
| CEmptyElementSolution | |
| CEnergyCacheChooser | |
| CEnergyCacheChooser< TypeTag, true > | |
| CEnergyIndices | Indices for the non-isothermal two-phase two-component model |
| CEnergyIOFields | Adds I/O fields specific to non-isothermal models |
| CEnergyIOFields< void > | Adds I/O fields specific to non-isothermal models |
| CEnergyLocalResidualImplementation | |
| CEnergyLocalResidualImplementation< TypeTag, false > | Element-wise calculation of the energy residual for non-isothermal problems |
| CEnergyLocalResidualImplementation< TypeTag, true > | TODO docme! |
| CEnergyLocalResidualNonEquilibrium | This file contains the parts of the local residual to calculate the heat conservation in the thermal non-equilibrium model |
| CEnergyLocalResidualNonEquilibrium< TypeTag, 1 > | |
| CEnergyLocalResidualNonEquilibrium< TypeTag, 2 > | |
| CEnergyVolumeVariablesImplementation | |
| CEnergyVolumeVariablesImplementation< IsothermalTraits, Impl, false > | The isothermal base class |
| CEnergyVolumeVariablesImplementation< Traits, Impl, true > | The non-isothermal implicit volume variables base class |
| CEnrichedVertexDofMapper | A vertex mapper that allows for enrichment of nodes. Indication on where to enrich the nodes is done on the basis of a grid of codimension one living on the facets of the bulk grid |
| CEnrichmentIndicator | An indicator class used to mark vertices for enrichment. This implementation marks all vertices of a given grid of codimension one for enrichment, except those that are connected to inmersed boundaries |
| CEntityMap | A map from indices to entities using grid entity seeds |
| CEvalCflFlux | Base class for implementations of different kinds of fluxes to evaluate a CFL-Condition |
| CEvalCflFluxCoats | Cfl-flux-function to evaluate a Cfl-Condition after Coats 2003 |
| CEvalCflFluxDefault | Default implementation of cfl-fluxes to evaluate a CFL-Condition |
| CExplicitDiagonalSolver | Solver for simple block-diagonal matrices (e.g. from explicit time stepping schemes) |
| CExtendedRichardsPrimaryVariableSwitch | The primary variable switch controlling the phase presence state variable |
| CExtrusion | Traits extracting the public Extrusion type from T Defaults to NoExtrusion if no such type is found |
| CFaceFVGridGeometry | Face specific auxiliary FvGridGeometry classes. Required for the Dumux multi-domain framework |
| CFaceGridVariablesView | Face specific auxiliary GridVariables classes. Required for the Dumux multi-domain framework |
| CFacetCouplingEmbeddings | Contains the embeddings between grids with codimension one among the grid hierarchy. All these embedments are given in insertion indices as they are read directly from the grid. Therefore, this class furthermore allows access to the insertion indices of entities. Additionally, it gives access to the grid views of the different grids on the hierarchy |
| CFacetCouplingGmshReader | Reads gmsh files where (n-1)-dimensional grids are defined on the faces or edges of n-dimensional grids |
| CFacetCouplingGridDataWrapper | Grid data object to store element and boundary segment markers for all grids of the hierarchy |
| CFacetCouplingGridManager | Creates the grids in the context of hybrid-dimensional coupled models, where the (n-1)-dimensional domains live on the element facets of the n-dimensional domains |
| CFacetCouplingManager | Implementation for the coupling manager between two domains of dimension d and (d-1) for models considering coupling across the bulk domain element facets. The implementations are specificto the discretization method used in the bulk domain, which is extracted automatically from the grid geometry corresponding to the provided bulk domain id. Implementations for the different methods have to be provided and included at the end of this file |
| CFacetCouplingManager< MDTraits, CouplingMapper, bulkDomainId, lowDimDomainId, DiscretizationMethod::box > | Manages the coupling between bulk elements and lower dimensional elements where the coupling occurs across the facets of the bulk grid. This implementation is to be used in conjunction with models using the box scheme in the bulk domain |
| CFacetCouplingManager< MDTraits, CouplingMapper, bulkDomainId, lowDimDomainId, DiscretizationMethod::ccmpfa > | Manages the coupling between bulk elements and lower dimensional elements where the coupling occurs across the facets of the bulk grid. This implementation is to be used in conjunction with models using the cell-centered mpfa scheme |
| CFacetCouplingManager< MDTraits, CouplingMapper, bulkDomainId, lowDimDomainId, DiscretizationMethod::cctpfa > | Manages the coupling between bulk elements and lower dimensional elements where the coupling occurs across the facets of the bulk grid. This implementation is to be used in conjunction with models using the cell-centered tpfa scheme |
| CFacetCouplingMapper | Implementation for the coupling mapper that sets up and stores the coupling maps between two domains of dimension d and (d-1). The implementations are specific to the discretization method used in the bulk domain, which is extracted automatically from the bulk grid geometry. Implementations for the different methods have to be provided and included at the end of this file |
| CFacetCouplingMapper< BulkFVG, LowDimFVG, bulkId, lowDimId, DiscretizationMethod::box > | Base class for the coupling mapper that sets up and stores the coupling maps between two domains of dimension d and (d-1). This specialization is for the bulk domain using the box scheme |
| CFacetCouplingMapper< BulkFVG, LowDimFVG, bulkId, lowDimId, DiscretizationMethod::ccmpfa > | Base class for the coupling mapper that sets up and stores the coupling maps between two domains of dimension d and (d-1). This specialization is for the bulk domain using the cell-centered scheme with multi-point flux approximation |
| CFacetCouplingMapper< BulkFVG, LowDimFVG, bulkId, lowDimId, DiscretizationMethod::cctpfa > | Base class for the coupling mapper that sets up and stores the coupling maps between two domains of dimension d and (d-1). This specialization is for the bulk domain using the cell-centered scheme with two-point flux approximation |
| CFacetCouplingMapperBase | Base class for the coupling mapper that sets up and stores the coupling maps between two domains of dimension d and (d-1) |
| CFacetCouplingThreeDomainManager | Class that handles the coupling between three sub-domains in models where the coupling between the two occurs across the facets of the d- and (d-1)- dimensional domains |
| CFacetCouplingThreeDomainMapper | Specialization of the mapper class for the case of three domains with the grid dimensions d, (d-1) & (d-2) |
| CFEElementGeometry | Grid geometry local view, which is a wrapper around a finite element basis local view |
| CFEGridGeometry | The grid geometry class for models using finite element schemes. This is basically a wrapper around a function space basis |
| CFickianDiffusionCoefficients | Container storing the diffusion coefficients required by Fick's law. Uses the minimal possible container size and provides unified access |
| CFicksLawImplementation | Forward declaration of the method-specific implemetation |
| CFicksLawImplementation< TypeTag, DiscretizationMethod::box, referenceSystem > | Specialization of Fick's Law for the box method |
| CFicksLawImplementation< TypeTag, DiscretizationMethod::ccmpfa, referenceSystem > | Fick's law for cell-centered finite volume schemes with multi-point flux approximation |
| CFicksLawImplementation< TypeTag, DiscretizationMethod::cctpfa, referenceSystem > | Fick's law for cell-centered finite volume schemes with two-point flux approximation |
| CFicksLawImplementation< TypeTag, DiscretizationMethod::staggered, referenceSystem > | Specialization of Fick's Law for the staggered free flow method |
| CFixedLengthSpline_ | The common code for all 3rd order polynomial splines with more than two sampling points |
| CFluidMatrixInteraction | Wrapper type to combine an arbitrary number of different laws for fluid-matrix interaction (e.g., pc-Sw-curves) |
| CFluidSolidInterfacialAreaShiWang | Description of a interfacial area between solid and fluid phase |
| CFluidStateAdapter | Adapter class for fluid states with different indices |
| CFluxData1P | Class storing data assigned to a cell-cell interfaces, so-called flux-data |
| CFluxData2P | Class storing data assigned to a cell-cell interfaces, so-called flux-data |
| CFluxData2P2C | Class including the variables and data of discretized data of the constitutive relations |
| CFluxOverSurface | Class used to calculate fluxes over surfaces. This only works for the staggered grid discretization |
| CFluxStencil | The flux stencil specialized for different discretization schemes |
| CFluxStencil< FVElementGeometry, DiscretizationMethod::ccmpfa > | |
| CFluxStencil< FVElementGeometry, DiscretizationMethod::cctpfa > | |
| CFluxTraits | Traits of a flux variables type |
| CFluxVariablesBase | Base class for the flux variables living on a sub control volume face |
| CForchheimersLawImplementation | Forward declare |
| CForchheimersLawImplementation< TypeTag, DiscretizationMethod::cctpfa > | Forchheimer's law for cell-centered finite volume schemes with two-point flux approximation |
| CFouriersLawImplementation | Forward declaration of the method-specific implementation |
| CFouriersLawImplementation< TypeTag, DiscretizationMethod::box > | Specialization of Fourier's Law for the box method |
| CFouriersLawImplementation< TypeTag, DiscretizationMethod::ccmpfa > | Fourier's law for cell-centered finite volume schemes with two-point flux approximation |
| CFouriersLawImplementation< TypeTag, DiscretizationMethod::cctpfa > | Fourier's law for cell-centered finite volume schemes with two-point flux approximation |
| CFouriersLawImplementation< TypeTag, DiscretizationMethod::staggered > | Specialization of Fourier's Law for the staggered free flow method |
| CFouriersLawNonEquilibriumImplementation | |
| CFouriersLawNonEquilibriumImplementation< TypeTag, DiscretizationMethod::box > | Specialization of Fourier's Law for the box method for thermal nonequilibrium models |
| CFouriersLawNonEquilibriumImplementation< TypeTag, DiscretizationMethod::cctpfa > | Fourier's law for cell-centered finite volume schemes with two-point flux approximation |
| CFreeFlowEnergyLocalResidualImplementation | |
| CFreeFlowEnergyLocalResidualImplementation< GridGeometry, FluxVariables, discMethod, false, isCompositional > | Specialization for isothermal models, does nothing |
| CFreeFlowEnergyLocalResidualImplementation< GridGeometry, FluxVariables, DiscretizationMethod::staggered, true, false > | Specialization for staggered one-phase, non-isothermal models |
| CFreeFlowEnergyLocalResidualImplementation< GridGeometry, FluxVariables, DiscretizationMethod::staggered, true, true > | Specialization for staggered compositional, non-isothermal models |
| CFreeflowNCFluxVariablesImpl | The flux variables class for the multi-component free-flow model using the staggered grid discretization |
| CFreeflowNCFluxVariablesImpl< TypeTag, DiscretizationMethod::staggered > | |
| CFreeflowNCIOFields | Adds I/O fields specific to the FreeflowNC model |
| CFreeflowNCResidualImpl | Element-wise calculation of the multi-component free-flow residual for models using the staggered discretization |
| CFreeflowNCResidualImpl< TypeTag, DiscretizationMethod::staggered > | |
| CFreeflowNCVolumeVariables | Volume variables for the single-phase, multi-component free-flow model |
| CFreeflowNIModelTraits | Specifies a number properties of non-isothermal free-flow flow models based on the specifics of a given isothermal model |
| CFreeflowNonIsothermalIndices | Indices for the non-isothermal Navier-Stokes model |
| CFreeflowNonIsothermalIOFields | Adds I/O fields specific to non-isothermal free-flow models |
| ►CFreeFlowStaggeredDefaultScvfGeometryTraits | Default traits class to be used for the sub-control volume faces for the free-flow staggered finite volume scheme |
| ►CScvfMLGTraits | |
| CCornerStorage | |
| CFreeFlowStaggeredGeometryHelper | Helper class constructing the dual grid finite volume geometries for the free flow staggered discretization method |
| ►CFreeflowStaggeredSCV | |
| CTraits | |
| ►CFreeflowStaggeredSCVF | |
| CTraits | |
| CFreeFlowStaggeredSubControlVolumeFace | Class for a sub control volume face in the staggered method, i.e a part of the boundary of a sub control volume we compute fluxes on. This is a specialization for free flow models |
| CFreeFlowVolumeVariablesImplementation | |
| CFreeFlowVolumeVariablesImplementation< Traits, Impl, false > | Volume variables for isothermal free-flow models |
| CFreeFlowVolumeVariablesImplementation< Traits, Impl, true > | Volume variables for the non-isothermal free-flow models |
| CFrictionLaw | Implementation of the abstract base class for friction laws |
| CFrictionLawManning | Implementation of the friction law after Manning |
| CFrictionLawNikuradse | Implementation of the friction law after Nikuradse |
| CFrictionLawNoFriction | A pseudo friction law with no bottom friction |
| CFV2dPressure2P2CAdaptive | The finite volume model for the solution of the compositional pressure equation |
| CFV2dTransport2P2CAdaptive | Compositional Transport step in a Finite Volume discretization for a adaptive 2D-grid |
| CFV3dPressure2P2CAdaptive | The finite volume model for the solution of the compositional pressure equation |
| CFV3dTransport2P2CAdaptive | Compositional transport step in a finite volume discretization |
| CFVAssembler | A linear system assembler (residual and Jacobian) for finite volume schemes (box, tpfa, mpfa, ...) |
| CFVGridVariables | The grid variable class for finite volume schemes storing variables on scv and scvf (volume and flux variables) |
| CFVLocalAssemblerBase | A base class for all local assemblers |
| CFVLocalResidual | The element-wise residual for finite volume schemes |
| CFvMpfaL2dPressure2p | Finite volume MPFA L-method discretization of a two-phase flow pressure equation of the sequential IMPES model |
| CFvMpfaL2dPressure2pAdaptive | Grid adaptive finite volume MPFA L-method discretization of a two-phase flow pressure equation of the sequential IMPES model |
| CFvMpfaL2dPressureVelocity2p | Class for the calculation of velocities from the pressure solution of an IMPES scheme using a MPFA L-method |
| CFvMpfaL2dPressureVelocity2pAdaptive | Class for the calculation of velocities from the pressure solution of an IMPES scheme using a grid adaptive MPFA L-method |
| CFvMpfaL2dTransmissibilityCalculator | Provides methods for transmissibility calculation in 2-d |
| CFvMpfaL2dVelocity2p | Class for calculating 2-d velocities from cell-wise constant pressure values |
| CFvMpfaL2dVelocity2pAdaptive | Class for calculating 2-d velocities from cell-wise constant pressure values |
| CFvMpfaL3d2P2CInteractionVolumeContainerAdaptive | Interaction volume container for compositional adaptive 3-d (using MPFA L-method) Model |
| CFvMpfaL3dInteractionVolume | Class including the information of a 3d interaction volume of a MPFA L-method that does not change with time |
| CFvMpfaL3dInteractionVolumeAdaptive | Class including the information of a 3d interaction volume of an adaptive MPFA L-method that does not change with time |
| CFvMpfaL3dInteractionVolumeContainer | Interactionvolume container for 3-d MPFA L-method |
| CFvMpfaL3dInteractionVolumeContainerAdaptive | Interactionvolume container for 3-d MPFA L-method on an h-adaptive grid |
| CFvMpfaL3dPressure2p | 3-d finite volume MPFA L-method discretization of a two-phase flow pressure equation of the sequential IMPES model |
| CFvMpfaL3dPressure2pAdaptive | 3-d finite volume MPFA L-method discretization of a two-phase flow pressure equation of the sequential IMPES model on h-adaptive grids |
| CFvMpfaL3dPressureVelocity2p | Class for the calculation of 3d velocities from the pressure solution of an IMPES scheme using a MPFA L-method |
| CFvMpfaL3dPressureVelocity2pAdaptive | Class for the calculation of 3d velocities from the pressure solution of an IMPES scheme using a grid adaptive MPFA L-method |
| CFvMpfaL3dTransmissibilityCalculator | Provides methods for transmissibility calculation in 3-d |
| CFvMpfaL3dVelocity2p | Class for calculating 3-d velocities from cell-wise constant pressure values |
| CFvMpfaL3dVelocity2pAdaptive | Class for calculating 3-d velocities from cell-wise constant pressure values |
| CFVMPFALInteractionVolume | Class including the information of an interaction volume of a MPFA L-method that does not change with time |
| CFvMpfaO2dPressure2p | Finite volume MPFA O-method discretization of a two-phase flow pressure equation of the sequential IMPES model |
| CFvMpfaO2dPressureVelocity2p | Class for the calculation of velocities from the pressure solution of an IMPES scheme using a MPFA O-method |
| CFvMpfaO2dVelocity2P | Class for calculating velocities from cell-wise constant pressure values |
| CFVMPFAOInteractionVolume | Class including the information of an interaction volume of a MPFA O-method that does not change with time |
| CFvMpfaVelocityInTransport | Implementation of a interface velocity class for MPFA models |
| CFVNonEquilibriumSpatialParams | Definition of the spatial parameters for non-equilibrium |
| CFVPressure | The finite volume base class for the solution of a pressure equation |
| CFVPressure1P | Sequential OneP Model solving the equations for pressure and velocity separately |
| CFVPressure2P | Finite Volume discretization of a two-phase flow pressure equation of the sequential IMPES model |
| CFVPressure2P2C | The finite volume model for the solution of the compositional pressure equation |
| CFVPressure2P2CMultiPhysics | The finite volume model for the solution of the compositional pressure equation |
| CFVPressure2PAdaptive | Finite volume discretization of a two-phase flow pressure equation of the sequential IMPES model |
| CFVPressureCompositional | The finite volume model for the solution of the compositional pressure equation |
| CFVPressureVelocity1P | Single Phase Finite Volume Model |
| CFVPressureVelocity2P | Two-phase finite volume model |
| ►CFVProblem | Base class for all finite-volume problems |
| CTraits | Export traits of this problem |
| CFVSaturation2P | The finite volume discretization of a saturation transport equation |
| CFVSpatialParams | The base class for spatial parameters of multi-phase problems using a fully implicit discretization method |
| CFVSpatialParamsElastic | The base class for spatial parameters of linear elastic geomechanical problems |
| CFVSpatialParamsOneP | The base class for spatial parameters of one-phase problems using a fully implicit discretization method |
| CFVSpatialParamsOnePConstant | A spatial params implementation for 1p problem with constant properties |
| CFVSpatialParamsPoroElastic | The base class for spatial parameters of poro-elastic geomechanical problems |
| CFVTransport | The finite volume discretization of a transport equation |
| ►CFVTransport2P2C | Compositional transport step in a Finite Volume discretization |
| CLocalTimesteppingData | |
| CFVTransport2P2CMultiPhysics | Compositional transport step in a finite volume discretization |
| CFVVelocity | Base class for finite volume velocity reconstruction |
| CFVVelocity1P | Single phase finite volume velocity reconstruction |
| CFVVelocity2P | Determines the velocity from a finite volume solution of the pressure equation of a sequential model (IMPES) |
| CFVVelocity2PAdaptive | Determines the velocity from a finite volume solution of the pressure equation of a sequential model (IMPES) |
| CFVVelocityDefault | Default implementation of a velocity class |
| CGeomechanicsFVProblem | Base class for all geomechanical problems |
| CGeomechanicsVelocityOutput | Velocity output for geomechanical models. This class could be used to compute the temporal derivative of the displacement. Currently this is not implemented and we simply define this here in order to be able to reuse the VtkOutputModule which expects a VelocityOutput class |
| CGeometriesEntitySet | An interface for a set of geometric entities |
| CGeometryIntersection | A class for geometry collision detection and intersection calculation The class can be specialized for combinations of dimworld, dim1, dim2, where dimworld is the world dimension embedding a grid of dim1 and a grid of dim2 |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 2, 1, 1 > | A class for segment–segment intersection in 2d space |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 2, 1, 2 > | A class for segment–polygon intersection in 2d space |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 2, 2, 1 > | A class for polygon–segment intersection in 2d space |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 2, 2, 2 > | A class for polygon–polygon intersection in 2d space |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 3, 1, 1 > | A class for segment–segment intersection in 3d space |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 3, 1, 2 > | A class for segment–polygon intersection in 3d space |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 3, 1, 3 > | A class for segment–polyhedron intersection in 3d space |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 3, 2, 1 > | A class for polygon–segment intersection in 3d space |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 3, 2, 3 > | A class for polygon–polyhedron intersection in 3d space |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 3, 3, 1 > | A class for polyhedron–segment intersection in 3d space |
| CGeometryIntersection< Geometry1, Geometry2, Policy, 3, 3, 2 > | A class for polyhedron–polygon intersection in 3d space |
| CGmshGridDataHandle | A data handle for commucating grid data for gmsh grids |
| CGnuplotInterface | Interface for passing data sets to a file and plotting them, if gnuplot is installed |
| CGravityPart | Class for defining the gravity term of a two-phase flow saturation equation |
| CGridAdapt | Standard Module for h-adaptive simulations |
| CGridAdapt< TypeTag, false > | Class for NON-adaptive simulations |
| CGridAdaptInitializationIndicator | Class defining an initialization indicator for grid adaption. Refines at sources and boundaries. Use before computing on the grid |
| CGridAdaptInitializationIndicatorDefault | Class defining a start indicator for grid adaption |
| CGridAdaptionIndicator2P | Class defining a standard, saturation dependent indicator for grid adaption |
| CGridAdaptionIndicator2PLocal | Class defining a standard, saturation dependent indicator for grid adaption |
| CGridData | Class for grid data attached to dgf or gmsh grid files |
| CGridDataTransfer | Interface to be used by classes transferring grid data on adpative grids |
| CGridGeometryView | Base class for cell center of face specific auxiliary FvGridGeometry classes. Provides a common interface and a pointer to the actual gridGeometry |
| CGridManager | The grid manager (this is the class used by the user) for all supported grid managers that constructs a grid from information in the input file and handles the data |
| CGridManager< Dune::OneDGrid > | Provides a grid manager for OneDGrids from information in the input file |
| CGridManager< Dune::YaspGrid< dim, Coordinates > > | Provides a grid manager for YaspGrids from information in the input file |
| CGridManager< Dune::YaspGrid< dim, Dune::TensorProductCoordinates< ctype, dim > > > | Provides a grid manager for YaspGrids with different zones and grading |
| CGridManagerBase | The grid manager base interface (public) and methods common to most grid manager specializations (protected) |
| CGridTypes | Indices denoting the different grid types |
| CGridViewGeometricEntitySet | An interface for a set of geometric entities based on a GridView |
| CGSBiCGSTABBackend | Sequential GS-preconditioned BiCGSTAB solver |
| CGSCGBackend | Sequential GS-preconditioned CG solver |
| CGstatRandomField | Creating random fields using gstat |
| CHasStationaryVelocityField | Trait of an advection type stating whether it implements a stationary velocity field |
| CHasStationaryVelocityField< StationaryVelocityField< Scalar > > | Set stationary velocity field to true in the FluxTraits |
| ChasVertexColor | Helper struct to determine whether the an engine class has vertex colors |
| CHeatConductionDataHandle | Data handle for quantities related to heat conduction |
| CHeatConductionDataHandle< MatVecTraits, PhysicsTraits, false > | |
| CHeatPipeLawParams | Reference implementation of a params for the heat pipe's material law |
| CHookesLaw | This computes the stress tensor and surface forces resulting from mechanical deformation |
| CHookesLaw< ScalarType, GridGeometry, DiscretizationMethod::box > | Hooke's law for box scheme |
| CIdealGas | Relations valid for an ideal gas |
| CIdPointSource | A point source class with an identifier to attach data |
| CILU0BiCGSTABBackend | Sequential ILU(0)-preconditioned BiCGSTAB solver |
| CILU0CGBackend | Sequential ILU(0)-preconditioned CG solver |
| CILU0RestartedGMResBackend | Sequential ILU0-preconditioned GMRes solver |
| CILUnBiCGSTABBackend | Sequential ILU(n)-preconditioned BiCSTAB solver |
| CILUnCGBackend | Sequential ILU(n)-preconditioned CG solver |
| CILUnRestartedGMResBackend | Sequential ILU(n)-preconditioned GMRes solver |
| CImmiscibleFlash | Determines the pressures and saturations of all fluid phases given the total mass of all components |
| CImmiscibleFluidState | Represents all relevant thermodynamic quantities of a multi-phase fluid system assuming immiscibility and thermodynamic equilibrium |
| CImmiscibleLocalResidual | Element-wise calculation of the residual for problems using the n-phase immiscible fully implicit models |
| CIMPESProblem2P | Base class for all 2-phase problems which use an IMPES algorithm |
| CIMPET | IMplicit Pressure Explicit Transport (IMPET) scheme for the solution of weakly coupled diffusion-transport formulations |
| CIMPETProblem | Base class for problems using a sequential implicit-explicit strategy |
| CIMPETProblem2P2C | Base class for all compositional 2-phase problems which use an impet algorithm |
| CIndexHelper | Helper struct to choose the correct index for phases and components. This is need if the porous-medium-flow model features more fluid phases than the free-flow model |
| CIndexHelper< stokesIdx, darcyIdx, FFFS, false > | Helper struct to choose the correct index for phases and components. This is need if the porous-medium-flow model features more fluid phases than the free-flow model. Specialization for the case that no adapter is used |
| CIndexHelper< stokesIdx, darcyIdx, FFFS, true > | Helper struct to choose the correct index for phases and components. This is need if the porous-medium-flow model features more fluid phases than the free-flow model. Specialization for the case that a adapter is used |
| CIndexTraits | Struture to define the index types used for grid and local indices |
| CInertSolidState | Represents all relevant thermodynamic quantities of a inert solid system |
| CIntegrationPointSource | An integration point source class with an identifier to attach data and a quadrature weight and integration element |
| CIntegrationPointSourceHelper | A helper class calculating a DOF-index to point source map |
| CInteractionVolumeAssemblerBase | Defines the general interface of the local assembler classes for the assembly of the interaction volume-local transmissibility matrix. Specializations have to be provided for the available interaction volume implementations. these should derive from this base class |
| CInteractionVolumeAssemblerHelper | A class that contains helper functions as well as functionality which is common to different mpfa schemes and which solely operate on the interaction volume |
| CInteractionVolumeDataHandle | Class for the interaction volume data handle |
| CInteractionVolumeDataStorage | Structure to store interaction volumes and data handles |
| CInteractionVolumeLocalFaceData | General implementation of a data structure holding interaction volume-local information for a grid sub-control volume face embedded in it |
| CIntersectionEntitySet | A class representing the intersection entites two geometric entity sets |
| CIntersectionInfo | An intersection object resulting from the intersection of two primitives in an entity set |
| CIntersectionMapper | Defines an intersection mapper for mapping of global DOFs assigned to faces which also works for adaptive grids |
| CisBCRSMatrix | Helper type to determine whether a given type is a Dune::BCRSMatrix |
| CisBCRSMatrix< Dune::BCRSMatrix< B, A > > | |
| CIsFicksLaw | This structs indicates that Fick's law is not used for diffusion |
| CIsFicksLaw< FicksLawImplementation< T, discMethod, referenceSystem > > | This structs indicates that Fick's law is used for diffusion |
| CisMultiTypeBlockMatrix | Helper type to determine whether a given type is a Dune::MultiTypeBlockMatrix |
| CisMultiTypeBlockMatrix< Dune::MultiTypeBlockMatrix< Args... > > | |
| CisMultiTypeBlockVector | Helper type to determine whether a given type is a Dune::MultiTypeBlockVector |
| CisMultiTypeBlockVector< Dune::MultiTypeBlockVector< T... > > | Helper type to determine whether a given type is a Dune::MultiTypeBlockVector |
| CIsothermalImmiscibleFluidState | Represents all relevant thermodynamic quantities of a multi-phase fluid system assuming immiscibility and thermodynamic equilibrium |
| CIsSameFluidSystem | This structs helps to check if the two sub models use the same fluidsystem. Specialization for the case of using an adapter only for the free-flow model |
| CIsSameFluidSystem< FS, FS > | This structs helps to check if the two sub models use the same fluidsystem |
| CIstlSolverFactoryBackend | A linear solver using the dune-istl solver factory to choose the solver and preconditioner at runtime |
| CIterativePreconditionedSolverImpl | A general solver backend allowing arbitrary preconditioners and solvers |
| CIvDataHandlePhysicsTraits | Data handle physics traits |
| CJacBiCGSTABBackend | Sequential Jacobi-preconditioned BiCSTAB solver |
| CJacCGBackend | Sequential Jacobi-preconditioned CG solver |
| CKEpsilonFluxVariablesImpl | The flux variables class for the k-epsilon model using the staggered grid discretization |
| CKEpsilonFluxVariablesImpl< TypeTag, BaseFluxVariables, DiscretizationMethod::staggered > | |
| CKEpsilonIOFields | Adds I/O fields for the k-epsilon turbulence model |
| CKEpsilonResidualImpl | Element-wise calculation of the residual for k-epsilon models using the staggered discretization |
| CKEpsilonResidualImpl< TypeTag, BaseLocalResidual, DiscretizationMethod::staggered > | |
| CKEpsilonVolumeVariables | Volume variables for the isothermal single-phase k-epsilon model |
| CKOmegaFluxVariablesImpl | The flux variables class for the k-omega model using the staggered grid discretization |
| CKOmegaFluxVariablesImpl< TypeTag, BaseFluxVariables, DiscretizationMethod::staggered > | |
| CKOmegaIOFields | Adds I/O fields for the Reynolds-Averaged Navier-Stokes model |
| CKOmegaResidualImpl | Element-wise calculation of the residual for k-omega models using the staggered discretization |
| CKOmegaResidualImpl< TypeTag, BaseLocalResidual, DiscretizationMethod::staggered > | |
| CKOmegaVolumeVariables | Volume variables for the isothermal single-phase k-omega 2-Eq model |
| CLameParams | Structure encapsulating the lame parameters |
| CLinearLocalStiffness | Base class for linear local assemblers |
| CLinearPDESolver | An implementation of a linear PDE solver |
| CLinearSolver | Base class for linear solvers |
| ClinearSolverAcceptsMultiTypeMatrix | The default |
| ClinearSolverAcceptsMultiTypeMatrix< ILU0BiCGSTABBackend > | |
| ClinearSolverAcceptsMultiTypeMatrix< ILU0CGBackend > | |
| ClinearSolverAcceptsMultiTypeMatrix< ILU0RestartedGMResBackend > | |
| ClinearSolverAcceptsMultiTypeMatrix< ILUnBiCGSTABBackend > | |
| ClinearSolverAcceptsMultiTypeMatrix< ILUnCGBackend > | |
| ClinearSolverAcceptsMultiTypeMatrix< ILUnRestartedGMResBackend > | |
| CLinearSolverParameters | |
| CLinearSolverTraitsBase | |
| CLinearSolverTraitsImpl | The implementation is specialized for the different discretizations |
| CLinearSolverTraitsImpl< GridGeometry, DiscretizationMethod::box > | Box: use overlapping or non-overlapping model depending on the grid |
| CLinearSolverTraitsImpl< GridGeometry, DiscretizationMethod::ccmpfa > | Cell-centered mpfa: use overlapping model |
| CLinearSolverTraitsImpl< GridGeometry, DiscretizationMethod::cctpfa > | Cell-centered tpfa: use overlapping model |
| CLinearSolverTraitsImpl< GridGeometry, DiscretizationMethod::staggered > | Staggered: use overlapping model TODO provide staggered-specific traits, combining overlapping/non-overlapping |
| CLoadSolutionDataHandle | Data handle to communicate the solution on ghosts and overlaps when reading from vtk file in parallel |
| CLocalStiffness | Base class for local assemblers |
| CLoggingParameterTree | A parameter tree that logs which parameters have been used |
| CLowReKEpsilonFluxVariablesImpl | The flux variables class for the low-Reynolds k-epsilon model using the staggered grid discretization |
| CLowReKEpsilonFluxVariablesImpl< TypeTag, BaseFluxVariables, DiscretizationMethod::staggered > | |
| CLowReKEpsilonIOFields | Adds I/O fields for the low-Re k-epsilon turbulence model |
| CLowReKEpsilonResidualImpl | Element-wise calculation of the residual for low-Reynolds k-epsilon models using the staggered discretization |
| CLowReKEpsilonResidualImpl< TypeTag, BaseLocalResidual, DiscretizationMethod::staggered > | |
| CLowReKEpsilonVolumeVariables | Volume variables for the isothermal single-phase low-Re k-epsilons model |
| CmakeFromIndexedType | |
| CmakeFromIndexedType< Variadic, Indexed, std::index_sequence< IndexSeq... > > | |
| CMatrixConverter | A helper classe that converts a Dune::MultiTypeBlockMatrix into a plain Dune::BCRSMatrix TODO: allow block sizes for BCRSMatrix other than 1x1 ? |
| CMaxwellStefanDiffusionCoefficients | Container storing the diffusion coefficients required by the Maxwell- Stefan diffusion law. Uses the minimal possible container size and provides unified access |
| CMaxwellStefansLawImplementation | |
| CMaxwellStefansLawImplementation< TypeTag, DiscretizationMethod::box, referenceSystem > | Specialization of Maxwell Stefan's Law for the Box method |
| CMaxwellStefansLawImplementation< TypeTag, DiscretizationMethod::cctpfa, referenceSystem > | Specialization of Maxwell Stefan's Law for the CCTpfa method |
| CMaxwellStefansLawImplementation< TypeTag, DiscretizationMethod::staggered, referenceSystem > | Specialization of Maxwell Stefan's Law for the Staggered method |
| CMimeticOperatorAssemblerTwoP | Levelwise assembler |
| CMimeticOperatorAssemblerTwoPAdaptive | Levelwise assembler |
| CMimeticPressure2P | Mimetic method for the pressure equation |
| CMimeticPressure2PAdaptive | Mimetic method for the pressure equation |
| CMimeticTwoPLocalStiffness | Compute local stiffness matrix for conforming finite elements for the full 2-phase pressure equation |
| CMimeticTwoPLocalStiffnessAdaptive | Compute local stiffness matrix for conforming finite elements for the full 2-phase pressure equation |
| CMineralizationIOFields | Adds I/O fields specific to a NCMin model |
| CMineralizationLocalResidual | Element-wise calculation of the local residual for problems using a one/two-phase n-component mineralization model |
| CMineralizationModelTraits | Specifies a number properties of models that consider mineralization proceses |
| CMineralizationVolumeVariables | Contains the quantities which are are constant within a sub-control volume of the finite volume grid in an m-phase, n-component, mineralization model |
| CMiscibleMultiPhaseComposition | Computes the composition of all phases of a N-phase, N-component fluid system assuming that all N phases are present |
| CMonotoneCubicSpline | A monotone cubic spline |
| CMpfaDimensionHelper | Dimension-specific helper class to get data required for mpfa scheme |
| CMpfaDimensionHelper< GridGeometry, 2, 2 > | Dimension-specific mpfa helper class for dim == 2 & dimWorld == 2 |
| CMpfaDimensionHelper< GridGeometry, 2, 3 > | Dimension-specific mpfa helper class for dim == 2 & dimWorld == 3. Reuses some functionality of the specialization for dim = dimWorld = 2 |
| CMpfaDimensionHelper< GridGeometry, 3, 3 > | Dimension-specific mpfa helper class for dim == 3 & dimWorld == 3 |
| CMpfaOFacetCouplingInteractionVolumeAssembler | Specialization of the interaction volume-local assembler class for the schemes using an mpfa-o type assembly in the context of facet coupling |
| CMpfaOInteractionVolumeAssembler | Specialization of the interaction volume-local assembler class for the schemes using an mpfa-o type assembly |
| CMPNCIndices | The primary variable and equation indices for the MpNc model |
| CMPNCIOFields | Adds I/O fields specific to the mpnc model |
| CMPNCLocalResidual | MpNc specific details needed to approximately calculate the local defect in the fully implicit scheme |
| CMPNCModelTraits | Specifies a number properties of the m-phase n-component model |
| CMPNCNonequilibriumModelTraits | Specifies a number properties of the m-phase n-component model in conjunction with non-equilibrium. This is necessary because the mpnc indices are affected by the non-equilibrium which can thus not be plugged on top of it that easily |
| CMPNCVolumeVariablesImplementation | |
| CMPNCVolumeVariablesImplementation< Traits, false > | |
| CMPNCVolumeVariablesImplementation< Traits, true > | |
| CMPNCVolumeVariablesTraits | Traits class for the mpnc volume variables |
| CMultiDomainFVAssembler | A linear system assembler (residual and Jacobian) for finite volume schemes (box, tpfa, mpfa, ...) with multiple domains |
| CMultiDomainFVGridGeometry | A multidomain wrapper for multiple grid geometries |
| CMultiDomainFVGridVariables | A multidomain wrapper for multiple grid variables |
| CMultiDomainFVProblem | A multidomain wrapper for multiple problems |
| CMultiDomainNewtonConvergenceWriter | Writes the intermediate solutions for every Newton iteration |
| CMultiDomainNewtonSolver | Newton sover for coupled problems |
| ►CMultiDomainTraits | |
| CSubDomain | |
| CMultiDomainVtkOutputModule | A multidomain wrapper for multiple vtk output modules |
| ►CNavierStokesBoundaryTypes | Class to specify the type of a boundary condition for the Navier-Stokes model |
| CNavierStokesBoundaryInfo | Use bitfields to minimize the size |
| CNavierStokesFluxVariablesImpl | The flux variables class for the Navier-Stokes model using the staggered grid discretization |
| CNavierStokesFluxVariablesImpl< TypeTag, DiscretizationMethod::staggered > | |
| CNavierStokesIndices | The common indices for the isothermal Navier-Stokes model |
| CNavierStokesIOFields | Adds I/O fields for the Navier-Stokes model |
| CNavierStokesModelTraits | Traits for the Navier-Stokes model |
| CNavierStokesNCModelTraits | Traits for the multi-component free-flow model |
| CNavierStokesParentProblemImpl | The implementation is specialized for the different discretizations |
| CNavierStokesParentProblemImpl< TypeTag, DiscretizationMethod::staggered > | |
| CNavierStokesProblem | Navier-Stokes problem base class |
| CNavierStokesResidualImpl | Element-wise calculation of the Navier-Stokes residual for models using the staggered discretization |
| CNavierStokesResidualImpl< TypeTag, DiscretizationMethod::staggered > | |
| CNavierStokesVolumeVariables | Volume variables for the single-phase Navier-Stokes model |
| CNavierStokesVolumeVariablesTraits | Traits class for the volume variables of the Navier-Stokes model |
| CNcpFlash | Determines the phase compositions, pressures and saturations given the total mass of all components |
| ►CNetPBMReader | A simple reader class for the Netpbm format (https://en.wikipedia.org/wiki/Netpbm_format). So far, only black and white (*.pbm) and grayscale (*pgm) images are supported |
| CFormat | A struct that holds all information of the image format |
| CHeaderData | A struct that contains all header data of the image |
| CResult | The return type of the reading functions. Holds the actual pixel values and the header data |
| CNewtonConvergenceWriter | Writes the intermediate solutions for every Newton iteration |
| CNewtonSolver | An implementation of a Newton solver |
| CNodalIndexSetDefaultTraits | Default traits to be used in conjuntion with the dual grid nodal index set |
| CNoExtrusion | Default implementation that performs no extrusion (extrusion with identity) |
| CNonConformingGridIntersectionMapper | Defines an intersection mapper for mapping of global DOFs assigned to faces which also works for non-conforming grids and corner-point grids |
| CNonEquilbriumIndices | The primary variable and equation indices for the MpNc model |
| CNonEquilibriumFluidState | Represents all relevant thermodynamic quantities of a multi-phase, multi-component fluid system without using any assumptions |
| CNonEquilibriumGridVariables | This class stores the velocities which are used to compute Reynolds numbers for the source terms of non-equilibrium models |
| CNonEquilibriumIOFieldsImplementation | |
| CNonEquilibriumIOFieldsImplementation< ModelTraits, EquilibriumIOFields, false > | |
| CNonEquilibriumIOFieldsImplementation< ModelTraits, EquilibriumIOFields, true > | Adds I/O fields specific to non-equilibrium models with chemical and thermal nonequilbirum or thermal non-equilibrium only |
| CNonEquilibriumLocalResidualImplementation | |
| CNonEquilibriumLocalResidualImplementation< TypeTag, false > | The local residual for a model without chemical non-equilibrium but potentially with thermal non-equilibrium |
| CNonEquilibriumLocalResidualImplementation< TypeTag, true > | The local residual for a model assuming chemical non-equilibrium and potentially thermal non-equilibrium |
| CNonEquilibriumMassFluidState | Represents all relevant thermodynamic quantities of a multi-phase, multi-component fluid system |
| CNonEquilibriumModelTraits | Specifies a number properties of porous-medium flow non-equilibrium models |
| CNonEquilibriumNewtonSolver | A nonequilibrium specific newton solver |
| CNonEquilibriumVolumeVariablesImplementation | This class contains the volume variables required for the modules which require the specific interfacial area between fluid phases |
| CNonEquilibriumVolumeVariablesImplementation< Traits, EquilibriumVolumeVariables, false, true, 1 > | |
| CNonEquilibriumVolumeVariablesImplementation< Traits, EquilibriumVolumeVariables, false, true, 2 > | |
| CNonEquilibriumVolumeVariablesImplementation< Traits, EquilibriumVolumeVariables, true, false, 0 > | |
| CNonEquilibriumVolumeVariablesImplementation< Traits, EquilibriumVolumeVariables, true, true, 2 > | |
| CNonoverlappingSolverTraits | |
| CNoPrimaryVariableSwitch | Empty class for models without pri var switch |
| CNullParameterCache | The a parameter cache which does nothing |
| CNumEqVectorTraits | |
| CNumEqVectorTraits< SwitchablePrimaryVariables< PrimaryVariables, StateType > > | The corresponding NumEqVectorTraits for the primary variables with switchable state |
| CNumericalProblem | Exception thrown if a fixable numerical problem occurs |
| CNumericDifferentiation | A class for numeric differentiation with respect to a scalar parameter |
| CNumericEpsilon | A helper class for local assemblers using numeric differentiation to determine the epsilon |
| COneEqFluxVariablesImpl | The flux variables class for the one-equation model by Spalart-Allmaras using the staggered grid discretization |
| COneEqFluxVariablesImpl< TypeTag, BaseFluxVariables, DiscretizationMethod::staggered > | |
| COneEqIndices | The common indices for the isothermal one-equation turbulence model by Spalart-Allmaras |
| COneEqIOFields | Adds I/O fields for the one-equation turbulence model by Spalart-Allmaras |
| COneEqResidualImpl | Element-wise calculation of the residual for one-equation turbulence models using the staggered discretization |
| COneEqResidualImpl< TypeTag, BaseLocalResidual, DiscretizationMethod::staggered > | |
| COneEqVolumeVariables | Volume variables for the isothermal single-phase one-equation turbulence model by Spalart-Allmaras |
| COneModelProblem | Base class for definition of an sequential diffusion (pressure) or transport problem |
| COnePIncompressibleLocalResidual | Element-wise calculation of the residual and its derivatives for a single-phase, incompressible, test problem |
| COnePIndices | Indices for the one-phase model |
| COnePIOFields | Adds I/O fields specific to the one phase model |
| COnePModelTraits | Specifies a number properties of single-phase models |
| COnePNCIndices | The indices for the isothermal one-phase n-component model |
| COnePNCIOFields | Adds I/O fields specific to the OnePNC model |
| COnePNCModelTraits | Specifies a number properties of models that consider a single-phase with multiple components |
| COnePNCUnconstrainedModelTraits | |
| COnePNCVolumeVariables | Contains the quantities which are are constant within a finite volume in the one-phase, n-component model |
| COnePVolumeVariables | Contains the quantities which are constant within a finite volume in the one-phase model |
| COnePVolumeVariablesTraits | Traits class for the volume variables of the single-phase model |
| COptionalScalar | A type for an optional scalar (contains either a valid number or NaN) |
| COverlappingSolverTraits | |
| CParallelISTLHelper | A parallel helper class providing a nonoverlapping decomposition of all degrees of freedom |
| CParallelMatrixHelper | Helper class for adding up matrix entries on border |
| CParallelVectorHelper | |
| CParameterCacheBase | The base class of the parameter cache classes for fluid systems |
| CParameterException | Exception thrown if a run-time parameter is not specified correctly |
| CParameters | Parameter class managing runtime input parameters |
| CPartialReassembler | Detects which entries in the Jacobian have to be recomputed |
| CPartialReassemblerEngine | Partial reassembler engine specialized for discretization methods |
| CPartialReassemblerEngine< Assembler, DiscretizationMethod::box > | The partial reassembler engine specialized for the box method |
| CPartialReassemblerEngine< Assembler, DiscretizationMethod::ccmpfa > | The partial reassembler engine specialized for the cellcentered MPFA method |
| CPartialReassemblerEngine< Assembler, DiscretizationMethod::cctpfa > | The partial reassembler engine specialized for the cellcentered TPFA method |
| CPDESolver | A high-level interface for a PDESolver |
| CPengRobinson | Implements the Peng-Robinson equation of state for liquids and gases |
| CPengRobinsonMixture | Implements the Peng-Robinson equation of state for a mixture |
| CPengRobinsonParams | Stores and provides access to the Peng-Robinson parameters |
| CPengRobinsonParamsMixture | The mixing rule for the oil and the gas phases of the SPE5 problem |
| CPermeabilityKozenyCarman | The Kozeny-Carman relationship for the calculation of a porosity-dependent permeability. When the porosity is implemented as solution-independent, using this relationship for the permeability leads to unnecessary overhead |
| CPlotEffectiveDiffusivityModel | Interface for plotting the multi-component-matrix-interaction laws |
| CPlotMaterialLaw | Interface for plotting the three-phase fluid-matrix-interaction laws TODO: add theta head pressure plot (porosity and density is needed) |
| CPlotThermalConductivityModel | Interface for plotting the non-isothermal two-phase fluid-matrix-interaction laws |
| CPointCloudVtkWriter | A VTK output module to simplify writing dumux simulation data to VTK format |
| CPointSource | A point source base class |
| CPointSourceData | A point source data class used for integration in multidimension models |
| CPointSourceDataCircleAverage | A point source data class used for integration in multidimension models |
| CPoroElasticIOFields | Adds I/O fields specific to the poro-elastic model |
| CPoroElasticLocalResidual | Element-wise calculation of the local residual for problems using the poroelastic model |
| CPoroElasticModelTraits | Specifies a number properties of the poroelastic model |
| CPoroElasticVolumeVariables | Contains the quantities which are constant within a finite volume in the poroelastic model |
| CPoroMechanicsCouplingManager | |
| CPorosityDeformation | A relationship for the porosity of a porous medium under mechanical deformation |
| CPorosityPrecipitation | Calculates the porosity depending on the volume fractions of precipitated minerals |
| CPorousMediumFlowNIModelTraits | Specifies a number properties of non-isothermal porous medium flow models based on the specifics of a given isothermal model |
| CPorousMediumFlowProblem | Base class for all fully implicit porous media problems |
| CPorousMediumFlowVelocity | Velocity computation for implicit (porous media) models |
| CPorousMediumFlowVelocityOutput | Velocity output policy for implicit (porous media) models |
| CPorousMediumFlowVolumeVariables | The isothermal base class |
| CPorousMediumFluxVariables | The porous medium flux variables class that computes advective / convective, molecular diffusive and heat conduction fluxes |
| CPorousMediumFluxVariablesCacheFillerImplementation | |
| CPorousMediumFluxVariablesCacheFillerImplementation< TypeTag, DiscretizationMethod::ccmpfa > | Specialization of the flux variables cache filler for the cell centered mpfa method |
| CPorousMediumFluxVariablesCacheFillerImplementation< TypeTag, DiscretizationMethod::cctpfa > | Specialization of the flux variables cache filler for the cell centered tpfa method |
| CPorousMediumFluxVariablesCacheImplementation | |
| CPorousMediumFluxVariablesCacheImplementation< TypeTag, DiscretizationMethod::box > | |
| CPorousMediumFluxVariablesCacheImplementation< TypeTag, DiscretizationMethod::ccmpfa > | |
| CPorousMediumFluxVariablesCacheImplementation< TypeTag, DiscretizationMethod::cctpfa > | |
| CPressureOverlayFluidState | This is a fluid state which allows to set the fluid pressures and takes all other quantities from an other fluid state |
| CPrimaryVariableSwitch | The primary variable switch controlling the phase presence state variable |
| CPrimaryVariableSwitchAdapter | An adapter for the Newton to manage models with primary variable switch |
| CPrimaryVariableSwitchAdapter< Variables, false > | An empty adapter for the Newton for models without primary variable switch |
| CProblemTraits | Type traits for problem classes |
| ►CProjector | Does an L2-projection from one discrete function space into another. The convenience functions makeProjectorPair or makeProjector can be used to create such a projection |
| CParams | Parameters that can be passed to project() |
| CProjectorTraits | Traits class stating the type of projector between to bases |
| CPseudoOnePTwoCFluidState | Container for compositional variables in a 1p2c situation |
| CRANSIOFields | Adds I/O fields for the Reynolds-Averaged Navier-Stokes model |
| CRANSProblemBase | Reynolds-Averaged Navier-Stokes problem base class |
| CRANSProblemImpl | Forward declare |
| CRANSProblemImpl< TypeTag, TurbulenceModel::kepsilon > | K-epsilon turbulence problem base class |
| CRANSProblemImpl< TypeTag, TurbulenceModel::komega > | K-Omega turbulence model problem base class |
| CRANSProblemImpl< TypeTag, TurbulenceModel::lowrekepsilon > | Low-Re k-epsilon turbulence problem base class |
| CRANSProblemImpl< TypeTag, TurbulenceModel::oneeq > | One-equation turbulence problem base class |
| CRANSProblemImpl< TypeTag, TurbulenceModel::zeroeq > | Zero-equation turbulence problem base class |
| CRANSTwoEqIndices | The common indices for isothermal two-equation RANS models |
| CRANSVolumeVariables | Volume variables for the isothermal single-phase Reynolds-Averaged Navier-Stokes models |
| CRefinementQuadratureRule | A "quadrature" based on virtual refinement |
| CReservedBlockVector | A arithmetic block vector type based on DUNE's reserved vector |
| CRestart | Load or save a state of a model to/from the harddisk |
| CRichardsIndices | Index names for the Richards model |
| CRichardsIOFields | Adds I/O fields specific to the Richards model |
| CRichardsLocalResidual | Element-wise calculation of the Jacobian matrix for problems using the Richards fully implicit models |
| CRichardsModelTraits | Specifies a number properties of the Richards model |
| CRichardsNCIndices | The indices for the isothermal Richards, n-component model |
| CRichardsNCIOFields | Adds I/O fields specific to the Richards model |
| CRichardsNCModelTraits | Specifies a number properties of the Richards n-components model |
| CRichardsNCVolumeVariables | Contains the quantities which are constant within a finite volume in the Richards, n-component model |
| CRichardsNewtonSolver | A Richards model specific Newton solver |
| CRichardsVolumeVariables | Volume averaged quantities required by the Richards model |
| CRichardsVolumeVariablesTraits | Traits class for the Richards model |
| CRotationalExtrusion | Rotation symmetric extrusion policy for rotating about an external axis |
| CSaturationOverlayFluidState | This is a fluid state which allows to set the fluid saturations and takes all other quantities from an other fluid state |
| CScotchBackend | |
| CScvfIterator | Iterators over sub control volume faces of an fv geometry |
| CScvfToScvBoundaryTypes | Convert intersection boundary types to vertex boundary types |
| CScvIterator | Iterators over sub control volumes |
| ►CSequentialBoundaryTypes | Class to specify the type of a boundary |
| CBoundaryInfo | Use bitfields to minimize the size |
| CSequentialFVSpatialParams | The base class for spatial parameters of a multi-phase problem using the fv method |
| CSequentialFVSpatialParamsOneP | The base class for spatial parameters of problems using the fv method |
| CSequentialOnePCommonIndices | The common indices for the 1-p models |
| CSequentialSolverTraits | Sequential solver traits |
| CSequentialTwoPCommonIndices | The common indices for the isothermal two-phase model |
| CSequentialTwoPIndices | The indices for the \(p_w-S_n\) formulation of the isothermal two-phase model |
| CSequentialTwoPIndices< SequentialTwoPCommonIndices::pGlobalSn, PVOffset > | The indices for the \(p_{global}-S_n\) formulation of the isothermal two-phase model |
| CSequentialTwoPIndices< SequentialTwoPCommonIndices::pGlobalSw, PVOffset > | The indices for the \(p_{global}-S_w\) formulation of the isothermal two-phase model |
| CSequentialTwoPIndices< SequentialTwoPCommonIndices::pnsn, PVOffset > | The indices for the \(p_n-S_n\) formulation of the isothermal two-phase model |
| CSequentialTwoPIndices< SequentialTwoPCommonIndices::pnsw, PVOffset > | The indices for the \(p_n-S_w\) formulation of the isothermal two-phase model |
| CSequentialTwoPIndices< SequentialTwoPCommonIndices::pwsw, PVOffset > | The indices for the \(p_w-S_w\) formulation of the isothermal two-phase model |
| CSequentialTwoPTwoCIndices | The common indices for the 2p2c model |
| CSequentialTwoPTwoCIndicesAdaptive | Missing indices to the mpfa2p model |
| CSeqUzawa | A preconditioner based on the Uzawa algorithm for saddle-point problems of the form \( \begin{pmatrix} A & B \\ C & D \end{pmatrix} \begin{pmatrix} u\\ p \end{pmatrix} = \begin{pmatrix} f\\ g \end{pmatrix} \) |
| CShallowWaterFlux | Computes the shallow water flux by solving a riemann problem |
| CShallowWaterFluxVariables | The flux variables class for the shallow water model |
| CShallowWaterIndices | The common indices for the shallow water equations model |
| CShallowWaterIOFields | Adds vtk output fields for the shallow water model |
| CShallowWaterModelTraits | Specifies a number properties of shallow water models |
| CShallowWaterProblem | Shallow water problem base class |
| CShallowWaterResidual | Element-wise calculation of the residual for the shallow water equations |
| CShallowWaterViscousFlux | Computes the shallow water viscous momentum flux due to (turbulent) viscosity by adding all surrounding shear stresses. For now implemented strictly for 2D depth-averaged models (i.e. 3 equations) |
| CShallowWaterVolumeVariables | Volume variables for the shallow water equations model |
| CShallowWaterVolumeVariablesTraits | Traits class for the volume variables of the shallow water model |
| CSimpleLogNormalDistribution | |
| CSimpleNormalDistribution | |
| CSimpleUniformDistribution | |
| CSolDependentPointSource | A point source class for time dependent point sources |
| CSolidEnergyIndices | The indices |
| CSolidEnergyLocalResidual | Element-wise calculation of the residual |
| CSolidEnergyModelTraits | The energy balance equation for a porous solid |
| CSolidEnergyVolumeVariables | Class for computation of all volume averaged quantities |
| CSolidEnergyVolumeVariablesTraits | The volume variable traits |
| CSORBiCGSTABBackend | Sequential SOR-preconditioned BiCSTAB solver |
| CSORCGBackend | Sequential SOR-preconditioned CG solver |
| CSpe5ParameterCache | Specifies the parameters required by the SPE5 problem which are despondent on the thermodynamic state |
| CSphericalExtrusion | Rotation symmetric extrusion policy for spherical rotation |
| CSpline | A 3rd order polynomial spline |
| CSpline< Scalar, -1 > | Specialization of a spline with the number of sampling points only known at run time |
| CSpline< Scalar, 0 > | Do not allow splines with zero sampling points |
| CSpline< Scalar, 1 > | Do not allow splines with one sampling point |
| CSpline< Scalar, 2 > | Spline for two sampling points |
| CSplineCommon_ | The common code for all 3rd order polynomial splines |
| CSSORBiCGSTABBackend | Sequential SSOR-preconditioned BiCGSTAB solver |
| CSSORCGBackend | Sequential SSOR-preconditioned CG solver |
| CSSORRestartedGMResBackend | Sequential SSOR-preconditioned GMRes solver |
| CStaggeredCouplingManager | Base coupling manager for the staggered discretization |
| CStaggeredDefaultGridFaceVariablesTraits | Traits class to be used for the StaggeredGridFaceVariables |
| CStaggeredDefaultGridFluxVariablesCacheTraits | Traits class to be used for the StaggeredGridVFluxVariablesCache |
| CStaggeredDefaultScvfGeometryTraits | Default traits class to be used for the sub-control volume faces for the staggered finite volume scheme |
| CStaggeredElementFaceVariables | Base class for the face variables vector |
| CStaggeredElementFaceVariables< GFV, false > | Class for the face variables vector. Specialization for the case of not storing the face variables globally |
| CStaggeredElementFaceVariables< GFV, true > | Class for the face variables vector. Specialization for the case of storing the face variables globally |
| CStaggeredElementFluxVariablesCache | Base class for the stencil local flux variables cache for the staggered model |
| CStaggeredElementFluxVariablesCache< GFVC, false > | Class for the stencil local flux variables cache for the staggered model. Specialization for the case of not storing the fluxvars cache globally |
| CStaggeredElementFluxVariablesCache< GFVC, true > | Class for the stencil local flux variables cache for the staggered model. Specialization for the case of storing the fluxvars cache globally |
| CStaggeredElementVolumeVariables | Base class for the element volume variables vector for the staggered model |
| CStaggeredElementVolumeVariables< GVV, false > | Class for the element volume variables vector for the staggered model. Specialization in case the volume variables are not stored globally |
| CStaggeredElementVolumeVariables< GVV, true > | Class for the element volume variables vector for the staggered model. Specialization in case the volume variables are stored globally |
| CStaggeredFaceSolution | The global face variables class for staggered models |
| CStaggeredFaceVariables | The face variables class for free flow staggered grid models. Contains all relevant velocities for the assembly of the momentum balance. When the upwindSchemeOrder is set to 2, additional velocities located at Dofs further from the central stencil will be added and used when calculating the advective term. When the order remains at 1, these velocities will not be provided |
| CStaggeredFreeFlowConnectivityMap | Stores the dof indices corresponding to the neighboring cell centers and faces that contribute to the derivative calculation. Specialization for the staggered free flow model |
| ►CStaggeredFreeFlowDefaultFVGridGeometryTraits | Default traits for the finite volume grid geometry |
| CDofTypeIndices | |
| CPublicTraits | |
| CStaggeredFreeFlowVelocityOutput | Velocity output for staggered free-flow models |
| CStaggeredFVAssembler | A linear system assembler (residual and Jacobian) for staggered finite volume schemes. This is basically just a wrapper for the MultiDomainFVAssembler which simplifies the set-up of uncoupled problems using the staggered scheme |
| CStaggeredFVElementGeometry | Stencil-local finite volume geometry (scvs and scvfs) for staggered models This builds up the sub control volumes and sub control volume faces for each element in the local scope we are restricting to, e.g. stencil or element |
| CStaggeredFVElementGeometry< GG, false > | Base class for the finite volume geometry vector for staggered models This locally builds up the sub control volumes and sub control volume faces for each element. Specialization for grid caching enabled |
| CStaggeredFVElementGeometry< GG, true > | Base class for the finite volume geometry vector for staggered models This locally builds up the sub control volumes and sub control volume faces for each element. Specialization for grid caching enabled |
| CStaggeredFVGridGeometry | Base class for the finite volume geometry vector for staggered models This builds up the sub control volumes and sub control volume faces for each element |
| CStaggeredFVGridGeometry< GV, false, T > | Base class for the finite volume geometry vector for staggered models This builds up the sub control volumes and sub control volume faces for each element. Specialization in case the FVElementGeometries are stored |
| CStaggeredFVGridGeometry< GV, true, T > | Base class for the finite volume geometry vector for staggered models This builds up the sub control volumes and sub control volume faces for each element. Specialization in case the FVElementGeometries are stored |
| CStaggeredFVProblem | Base class for all staggered finite-volume problems |
| CStaggeredGridDefaultGridVolumeVariablesTraits | |
| CStaggeredGridFaceVariables | Face variables cache class for staggered models |
| CStaggeredGridFaceVariables< P, FV, false, Traits > | Face variables cache class for staggered models. Specialization in case of not storing the face variables |
| CStaggeredGridFaceVariables< P, FV, true, Traits > | Face variables cache class for staggered models. Specialization in case of storing the face variables |
| CStaggeredGridFluxVariablesCache | Flux variables cache class for staggered models |
| CStaggeredGridFluxVariablesCache< P, FVC, FVCF, false, upwindSchemeOrder, TheTraits > | Flux variables cache class for staggered models. Specialization in case of not storing the flux cache |
| CStaggeredGridFluxVariablesCache< P, FVC, FVCF, true, upwindSchemeOrder, TheTraits > | Flux variables cache class for staggered models. Specialization in case of storing the flux cache |
| CStaggeredGridVariables | Class storing data associated to scvs and scvfs |
| CStaggeredGridVariablesView | Base class for cell center of face specific auxiliary GridVariables classes. Provides a common interface and a pointer to the actual grid variables |
| CStaggeredGridVolumeVariables | Grid volume variables class for staggered models |
| CStaggeredGridVolumeVariables< Traits, false > | Grid volume variables class for staggered models. Specialization in case of not storing the volume variables |
| CStaggeredGridVolumeVariables< Traits, true > | Grid volume variables class for staggered models. Specialization in case of storing the volume variables |
| CStaggeredLocalResidual | Calculates the element-wise residual for the staggered FV scheme |
| ►CStaggeredMultiDomainTraits | |
| CSubDomain | |
| CStaggeredNewtonConvergenceWriter | Writes the intermediate solutions for every Newton iteration (for staggered grid scheme) |
| CStaggeredSubControlVolumeFace | Class for a sub control volume face in the staggered method, i.e a part of the boundary of a sub control volume we compute fluxes on |
| CStaggeredUpwindHelper | The upwinding variables class for the Navier-Stokes model using the staggered grid discretization |
| CStaggeredUpwindMethods | This file contains different higher order methods for approximating the velocity |
| CStaggeredVelocityGradients | Helper class for calculating the velocity gradients for the Navier-Stokes model using the staggered grid discretization |
| CStaggeredVtkOutputModule | A VTK output module to simplify writing dumux simulation data to VTK format Specialization for staggered grids with dofs on faces |
| CStationaryVelocityField | Evaluates a user given velocity field |
| CStokesDarcyCouplingDataImplementation | |
| CStokesDarcyCouplingDataImplementation< MDTraits, CouplingManager, enableEnergyBalance, false > | Coupling data specialization for non-compositional models |
| CStokesDarcyCouplingDataImplementation< MDTraits, CouplingManager, enableEnergyBalance, true > | Coupling data specialization for compositional models |
| CStokesDarcyCouplingDataImplementationBase | A base class which provides some common methods used for Stokes-Darcy coupling |
| CStokesDarcyCouplingManager | Coupling manager for Stokes and Darcy domains with equal dimension |
| CStokesDarcyCouplingMapper | Coupling mapper for Stokes and Darcy domains with equal dimension |
| CStokesDarcyCouplingOptions | This structs holds a set of options which allow to modify the Stokes-Darcy coupling mechanism during runtime |
| CStressVariablesCache | The stress variables cache classes for models involving geomechanics. Store data required for stress calculation |
| CStressVariablesCache< Scalar, GridGeometry, DiscretizationMethod::box > | We only store discretization-related quantities for the box method |
| CStressVariablesCache< Scalar, GridGeometry, DiscretizationMethod::ccmpfa > | |
| CStressVariablesCache< Scalar, GridGeometry, DiscretizationMethod::cctpfa > | |
| CSubControlVolumeBase | Base class for a sub control volume, i.e a part of the control volume we are making the balance for. Defines the general interface |
| CSubControlVolumeFaceBase | Base class for a sub control volume face, i.e a part of the boundary of a sub control volume we computing a flux on |
| CSubDomainBoxLocalAssembler | The box scheme multidomain local assembler |
| CSubDomainBoxLocalAssembler< id, TypeTag, Assembler, DiffMethod::numeric, false > | Box scheme multi domain local assembler using numeric differentiation and explicit time discretization |
| CSubDomainBoxLocalAssembler< id, TypeTag, Assembler, DiffMethod::numeric, true > | Box scheme multi domain local assembler using numeric differentiation and implicit time discretization |
| CSubDomainBoxLocalAssemblerBase | A base class for all box local assemblers |
| CSubDomainCCLocalAssembler | The cell-centered scheme multidomain local assembler |
| CSubDomainCCLocalAssembler< id, TypeTag, Assembler, DiffMethod::analytic, true > | Cell-centered scheme local assembler using analytic differentiation and implicit time discretization |
| CSubDomainCCLocalAssembler< id, TypeTag, Assembler, DiffMethod::numeric, false > | Cell-centered scheme multidomain local assembler using numeric differentiation and explicit time discretization |
| CSubDomainCCLocalAssembler< id, TypeTag, Assembler, DiffMethod::numeric, true > | Cell-centered scheme multidomain local assembler using numeric differentiation and implicit time discretization |
| CSubDomainCCLocalAssemblerBase | A base class for all multidomain local assemblers |
| CSubDomainStaggeredLocalAssembler | The staggered multidomain local assembler |
| CSubDomainStaggeredLocalAssembler< id, TypeTag, Assembler, DiffMethod::numeric, true > | Staggered scheme local assembler using numeric differentiation and implicit time discretization |
| CSubDomainStaggeredLocalAssemblerBase | A base class for all multidomain local assemblers (staggered) |
| CSubDomainStaggeredLocalAssemblerImplicitBase | A base class for all implicit multidomain local assemblers (staggered) |
| CSwitchablePrimaryVariables | A primary variable vector with a state to allow variable switches |
| CTabulated2DFunction | Implements tabulation for a two-dimensional function |
| CTabulatedCO2Properties | A generic template for tabulated material laws that depend on two parameters |
| CTemperatureOverlayFluidState | This is a fluid state which allows to set the fluid temperatures and takes all other quantities from an other fluid state |
| CThermalConductivityAverage | Relation for a simple effective thermal conductivity |
| CThermalConductivityJohansen | Relation for the saturation-dependent effective thermal conductivity |
| CThermalConductivitySimpleFluidLumping | Relation for the saturation-dependent effective thermal conductivity |
| CThermalConductivitySolidEnergy | |
| CThermalConductivitySomerton | Relation for the saturation-dependent effective thermal conductivity |
| CThreePIndices | The common indices for the isothermal three-phase model |
| CThreePIOFields | Adds I/O fields specific to the three-phase model |
| CThreePModelTraits | Specifies a number properties of three-phase models |
| CThreePThreeCIndices | The indices for the isothermal three-phase three-component model |
| CThreePThreeCIOFields | Adds I/O fields specific to the three-phase three-component model |
| CThreePThreeCLocalResidual | Element-wise calculation of the Jacobian matrix for problems using the three-phase three-component fully implicit model |
| CThreePThreeCModelTraits | Specifies a number properties of two-phase models |
| CThreePThreeCPrimaryVariableSwitch | The primary variable switch controlling the phase presence state variable |
| CThreePThreeCVolumeVariables | Contains the quantities which are are constant within a finite volume in the three-phase three-component model |
| CThreePVolumeVariables | Contains the quantities which are constant within a finite volume in the three-phase model |
| CThreePVolumeVariablesTraits | Traits class for the two-phase model |
| CThreePWaterOilIndices | The indices for the isothermal 3p2cni model |
| CThreePWaterOilIOFields | Adds I/O fields specific to the three-phase three-component model |
| CThreePWaterOilLocalResidual | Element-wise calculation of the local residual for problems using the ThreePWaterOil fully implicit model |
| CThreePWaterOilModelTraits | Specifies a number properties of the three-phase two-component model |
| CThreePWaterOilPrimaryVariableSwitch | The primary variable switch controlling the phase presence state variable |
| CThreePWaterOilVolumeVariables | Contains the quantities which are are constant within a finite volume in the three-phase, two-component model |
| CTimeLoop | The default time loop for instationary simulations |
| CTimeLoopBase | Manages the handling of time dependent problems |
| CTimeManager | Manages the handling of time dependent problems |
| CTpfaDarcysLawCache | The cache corresponding to tpfa Darcy's Law |
| CTpfaDarcysLawCacheFiller | Class that fills the cache corresponding to tpfa Darcy's Law |
| CTpfaForchheimersLawCache | The cache corresponding to tpfa Forchheimer's Law |
| CTpfaForchheimersLawCacheFiller | Class that fills the cache corresponding to tpfa Forchheimer's Law |
| CTracerIndices | Defines the primary variable and equation indices used by the isothermal tracer model |
| CTracerIOFields | Adds I/O fields specific to the tracer model |
| CTracerLocalResidual | Element-wise calculation of the local residual for problems using fully implicit tracer model |
| CTracerModelTraits | Specifies a number properties of the Richards n-components model |
| CTracerVolumeVariables | Contains the quantities which are constant within a finite volume for the tracer model |
| CTracerVolumeVariablesTraits | Traits class for the volume variables of the single-phase model |
| CTransportProblem2P | Base class for a sequential two-phase transport problem |
| CTurbulenceProperties | This class contains different functions for estimating turbulence properties |
| CTwoPGridAdaptIndicator | Class defining a standard, saturation dependent indicator for grid adaptation |
| CTwoPGridDataTransfer | Class performing the transfer of data on a grid from before to after adaptation |
| CTwoPIncompressibleLocalResidual | Element-wise calculation of the residual and its derivatives for a two-phase, incompressible test problem |
| CTwoPIndices | Defines the indices required for the two-phase fully implicit model |
| CTwoPIOFields | Adds I/O fields specific to the two-phase model |
| CTwoPModelTraits | Specifies a number properties of two-phase models |
| CTwoPNCIndices | The indices for the isothermal two-phase n-component model |
| CTwoPNCIOFields | Adds I/O fields specific to the TwoPNC model |
| CTwoPNCModelTraits | Specifies a number properties of two-phase n-component models |
| CTwoPNCPrimaryVariableSwitch | The primary variable switch controlling the phase presence state variable |
| CTwoPNCVolumeVariables | Contains the quantities which are are constant within a finite volume in the two-phase, n-component model |
| CTwoPOneCDarcysLaw | Specialization of Darcy's Law for the two-phase one-component model, including a the possibility to block spurious fluxes of cold water into the steam zone, which can improve the model's convergence behavior (Gudbjerg et al., 2005) [32] |
| CTwoPOneCIndices | The indices for the two-phase one-component model |
| CTwoPOneCIOFields | Adds I/O fields specific to two-phase one-component model |
| CTwoPOneCLocalResidual | Element-wise calculation of the residual for the fully implicit two-phase one-component flow model |
| CTwoPOneCNIModelTraits | Specifies a number properties of models considering two phases with water as a single component |
| CTwoPOneCPrimaryVariableSwitch | The primary variable switch for the two-phase one-component model |
| CTwoPOneCVolumeVariables | The volume variables (i.e. secondary variables) for the two-phase one-component model |
| CTwoPOneCVolumeVariablesTraits | Traits class for the two-phase model |
| CTwoPScvSaturationReconstruction | Class that computes the nonwetting saturation in an scv from the saturation at the global degree of freedom |
| CTwoPScvSaturationReconstruction< DiscretizationMethod::box, true > | Specialization for the box scheme with the interface solver enabled |
| CTwoPTwoCCO2PrimaryVariableSwitch | The primary variable switch for the 2p2c-CO2 model controlling the phase presence state variable |
| CTwoPTwoCCO2VolumeVariables | Contains the quantities which are are constant within a finite volume in the CO2 model |
| CTwoPTwoCUnconstrainedModelTraits | |
| CTwoPTwoCVolumeVariablesBase | Contains the quantities which are constant within a finite volume in the two-phase two-component model. This is the base class for a 2p2c model with and without chemical nonequilibrium |
| CTwoPTwoCVolumeVariablesImplementation | |
| CTwoPTwoCVolumeVariablesImplementation< Traits, false, useConstraintSolver > | Contains the quantities which are constant within a finite volume in the two-phase two-component model. Specialization for chemical equilibrium |
| CTwoPTwoCVolumeVariablesImplementation< Traits, true, useConstraintSolver > | Contains the quantities which are constant within a finite volume in the two-phase two-component model. Specialization for chemical non-equilibrium. The equilibrium mole fraction is calculated using Henry's and Raoult's law |
| CTwoPVolumeVariables | Contains the quantities which are are constant within a finite volume in the two-phase model |
| CTwoPVolumeVariablesTraits | Traits class for the two-phase model |
| CUpwindSchemeImpl | Forward declaration of the upwind scheme implementation |
| CUpwindSchemeImpl< GridGeometry, DiscretizationMethod::box > | Upwind scheme for the box method (uses the standard scheme) |
| CUpwindSchemeImpl< GridGeometry, DiscretizationMethod::ccmpfa > | Upwind scheme for cell-centered mpfa schemes |
| CUpwindSchemeImpl< GridGeometry, DiscretizationMethod::cctpfa > | Upwind scheme for the cell-centered tpfa scheme |
| CUzawaBiCGSTABBackend | A Uzawa preconditioned BiCGSTAB solver for saddle-point problems |
| CVariableClass | Base class holding the variables and discretized data for sequential models |
| ►CVariableClass2P2CAdaptive | Class holding additionally mpfa data of adaptive compositional models |
| CmpfaData | Storage object for data related to the MPFA method |
| CVariableClassAdaptive | Base class holding the variables and discretized data for sequential models |
| CVariableLengthSpline_ | The common code for all 3rd order polynomial splines with where the number of sampling points only known at run-time |
| CVectorCommDataHandle | A data handle class to exchange entries of a vector |
| CVectorConverter | A helper classe that converts a Dune::MultiTypeBlockVector into a plain Dune::BlockVector and transfers back values |
| CVelocityOutput | Velocity output for implicit (porous media) models |
| CVertexEnrichmentHelper | Specialization of the enrichment helper class for 2d grids. In this case, we look for two-dimensional bulk grid elements that are enclosed by (lie in between) two 1-dimensional facet grid elements |
| CVtkMultiWriter | Simplifies writing multi-file VTK datasets |
| CVtkNestedFunction | Provides a vector-valued function using Dune::FieldVectors as elements. DEPRECATED will be removed once this header is removed |
| CVtkOutputModule | A VTK output module to simplify writing dumux simulation data to VTK format |
| ►CVtkOutputModuleBase | A VTK output module to simplify writing dumux simulation data to VTK format |
| CFieldType | Export field type |
| CVTKReader | A vtk file reader using tinyxml2 as xml backend |
| CVTKSequenceWriter | Base class to write pvd-files which contains a list of all collected vtk-files. This is a modified version of DUNE's pvd writer which takes a VTKWriter as template argument making it more general |
| CZeroEqVolumeVariables | Volume variables for the single-phase 0-Eq. model |
| ►NDune | |
| CBCRSMatrix | |
| CMultiTypeBlockMatrix | |
| CMultiTypeBlockVector |
1.9.3
