| NAmgx | |
| CAmgxConfig | Configuration structure for AMGX parameters |
| CAmgxPreconditioner | Wrapper for AMGX's AMG preconditioner |
| Nboost | |
| Nproperty_tree | |
| Cbasic_ptree | |
| NDune | |
| Ndetail | |
| CStructMPITraitsImpl | |
| NAmg | |
| CKAMG | |
| CKAmgTwoGrid | |
| CAMGCPR | Parallel algebraic multigrid based on agglomeration |
| CConstructionTraits< MultithreadDILU< M, X, Y > > | Policy for the construction of the MultithreadDILU smoother |
| CSmootherTraits< Opm::ParallelOverlappingILU0< M, X, Y, C > > | |
| CConstructionTraits< Opm::ParallelOverlappingILU0< Matrix, Domain, Range, ParallelInfo > > | Tells AMG how to construct the Opm::ParallelOverlappingILU0 smoother |
| CConstructionTraits< Opm::ParallelRestrictedOverlappingSchwarz< Range, Domain, ParallelInfo, SeqPreconditioner > > | Tells AMG how to construct the Opm::ParallelOverlappingILU0 smoother |
| CSmootherTraits< Opm::ParallelRestrictedOverlappingSchwarz< Range, Domain, ParallelInfo, SeqPreconditioner > > | Tells AMG how to use Opm::ParallelOverlappingILU0 smoother |
| CPressureSolverPolicy | |
| CLevelTransferPolicyCpr | Abstract base class for transfer between levels and creation of the coarse level system |
| CAggregationLevelTransferPolicyCpr | A LeveTransferPolicy that used aggregation to construct the coarse level system |
| COneStepAMGCoarseSolverPolicyCpr | A policy class for solving the coarse level system using one step of AMG |
| CTwoLevelMethodCpr | |
| CConstructionTraits< Opm::GhostLastMatrixAdapter< M, X, Y, C > > | |
| NMatrixMarketImpl | |
| Cmm_header_printer< BCRSMatrix< Opm::MatrixBlock< T, i, j >, A > > | |
| Cmm_block_structure_header< BCRSMatrix< Opm::MatrixBlock< T, i, j >, A > > | |
| Cmm_multipliers< BCRSMatrix< Opm::MatrixBlock< T, i, j >, A > > | |
| CFieldTraitsImpl | Compatibility traits class for DenseVector and DenseMatrix |
| CFieldTraitsImpl< TypeTag, true > | FieldTraitsImpl for classes derived from Opm::FvBasePrimaryVariables: use FieldVector's FieldTraits implementation) |
| CFieldTraitsImpl< T, false > | FieldTraitsImpl for classes not derived from Opm::FvBasePrimaryVariables, fall bakc to existing implementation |
| CFieldTraits< EwomsPrimaryVariable< TypeTag > > | Specialization of FieldTraits for all PrimaryVariables derived from Opm::FvBasePrimaryVariables |
| CCartesianIndexMapper< Dune::ALUGrid< 3, 3, Dune::cube, Dune::nonconforming > > | Interface class to access the logical Cartesian grid as used in industry standard simulator decks |
| CGlobalIndexDataHandle | |
| CCartesianIndexMapper | |
| CMPITraits<::Opm::ReservoirCoupling::Potentials > | |
| CMultithreadDILU | The OpenMP thread parallelized DILU preconditioner |
| CFlexibleSolver | A solver class that encapsulates all needed objects for a linear solver (operator, scalar product, iterative solver and preconditioner) and sets them up based on runtime parameters, using the PreconditionerFactory for setting up preconditioners |
| CMatrixDimension< Opm::MatrixBlock< Scalar, n, m > > | |
| CIsNumber< Opm::MatrixBlock< T, n, m > > | |
| COwningBlockPreconditioner | |
| COwningTwoLevelPreconditioner | A version of the two-level preconditioner that is: |
| CPreconditionerWithUpdate | Interface class adding the update() method to the preconditioner interface |
| CDummyUpdatePreconditioner | |
| CGeneralPreconditionerMaker | Interface class ensuring make function is overriden |
| CPreconditionerMaker | Struct implementing a make function which creates a preconditioner Can create arbitrary preconditioners using parameter packs as template arguments |
| CRebuildOnUpdatePreconditioner | Wrapper class of preconditioners that should be reconstructed on update |
| CUMFPack | |
| NHypre | |
| CHyprePreconditioner | Wrapper for Hypre's BoomerAMG preconditioner |
| NOpm | This file contains a set of helper functions used by VFPProd / VFPInj |
| NProperties | |
| NTTag | The generic type tag for problems using the immiscible multi-phase model |
| CBlackOilModel | The type tag for the black-oil problems |
| CMultiPhaseBaseModel | |
| CDiscreteFractureModel | The generic type tag for problems using the immiscible multi-phase model |
| CAutoDiffLocalLinearizer | |
| CFiniteDifferenceLocalLinearizer | |
| CFvBaseNewtonMethod | |
| CFvBaseDiscretization | The type tag for models based on the finite volume schemes |
| CEcfvDiscretization | |
| CVcfvDiscretization | |
| CFlashModel | The type tag for the isothermal single phase problems |
| CImmiscibleModel | The generic type tag for problems using the immiscible multi-phase model |
| CImmiscibleSinglePhaseModel | The type tag for single-phase immiscible problems |
| CImmiscibleTwoPhaseModel | The type tag for two-phase immiscible problems |
| CStructuredGridVanguard | |
| CVtkBlackOilPolymer | |
| CNcpModel | Define the type tag for the compositional NCP model |
| CNewtonMethod | The type tag on which the default properties for the Newton method are attached |
| CPvsModel | The type tag for the isothermal single phase problems |
| CRichards | The type tag for problems discretized using the Richards model |
| CNumericModel | Type tag for all models |
| CImplicitModel | Type tag for all fully coupled models |
| CAluGridVanguard | |
| CFlowProblem | |
| CCpGridVanguard | |
| CFlowBaseProblem | |
| CFlowBaseVanguard | |
| CFlowBaseProblemBlackoil | |
| CFlowBaseProblemComp | |
| CFlowEarlyBird | |
| CPolyhedralGridVanguard | |
| CFlowGasWaterProblem | Specialized type tag for gas-water simulations |
| CFlowOnePhaseProblem | Specialized type tag for one phase (water) simulations |
| CFlowProblemTPFA | Specialised type tag for simulations that can use the customised assembly process for TPFA discretisation schemes |
| CFlowIstlSolverParams | |
| CFlowIstlSolver | |
| CParallelAmgLinearSolver | |
| CParallelBaseLinearSolver | |
| CParallelBiCGStabLinearSolver | |
| CParallelIstlLinearSolver | |
| NTag | |
| CAuxModule | |
| NDetail | Implementation details for template meta programming |
| CGetDefined | Helper struct to get the first property that is defined in the TypeTag hierarchy |
| CGetNextTypeTag | Helper struct to iterate over the TypeTag hierarchy |
| 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 > > | |
| 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 > > | |
| CGetDefined< TypeTag, Property, std::tuple< LastTypeTag > > | |
| CGetDefined< TypeTag, Property, std::tuple< FirstTypeTag, Args... > > | |
| CGetDefinedSplice | Helper struct to get the first property that is defined in the TypeTag hierarchy |
| CGetNextSpliceTypeTag | Helper struct to iterate over the TypeTag hierarchy |
| CGetNextSpliceTypeTag< TypeTag, std::tuple< LastTypeTag >, std::enable_if_t< hasParentTypeTag< LastTypeTag >(int{}), void > > | |
| CGetNextSpliceTypeTag< TypeTag, std::tuple< LastTypeTag >, std::enable_if_t<!hasParentTypeTag< LastTypeTag >(int{}), void > > | |
| CGetNextSpliceTypeTag< TypeTag, std::tuple< FirstTypeTag, Args... >, std::enable_if_t< hasParentTypeTag< FirstTypeTag >(int{}), void > > | |
| CGetNextSpliceTypeTag< TypeTag, std::tuple< FirstTypeTag, Args... >, std::enable_if_t<!hasParentTypeTag< FirstTypeTag >(int{}), void > > | |
| CGetDefinedSplice< TypeTag, std::tuple< LastTypeTag > > | |
| CGetDefinedSplice< TypeTag, std::tuple< FirstTypeTag, Args... > > | |
| CGetPropImpl | Helper struct to extract get the Property specilization given a TypeTag, asserts that the property is defined |
| CGetSplicePropImpl | |
| CLocalResidual< TypeTag, TTag::BlackOilModel > | Set the local residual function |
| CNewtonMethod< TypeTag, TTag::BlackOilModel > | Use the black-oil specific newton method |
| CModel< TypeTag, TTag::BlackOilModel > | The Model property |
| CBaseProblem< TypeTag, TTag::BlackOilModel > | The Problem property |
| CRateVector< TypeTag, TTag::BlackOilModel > | RateVector property |
| CBoundaryRateVector< TypeTag, TTag::BlackOilModel > | BoundaryRateVector property |
| CPrimaryVariables< TypeTag, TTag::BlackOilModel > | PrimaryVariables property |
| CIntensiveQuantities< TypeTag, TTag::BlackOilModel > | IntensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::BlackOilModel > | ExtensiveQuantities property |
| CFluxModule< TypeTag, TTag::BlackOilModel > | Use the the velocity module which is aware of the black-oil specific model extensions (i.e., the polymer and solvent extensions) |
| CIndices< TypeTag, TTag::BlackOilModel > | The indices required by the model |
| CFluidSystem< TypeTag, TTag::BlackOilModel > | Set the fluid system to the black-oil fluid system by default |
| CEnableSolvent< TypeTag, TTag::BlackOilModel > | |
| CEnableExtbo< TypeTag, TTag::BlackOilModel > | |
| CEnablePolymer< TypeTag, TTag::BlackOilModel > | |
| CEnablePolymerMW< TypeTag, TTag::BlackOilModel > | |
| CEnableFoam< TypeTag, TTag::BlackOilModel > | |
| CEnableBrine< TypeTag, TTag::BlackOilModel > | |
| CEnableVapwat< TypeTag, TTag::BlackOilModel > | |
| CEnableDisgasInWater< TypeTag, TTag::BlackOilModel > | |
| CEnableSaltPrecipitation< TypeTag, TTag::BlackOilModel > | |
| CEnableBioeffects< TypeTag, TTag::BlackOilModel > | |
| CEnableTemperature< TypeTag, TTag::BlackOilModel > | By default, the blackoil model is isothermal and does not conserve energy |
| CEnableEnergy< TypeTag, TTag::BlackOilModel > | |
| CEnableDiffusion< TypeTag, TTag::BlackOilModel > | Disable diffusion by default |
| CEnableDispersion< TypeTag, TTag::BlackOilModel > | Disable dispersion by default |
| CEnableConvectiveMixing< TypeTag, TTag::BlackOilModel > | |
| CBlackOilEnergyScalingFactor< TypeTag, TTag::BlackOilModel > | By default, scale the energy equation by the inverse of the energy required to heat up one kg of water by 30 Kelvin |
| CBlackOilUreaScalingFactor< TypeTag, TTag::BlackOilModel > | Similarly to the energy equation, the urea equation in MICP is scaled by a factor of 0.1 |
| CBlackoilConserveSurfaceVolume< TypeTag, TTag::BlackOilModel > | |
| CDiscNewtonMethod | The discretization specific part of he implementing the Newton algorithm |
| CEnableEclipseOutput | Specifies if the simulation should write output files that are compatible with those produced by the commercial Eclipse simulator |
| CEnableSolvent | Enable the ECL-blackoil extension for solvents. ("Second gas") |
| CEnableExtbo | Enable the ECL-blackoil extension for extended BO. ("Second gas" - alternative approach) |
| CEnablePolymer | Enable the ECL-blackoil extension for polymer |
| CEnablePolymerMW | Enable the tracking polymer molecular weight tracking and related functionalities |
| CBlackoilConserveSurfaceVolume | Enable surface volume scaling |
| CEnableFoam | Enable the ECL-blackoil extension for foam |
| CEnableBrine | Enable the ECL-blackoil extension for salt |
| CEnableSaltPrecipitation | Enable the ECL-blackoil extension for salt precipitation |
| CEnableVapwat | Enable the ECL-blackoil extension for water evaporation |
| CEnableDisgasInWater | Enable the ECL-blackoil extension for disolution of gas into water |
| CEnableBioeffects | Enable the ECL-blackoil extension for bioeffects (biofilm/MICP) |
| CEnableTemperature | Allow the spatial and temporal domains to exhibit non-constant temperature in the black-oil model |
| CEnableMech | |
| CBlackOilEnergyScalingFactor | The relative weight of the residual of the energy equation compared to the mass residuals |
| CBlackOilUreaScalingFactor | Similarly to the energy equation, a scaling is applied to the urea equation in MICP |
| CSplices< TypeTag, TTag::MultiPhaseBaseModel > | Specify the splices of the MultiPhaseBaseModel type tag |
| CSpatialDiscretizationSplice< TypeTag, TTag::MultiPhaseBaseModel > | Set the default spatial discretization |
| CNumEq< TypeTag, TTag::MultiPhaseBaseModel > | Set the number of equations to the number of phases |
| CNumPhases< TypeTag, TTag::MultiPhaseBaseModel > | The number of phases is determined by the fluid system |
| CNumComponents< TypeTag, TTag::MultiPhaseBaseModel > | Number of chemical species in the system |
| CBaseProblem< TypeTag, TTag::MultiPhaseBaseModel > | The type of the base base class for actual problems |
| CFluxModule< TypeTag, TTag::MultiPhaseBaseModel > | By default, use the Darcy relation to determine the phase velocity |
| CMaterialLaw< TypeTag, TTag::MultiPhaseBaseModel > | Set the material law to the null law by default |
| CMaterialLawParams< TypeTag, TTag::MultiPhaseBaseModel > | Set the property for the material parameters by extracting it from the material law |
| CSolidEnergyLaw< TypeTag, TTag::MultiPhaseBaseModel > | Set the energy storage law for the solid to the one which assumes zero heat capacity by default |
| CSolidEnergyLawParams< TypeTag, TTag::MultiPhaseBaseModel > | Extract the type of the parameter objects for the solid energy storage law from the law itself |
| CThermalConductionLaw< TypeTag, TTag::MultiPhaseBaseModel > | Set the thermal conduction law to a dummy one by default |
| CThermalConductionLawParams< TypeTag, TTag::MultiPhaseBaseModel > | Extract the type of the parameter objects for the thermal conduction law from the law itself |
| CSpatialDiscretizationSplice | The splice to be used for the spatial discretization |
| CNumPhases | Number of fluid phases in the system |
| CNumComponents | Number of chemical species in the system |
| CIndices | Enumerations used by the model |
| CMaterialLaw | The material law which ought to be used (extracted from the spatial parameters) |
| CMaterialLawParams | The context material law (extracted from the spatial parameters) |
| CSolidEnergyLaw | The material law for the energy stored in the solid matrix |
| CSolidEnergyLawParams | The parameters of the material law for energy storage of the solid |
| CThermalConductionLaw | The material law for thermal conduction |
| CThermalConductionLawParams | The parameters of the material law for thermal conduction |
| CFluidSystem | The fluid systems including the information about the phases |
| CFluxModule | Specifies the relation used for velocity |
| CEnableEnergy | Specify whether energy should be considered as a conservation quantity or not |
| CEnableDiffusion | Enable diffusive fluxes? |
| CEnableDispersion | Enable dispersive fluxes? |
| CEnableConvectiveMixing | Enable convective mixing? |
| CEnableWater | Enable water? |
| CModel< TypeTag, TTag::DiscreteFractureModel > | The class for the model |
| CBaseProblem< TypeTag, TTag::DiscreteFractureModel > | The class for the model |
| CLocalResidual< TypeTag, TTag::DiscreteFractureModel > | Use the immiscible multi-phase local jacobian operator for the immiscible multi-phase model |
| CPrimaryVariables< TypeTag, TTag::DiscreteFractureModel > | PrimaryVariables property |
| CIntensiveQuantities< TypeTag, TTag::DiscreteFractureModel > | IntensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::DiscreteFractureModel > | ExtensiveQuantities property |
| CUseTwoPointGradients< TypeTag, TTag::DiscreteFractureModel > | For the discrete fracture model, we need to use two-point flux approximation or it will converge very poorly |
| CUseTwoPointGradients | |
| CLocalLinearizer< TypeTag, TTag::AutoDiffLocalLinearizer > | |
| CEvaluation< TypeTag, TTag::AutoDiffLocalLinearizer > | Set the function evaluation w.r.t. the primary variables |
| CSimulator< TypeTag, TTag::FvBaseDiscretization > | Set the default type for the time manager |
| CVertexMapper< TypeTag, TTag::FvBaseDiscretization > | Mapper for the grid view's vertices |
| CElementMapper< TypeTag, TTag::FvBaseDiscretization > | Mapper for the grid view's elements |
| CBorderListCreator< TypeTag, TTag::FvBaseDiscretization > | Marks the border indices (required for the algebraic overlap stuff) |
| CDiscLocalResidual< TypeTag, TTag::FvBaseDiscretization > | |
| CDiscIntensiveQuantities< TypeTag, TTag::FvBaseDiscretization > | |
| CDiscExtensiveQuantities< TypeTag, TTag::FvBaseDiscretization > | |
| CGradientCalculator< TypeTag, TTag::FvBaseDiscretization > | Calculates the gradient of any quantity given the index of a flux approximation point |
| CEqVector< TypeTag, TTag::FvBaseDiscretization > | A vector of quanties, each for one equation |
| CRateVector< TypeTag, TTag::FvBaseDiscretization > | A vector for mass/energy rates |
| CBoundaryRateVector< TypeTag, TTag::FvBaseDiscretization > | Type of object for specifying boundary conditions |
| CConstraints< TypeTag, TTag::FvBaseDiscretization > | The class which represents constraints |
| CElementEqVector< TypeTag, TTag::FvBaseDiscretization > | The type for storing a residual for an element |
| CGlobalEqVector< TypeTag, TTag::FvBaseDiscretization > | The type for storing a residual for the whole grid |
| CPrimaryVariables< TypeTag, TTag::FvBaseDiscretization > | An object representing a local set of primary variables |
| CSolutionVector< TypeTag, TTag::FvBaseDiscretization > | The type of a solution for the whole grid at a fixed time |
| CIntensiveQuantities< TypeTag, TTag::FvBaseDiscretization > | The class representing intensive quantities |
| CElementContext< TypeTag, TTag::FvBaseDiscretization > | The element context |
| CBoundaryContext< TypeTag, TTag::FvBaseDiscretization > | |
| CConstraintsContext< TypeTag, TTag::FvBaseDiscretization > | |
| CThreadManager< TypeTag, TTag::FvBaseDiscretization > | The OpenMP threads manager |
| CUseLinearizationLock< TypeTag, TTag::FvBaseDiscretization > | |
| CLinearizer< TypeTag, TTag::FvBaseDiscretization > | Linearizer for the global system of equations |
| CVtkOutputFormat< TypeTag, TTag::FvBaseDiscretization > | Set the format of the VTK output to ASCII by default |
| CEnableConstraints< TypeTag, TTag::FvBaseDiscretization > | |
| CTimeDiscHistorySize< TypeTag, TTag::FvBaseDiscretization > | Set the history size of the time discretization to 2 (for implicit euler) |
| CExtensiveStorageTerm< TypeTag, TTag::FvBaseDiscretization > | Most models use extensive quantities for their storage term (so far, only the Stokes model does), so we disable this by default |
| CUseVolumetricResidual< TypeTag, TTag::FvBaseDiscretization > | |
| CEnableExperiments< TypeTag, TTag::FvBaseDiscretization > | EWoms is mainly targeted at research, so experimental features are enabled by default |
| CBaseDiscretizationType | |
| CBaseDiscretizationType< TypeTag, TTag::FvBaseDiscretization > | |
| CDiscreteFunction< TypeTag, TTag::FvBaseDiscretization > | |
| CBaseEpsilon | |
| CLocalLinearizer< TypeTag, TTag::FiniteDifferenceLocalLinearizer > | |
| CEvaluation< TypeTag, TTag::FiniteDifferenceLocalLinearizer > | |
| CBaseEpsilon< TypeTag, TTag::FiniteDifferenceLocalLinearizer > | The base epsilon value for finite difference calculations |
| CDiscNewtonMethod< TypeTag, TTag::FvBaseNewtonMethod > | |
| CNewtonMethod< TypeTag, TTag::FvBaseNewtonMethod > | |
| CNewtonConvergenceWriter< TypeTag, TTag::FvBaseNewtonMethod > | |
| CNewtonMethod | Specifies the type of the actual Newton method |
| CLinearSolverSplice | |
| CLocalLinearizerSplice | |
| CEvaluation | Representation of a function evaluation and all necessary derivatives with regard to the intensive quantities of the primary variables |
| CStencil | The class describing the stencil of the spatial discretization |
| CDiscreteFunctionSpace | The class describing the discrete function space when dune-fem is used, otherwise it points to the stencil class |
| CDiscreteFunction | |
| CProblem | The type of the problem |
| CBaseProblem | The type of the base class for all problems which use this model |
| CDiscretization | The type of the spatial discretization used by the model |
| CDiscLocalResidual | The discretization specific part of the local residual |
| CLocalResidual | The type of the local residual function |
| CLocalLinearizer | The type of the local linearizer |
| CLinearizeNonLocalElements | Specify if elements that do not belong to the local process' grid partition should be skipped |
| CBaseLinearizer | Linearizes the global non-linear system of equations |
| CEqVector | A vector of holding a quantity for each equation (usually at a given spatial location) |
| CElementEqVector | A vector of holding a quantity for each equation for each DOF of an element |
| CRateVector | Vector containing volumetric or areal rates of quantities |
| CBoundaryRateVector | Type of object for specifying boundary conditions |
| CConstraints | The class which represents a constraint degree of freedom |
| CSolutionVector | Vector containing all primary variables of the grid |
| CPrimaryVariables | A vector of primary variables within a sub-control volume |
| CIntensiveQuantities | The secondary variables within a sub-control volume |
| CDiscIntensiveQuantities | The discretization specific part of the intensive quantities |
| CElementContext | The secondary variables of all degrees of freedom in an element's stencil |
| CBoundaryContext | The secondary variables of a boundary segment |
| CConstraintsContext | The secondary variables of a constraint degree of freedom |
| CExtensiveQuantities | Data required to calculate a flux over a face |
| CGradientCalculator | Calculates gradients of arbitrary quantities at flux integration points |
| CDiscBaseIntensiveQuantities | The part of the intensive quantities which is specific to the spatial discretization |
| CDiscExtensiveQuantities | The part of the extensive quantities which is specific to the spatial discretization |
| CDiscBaseOutputModule | The part of the VTK ouput modules which is specific to the spatial discretization |
| CGridCommHandleFactory | The class to create grid communication handles |
| CThreadManager | The OpenMP threads manager |
| CUseLinearizationLock | Use locking to prevent race conditions when linearizing the global system of equations in multi-threaded mode |
| CVtkOutputFormat | Specify the format the VTK output is written to disk |
| CEnableConstraints | Specify whether the some degrees of fredom can be constraint |
| CVertexMapper | The mapper to find the global index of a vertex |
| CElementMapper | The mapper to find the global index of an element |
| CDofMapper | The mapper to find the global index of a degree of freedom |
| CTimeDiscHistorySize | The history size required by the time discretization |
| CExtensiveStorageTerm | Specify whether the storage terms use extensive quantities or not |
| CUseVolumetricResidual | Specify whether to use volumetric residuals or not |
| CEnableExperiments | Specify if experimental features should be enabled or not |
| CSplices< TypeTag, TTag::FvBaseDiscretization > | Set the splices for the finite volume discretizations |
| CLinearSolverSplice< TypeTag, TTag::FvBaseDiscretization > | Use a parallel BiCGStab linear solver by default |
| CLocalLinearizerSplice< TypeTag, TTag::FvBaseDiscretization > | By default, use finite differences to linearize the system of PDEs |
| CStencil< TypeTag, TTag::EcfvDiscretization > | Set the stencil |
| CDofMapper< TypeTag, TTag::EcfvDiscretization > | Mapper for the degrees of freedoms |
| CDiscretization< TypeTag, TTag::EcfvDiscretization > | The concrete class which manages the spatial discretization |
| CDiscBaseOutputModule< TypeTag, TTag::EcfvDiscretization > | The base class for the output modules (decides whether to write element or vertex based fields) |
| CGridCommHandleFactory< TypeTag, TTag::EcfvDiscretization > | The class to create grid communication handles |
| CDummySpaceEcfv | |
| CDiscreteFunctionSpace< TypeTag, TTag::EcfvDiscretization > | |
| CBorderListCreator< TypeTag, TTag::EcfvDiscretization > | Set the border list creator for to the one of an element based method |
| CLinearizeNonLocalElements< TypeTag, TTag::EcfvDiscretization > | For the element centered finite volume method, ghost and overlap elements must be assembled to calculate the fluxes over the process boundary faces of the local process' grid partition |
| CUseLinearizationLock< TypeTag, TTag::EcfvDiscretization > | Locking is not required for the element centered finite volume method because race conditions cannot occur since each matrix/vector entry is written exactly once |
| CStencil< TypeTag, TTag::VcfvDiscretization > | Set the stencil |
| CDofMapper< TypeTag, TTag::VcfvDiscretization > | Mapper for the degrees of freedoms |
| CDiscretization< TypeTag, TTag::VcfvDiscretization > | The concrete class which manages the spatial discretization |
| CDiscBaseOutputModule< TypeTag, TTag::VcfvDiscretization > | The base class for the output modules (decides whether to write element or vertex based fields) |
| CGradientCalculator< TypeTag, TTag::VcfvDiscretization > | Calculates the gradient of any quantity given the index of a flux approximation point |
| CGridCommHandleFactory< TypeTag, TTag::VcfvDiscretization > | The class to create grid communication handles |
| CUseP1FiniteElementGradients< TypeTag, TTag::VcfvDiscretization > | Use two-point gradients by default for the vertex centered finite volume scheme |
| CDummySpaceVcfv | |
| CDiscreteFunctionSpace< TypeTag, TTag::VcfvDiscretization > | |
| CBorderListCreator< TypeTag, TTag::VcfvDiscretization > | Set the border list creator for vertices |
| CLinearizeNonLocalElements< TypeTag, TTag::VcfvDiscretization > | For the vertex centered finite volume method, ghost and overlap elements must not be assembled to avoid accounting twice for the fluxes over the process boundary faces of the local process' grid partition |
| CUseP1FiniteElementGradients | Use P1 finite-elements gradients instead of two-point gradients |
| CLocalResidual< TypeTag, TTag::FlashModel > | Use the FlashLocalResidual function for the flash model |
| CFlashSolver< TypeTag, TTag::FlashModel > | Use the NCP flash solver by default |
| CModel< TypeTag, TTag::FlashModel > | Model property |
| CPrimaryVariables< TypeTag, TTag::FlashModel > | PrimaryVariables property |
| CRateVector< TypeTag, TTag::FlashModel > | RateVector property |
| CBoundaryRateVector< TypeTag, TTag::FlashModel > | BoundaryRateVector property |
| CIntensiveQuantities< TypeTag, TTag::FlashModel > | IntensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::FlashModel > | ExtensiveQuantities property |
| CIndices< TypeTag, TTag::FlashModel > | The indices required by the flash-baseed isothermal compositional model |
| CEnableDiffusion< TypeTag, TTag::FlashModel > | |
| CEnableEnergy< TypeTag, TTag::FlashModel > | Disable the energy equation by default |
| CFlashSolver | The type of the flash constraint solver |
| CLocalResidual< TypeTag, TTag::ImmiscibleModel > | Use the immiscible multi-phase local jacobian operator for the immiscible multi-phase model |
| CModel< TypeTag, TTag::ImmiscibleModel > | Model property |
| CRateVector< TypeTag, TTag::ImmiscibleModel > | RateVector property |
| CBoundaryRateVector< TypeTag, TTag::ImmiscibleModel > | BoundaryRateVector property |
| CPrimaryVariables< TypeTag, TTag::ImmiscibleModel > | PrimaryVariables property |
| CIntensiveQuantities< TypeTag, TTag::ImmiscibleModel > | IntensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::ImmiscibleModel > | ExtensiveQuantities property |
| CIndices< TypeTag, TTag::ImmiscibleModel > | The indices required by the isothermal immiscible multi-phase model |
| CEnableEnergy< TypeTag, TTag::ImmiscibleModel > | Disable the energy equation by default |
| CFluidSystem< TypeTag, TTag::ImmiscibleSinglePhaseModel > | The fluid system to use by default |
| CFluid< TypeTag, TTag::ImmiscibleSinglePhaseModel > | |
| CWettingPhase< TypeTag, TTag::ImmiscibleTwoPhaseModel > | |
| CNonwettingPhase< TypeTag, TTag::ImmiscibleTwoPhaseModel > | |
| CFluidSystem< TypeTag, TTag::ImmiscibleTwoPhaseModel > | |
| CWettingPhase | The wetting phase for two-phase models |
| CNonwettingPhase | The non-wetting phase for two-phase models |
| CFluid | The fluid used by the model |
| CGrid< TypeTag, TTag::StructuredGridVanguard > | |
| CVanguard< TypeTag, TTag::StructuredGridVanguard > | |
| CLocalResidual< TypeTag, TTag::NcpModel > | Use the Ncp local jacobian operator for the compositional NCP model |
| CNewtonMethod< TypeTag, TTag::NcpModel > | Use the Ncp specific newton method for the compositional NCP model |
| CModel< TypeTag, TTag::NcpModel > | Model property |
| CBaseProblem< TypeTag, TTag::NcpModel > | The type of the base base class for actual problems |
| CEnableEnergy< TypeTag, TTag::NcpModel > | Disable the energy equation by default |
| CEnableDiffusion< TypeTag, TTag::NcpModel > | Disable diffusion by default |
| CRateVector< TypeTag, TTag::NcpModel > | RateVector property |
| CBoundaryRateVector< TypeTag, TTag::NcpModel > | BoundaryRateVector property |
| CPrimaryVariables< TypeTag, TTag::NcpModel > | PrimaryVariables property |
| CIntensiveQuantities< TypeTag, TTag::NcpModel > | IntensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::NcpModel > | ExtensiveQuantities property |
| CIndices< TypeTag, TTag::NcpModel > | The indices required by the compositional NCP model |
| CNcpPressureBaseWeight< TypeTag, TTag::NcpModel > | The unmodified weight for the pressure primary variable |
| CNcpSaturationsBaseWeight< TypeTag, TTag::NcpModel > | The weight for the saturation primary variables |
| CNcpFugacitiesBaseWeight< TypeTag, TTag::NcpModel > | The unmodified weight for the fugacity primary variables |
| CNcpPressureBaseWeight | The unmodified weight for the pressure primary variable |
| CNcpSaturationsBaseWeight | The weight for the saturation primary variables |
| CNcpFugacitiesBaseWeight | The unmodified weight for the fugacity primary variables |
| CNcpCompositionFromFugacitiesSolver | The themodynamic constraint solver which calculates the composition of any phase given all component fugacities |
| CNewtonMethod< TypeTag, TTag::NewtonMethod > | |
| CNewtonConvergenceWriter< TypeTag, TTag::NewtonMethod > | |
| CLinearizer | The class which linearizes the non-linear system of equations |
| CNewtonConvergenceWriter | Specifies the type of the class which writes out the Newton convergence |
| CConvergenceWriter | Specifies whether the convergence rate and the global residual gets written out to disk for every Newton iteration |
| CNewtonMethod< TypeTag, TTag::FlashModel > | Use the PT flash specific newton method for the flash model |
| CEnableWater< TypeTag, TTag::MultiPhaseBaseModel > | |
| CLocalResidual< TypeTag, TTag::PvsModel > | Use the PVS local jacobian operator for the PVS model |
| CNewtonMethod< TypeTag, TTag::PvsModel > | Use the PVS specific newton method for the PVS model |
| CModel< TypeTag, TTag::PvsModel > | Model property |
| CPrimaryVariables< TypeTag, TTag::PvsModel > | PrimaryVariables property |
| CRateVector< TypeTag, TTag::PvsModel > | RateVector property |
| CBoundaryRateVector< TypeTag, TTag::PvsModel > | BoundaryRateVector property |
| CIntensiveQuantities< TypeTag, TTag::PvsModel > | IntensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::PvsModel > | ExtensiveQuantities property |
| CIndices< TypeTag, TTag::PvsModel > | The indices required by the isothermal PVS model |
| CEnableEnergy< TypeTag, TTag::PvsModel > | Disable the energy equation by default |
| CEnableDiffusion< TypeTag, TTag::PvsModel > | |
| CPvsPressureBaseWeight< TypeTag, TTag::PvsModel > | The basis value for the weight of the pressure primary variable |
| CPvsSaturationsBaseWeight< TypeTag, TTag::PvsModel > | The basis value for the weight of the saturation primary variables |
| CPvsMoleFractionsBaseWeight< TypeTag, TTag::PvsModel > | The basis value for the weight of the mole fraction primary variables |
| CPvsPressureBaseWeight | The basis value for the weight of the pressure primary variable |
| CPvsSaturationsBaseWeight | The basis value for the weight of the saturation primary variables |
| CPvsMoleFractionsBaseWeight | The basis value for the weight of the mole fraction primary variables |
| CLiquidPhaseIndex< TypeTag, TTag::Richards > | By default, assume that the first phase is the liquid one |
| CGasPhaseIndex< TypeTag, TTag::Richards > | By default, assume that the non-liquid phase is gaseos |
| CLiquidComponentIndex< TypeTag, TTag::Richards > | By default, assume that component which the liquid is made of has the same index as the liquid phase |
| CGasComponentIndex< TypeTag, TTag::Richards > | By default, assume that the gas component is the other than the liquid one |
| CLocalResidual< TypeTag, TTag::Richards > | The local residual operator |
| CModel< TypeTag, TTag::Richards > | The global model used |
| CRateVector< TypeTag, TTag::Richards > | RateVector property |
| CBoundaryRateVector< TypeTag, TTag::Richards > | BoundaryRateVector property |
| CPrimaryVariables< TypeTag, TTag::Richards > | PrimaryVariables property |
| CIntensiveQuantities< TypeTag, TTag::Richards > | The class for the intensive quantities |
| CExtensiveQuantities< TypeTag, TTag::Richards > | The class for the quantities required for the flux calculation |
| CNewtonMethod< TypeTag, TTag::Richards > | The class of the Newton method |
| CIndices< TypeTag, TTag::Richards > | The class with all index definitions for the model |
| CWettingFluid< TypeTag, TTag::Richards > | The wetting phase used |
| CNonWettingFluid< TypeTag, TTag::Richards > | The non-wetting phase used |
| CFluidSystem< TypeTag, TTag::Richards > | The fluid system used by the model |
| CWettingFluid | The fluid used as the wetting phase (by default, we set the fluid system to the immiscible one, which requires this property.) |
| CNonWettingFluid | The fluid used as the non-wetting phase (by default, we set the fluid system to the immiscible one, which requires this property.) |
| CLiquidPhaseIndex | Index of the fluid which represents the wetting phase |
| CGasPhaseIndex | Index of the fluid which represents the non-wetting phase |
| CLiquidComponentIndex | Index of the component which constitutes the liquid |
| CGasComponentIndex | Index of the component which constitutes the gas |
| CScalar | Property to specify the type of scalar values |
| CNumEq | Number of equations in the system of PDEs |
| CParameterTree | Property which provides a Dune::ParameterTree |
| CModel | The type of the model |
| CModelParameterGroup | Property which defines the group that is queried for parameters by default |
| CVanguard | Property which provides a Vanguard (manages grids) |
| CGrid | The type of the DUNE grid |
| CGridView | |
| CGridViewLevel | Level of the grid view |
| CSimulator | Manages the simulation time |
| CBorderListCreator | The class which marks the border indices associated with the degrees of freedom on a process boundary |
| CScalar< TypeTag, TTag::NumericModel > | Set the default type of scalar values to double |
| CParameterTree< TypeTag, TTag::NumericModel > | Set the ParameterTree property |
| CModelParameterGroup< TypeTag, TTag::NumericModel > | Use the global group as default for the model's parameter group |
| CGridView< TypeTag, TTag::NumericModel > | Use the leaf grid view by default |
| CVanguard< TypeTag, TTag::NumericModel > | |
| CUndefinedProperty | Tag to mark properties as undefined |
| CSplices | |
| CSimulator< TypeTag, TTag::NumericModel > | |
| CVanguard< TypeTag, TTag::AluGridVanguard > | |
| CGrid< TypeTag, TTag::AluGridVanguard > | |
| CEquilGrid< TypeTag, TTag::AluGridVanguard > | |
| CBlackoilConserveSurfaceVolume< TypeTag, TTag::FlowProblem > | |
| CUseVolumetricResidual< TypeTag, TTag::FlowProblem > | |
| CAquiferModel< TypeTag, TTag::FlowProblem > | |
| CEnablePolymer< TypeTag, TTag::FlowProblem > | |
| CEnableSolvent< TypeTag, TTag::FlowProblem > | |
| CEnableTemperature< TypeTag, TTag::FlowProblem > | |
| CEnableEnergy< TypeTag, TTag::FlowProblem > | |
| CEnableFoam< TypeTag, TTag::FlowProblem > | |
| CEnableBrine< TypeTag, TTag::FlowProblem > | |
| CEnableSaltPrecipitation< TypeTag, TTag::FlowProblem > | |
| CEnableBioeffects< TypeTag, TTag::FlowProblem > | |
| CEnableDispersion< TypeTag, TTag::FlowProblem > | |
| CEnableConvectiveMixing< TypeTag, TTag::FlowProblem > | |
| CWellModel< TypeTag, TTag::FlowProblem > | |
| CLinearSolverSplice< TypeTag, TTag::FlowProblem > | |
| CEnableDebuggingChecks< TypeTag, TTag::FlowProblem > | |
| CVanguard< TypeTag, TTag::CpGridVanguard > | |
| CGrid< TypeTag, TTag::CpGridVanguard > | |
| CEquilGrid< TypeTag, TTag::CpGridVanguard > | |
| CNonlinearSystem | |
| CAquiferModel | |
| CEnableApiTracking | |
| CEnableDebuggingChecks | |
| CEnableHysteresis | |
| CEnableEndpointScaling | |
| CAvoidElementContext | |
| CEnableThermalFluxBoundaries | |
| CWellModel | |
| CTracerModel | |
| CTracerModel< TypeTag, TTag::FlowBaseProblem > | |
| CSpatialDiscretizationSplice< TypeTag, TTag::FlowBaseProblem > | |
| CLocalLinearizerSplice< TypeTag, TTag::FlowBaseProblem > | |
| CBaseDiscretizationType< TypeTag, TTag::FlowBaseProblem > | |
| CDiscreteFunction< TypeTag, TTag::FlowBaseProblem > | |
| CGridView< TypeTag, TTag::FlowBaseProblem > | |
| CSolidEnergyLaw< TypeTag, TTag::FlowBaseProblem > | |
| CThermalConductionLaw< TypeTag, TTag::FlowBaseProblem > | |
| CStencil< TypeTag, TTag::FlowBaseProblem > | |
| CAquiferModel< TypeTag, TTag::FlowBaseProblem > | |
| CEnableDiffusion< TypeTag, TTag::FlowBaseProblem > | |
| CEnableDispersion< TypeTag, TTag::FlowBaseProblem > | |
| CEnableConvectiveMixing< TypeTag, TTag::FlowBaseProblem > | |
| CEnableApiTracking< TypeTag, TTag::FlowBaseProblem > | |
| CEnableTemperature< TypeTag, TTag::FlowBaseProblem > | |
| CEnableMech< TypeTag, TTag::FlowBaseProblem > | |
| CEnablePolymer< TypeTag, TTag::FlowBaseProblem > | |
| CEnableSolvent< TypeTag, TTag::FlowBaseProblem > | |
| CEnableEnergy< TypeTag, TTag::FlowBaseProblem > | |
| CEnableFoam< TypeTag, TTag::FlowBaseProblem > | |
| CEnableExtbo< TypeTag, TTag::FlowBaseProblem > | |
| CEnableBioeffects< TypeTag, TTag::FlowBaseProblem > | |
| CEnableThermalFluxBoundaries< TypeTag, TTag::FlowBaseProblem > | |
| CEnableExperiments< TypeTag, TTag::FlowBaseProblem > | |
| CEnableDebuggingChecks< TypeTag, TTag::FlowBaseProblem > | |
| CEnableHysteresis< TypeTag, TTag::FlowBaseProblem > | |
| CEnableEndpointScaling< TypeTag, TTag::FlowBaseProblem > | |
| CAvoidElementContext< TypeTag, TTag::FlowBaseProblem > | |
| CEquilGrid | |
| CNonlinearSystem< TypeTag, TTag::FlowBaseProblemBlackoil > | |
| CProblem< TypeTag, TTag::FlowBaseProblemBlackoil > | |
| CModel< TypeTag, TTag::FlowBaseProblemBlackoil > | |
| CMaterialLaw< TypeTag, TTag::FlowBaseProblem > | |
| CFluxModule< TypeTag, TTag::FlowBaseProblemBlackoil > | |
| CGradientCalculator< TypeTag, TTag::FlowBaseProblemBlackoil > | |
| CProblem< TypeTag, TTag::FlowBaseProblemComp > | |
| CTracerModel< TypeTag, TTag::FlowBaseProblemComp > | |
| CMaterialLaw< TypeTag, TTag::FlowBaseProblemComp > | |
| CEnableDiffusion< TypeTag, TTag::FlowBaseProblemComp > | |
| CVanguard< TypeTag, TTag::PolyhedralGridVanguard > | |
| CGrid< TypeTag, TTag::PolyhedralGridVanguard > | |
| CEquilGrid< TypeTag, TTag::PolyhedralGridVanguard > | |
| CEnableTracerModel | |
| CLinearSolverBackend< TypeTag, TTag::FlowIstlSolverParams > | |
| CSparseMatrixAdapter< TypeTag, TTag::FlowIstlSolver > | Set the type of a global jacobian matrix for linear solvers that are based on dune-istl |
| CLinearSolverBackend | The type of the linear solver to be used |
| CPreconditionerWrapper | Preconditioner used by the linear solver |
| CLinearSolverScalar | The floating point type used internally by the linear solver |
| CSparseMatrixAdapter | The class that allows to manipulate sparse matrices |
| CGlobalEqVector | Vector containing a quantity of for equation for each DOF of the whole grid |
| CLinearSolverWrapper | |
| COverlap | |
| COverlappingLinearOperator | |
| COverlappingMatrix | |
| COverlappingScalarProduct | |
| COverlappingVector | |
| CLinearSolverBackend< TypeTag, TTag::ParallelAmgLinearSolver > | |
| CSparseMatrixAdapter< TypeTag, TTag::ParallelBaseLinearSolver > | Set the type of a global jacobian matrix for linear solvers that are based on dune-istl |
| CLinearSolverScalar< TypeTag, TTag::ParallelBaseLinearSolver > | By default use the same kind of floating point values for the linearization and for the linear solve |
| COverlappingMatrix< TypeTag, TTag::ParallelBaseLinearSolver > | |
| COverlap< TypeTag, TTag::ParallelBaseLinearSolver > | |
| COverlappingVector< TypeTag, TTag::ParallelBaseLinearSolver > | |
| COverlappingScalarProduct< TypeTag, TTag::ParallelBaseLinearSolver > | |
| COverlappingLinearOperator< TypeTag, TTag::ParallelBaseLinearSolver > | |
| CPreconditionerWrapper< TypeTag, TTag::ParallelBaseLinearSolver > | |
| CLinearSolverBackend< TypeTag, TTag::ParallelBiCGStabLinearSolver > | |
| CLinearSolverBackend< TypeTag, TTag::ParallelIstlLinearSolver > | |
| CLinearSolverWrapper< TypeTag, TTag::ParallelIstlLinearSolver > | |
| CPreconditionerWrapper< TypeTag, TTag::ParallelIstlLinearSolver > | |
| NParameters | |
| Ndetail | |
| Chas_name | |
| Chas_name< T, std::void_t< decltype(std::declval< T >().name)> > | |
| CDpMaxRel | |
| CDsMax | |
| CPriVarOscilationThreshold | |
| CProjectSaturations | |
| CMaxTemperatureChange | |
| CTemperatureMax | |
| CTemperatureMin | |
| CPressureMax | |
| CPressureMin | |
| CMaximumWaterSaturation | |
| CWaterOnlyThreshold | |
| CPressureScale | |
| CEnableGravity | Returns whether gravity is considered in the problem |
| CNumericDifferenceMethod | Specify which kind of method should be used to numerically calculate the partial derivatives of the residual |
| CContinueOnConvergenceError | Continue with a non-converged solution instead of giving up if we encounter a time step size smaller than the minimum time step size |
| CEnableAsyncVtkOutput | Determines if the VTK output is written to disk asynchronously |
| CEnableGridAdaptation | Switch to enable or disable grid adaptation |
| CEnableIntensiveQuantityCache | Specify whether all intensive quantities for the grid should be cached in the discretization |
| CEnableStorageCache | Specify whether the storage terms for previous solutions should be cached |
| CEnableThermodynamicHints | Specify whether to use the already calculated solutions as starting values of the intensive quantities |
| CEnableVtkOutput | Global switch to enable or disable the writing of VTK output files |
| CMaxTimeStepSize | Specify the maximum size of a time integration [s] |
| CMaxTimeStepDivisions | The maximum allowed number of timestep divisions for the Newton solver |
| CMinTimeStepSize | Specify the minimal size of a time integration [s] |
| COutputDir | The directory to which simulation output ought to be written to |
| CThreadsPerProcess | Number of threads per process |
| CSeparateSparseSourceTerms | |
| CFlashTolerance | The maximum accepted error of the flash solver Let the flash solver choose its tolerance by default |
| CVtkWriteMicrobialConcentration | |
| CVtkWriteOxygenConcentration | |
| CVtkWriteUreaConcentration | |
| CVtkWriteBiofilmVolumeFraction | |
| CVtkWriteCalciteVolumeFraction | |
| CVtkWriteRockInternalEnergy | |
| CVtkWriteTotalThermalConductivity | |
| CVtkWriteFluidInternalEnergies | |
| CVtkWriteFluidEnthalpies | |
| CVtkWriteGasDissolutionFactor | |
| CVtkWriteOilVaporizationFactor | |
| CVtkWriteOilFormationVolumeFactor | |
| CVtkWriteGasFormationVolumeFactor | |
| CVtkWriteWaterFormationVolumeFactor | |
| CVtkWriteOilSaturationPressure | |
| CVtkWriteGasSaturationPressure | |
| CVtkWriteSaturationRatios | |
| CVtkWriteSaturatedOilGasDissolutionFactor | |
| CVtkWriteSaturatedGasOilVaporizationFactor | |
| CVtkWritePrimaryVarsMeaning | |
| CVtkWritePolymerConcentration | |
| CVtkWritePolymerDeadPoreVolume | |
| CVtkWritePolymerViscosityCorrection | |
| CVtkWriteWaterViscosityCorrection | |
| CVtkWritePolymerRockDensity | |
| CVtkWritePolymerAdsorption | |
| CVtkWriteSolventSaturation | |
| CVtkWriteSolventRsw | |
| CVtkWriteSolventDensity | |
| CVtkWriteSolventViscosity | |
| CVtkWriteSolventMobility | |
| CVtkWriteMassFractions | |
| CVtkWriteMoleFractions | |
| CVtkWriteTotalMassFractions | |
| CVtkWriteTotalMoleFractions | |
| CVtkWriteMolarities | |
| CVtkWriteFugacities | |
| CVtkWriteFugacityCoeffs | |
| CVtkWriteTortuosities | |
| CVtkWriteDiffusionCoefficients | |
| CVtkWriteEffectiveDiffusionCoefficients | |
| CVtkWriteFractureSaturations | |
| CVtkWriteFractureMobilities | |
| CVtkWriteFractureRelativePermeabilities | |
| CVtkWriteFracturePorosity | |
| CVtkWriteFractureIntrinsicPermeabilities | |
| CVtkWriteFractureFilterVelocities | |
| CVtkWriteFractureVolumeFraction | |
| CVtkWriteSolidInternalEnergy | |
| CVtkWriteThermalConductivity | |
| CVtkWriteInternalEnergies | |
| CVtkWriteEnthalpies | |
| CVtkWriteExtrusionFactor | |
| CVtkWritePressures | |
| CVtkWriteDensities | |
| CVtkWriteSaturations | |
| CVtkWriteMobilities | |
| CVtkWriteRelativePermeabilities | |
| CVtkWriteViscosities | |
| CVtkWriteAverageMolarMasses | |
| CVtkWritePorosity | |
| CVtkWriteIntrinsicPermeabilities | |
| CVtkWritePotentialGradients | |
| CVtkWriteFilterVelocities | |
| CVtkWritePhasePresence | |
| CVtkWritePrimaryVars | |
| CVtkWriteProcessRank | |
| CVtkWriteDofIndex | |
| CVtkWriteLiquidMoleFractions | |
| CVtkWriteEquilibriumConstants | |
| CVtkWriteTemperature | |
| CNewtonMaxError | The maximum error which may occur in a simulation before the Newton method for the time step is aborted |
| CNewtonMaxIterations | Number of maximum iterations for the Newton method |
| CNewtonTargetIterations | The number of iterations at which the Newton method should aim at |
| CNewtonTolerance | The value for the error below which convergence is declared |
| CNewtonVerbose | Specifies whether the Newton method should print messages or not |
| CNewtonWriteConvergence | Specifies whether the convergence rate and the global residual gets written out to disk for every Newton iteration |
| CFlashTwoPhaseMethod | Two-phase flash method |
| CFlashVerbosity | The verbosity level of the flash solver |
| CPvsVerbosity | The verbosity of the model (0 -> do not print anything, 2 -> spam stdout a lot) |
| CCellsX | Grid resolution |
| CCellsY | |
| CCellsZ | |
| CDomainSizeX | Domain size |
| CDomainSizeY | |
| CDomainSizeZ | |
| CEndTime | The default value for the simulation's end time |
| CGridFile | Name of the grid file |
| CGridGlobalRefinements | Property which tells the Vanguard how often the grid should be refined after creation |
| CInitialTimeStepSize | The default value for the simulation's initial time step size |
| CParameterFile | Set a value for the ParameterFile property |
| CPredeterminedTimeStepsFile | By default, do not force any time steps |
| CPrintParameters | Print all parameters on startup? |
| CRestartTime | The default value for the simulation's restart time |
| CParameter | A struct holding the key-value pair for a parameter |
| CDbhpMaxRel | |
| CDwellFractionMax | |
| CEclDeckFileName | |
| CInjMultOscThreshold | |
| CInjMultDampMult | |
| CInjMultMinDampFactor | |
| CMaxResidualAllowed | |
| CRelaxedMaxPvFraction | |
| CToleranceMb | |
| CToleranceMbRelaxed | |
| CToleranceEnergyBalance | |
| CToleranceEnergyBalanceRelaxed | |
| CToleranceCnv | |
| CToleranceCnvRelaxed | |
| CToleranceCnvEnergy | |
| CToleranceCnvEnergyRelaxed | |
| CToleranceWells | |
| CToleranceWellControl | |
| CMaxWelleqIter | |
| CMaxSinglePrecisionDays | |
| CMinStrictCnvIter | |
| CMinStrictMbIter | |
| CSolveWelleqInitially | |
| CPreSolveNetwork | |
| CUpdateEquationsScaling | |
| CUseUpdateStabilization | |
| CMatrixAddWellContributions | |
| CUseMultisegmentWell | |
| CTolerancePressureMsWells | |
| CMaxPressureChangeMsWells | |
| CMaxNewtonIterationsWithInnerWellIterations | |
| CMaxInnerIterMsWells | |
| CMaxInnerIterWells | |
| CMaxWellStatusSwitchInInnerIterWells | |
| CMaxWellStatusSwitchForWells | |
| CShutUnsolvableWells | |
| CAlternativeWellRateInit | |
| CStrictOuterIterWells | |
| CStrictInnerIterWells | |
| CRegularizationFactorWells | |
| CEnableWellOperabilityCheck | |
| CEnableWellOperabilityCheckIter | |
| CDebugEmitCellPartition | |
| CRelaxedWellFlowTol | |
| CRelaxedPressureTolMsw | |
| CMaximumNumberOfWellSwitches | |
| CMaximumNumberOfGroupSwitches | |
| CUseAverageDensityMsWells | |
| CLocalWellSolveControlSwitching | |
| CUseImplicitIpr | |
| CCheckGroupConstraintsInnerWellIterations | |
| CNetworkMaxStrictOuterIterations | |
| CNetworkMaxOuterIterations | |
| CNetworkMaxSubIterations | |
| CNetworkPressureUpdateDampingFactor | |
| CNetworkMaxPressureUpdateInBars | |
| CNonlinearSolver | |
| CLocalSolveApproach | |
| CMaxLocalSolveIterations | |
| CNewtonMinIterations | |
| CWellGroupConstraintsMaxIterations | |
| CLocalToleranceScalingMb | |
| CLocalToleranceScalingCnv | |
| CNlddNumInitialNewtonIter | |
| CNlddRelativeMobilityChangeTol | |
| CNumLocalDomains | |
| CLocalDomainsPartitioningImbalance | |
| CLocalDomainsPartitioningMethod | |
| CLocalDomainsPartitionWellNeighborLevels | |
| CLocalDomainsOrderingMeasure | |
| CConvergenceMonitoring | |
| CConvergenceMonitoringCutOff | |
| CConvergenceMonitoringDecayFactor | |
| CNupcolGroupRateTolerance | |
| CEnableDamarisOutput | |
| CDamarisOutputHdfCollective | |
| CDamarisSaveMeshToHdf | |
| CDamarisSaveToHdf | |
| CDamarisPythonScript | |
| CDamarisPythonParaviewScript | |
| CDamarisSimName | |
| CDamarisDedicatedCores | |
| CDamarisDedicatedNodes | |
| CDamarisSharedMemoryName | |
| CDamarisSharedMemorySizeBytes | |
| CDamarisLogLevel | |
| CDamarisDaskFile | |
| CDamarisLimitVariables | |
| CEnableAsyncEclOutput | |
| CEclOutputDoublePrecision | |
| CEnableWriteAllSolutions | |
| CEnableEsmry | |
| CAllowDistributedWells | |
| CAllowSplittingInactiveWells | |
| CEclOutputInterval | |
| CEdgeWeightsMethod | |
| CEnableDryRun | |
| CEnableEclOutput | |
| CEnableOpmRstFile | |
| CExternalPartition | |
| CImbalanceTol | |
| CIgnoreKeywords | |
| CInputSkipMode | |
| CMetisParams | |
| COwnerCellsFirst | |
| CParsingStrictness | |
| CActionParsingStrictness | |
| CPartitionMethod | 0: simple, 1: Zoltan, 2: METIS, 3: Zoltan with a all cells of a well represented by one vertex in the graph, see GridEnums.hpp |
| CAddCorners | |
| CNumOverlap | |
| CEdgeConformal | |
| CSchedRestart | |
| CSerialPartitioning | |
| CZoltanImbalanceTol | |
| CZoltanPhgEdgeSizeThreshold | |
| CZoltanParams | |
| CEnableDriftCompensation | |
| CExplicitRockCompaction | |
| CCheckSatfuncConsistency | |
| CNumSatfuncConsistencySamplePoints | |
| CNumPressurePointsEquil | |
| COutputMode | |
| CRestartWritingInterval | |
| CHyNeConfigFile | |
| CUseHyNe | |
| CForceDisableFluidInPlaceOutput | |
| CForceDisableResvFluidInPlaceOutput | |
| CNewtonMaxRelax | |
| CNewtonRelaxationType | |
| CEnableAdaptiveTimeStepping | |
| COutputExtraConvergenceInfo | |
| CSaveStep | |
| CSaveFile | |
| CLoadFile | |
| CLoadStep | |
| CSlave | |
| CVtkWriteTracerConcentration | |
| CLinearSolverReduction | |
| CNlddLocalLinearSolverReduction | |
| CRelaxedLinearSolverReduction | |
| CIluRelaxation | |
| CLinearSolverMaxIter | |
| CNlddLocalLinearSolverMaxIter | |
| CLinearSolverRestart | |
| CIluFillinLevel | |
| CMiluVariant | |
| CIluRedblack | |
| CIluReorderSpheres | |
| CUseGmres | |
| CLinearSolverIgnoreConvergenceFailure | |
| CScaleLinearSystem | |
| CLinearSolver | |
| CNlddLocalLinearSolver | |
| CLinearSolverPrintJsonDefinition | |
| CCprReuseSetup | |
| CCprReuseInterval | |
| CAcceleratorMode | |
| CGpuDeviceId | |
| COpenclPlatformId | |
| COpenclIluParallel | |
| CGpuAwareMpi | |
| CVerifyGpuAwareMpi | |
| CCprWeightsThreadParallel | |
| CGMResRestart | Number of iterations between solver restarts for the GMRES solver |
| CLinearSolverAbsTolerance | Maximum accepted error of the norm of the residual |
| CLinearSolverMaxError | |
| CLinearSolverMaxIterations | Maximum number of iterations eyecuted by the linear solver |
| CLinearSolverOverlapSize | The size of the algebraic overlap of the linear solver |
| CLinearSolverTolerance | Maximum accepted error of the solution of the linear solver |
| CLinearSolverVerbosity | Specifies the verbosity of the linear solver |
| CPreconditionerOrder | The order of the sequential preconditioner |
| CPreconditionerRelaxation | The relaxation factor of the preconditioner |
| CLinearSolverAccelerator | For the CLI options |
| CAmgCoarsenTarget | The target number of DOFs per processor for the parallel algebraic multi-grid solver |
| CSolverContinueOnConvergenceFailure | |
| CSolverMaxRestarts | |
| CSolverVerbosity | |
| CTimeStepVerbosity | |
| CInitialTimeStepInDays | |
| CFullTimeStepInitially | |
| CTimeStepControl | |
| CTimeStepControlTolerance | |
| CTimeStepControlTargetIterations | |
| CTimeStepControlTargetNewtonIterations | |
| CTimeStepControlDecayRate | |
| CTimeStepControlGrowthRate | |
| CTimeStepControlDecayDampingFactor | |
| CTimeStepControlGrowthDampingFactor | |
| CTimeStepControlFileName | |
| CMinTimeStepBeforeShuttingProblematicWellsInDays | |
| CMinTimeStepBasedOnNewtonIterations | |
| CTimeStepControlSafetyFactor | |
| CTimeStepControlRejectCompletedStep | |
| CTimeStepControlToleranceTestVersion | |
| CTimeStepControlMaxReductionTimeStep | |
| CTimeStepControlParameters | |
| CEnableTuning | |
| CSolverGrowthFactor | |
| CSolverMaxGrowth | |
| CSolverMinTimeStep | |
| CSolverMaxTimeStepInDays | |
| CSolverRestartFactor | |
| CTimeStepAfterEventInDays | |
| CEnableTerminalOutput | |
| Ndetail | |
| Cis_alignment_constant | |
| Cmin_size | |
| Coffset_object | |
| Calignment_of | |
| Cmax_align | |
| Cmax_count_of | |
| CExtractor | Wrapping struct holding types used for element-level data extraction |
| CHysteresisParams | Struct holding hysteresis parameters |
| CContext | Context passed to extractor functions |
| CScalarEntry | A scalar extractor descriptor |
| CPhaseEntry | A phase buffer extractor descriptor |
| CEntry | Descriptor for extractors |
| CBlockExtractor | Wrapping struct holding types used for block-level data extraction |
| CContext | Context passed to element extractor functions |
| CScalarEntry | |
| CPhaseEntry | |
| CExec | Descriptor for extractor execution |
| CFlexibleSolverInfo | |
| CGpuSolverInfo | |
| CReorderer | |
| CNoReorderer | |
| CRealReorderer | |
| CParallelFileMerger | A functor that merges multiple files of a parallel run to one file |
| CVFPEvaluation | An "ADB-like" structure with a single value and a set of derivatives |
| CInterpData | Helper struct for linear interpolation |
| NDamarisOutput | Below are the Damaris Keywords supported by Damaris to be filled in the built-in XML file |
| CDamarisSettings | |
| CDamarisVarXMLAttributes | This class contains the extra elements that need to be part of a Damaris <variable> type |
| CDamarisVar | Class to store a Damaris variable representation for the XML file (can be used with class DamarisKeywords) |
| NEQUIL | Types and routines that collectively implement a basic ECLIPSE-style equilibration-based initialisation scheme |
| NMiscibility | Types and routines relating to phase mixing in equilibration calculations |
| CRsFunction | Base class for phase mixing functions |
| CNoMixing | Type that implements "no phase mixing" policy |
| CRsVD | Type that implements "dissolved gas-oil ratio" tabulated as a function of depth policy |
| CPBVD | Type that implements "dissolved gas-oil ratio" tabulated as a function of depth policy |
| CPDVD | Type that implements "vaporized oil-gas ratio" tabulated as a function of depth policy |
| CRvVD | Type that implements "vaporized oil-gas ratio" tabulated as a function of depth policy |
| CRvwVD | Type that implements "vaporized water-gas ratio" tabulated as a function of depth policy |
| CRsSatAtContact | Class that implements "dissolved gas-oil ratio" (Rs) as function of depth and pressure as follows: |
| CRvSatAtContact | Class that implements "vaporized oil-gas ratio" (Rv) as function of depth and pressure as follows: |
| CRvwSatAtContact | Class that implements "vaporized water-gas ratio" (Rvw) as function of depth and pressure as follows: |
| NDeckDependent | |
| CInitialStateComputer | |
| NDetails | |
| NPhasePressODE | |
| CWater | |
| COil | |
| CGas | |
| CRK4IVP | |
| CPressureTable | |
| CPhaseQuantityValue | Simple set of per-phase (named by primary component) quantities |
| CPhaseSaturations | Calculator for phase saturations |
| CPosition | Evaluation point within a model geometry |
| CEquilReg | Aggregate information base of an equilibration region |
| CPcEq | Functor for inverting capillary pressure function |
| CPcEqSum | Functor for inverting a sum of capillary pressure functions |
| NKeywordValidation | |
| CUnsupportedKeywordProperties | |
| CSupportedKeywordProperties | |
| CValidationError | |
| CSupportedKeywords | |
| CKeywordValidator | |
| Callow_values | |
| Cis_bool_convertible | |
| Ndetails | |
| CDomainInfo | Struct holding information about domains used for printing a summary |
| NPybind | |
| CPyBaseSimulator | |
| CPyBlackOilSimulator | |
| CPyFluidState | |
| CPyGasWaterSimulator | |
| CPyMaterialState | |
| CPyOnePhaseSimulator | |
| NReservoirCoupling | |
| CLogger | |
| CPotentials | |
| CSeconds | Utility class for comparing double values representing epoch dates or elapsed time |
| NLinear | |
| CBiCGStabSolver | Implements a preconditioned stabilized BiCG linear solver |
| CBlackList | Expresses which degrees of freedom are blacklisted for the parallel linear solvers and which domestic indices they correspond to |
| CPeerBlackListedEntry | |
| CCombinedCriterion | Convergence criterion which looks at the absolute value of the residual and fails if the linear solver stagnates |
| CConvergenceCriterion | Base class for all convergence criteria which only defines an virtual API |
| CDomesticOverlapFromBCRSMatrix | This class creates and manages the foreign overlap given an initial list of border indices and a BCRS matrix |
| CElementBorderListFromGrid | Uses communication on the grid to find the initial seed list of indices for methods which use element-based degrees of freedom |
| CFixPointCriterion | Provides a convergence criterion for the linear solvers which looks at the weighted maximum of the difference between two iterations |
| CForeignOverlapFromBCRSMatrix | This class creates and manages the foreign overlap given an initial list of border indices and a BCRS matrix |
| CGlobalIndices | This class maps domestic row indices to and from "global" indices which is used to construct an algebraic overlap for the parallel linear solvers |
| CPreconditionerWrapperILU | |
| CSolverWrapperRestartedGMRes | Solver wrapper for the restarted GMRES solver of dune-istl |
| CIstlSparseMatrixAdapter | A sparse matrix interface backend for BCRSMatrix from dune-istl |
| CSolverReport | Collects summary information about the execution of the linear solver |
| CNullBorderListCreator | This is a grid manager which does not create any border list |
| COverlappingBCRSMatrix | An overlap aware block-compressed row storage (BCRS) matrix |
| COverlappingBlockVector | An overlap aware block vector |
| COverlappingOperator | An overlap aware linear operator usable by ISTL |
| COverlappingPreconditioner | An overlap aware preconditioner for any ISTL linear solver |
| COverlappingScalarProduct | An overlap aware ISTL scalar product |
| CIndexRank | This structure stores an index and a process rank |
| CPeerIndexGlobalIndex | This structure stores a local index on a peer process and a global index |
| CIndexRankDist | This structure stores an index, a process rank, and the distance of the degree of freedom to the process border |
| CIndexDistanceNpeers | This structure stores an index, a process rank, and the number of processes which "see" the degree of freedom with the index |
| CBorderIndex | A single index intersecting with the process boundary |
| CSeedList | The list of indices which are on the process boundary |
| CPeerSet | A set of process ranks |
| CParallelAmgBackend | Provides a linear solver backend using the parallel algebraic multi-grid (AMG) linear solver from DUNE-ISTL |
| CParallelBaseBackend | Provides the common code which is required by most linear solvers |
| CParallelBiCGStabSolverBackend | Implements a generic linear solver abstraction |
| CParallelIstlSolverBackend | Provides all unmodified linear solvers from dune-istl |
| CResidReductionCriterion | Provides a convergence criterion which looks at the reduction of the two-norm of the residual for the linear solvers |
| CVertexBorderListFromGrid | Uses communication on the grid to find the initial seed list of indices |
| CWeightedResidualReductionCriterion | Convergence criterion which looks at the weighted absolute value of the residual |
| NAccelerator | |
| CamgclSolverBackend | This class does not implement a solver, but converts the BCSR format to normal CSR and uses amgcl for solving Note amgcl also implements blocked solvers, but looks like it needs unblocked input data |
| CBlockedMatrix | This struct resembles a blocked csr matrix, like Dune::BCRSMatrix |
| CCprCreation | This class implements a Constrained Pressure Residual (CPR) preconditioner |
| CcusparseSolverBackend | This class implements a cusparse-based ilu0-bicgstab solver on GPU |
| CGpuResult | This class is based on InverseOperatorResult struct from dune/istl/solver.hh It is needed to prevent a compile error in basearray.hh, the nvcc compiler might not support all features in there |
| CGpuSolver | This class serves to simplify choosing between different backend solvers, such as cusparseSolver and openclSolver This class is abstract, no instantiations can of it can be made, only of its children |
| CMatrix | This struct resembles a csr matrix, only doubles are supported The data is stored in contiguous memory, such that they can be copied to a device in one transfer |
| CopenclBILU0 | This class implements a Blocked ILU0 preconditioner The decomposition is done on GPU, using exact decomposition, or ChowPatel decomposition The preconditioner is applied via two exact triangular solves |
| CopenclBISAI | This class implements a Blocked version of the Incomplete Sparse Approximate Inverse (ISAI) preconditioner |
| CopenclCPR | This class implements a Constrained Pressure Residual (CPR) preconditioner |
| COpenclKernels | |
| COpenclMatrix | This struct resembles a csr matrix, only doubles are supported The matrix data is stored in OpenCL Buffers |
| CopenclPreconditioner | |
| CopenclSolverBackend | This class implements a opencl-based ilu0-bicgstab solver on GPU |
| CPreconditioner | |
| CrocalutionSolverBackend | This class implements a rocalution based linear solver solver on GPU It uses ilu0-bicgstab |
| CrocsparseBILU0 | This class implements a Blocked ILU0 preconditioner The decomposition is done on GPU, using exact decomposition, or ChowPatel decomposition The preconditioner is applied via two exact triangular solves |
| CrocsparseCPR | This class implements a Constrained Pressure Residual (CPR) preconditioner |
| CRocmMatrix | This struct resembles a csr matrix |
| CRocmVector | |
| CrocsparsePreconditioner | |
| CrocsparseSolverBackend | This class implements a rocsparse-based ilu0-bicgstab solver on GPU |
| Ngpuistl | |
| Ndetail | Contains wrappers to make the CuBLAS library behave as a modern C++ library with function overlading |
| CCuBlasHandle | Singleton for the simulator universal cuBlasHandle |
| CCuSparseHandle | Singleton for the simulator universal cuSparseHandle |
| CCuSparseResource | The CuSparseResource class wraps a CuSparse resource in a proper RAII pattern |
| CFlexibleSolverWrapper | FlexibleSolverWrapper is compilational trick to reduce compile time overhead |
| Chas_should_call_pre | The has_should_call_pre class detects the presence of the method shouldCallPre |
| Chas_should_call_post | The has_should_call_post class detects the presence of the method shouldCallPost |
| Chas_communication | The has_communication class checks if the type has the member function getCommunication |
| Cis_a_well_operator | The is_a_well_operator class tries to guess if the operator is a well type operator |
| CAmgxError | Exception class for AMGX errors |
| CAmgxInterface | Unified interface for AMGX operations with both CPU and GPU data structures |
| CGpuVector | |
| CGpuSparseMatrixWrapper | The GpuSparseMatrixWrapper Checks CUDA/HIP version and dispatches a version either using the old or the generic CUDA API |
| CGpuSparseMatrixGeneric | The GpuSparseMatrixGeneric class uses cuSPARSE Generic API for sparse matrix operations |
| Cis_gpu_type | Type trait to detect if a type is a GPU type |
| Cis_gpu_type< GpuVector< T > > | |
| Cis_gpu_type< GpuSparseMatrixWrapper< T > > | |
| Cis_gpu_type< GpuSparseMatrixGeneric< T > > | |
| CPointerView | A view towards a smart pointer to GPU-allocated memory |
| CPointerView< void > | Specialization of PointerView for void type This is needed beause we cannot have a PointerView<void> specialization due to dereferincing a void ptr |
| CValueAsPointer | A value stored with a pointer interface |
| CGPUAwareMPISender | Derived class of GPUSender that handles MPI made with CUDA aware MPI The copOwnerToAll function uses MPI calls refering to data that resides on the GPU in order to send it directly to other GPUs, skipping the staging step on the CPU |
| CGpuBlockPreconditioner | Is an adaptation of Dune::BlockPreconditioner that works within the CuISTL framework |
| CGpuDILU | DILU preconditioner on the GPU |
| CGpuJac | Jacobi preconditioner on the GPU |
| CGPUObliviousMPISender | Derived class of GPUSender that handles MPI calls that should NOT use GPU direct communicatoin The implementation moves data fromthe GPU to the CPU and then sends it using regular MPI |
| CGpuOwnerOverlapCopy | CUDA compatiable variant of Dune::OwnerOverlapCopyCommunication |
| CGpuPressureTransferPolicy | |
| CGPUSender | GPUSender is a wrapper class for classes which will implement copOwnerToAll This is implemented with the intention of creating communicators with generic GPUSender To hide implementation that will either use GPU aware MPI or not |
| CGpuSeqILU0 | Sequential ILU0 preconditioner on the GPU through the CuSparse library |
| CGpuSparseMatrix | The GpuSparseMatrix class simple wrapper class for a CuSparse matrix |
| CGpuView | The GpuView class is provides a view of some data allocated on the GPU Essenstially is only stores a pointer and a size |
| Citerator | Iterator class to make GpuViews more similar to std containers |
| CParallelInfo | Parallel domain decomposition information for HYPRE-Dune interface |
| CSparsityPattern | Compressed Sparse Row (CSR) sparsity pattern for HYPRE matrix assembly |
| CHypreHostDataArrays | Host arrays for HYPRE matrix and vector data transfers |
| CHypreDeviceDataArrays | GPU device memory arrays for HYPRE operations with GPU backend |
| CHypreError | Exception class for Hypre errors |
| CISTLSolverGPUISTL | ISTL solver for GPU using the GPU ISTL backend |
| COpmGpuILU0 | ILU0 preconditioner on the GPU |
| CPinnedMemoryHolder | RAII class for pinning host memory using cudaHostRegister |
| CPreconditionerAdapter | Makes a CUDA preconditioner available to a CPU simulator |
| CPreconditionerConvertFieldTypeAdapter | Converts the field type (eg |
| CPreconditionerCPUMatrixToGPUMatrix | Convert a CPU matrix to a GPU matrix and use a CUDA preconditioner on the GPU |
| CPreconditionerHolder | Common interface for adapters that hold preconditioners |
| CSolverAdapter | Wraps a CUDA solver to work with CPU data |
| NOpm | |
| CBlackOilVariableAndEquationIndices | The primary variable and equation indices for the three-phase black-oil model |
| CBlackOilTwoPhaseIndices | The primary variable and equation indices for the black-oil model |
| CBlackOilOnePhaseIndices | The primary variable and equation indices for the black-oil model |
| NGridDataOutput | |
| CSimMeshDataAccessor | |
| NMpi | |
| Ndetail | |
| CPacking | Abstract struct for packing which is (partially) specialized for specific types |
| CPacking< true, T > | Packaging for pod data |
| CPacking< false, T > | Default handling for unsupported types |
| CPacking< false, std::bitset< Size > > | Specialization for std::bitset |
| CPacker | Struct handling packing of serialization for MPI communication |
| NParallel | |
| CRootRank | Avoid mistakes in calls to broadcast() by wrapping the root argument in an explicit type |
| CMpiSerializer | Class for serializing and broadcasting data using MPI |
| NSatfunc | |
| NPhaseChecks | |
| NGas | |
| CSGmin | Verify that minimum gas saturation is in valid range |
| CSGmax | Verify that maximum gas saturation is in valid range |
| CSGcr | Verify that critical gas saturation is in valid range |
| NOil | |
| CSOcr_GO | Verify that critical oil saturation in gas/oil system is in valid range |
| CSOmin_GO | Verify that minimum oil saturation in gas/oil system is in valid range |
| CMobileOil_GO_SGmin | Verify that critical oil saturation in gas/oil system is strictly smaller than maximum oil saturation |
| CMobileOil_GO_SGcr | Verify that critical oil saturation in gas/oil system is strictly smaller than oil saturation at critical gas saturation |
| CSOcr_OW | Verify that critical oil saturation in oil/water system is in valid range |
| CSOmin_OW | Verify that minimum oil saturation in oil/water system is in valid range |
| CMobileOil_OW_SWmin | Verify that critical oil saturation in oil/water system is strictly smaller than maximum oil saturation |
| CMobileOil_OW_SWcr | Verify that critical oil saturation in oil/water system is strictly smaller than oil saturation at critical water saturation |
| NThreePointHorizontal | |
| CDisplacingOil_GO | Verify that critical saturation of displacing phase (oil/liquid) is strictly between critical and maximum gas saturations for the alternative (three point) horizontal scaling method (SCALECRS=YES) in the gas/oil two-phase system |
| CDisplacingOil_OW | Verify that critical saturation of displacing phase (oil) is strictly between critical and maximum water saturations for the alternative (three point) horizontal scaling method (SCALECRS=YES) in the oil/water two-phase system |
| NWater | |
| CSWmin | Verify that minimum gas saturation is in valid range |
| CSWmax | Verify that maximum gas saturation is in valid range |
| CSWcr | Verify that critical gas saturation is in valid range |
| CPhaseCheckBase | Base class for all phase saturation function consistency checks |
| CSatfuncCheckPointInterface | Callback protocol for single saturation function consistency check point |
| CUnscaledSatfuncCheckPoint | Callbacks for defining the consistency check point of a single region |
| CUnscaledEndPoints | Collection of saturation function end-points and function values extracted from tabulated saturation functions |
| CSatfuncConsistencyCheckManager | Define and execute saturation function consistency checks for all cells in model |
| CScaledSatfuncCheckPoint | Callbacks for defining the scaled saturation function consistency check point of a single active grid block |
| NSerialization | |
| Ndetail | |
| CPacking< false, boost::gregorian::date > | |
| NWGHelpers | |
| CFractionCalculator | |
| CTargetCalculator | Based on a group control mode, extract or calculate rates, and provide other conveniences |
| CInjectionTargetCalculator | Based on a group control mode, extract or calculate rates, and provide other conveniences |
| Nmswellhelpers | |
| CParallellMSWellB | A wrapper around the B matrix for distributed MS wells |
| NRateConverter | |
| CSurfaceToReservoirVoidage | Convert component rates at surface conditions to phase (voidage) rates at reservoir conditions |
| NRegionAttributeHelpers | |
| NSelect | Convenience tools for processing region spesific attributes |
| CRegionIDParameter | |
| CRegionIDParameter< RegionID, true > | |
| CAverageIncrementCalculator | Computes the temperature, pressure, and counter increment |
| CAverageIncrementCalculator< Scalar, false > | |
| CRegionAttributes | Provide mapping from Region IDs to user-specified collection of per-region attributes |
| CValue | Aggregate per-region attributes along with region's representative cell |
| NRegionAverageCalculator | |
| CAverageRegionalPressure | Computes hydrocarbon weighed average pressures over regions |
| Nwellhelpers | |
| CParallelStandardWellB | A wrapper around the B matrix for distributed wells |
| CBlackOilBioeffectsModule | Contains the high level supplements required to extend the black oil model by bioeffects |
| CBlackOilBioeffectsIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the bioeffects extension of the black-oil model |
| CBlackOilBioeffectsIntensiveQuantities< TypeTag, false > | |
| CBlackOilBioeffectsExtensiveQuantities | Provides the bioeffects specific extensive quantities to the generic black-oil module's extensive quantities |
| CBlackOilBioeffectsExtensiveQuantities< TypeTag, false > | |
| CBlackOilBioeffectsParams | Struct holding the parameters for the BlackOilBioeffectsModule class |
| CBlackOilBoundaryRateVector | Implements a boundary vector for the fully implicit black-oil model |
| CBlackOilBrineModule | Contains the high level supplements required to extend the black oil model by brine |
| CBlackOilBrineIntensiveQuantities | |
| CBlackOilBrineIntensiveQuantities< TypeTag, true > | |
| CBlackOilBrineIntensiveQuantities< TypeTag, false > | |
| CBlackOilBrineParams | Struct holding the parameters for the BlackoilBrineModule class |
| CBlackOilConvectiveMixingModule | |
| CBlackOilConvectiveMixingModule< TypeTag, false > | |
| CConvectiveMixingModuleParam | |
| CBlackOilConvectiveMixingModule< TypeTag, true > | |
| CConvectiveMixingModuleParam | |
| CBlackOilConvectiveMixingIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the convective mixing (DRSDTCON) model |
| CBlackOilConvectiveMixingIntensiveQuantities< TypeTag, true > | |
| CBlackOilConvectiveMixingIntensiveQuantities< TypeTag, false > | |
| CBlackOilDarcyExtensiveQuantities | Specifies the extensive quantities for the black-oil model if using Darcy relation |
| CBlackOilDarcyFluxModule | Provides a Darcy flux module for the blackoil model |
| CBlackOilDiffusionModule | Provides the auxiliary methods required for consideration of the diffusion equation |
| CBlackOilDiffusionExtensiveQuantities | Provides the quantities required to calculate diffusive mass fluxes |
| CBlackOilDiffusionModule< TypeTag, false > | Provides the auxiliary methods required for consideration of the diffusion equation. |
| CBlackOilDiffusionModule< TypeTag, true > | Provides the auxiliary methods required for consideration of the diffusion equation. |
| CBlackOilDiffusionIntensiveQuantities | Provides the volumetric quantities required for the calculation of molecular diffusive fluxes |
| CBlackOilDiffusionIntensiveQuantities< TypeTag, false > | Provides the volumetric quantities required for the calculation of molecular diffusive fluxes. |
| CBlackOilDiffusionIntensiveQuantities< TypeTag, true > | Provides the volumetric quantities required for the calculation of molecular diffusive fluxes. |
| CBlackOilDiffusionExtensiveQuantities< TypeTag, false > | Provides the quantities required to calculate diffusive mass fluxes. |
| CBlackOilDiffusionExtensiveQuantities< TypeTag, true > | Provides the quantities required to calculate diffusive mass fluxes. |
| CBlackOilDispersionModule | Provides the auxiliary methods required for consideration of the dispersion equation |
| CBlackOilDispersionExtensiveQuantities | Provides the quantities required to calculate dispersive mass fluxes |
| CBlackOilDispersionModule< TypeTag, false > | Provides the auxiliary methods required for consideration of the dispersion equation. |
| CBlackOilDispersionModule< TypeTag, true > | Provides the auxiliary methods required for consideration of the dispersion equation. |
| CBlackOilDispersionIntensiveQuantities | Provides the volumetric quantities required for the calculation of dispersive fluxes |
| CBlackOilDispersionIntensiveQuantities< TypeTag, false > | |
| CBlackOilDispersionIntensiveQuantities< TypeTag, true > | |
| CBlackOilDispersionExtensiveQuantities< TypeTag, false > | |
| CBlackOilDispersionExtensiveQuantities< TypeTag, true > | Provides the quantities required to calculate dispersive mass fluxes. |
| CBlackOilEnergyModule | Contains the high level supplements required to extend the black oil model by energy |
| CBlackOilEnergyIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the energys extension of the black-oil model |
| CBlackOilEnergyIntensiveQuantities< TypeTag, true > | |
| CBlackOilEnergyIntensiveQuantities< TypeTag, false > | |
| CBlackOilEnergyExtensiveQuantities | Provides the energy specific extensive quantities to the generic black-oil module's extensive quantities |
| CBlackOilEnergyExtensiveQuantities< TypeTag, true > | |
| CBlackOilEnergyExtensiveQuantities< TypeTag, false > | |
| CBlackOilExtboModule | Contains the high level supplements required to extend the black oil model |
| CBlackOilExtboIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the solvents extension of the black-oil model |
| CBlackOilExtboIntensiveQuantities< TypeTag, true > | |
| CBlackOilExtboIntensiveQuantities< TypeTag, false > | |
| CBlackOilExtboExtensiveQuantities | Provides the solvent specific extensive quantities to the generic black-oil module's extensive quantities |
| CBlackOilExtboExtensiveQuantities< TypeTag, false > | |
| CBlackOilExtboParams | Struct holding the parameters for the BlackoilExtboModule class |
| CBlackOilExtensiveQuantities | This template class contains the data which is required to calculate the fluxes of the fluid phases over a face of a finite volume for the black-oil model |
| CBlackOilFoamModule | Contains the high level supplements required to extend the black oil model to include the effects of foam |
| CBlackOilFoamIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the polymers extension of the black-oil model |
| CBlackOilFoamIntensiveQuantities< TypeTag, true > | |
| CBlackOilFoamIntensiveQuantities< TypeTag, false > | |
| CBlackOilFoamParams | Struct holding the parameters for the BlackoilFoamModule class |
| CFoamCoefficients | |
| CBlackOilIntensiveQuantities | Contains the quantities which are are constant within a finite volume in the black-oil model |
| CBlackOilLocalResidual | Calculates the local residual of the black oil model |
| CBlackOilLocalResidualTPFA | Calculates the local residual of the black oil model |
| CResidualNBInfo | |
| CModuleParams | |
| CBlackOilModel | A fully-implicit black-oil flow model |
| CBlackOilNewtonMethod | A newton solver which is specific to the black oil model |
| CBlackoilNewtonParams | Struct holding the parameters for BlackoilNewtonMethod |
| CBlackOilOnePhaseIndices | The primary variable and equation indices for the black-oil model |
| CBlackOilPolymerModule | Contains the high level supplements required to extend the black oil model by polymer |
| CBlackOilPolymerIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the polymers extension of the black-oil model |
| CBlackOilPolymerIntensiveQuantities< TypeTag, true > | |
| CBlackOilPolymerIntensiveQuantities< TypeTag, false > | |
| CBlackOilPolymerExtensiveQuantities | Provides the polymer specific extensive quantities to the generic black-oil module's extensive quantities |
| CBlackOilPolymerExtensiveQuantities< TypeTag, true > | |
| CBlackOilPolymerExtensiveQuantities< TypeTag, false > | |
| CBlackOilPolymerParams | Struct holding the parameters for the BlackOilPolymerModule class |
| CPlyvmhCoefficients | |
| CSkprpolyTable | |
| CBlackOilPrimaryVariables | Represents the primary variables used by the black-oil model |
| CBlackOilProblem | Base class for all problems which use the black-oil model |
| CBlackOilRateVector | Implements a vector representing mass, molar or volumetric rates for the black oil model |
| CBlackOilSolventModule | Contains the high level supplements required to extend the black oil model by solvents |
| CBlackOilSolventIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the solvents extension of the black-oil model |
| CBlackOilSolventIntensiveQuantities< TypeTag, true > | |
| CBlackOilSolventIntensiveQuantities< TypeTag, false > | |
| CBlackOilSolventExtensiveQuantities | Provides the solvent specific extensive quantities to the generic black-oil module's extensive quantities |
| CBlackOilSolventExtensiveQuantities< TypeTag, false > | |
| CBlackOilSolventParams | Struct holding the parameters for the BlackOilSolventModule class |
| CBlackOilTwoPhaseIndices | The primary variable and equation indices for the black-oil model |
| CBlackOilVariableAndEquationIndices | The primary variable and equation indices for the three-phase black-oil model |
| CDarcyIntensiveQuantities | Provides the intensive quantities for the Darcy flux module |
| CDarcyExtensiveQuantities | Provides the Darcy flux module |
| CDarcyBaseProblem | Provides the defaults for the parameters required by the Darcy velocity approach |
| CDarcyFluxModule | Specifies a flux module which uses the Darcy relation |
| CDiffusionModule | Provides the auxiliary methods required for consideration of the diffusion equation |
| CDiffusionModule< TypeTag, false > | Provides the auxiliary methods required for consideration of the diffusion equation. |
| CDiffusionModule< TypeTag, true > | Provides the auxiliary methods required for consideration of the diffusion equation. |
| CDiffusionIntensiveQuantities | Provides the volumetric quantities required for the calculation of molecular diffusive fluxes |
| CDiffusionIntensiveQuantities< TypeTag, false > | Provides the volumetric quantities required for the calculation of molecular diffusive fluxes. |
| CDiffusionIntensiveQuantities< TypeTag, true > | Provides the volumetric quantities required for the calculation of molecular diffusive fluxes. |
| CDiffusionExtensiveQuantities | Provides the quantities required to calculate diffusive mass fluxes |
| CDiffusionExtensiveQuantities< TypeTag, false > | Provides the quantities required to calculate diffusive mass fluxes. |
| CDiffusionExtensiveQuantities< TypeTag, true > | Provides the quantities required to calculate diffusive mass fluxes. |
| CDirectionalMobility | |
| CEnergyModule | Provides the auxiliary methods required for consideration of the energy equation |
| CEnergyModule< TypeTag, false > | Provides the auxiliary methods required for consideration of the energy equation. |
| CEnergyModule< TypeTag, true > | Provides the auxiliary methods required for consideration of the energy equation. |
| CEnergyIndices | Provides the indices required for the energy equation |
| CEnergyIndices< PVOffset, false > | Provides the indices required for the energy equation. |
| CEnergyIndices< PVOffset, true > | Provides the indices required for the energy equation. |
| CEnergyIntensiveQuantities | Provides the volumetric quantities required for the energy equation |
| CEnergyIntensiveQuantities< TypeTag, false > | Provides the volumetric quantities required for the energy equation. |
| CEnergyIntensiveQuantities< TypeTag, true > | Provides the volumetric quantities required for the energy equation. |
| CEnergyExtensiveQuantities | Provides the quantities required to calculate energy fluxes |
| CEnergyExtensiveQuantities< TypeTag, false > | Provides the quantities required to calculate energy fluxes. |
| CEnergyExtensiveQuantities< TypeTag, true > | Provides the quantities required to calculate energy fluxes. |
| CForchheimerIntensiveQuantities | Provides the intensive quantities for the Forchheimer module |
| CForchheimerExtensiveQuantities | Provides the Forchheimer flux module |
| CForchheimerBaseProblem | Provides the defaults for the parameters required by the Forchheimer velocity approach |
| CForchheimerFluxModule | Specifies a flux module which uses the Forchheimer relation |
| CMultiPhaseBaseExtensiveQuantities | This class calculates the pressure potential gradients and the filter velocities for multi-phase flow in porous media |
| CMultiPhaseBaseModel | A base class for fully-implicit multi-phase porous-media flow models which assume multiple fluid phases |
| CMultiPhaseBaseProblem | The base class for the problems of ECFV discretizations which deal with a multi-phase flow through a porous medium |
| CTemperatureCallback | Callback class for temperature |
| CPressureCallback | Callback class for a phase pressure |
| CBoundaryPressureCallback | Callback class for a phase pressure |
| CDensityCallback | Callback class for the density of a phase |
| CMolarDensityCallback | Callback class for the molar density of a phase |
| CViscosityCallback | Callback class for the viscosity of a phase |
| CVelocityCallback | Callback class for the velocity of a phase at the center of a DOF |
| CVelocityComponentCallback | Callback class for the velocity of a phase at the center of a DOF |
| CMoleFractionCallback | Callback class for a mole fraction of a component in a phase |
| CTransIntensiveQuantities | Provides the intensive quantities for the transmissibility based flux module |
| CTransExtensiveQuantities | Provides the transmissibility based flux module |
| CTransBaseProblem | Provides the defaults for the parameters required by the transmissibility based volume flux calculation |
| CTransFluxModule | Specifies a flux module which uses transmissibilities |
| CDiscreteFractureExtensiveQuantities | This class expresses all intensive quantities of the discrete fracture model |
| CDiscreteFractureIntensiveQuantities | Contains the quantities which are are constant within a finite volume in the discret fracture immiscible multi-phase model |
| CDiscreteFractureLocalResidual | Calculates the local residual of the discrete fracture immiscible multi-phase model |
| CDiscreteFractureModel | A fully-implicit multi-phase flow model which assumes immiscibility of the phases and is able to include fractures in the domain |
| CDiscreteFracturePrimaryVariables | Represents the primary variables used by the discrete fracture multi-phase model |
| CDiscreteFractureProblem | The base class for the problems of ECFV discretizations which deal with a multi-phase flow through a porous medium |
| CFractureMapper | Stores the topology of fractures |
| CBaseAuxiliaryModule | Base class for specifying auxiliary equations |
| CFvBaseAdLocalLinearizer | Calculates the local residual and its Jacobian for a single element of the grid |
| CFvBaseBoundaryContext | Represents all quantities which available on boundary segments |
| CFvBaseConstraints | Class to specify constraints for a finite volume spatial discretization |
| CFvBaseConstraintsContext | Represents all quantities which available for calculating constraints |
| CFvBaseDiscretizationNoAdapt | The base class for the finite volume discretization schemes without adaptation |
| CSerializeHelper | |
| CFvBaseDiscretization | The base class for the finite volume discretization schemes |
| CBlockVectorWrapper | |
| CFvBaseDiscretizationFemAdapt | The base class for the finite volume discretization schemes |
| CSerializeHelper | |
| CFvBaseElementContext | This class stores an array of IntensiveQuantities objects, one intensive quantities object for each of the element's vertices |
| CFvBaseExtensiveQuantities | Provide the properties at a face which make sense independently of the conserved quantities |
| CFvBaseFdLocalLinearizer | Calculates the Jacobian of the local residual for finite volume spatial discretizations using a finite difference method |
| CEcfvDiscretization | The base class for the element-centered finite-volume discretization scheme |
| CFvBaseGradientCalculator | This class calculates gradients of arbitrary quantities at flux integration points using the two-point approximation scheme |
| CFvBaseIntensiveQuantities | Base class for the model specific class which provides access to all intensive (i.e., volume averaged) quantities |
| CFvBaseLinearizer | The common code for the linearizers of non-linear systems of equations |
| CFvBaseLocalResidual | Element-wise caculation of the residual matrix for models based on a finite volume spatial discretization |
| CFvBaseNewtonConvergenceWriter | Writes the intermediate solutions during the Newton scheme for models using a finite volume discretization |
| CFvBaseNewtonMethod | A Newton method for models using a finite volume discretization |
| CFvBasePrimaryVariables | Represents the primary variables used by the a model |
| CFvBaseProblem | Base class for all problems which use a finite volume spatial discretization |
| CLinearizationType | |
| CCopyRestrictProlong | |
| CCopyRestrictProlongTraits | |
| CEmptyRestrictProlongTraits | |
| CEmptyRestrictProlong | |
| CTpfaLinearizer | The common code for the linearizers of non-linear systems of equations |
| CEcfvBaseOutputModule | Implements the discretization specific parts of writing files |
| CEcfvGridCommHandleFactory | A class which provides types for DUNE grid handles for communication |
| CEcfvStencil | Represents the stencil (finite volume geometry) of a single element in the ECFV discretization |
| CSubControlVolume | Represents a sub-control volume |
| CEcfvSubControlVolumeFace | Represents a face of a sub-control volume |
| CP1FeGradientCalculator | This class calculates gradients of arbitrary quantities at flux integration points using first order finite elements ansatz functions |
| CVcfvBaseOutputModule | Implements the discretization specific parts of writing files |
| CVcfvDiscretization | The base class for the vertex centered finite volume discretization scheme |
| CVcfvGridCommHandleFactory | A class which provides types for DUNE grid handles for communication |
| CVcfvStencil | Represents the finite volume geometry of a single element in the VCFV discretization |
| CScvGeometry | |
| CSubControlVolume | Finite volume intersected with element |
| CSubControlVolumeFace | Interior face of a sub control volume |
| CFlashBoundaryRateVector | Implements a boundary vector for the fully implicit compositional multi-phase model which is based on flash calculations |
| CFlashExtensiveQuantities | This template class contains the data which is required to calculate all fluxes of components over a face of a finite volume for the compositional multi-phase model based on flash calculations |
| CFlashIndices | Defines the primary variable and equation indices for the compositional multi-phase model based on flash calculations |
| CFlashIntensiveQuantities | Contains the intensive quantities of the flash-based compositional multi-phase model |
| CFlashLocalResidual | Calculates the local residual of the compositional multi-phase model based on flash calculations |
| CFlashModel | A compositional multi-phase model based on flash-calculations |
| CFlashPrimaryVariables | Represents the primary variables used by the compositional flow model based on flash calculations |
| CFlashRateVector | Implements a vector representing rates of conserved quantities. |
| CImmiscibleBoundaryRateVector | Implements a boundary vector for the fully implicit multi-phase model which assumes immiscibility |
| CImmiscibleExtensiveQuantities | This class provides the data all quantities that are required to calculate the fluxes of the fluid phases over a face of a finite volume for the immiscible multi-phase model |
| CImmiscibleIndices | The indices for the isothermal multi-phase model |
| CImmiscibleIntensiveQuantities | Contains the quantities which are are constant within a finite volume for the immiscible multi-phase model |
| CImmiscibleLocalResidual | Calculates the local residual of the immiscible multi-phase model |
| CImmiscibleModel | A fully-implicit multi-phase flow model which assumes immiscibility of the phases |
| CImmisciblePrimaryVariables | Represents the primary variables used by the immiscible multi-phase, model |
| CImmiscibleRateVector | Implements a vector representing rates of conserved quantities |
| CBaseOutputModule | The base class for writer modules |
| CBaseOutputWriter | The base class for all output writers |
| CBaseVanguard | Provides the base class for most (all?) simulator vanguards |
| CCubeGridVanguard | Provides a simulator vanguad which creates a regular grid made of quadrilaterals |
| CDgfVanguard | Provides a simulator vanguard which creates a grid by parsing a Dune Grid Format (DGF) file |
| CRestart | Load or save a state of a problem to/from the harddisk |
| CSimplexGridVanguard | Provides a simulator vanguard which a creates regular grid made of simplices |
| CStructuredGridVanguard | Helper class for grid instantiation of the lens problem |
| CUnstructuredGridVanguard | Provides a simulator vanguard which creates a grid by parsing an unstructured grid file |
| CVtkBlackOilBioeffectsModule | VTK output module for the Bioeffect model's related quantities |
| CVtkBlackOilBioeffectsParams | Struct holding the parameters for VtkBlackOilBioeffectsModule |
| CVtkBlackOilEnergyModule | VTK output module for the black oil model's energy related quantities |
| CVtkBlackoilEnergyParams | Struct holding the parameters for VtkBlackoilEnergyOutputModule |
| CVtkBlackOilModule | VTK output module for the black oil model's parameters |
| CVtkBlackoilParams | Struct holding the parameters for VtkBlackoilOutputModule |
| CVtkBlackOilPolymerModule | VTK output module for the black oil model's polymer related quantities |
| CVtkBlackoilPolymerParams | Struct holding the parameters for VtkBlackoilPolymerModule |
| CVtkBlackOilSolventModule | VTK output module for the black oil model's solvent related quantities |
| CVtkBlackOilSolventParams | Struct holding the parameters for VtkBlackoilPolymerModule |
| CVtkCompositionModule | VTK output module for the fluid composition |
| CVtkCompositionParams | Struct holding the parameters for VtkCompositionModule |
| CVtkDiffusionModule | VTK output module for quantities which make sense for models which incorperate molecular diffusion |
| CVtkDiffusionParams | Struct holding the parameters for VtkDiffusionModule |
| CVtkDiscreteFractureModule | VTK output module for quantities which make sense for all models which deal with discrete fractures in porous media |
| CVtkDiscreteFractureParams | Struct holding the parameters for VtkDiscreteFractureModule |
| CVtkEnergyModule | VTK output module for quantities which make sense for models which assume thermal equilibrium |
| CVtkEnergyParams | Struct holding the parameters for VtkEnergyModule |
| CVtkMultiPhaseModule | VTK output module for quantities which make sense for all models which deal with multiple fluid phases in porous media that don't use flashy concepts like interfacial area |
| CVtkMultiPhaseParams | Struct holding the parameters for VtkMultiPhaseModule |
| CVtkMultiWriter | Simplifies writing multi-file VTK datasets |
| CVtkPhasePresenceModule | VTK output module for the fluid composition |
| CVtkPhasePresenceParams | Struct holding the parameters for VtkPhasePresenceModule |
| CVtkPrimaryVarsModule | VTK output module for the fluid composition |
| CVtkPrimaryVarsParams | Struct holding the parameters for VtkPrimaryPhaseModule |
| CVtkPTFlashModule | VTK output module for the PT Flash calculation This module deals with the following quantities: K, equilibrium ratio for all the components L, liquid fraction in the two-phase system |
| CVtkPtFlashParams | Struct holding the parameters for VtkPtFlashModule |
| CVtkScalarFunction | Provides a vector-valued function using Dune::FieldVectors as elements |
| CVtkTemperatureModule | VTK output module for the temperature in which assume thermal equilibrium |
| CVtkTemperatureParams | Struct holding the parameters for VtkTemperatureModule |
| CVtkTensorFunction | Provides a tensor-valued function using Dune::FieldMatrix objects as elements |
| CVtkVectorFunction | Provides a vector-valued function using Dune::FieldVectors as elements |
| CNcpBoundaryRateVector | Implements a boundary vector for the fully implicit compositional multi-phase NCP model |
| CNcpExtensiveQuantities | This template class represents the extensive quantities of the compositional NCP model |
| CNcpIndices | The primary variable and equation indices for the compositional multi-phase NCP model |
| CNcpIntensiveQuantities | Contains the quantities which are are constant within a finite volume in the compositional multi-phase NCP model |
| CNcpLocalResidual | Details needed to calculate the local residual in the compositional multi-phase NCP-model |
| CNcpModel | A compositional multi-phase model based on non-linear complementarity functions |
| CNcpNewtonMethod | A Newton solver specific to the NCP model |
| CNcpPrimaryVariables | Represents the primary variables used by the compositional multi-phase NCP model |
| CNcpRateVector | Implements a vector representing mass, molar or volumetric rates |
| CNewtonMethod | The multi-dimensional Newton method |
| CNewtonMethodParams | Struct holding the parameters for NewtonMethod |
| CNullConvergenceWriter | A convergence writer for the Newton method which does nothing |
| CGridCommHandleSum | Data handle for parallel communication which sums up all values are attached to DOFs |
| CGridCommHandleGhostSync | Data handle for parallel communication which can be used to set the values values of ghost and overlap DOFs from their respective master processes |
| CGridCommHandleMax | Data handle for parallel communication which takes the maximum of all values that are attached to DOFs |
| CGridCommHandleMin | Provides data handle for parallel communication which takes the minimum of all values that are attached to DOFs |
| CMpiBuffer | Simplifies handling of buffers to be used in conjunction with MPI |
| CTaskletInterface | The base class for tasklets |
| CFunctionRunnerTasklet | A simple tasklet that runs a function that returns void and does not take any arguments a given number of times |
| CTaskletRunner | Handles where a given tasklet is run |
| CThreadedEntityIterator | Provides an STL-iterator like interface to iterate over the enties of a GridView in OpenMP threaded applications |
| CThreadManager | Simplifies multi-threaded capabilities |
| CFlashNewtonMethod | A Newton solver specific to the PTFlash model |
| CPvsBoundaryRateVector | Implements a rate vector on the boundary for the fully implicit compositional multi-phase primary variable switching compositional model |
| CPvsExtensiveQuantities | Contains all data which is required to calculate all fluxes at a flux integration point for the primary variable switching model |
| CPvsIndices | The indices for the compositional multi-phase primary variable switching model |
| CPvsIntensiveQuantities | Contains the quantities which are are constant within a finite volume in the compositional multi-phase primary variable switching model |
| CPvsLocalResidual | Element-wise calculation of the local residual for the compositional multi-phase primary variable switching model |
| CPvsModel | A generic compositional multi-phase model using primary-variable switching |
| CPvsNewtonMethod | A newton solver which is specific to the compositional multi-phase PVS model |
| CPvsPrimaryVariables | Represents the primary variables used in the primary variable switching compositional model |
| CPvsRateVector | Implements a vector representing molar, mass or volumetric rates |
| CRichardsBoundaryRateVector | Implements a boundary vector for the fully implicit Richards model |
| CRichardsIndices | Indices for the primary variables/conservation equations of the Richards model |
| CRichardsIntensiveQuantities | Intensive quantities required by the Richards model |
| CRichardsLocalResidual | Element-wise calculation of the residual for the Richards model |
| CRichardsModel | This model implements a variant of the Richards equation for quasi-twophase flow |
| CRichardsNewtonMethod | A Richards model specific Newton method |
| CRichardsPrimaryVariables | Represents the primary variables used in the Richards model |
| CRichardsRateVector | Implements a vector representing mass, molar or volumetric rates |
| Caligned_allocator | |
| Crebind | |
| Caligned_allocator< void, Alignment > | |
| Crebind | |
| CGenericGuard | A simple class which makes sure that a cleanup function is called once the object is destroyed |
| CPffGridVector | A random-access container which stores data attached to a grid's degrees of freedom in a prefetch friendly manner |
| CQuadrialteralQuadratureGeometry | Quadrature geometry for quadrilaterals |
| CSimulator | Manages the initializing and running of time dependent problems |
| CTimer | Provides an encapsulation to measure the system time |
| CTimerGuard | A simple class which makes sure that a timer gets stopped if an exception is thrown |
| CAquiferAnalytical | |
| CAquiferCarterTracy | |
| CAquiferConstantFlux | |
| CAquiferFetkovich | |
| CIsNumericalAquiferCell | |
| CIsNumericalAquiferCell< Dune::CpGrid > | |
| CAquiferInterface | |
| CAquiferNumerical | |
| CBlackoilAquiferModel | Class for handling the blackoil aquifer model |
| CSupportsFaceTag | |
| CSupportsFaceTag< Dune::CpGrid > | |
| CBlackoilWellModelGeneric | Class for handling the blackoil well model |
| CActionHandler | Class handling Action support in simulator |
| CLevelCartesianIndexMapper< Dune::ALUGrid< 3, 3, Dune::cube, Dune::nonconforming > > | |
| CFlowAluGridVanguard | |
| CAluGridVanguard | Helper class for grid instantiation of ECL file-format using problems |
| CBaseAquiferModel | The base class which specifies the API of aquifer models |
| CBioeffectsSolutionContainer | Struct holding MICP extension data |
| CBioeffectsContainer | |
| CBlackoilModel | A model implementation for three-phase black oil |
| CBlackoilModelConvergenceMonitor | Implementation of penalty cards for three-phase black oil |
| CBlackoilModelNldd | A NLDD implementation for three-phase black oil |
| CBlackoilModelParameters | Solver parameters for the BlackoilModel |
| CConvergenceMonitorParams | Struct holding convergence monitor params |
| CBlackoilWellModel | Class for handling the blackoil well model |
| CCollectDataOnIORank | |
| CGlobalCellIndex | |
| CDistributeIndexMapping | |
| CElementIndexScatterHandle | Communication handle to scatter the global index |
| CElementIndexHandle | Communication handle to scatter the global index |
| CPackUnPackCellData | |
| CPackUnPackWellData | |
| CPackUnPackGroupAndNetworkValues | |
| CPackUnPackBlockData | |
| CPackUnPackWBPData | |
| CPackUnPackWellTestState | |
| CPackUnPackAquiferData | |
| CPackUnpackInterRegFlows | |
| CPackUnpackFlows | |
| CCompositionalContainer | |
| CConvergenceOutputConfiguration | Parse comma separated option strings into a runtime configuration object for whether to output additional convergence information and, if so, what information to output |
| CCpGridVanguard | Helper class for grid instantiation of ECL file-format using problems |
| CDamarisWriter | Collects necessary output values and pass them to Damaris server processes |
| CDummyGradientCalculator | This is a "dummy" gradient calculator which does not do anything |
| CEclGenericWriter | |
| CEclWriter | Collects necessary output values and pass it to opm-common's ECL output |
| CEquilInitializer | Computes the initial condition based on the EQUIL keyword from ECL |
| CExtboContainer | |
| CConvergenceReportQueue | Communication channel between thread creating output requests and consumer thread writing those requests to a file |
| COutputRequest | Single output request |
| CConvergenceOutputThread | Encapsulating object for thread processing producer's convergence output requests |
| CImpl | |
| CFIBlackOilModel | |
| CFIPContainer | |
| CCo2InGasInput | |
| CFlowBaseVanguard | Helper class for grid instantiation of ECL file-format using problems |
| CLookUpCellCentroid | |
| CLookUpData | |
| CFlowGenericProblem | This problem simulates an input file given in the data format used by the commercial ECLiPSE simulator |
| CRockParams | |
| CFlowGenericVanguard | |
| CSimulationModelParams | |
| CFlowProblem | This problem simulates an input file given in the data format used by the commercial ECLiPSE simulator |
| CPffDofData_ | |
| CBCData | |
| CFlowProblemBlackoil | This problem simulates an input file given in the data format used by the commercial ECLiPSE simulator |
| CFlowProblemComp | This problem simulates an input file given in the data format used by the commercial ECLiPSE simulator |
| CFlowsContainer | |
| CFlowsData | Simple container for FLOWS data |
| CFlowThresholdPressure | This class calculates the threshold pressure for grid faces according to the Eclipse Reference Manual |
| CGenericCpGridVanguard | |
| CGenericOutputBlackoilModule | |
| CLookUpCartesianData | |
| CGenericThresholdPressure | |
| CGenericTracerModel | |
| CBlackOilHybridNewton | Hybrid Newton solver extension for the black-oil model |
| CFeatureFlags | |
| CScaler | Represents scaling information for a feature |
| CTransform | Represents a transformation applied to a feature |
| CFeatureSpec | Metadata for a single feature (input or output) |
| CHybridNewtonConfig | Configuration for a Hybrid Newton ML model |
| CInterRegFlowMapSingleFIP | Form CSR adjacency matrix representation of inter-region flow rate graph provided as a list of connections between regions on local MPI rank |
| CCell | Minimal characteristics of a cell from a simulation grid |
| CInterRegFlowMap | Inter-region flow accumulation maps for all region definition arrays |
| CSingleRegion | Minimal representation of a single named region defintion |
| CLogOutputHelper | |
| CMain | |
| CMechContainer | |
| CMixingRateControls | Class handling mixing rate controls for a FlowProblemBlackoil |
| CNewTranIntensiveQuantities | Provides the intensive quantities for the ECL flux module |
| CNewTranExtensiveQuantities | Provides the ECL flux module |
| CNewTranBaseProblem | Provides the defaults for the parameters required by the transmissibility based volume flux calculation |
| CNewTranFluxModule | Specifies a flux module which uses ECL transmissibilities |
| CNonlinearSolverParameters | |
| CNonlinearSolver | A nonlinear solver class suitable for general fully-implicit models, as well as pressure, transport and sequential models |
| COutputBlackOilModule | Output module for the results black oil model writing in ECL binary format |
| COutputCompositionalModule | Output module for the results black oil model writing in ECL binary format |
| CZoltanPartitioningControl | Control parameters for on-rank subdomain partitioning using Zoltan library |
| CPolyhedralGridVanguard | Helper class for grid instantiation of ECL file-format using problems |
| CPyMain | |
| CRegionPhasePoreVolAverage | Facility for calculating volume-weighted average function values over user-defined regions in parallel |
| CCellValue | Minimal characteristics of a cell from a simulation grid |
| CPhase | Compile-time disambiguation type for phases |
| CRegion | Compile-time disambiguation type for regions |
| CReservoirCouplingMaster | |
| CReservoirCouplingSlave | |
| CReservoirCouplingSpawnSlaves | |
| CRFTContainer | Collection of cell-level RFT data–i.e., pressures and saturations–in cells intersected by wells |
| CRSTConv | Class computing RPTRST CONV output |
| CSimulatorConvergenceOutput | Class handling convergence history output for a simulator |
| CSimulatorFullyImplicitBlackoil | Simulator for the blackoil model |
| CSerializableSim | Abstract interface for simulator serialization ops |
| CSimulatorSerializer | Class handling simulator serialization |
| CPolymerSolutionContainer | Struct holding polymer extension data |
| CSubDomainIndices | Representing a part of a grid, in a way suitable for performing local solves |
| CSubDomain | Representing a part of a grid, in a way suitable for performing local solves |
| CTracerContainer | |
| CTracerModel | A class which handles tracers as specified in by ECL |
| CTracerBatch | |
| CTransmissibility | |
| CFaceInfo | |
| CVtkTracerModule | VTK output module for the tracer model's parameters |
| CAbstractISTLSolver | Abstract interface for ISTL solvers |
| CISTLSolverGpuBridge | This class solves the fully implicit black-oil system by solving the reduced system (after eliminating well variables) as a block-structured matrix (one block for all cell variables) for a fixed number of cell variables np |
| CISTLSolver | This class solves the fully implicit black-oil system by solving the reduced system (after eliminating well variables) as a block-structured matrix (one block for all cell variables) for a fixed number of cell variables np |
| CISTLSolverRuntimeOptionProxy | ISTLSolverRuntimeOptionProxy selects the appropriate ISTLSolver runtime based on CLI options |
| CFlowLinearSolverParameters | This class carries all parameters for the NewtonIterationBlackoilInterleaved class |
| CWellContributionsCuda | |
| CWellContributions | This class serves to eliminate the need to include the WellContributions into the matrix (with –matrix-add-well-contributions=true) for the cusparseSolver or openclSolver |
| CGpuBridge | GpuBridge acts as interface between opm-simulators with the GpuSolvers |
| CMultisegmentWellContribution | This class serves to duplicate the functionality of the MultisegmentWell A MultisegmentWell uses C, D and B and performs y -= (C^T * (D^-1 * (B*x))) B and C are matrices, with M rows and N columns, where N is the size of the matrix |
| CWellContributionsOCL | |
| CHipKernels | |
| CWellContributionsRocsparse | |
| Cis_gpu_operator | Check if a given operator is a GPU operator |
| Cis_gpu_matrix | Check if a given operator is a GPU matrix |
| CMatrixBlock | |
| CPreconditionerFactory | This is an object factory for creating preconditioners |
| CParallelOverlappingILU0 | A two-step version of an overlapping Schwarz preconditioner using one step ILU0 as |
| CCRS | |
| CParallelOverlappingILU0Args | |
| CParallelRestrictedOverlappingSchwarz | Block parallel preconditioner |
| CAMGHelper | |
| CPressureBhpTransferPolicy | |
| CPressureTransferPolicy | |
| CPropertyTree | Hierarchical collection of key/value pairs |
| CStandardPreconditioners< Operator, Comm, typename std::enable_if_t< Opm::is_gpu_operator_v< Operator > > > | |
| CStandardPreconditioners< Operator, Dune::Amg::SequentialInformation, typename std::enable_if_t< Opm::is_gpu_operator_v< Operator > > > | |
| CAMGSmootherArgsHelper | |
| CAMGSmootherArgsHelper< ParallelOverlappingILU0< M, V, V, C > > | |
| CStandardPreconditioners | |
| CStandardPreconditioners< Operator, Dune::Amg::SequentialInformation, typename std::enable_if_t<!Opm::is_gpu_operator_v< Operator > > > | |
| CLinearOperatorExtra | Linear operator wrapper for well model |
| CWellModelAsLinearOperator | |
| CDomainWellModelAsLinearOperator | |
| CWellModelMatrixAdapter | Adapter to combine a matrix and another linear operator into a combined linear operator |
| CWellModelGhostLastMatrixAdapter | Adapter to combine a matrix and another linear operator into a combined linear operator |
| CGhostLastMatrixAdapter | Dune linear operator that assumes ghost rows are ordered after interior rows |
| CAdaptiveSimulatorTimer | Simulation timer for adaptive time stepping |
| CAdaptiveTimeStepping | |
| CConvergenceReport | Represents the convergence status of the whole simulator, to make it possible to query and store the reasons for convergence failures |
| CPenaltyCard | |
| CReservoirFailure | |
| CReservoirConvergenceMetric | |
| CWellFailure | |
| CWellConvergenceMetric | |
| CStepReport | |
| CSimulatorReportSingle | A struct for returning timing data from a simulator to its caller |
| CSimulatorReport | |
| CSimulatorTimer | |
| CSimulatorTimerInterface | Interface class for SimulatorTimer objects, to be improved |
| CSimpleIterationCountTimeStepControl | A simple iteration count based adaptive time step control |
| CPIDTimeStepControl | PID controller based adaptive time step control as suggested in: Turek and Kuzmin |
| CPIDAndIterationCountTimeStepControl | PID controller based adaptive time step control as above that also takes target iterations into account |
| CGeneral3rdOrderController | General 3rd order controller |
| CHardcodedTimeStepControl | HardcodedTimeStepControl Input generated from summary file using the ert application: |
| CRelativeChangeInterface | RelativeChangeInterface |
| CTimeStepControlInterface | TimeStepControlInterface |
| CComponentName | |
| CDeferredLogger | |
| CMessage | |
| CHDF5File | Class handling simple output to HDF5 |
| CHDF5Serializer | Class for (de-)serializing using HDF5 |
| CParallelFieldPropsManager | Parallel frontend to the field properties |
| CParallelEclipseState | Parallel frontend to the EclipseState |
| CParallelNLDDPartitioningZoltan | Partition connectivity graph into non-overlapping domains using the Zoltan graph partitioning software package |
| CLevelCartesianIndexMapper | |
| CRelpermDiagnostics | This class is intend to be a relperm diagnostics, to detect wrong input of relperm table and endpoints |
| CEclEpsScalingPointsInfo | |
| CSatfuncConsistencyChecks | Platform for running sets of consistency checks against collection of saturation function end-points |
| CCheck | Call-back interface for an individual check |
| CVectorVectorDataHandle | A data handle sending multiple data store in vectors attached to cells |
| CALQState | |
| CBlackoilWellModelNldd | Class for handling the blackoil well model in a NLDD solver |
| CSparseTable | |
| CGroupState | |
| CGroupPotential | |
| CWellState | The state of a set of wells, tailored for use by the fully implicit blackoil simulator |
| CWellGroupHelpers | |
| CBlackoilWellModelConstraints | Class for handling constraints for the blackoil well model |
| CWellInterface | |
| CBlackoilWellModelGasLiftGeneric | |
| CBlackoilWellModelGasLift | Class for handling the gaslift in the blackoil well model |
| CGasLiftGroupInfo | |
| CGroupRates | |
| CGasLiftSingleWellGeneric | |
| CGradInfo | |
| CBasicRates | |
| CLimitedRates | |
| COptimizeState | |
| CGasLiftWellState | |
| CVFPProperties | A thin wrapper class that holds one VFPProdProperties and one VFPInjProperties object |
| CWellInterfaceGeneric | |
| COperabilityStatus | |
| CBlackoilWellModelGuideRates | Class for handling the guide rates in the blackoil well model |
| CBlackoilWellModelNlddGeneric | |
| CPerforationData | Static data associated with a well perforation |
| CSingleWellState | |
| CBlackoilWellModelRestart | Class for restarting the blackoil well model |
| CBlackoilWellModelWBP | Class for handling the blackoil well model |
| CConnectionIndexMap | Connection index mappings |
| CConnFiltrateData | |
| CConnFracStatistics | Collection of fracturing statistics measures at the connection level |
| CGasLiftCommon | |
| CPhaseUsageInfo | |
| CGasLiftSingleWell | |
| CGasLiftStage2 | |
| COptimizeState | |
| CSurplusState | |
| CGlobalWellInfo | |
| CGroupEconomicLimitsChecker | |
| CGuideRateHandler | Handles computation and reporting of guide rates for wells and groups |
| CGuideRateDumper | Responsible for formatting and printing guide rate information to logs |
| CUpdateGuideRates | Computes and updates guide rate values for wells and groups |
| CParallelWellInfo | Class encapsulating some information about parallel wells |
| CMultisegmentWell | |
| CMultisegmentWellEquationAccess | Class administering assembler access to equation system |
| CMultisegmentWellEquations | |
| CMultisegmentWellPrimaryVariables | |
| CWellInterfaceIndices | |
| CMultisegmentWellAssemble | Class handling assemble of the equation system for MultisegmentWell |
| CMultisegmentWellGeneric | |
| CMultisegmentWellEval | |
| CSegmentState | |
| CMultisegmentWellSegments | |
| CParallelPAvgCalculator | Facility for deriving well-level pressure values from selected block-averaging procedures |
| CParallelPAvgDynamicSourceData | Dynamic source data for block-average pressure calculations |
| CParallelWBPCalculation | Parallel facility for managing the on-rank collection and global distribution of WBPn source values as well as local calculation and distributed reduction of the inferred WBPn report values |
| CCopyGatherScatter | |
| CCommunicateAboveBelow | Class to facilitate getting values associated with the above/below perforation |
| CGlobalPerfContainerFactory | A factory for creating a global data representation for distributed wells |
| CCheckDistributedWellConnections | Class checking that all connections are on active cells |
| CPerfData | |
| CPerforationRates | |
| CRatioCalculator | |
| CRunningStatistics | Facility for calculating simple sample statistics without having full sample available |
| CRuntimePerforation | Simple model of a well connection created at runtime, possibly as a result of a geo-mechanical fracturing process |
| CStandardWell | |
| CStandardWellEquationAccess | Class administering assembler access to equation system |
| CStandardWellEquations | |
| CStandardWellPrimaryVariables | Class holding primary variables for StandardWell |
| CWellInterfaceFluidSystem | |
| CStandardWellAssemble | Class handling assemble of the equation system for StandardWell |
| CStandardWellConnections | |
| CProperties | |
| CPressurePropertyFunctions | |
| CDensityPropertyFunctions | |
| CStandardWellEval | |
| CVFPHelpers | |
| CVFPInjProperties | |
| CVFPProdProperties | Class which linearly interpolates BHP as a function of rate, tubing head pressure, water fraction, gas fraction, and artificial lift for production VFP tables, and similarly the BHP as a function of the rate and tubing head pressure |
| CWellAssemble | |
| CWellBhpThpCalculator | Class for computing BHP limits |
| CWellConnectionAuxiliaryModule | |
| CWellConstraints | Class for computing well group constraints |
| CWellContainer | |
| CWellConvergence | |
| CTolerances | |
| CWellFilterCake | Class for well calculations related to filter cakes |
| CWellGroupConstraints | Class for computing well group constraints |
| CWellGroupControls | Class for computing well group controls |
| CWellProdIndexCalculator | Collect per-connection static information to enable calculating connection-level or well-level productivity index values when incorporating dynamic phase mobilities |
| CWellTest | Class for performing well tests |
| CWellTracerRate | |
| CMSWellTracerRate | |
| CWGState | |
| CGpuResult | This class is based on InverseOperatorResult struct from dune/istl/solver.hh It is needed to prevent a compile error in basearray.hh, the nvcc compiler might not support all features in there |
| CGpuSolver | This class serves to simplify choosing between different backend solvers, such as cusparseSolver and openclSolver This class is abstract, no instantiations can of it can be made, only of its children |
| COpenclKernels | |
| Nrocalution | |
| CBiCGStab | |
| CILU | |
| CLocalMatrix | |
| CLocalVector | |
| CBlackOilBrineIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the brine extension of the black-oil model |
1.15.0