| NAmgx | |
| CAmgxConfig | Configuration structure for AMGX parameters |
| CAmgxPreconditioner | Wrapper for AMGX's AMG preconditioner |
| Nboost | |
| Nproperty_tree | |
| Cbasic_ptree | |
| NDune | |
| NAmg | |
| CAggregationLevelTransferPolicyCpr | A LeveTransferPolicy that used aggregation to construct the coarse level system |
| CAMGCPR | Parallel algebraic multigrid based on agglomeration |
| CConstructionTraits< MultithreadDILU< M, X, Y > > | Policy for the construction of the MultithreadDILU smoother |
| CConstructionTraits< Opm::GhostLastMatrixAdapter< 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 |
| CKAMG | |
| CKAmgTwoGrid | |
| CLevelTransferPolicyCpr | Abstract base class for transfer between levels and creation of the coarse level system |
| COneStepAMGCoarseSolverPolicyCpr | A policy class for solving the coarse level system using one step of AMG |
| CPressureSolverPolicy | |
| CSmootherTraits< Opm::ParallelOverlappingILU0< M, X, Y, C > > | |
| CSmootherTraits< Opm::ParallelRestrictedOverlappingSchwarz< Range, Domain, ParallelInfo, SeqPreconditioner > > | Tells AMG how to use Opm::ParallelOverlappingILU0 smoother |
| CTwoLevelMethodCpr | |
| Ndetail | |
| CStructMPITraitsImpl | |
| 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 > > | |
| CCartesianIndexMapper | |
| 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 | |
| CDummyUpdatePreconditioner | |
| CFieldTraits< EwomsPrimaryVariable< TypeTag > > | Specialization of FieldTraits for all PrimaryVariables derived from Opm::FvBasePrimaryVariables |
| CFieldTraitsImpl | Compatibility traits class for DenseVector and DenseMatrix |
| CFieldTraitsImpl< T, false > | FieldTraitsImpl for classes not derived from Opm::FvBasePrimaryVariables, fall bakc to existing implementation |
| CFieldTraitsImpl< TypeTag, true > | FieldTraitsImpl for classes derived from Opm::FvBasePrimaryVariables: use FieldVector's FieldTraits implementation) |
| 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 |
| CGeneralPreconditionerMaker | Interface class ensuring make function is overriden |
| CIsNumber< Opm::MatrixBlock< T, n, m > > | |
| CMatrixDimension< Opm::MatrixBlock< Scalar, n, m > > | |
| CMPITraits<::Opm::ReservoirCoupling::Potentials > | |
| CMultithreadDILU | The OpenMP thread parallelized DILU preconditioner |
| COwningBlockPreconditioner | |
| COwningTwoLevelPreconditioner | A version of the two-level preconditioner that is: |
| CPreconditionerMaker | Struct implementing a make function which creates a preconditioner Can create arbitrary preconditioners using parameter packs as template arguments |
| CPreconditionerWithUpdate | Interface class adding the update() method to the preconditioner interface |
| 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 |
| 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 |
| CRocmMatrix | This struct resembles a csr matrix |
| CRocmVector | |
| 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 |
| CrocsparsePreconditioner | |
| CrocsparseSolverBackend | This class implements a rocsparse-based ilu0-bicgstab solver on GPU |
| NDamarisOutput | Below are the Damaris Keywords supported by Damaris to be filled in the built-in XML file |
| CDamarisSettings | |
| CDamarisVar | Class to store a Damaris variable representation for the XML file (can be used with class DamarisKeywords) |
| CDamarisVarXMLAttributes | This class contains the extra elements that need to be part of a Damaris <variable> type |
| Ndetail | |
| Calignment_of | |
| 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 |
| 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 |
| CFlexibleSolverInfo | |
| CGpuSolverInfo | |
| CInterpData | Helper struct for linear interpolation |
| Cis_alignment_constant | |
| Cmax_align | |
| Cmax_count_of | |
| Cmin_size | |
| CNoReorderer | |
| Coffset_object | |
| CParallelFileMerger | A functor that merges multiple files of a parallel run to one file |
| CRealReorderer | |
| CReorderer | |
| CVFPEvaluation | An "ADB-like" structure with a single value and a set of derivatives |
| Ndetails | |
| CDomainInfo | Struct holding information about domains used for printing a summary |
| NEQUIL | Types and routines that collectively implement a basic ECLIPSE-style equilibration-based initialisation scheme |
| 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 |
| 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: |
| 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 |
| 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_communication | The has_communication class checks if the type has the member function getCommunication |
| Chas_should_call_post | The has_should_call_post class detects the presence of the method shouldCallPost |
| Chas_should_call_pre | The has_should_call_pre class detects the presence of the method shouldCallPre |
| 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 |
| 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 |
| CGpuSparseMatrixGeneric | The GpuSparseMatrixGeneric class uses cuSPARSE Generic API for sparse matrix operations |
| CGpuSparseMatrixWrapper | The GpuSparseMatrixWrapper Checks CUDA/HIP version and dispatches a version either using the old or the generic CUDA API |
| CGpuVector | |
| 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 |
| CHypreDeviceDataArrays | GPU device memory arrays for HYPRE operations with GPU backend |
| CHypreError | Exception class for Hypre errors |
| CHypreHostDataArrays | Host arrays for HYPRE matrix and vector data transfers |
| Cis_gpu_type | Type trait to detect if a type is a GPU type |
| Cis_gpu_type< GpuSparseMatrixGeneric< T > > | |
| Cis_gpu_type< GpuSparseMatrixWrapper< T > > | |
| Cis_gpu_type< GpuVector< T > > | |
| CISTLSolverGPUISTL | ISTL solver for GPU using the GPU ISTL backend |
| COpmGpuILU0 | ILU0 preconditioner on the GPU |
| CParallelInfo | Parallel domain decomposition information for HYPRE-Dune interface |
| CPinnedMemoryHolder | RAII class for pinning host memory using cudaHostRegister |
| 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 |
| 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 |
| CSparsityPattern | Compressed Sparse Row (CSR) sparsity pattern for HYPRE matrix assembly |
| CValueAsPointer | A value stored with a pointer interface |
| NGridDataOutput | |
| CSimMeshDataAccessor | |
| NKeywordValidation | |
| CUnsupportedKeywordProperties | |
| CSupportedKeywordProperties | |
| CValidationError | |
| CSupportedKeywords | |
| CKeywordValidator | |
| Callow_values | |
| Cis_bool_convertible | |
| 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 | |
| CBorderIndex | A single index intersecting with the process boundary |
| 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 |
| CIndexDistanceNpeers | This structure stores an index, a process rank, and the number of processes which "see" the degree of freedom with the index |
| CIndexRank | This structure stores an index and a process rank |
| CIndexRankDist | This structure stores an index, a process rank, and the distance of the degree of freedom to the process border |
| CIstlSparseMatrixAdapter | A sparse matrix interface backend for BCRSMatrix from dune-istl |
| 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 |
| 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 |
| CPeerIndexGlobalIndex | This structure stores a local index on a peer process and a global index |
| CPeerSet | A set of process ranks |
| CPreconditionerWrapperILU | |
| CResidReductionCriterion | Provides a convergence criterion which looks at the reduction of the two-norm of the residual for the linear solvers |
| CSeedList | The list of indices which are on the process boundary |
| CSolverReport | Collects summary information about the execution of the linear solver |
| CSolverWrapperRestartedGMRes | Solver wrapper for the restarted GMRES solver of dune-istl |
| 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 |
| 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 |
| Nmswellhelpers | |
| CParallellMSWellB | A wrapper around the B matrix for distributed MS wells |
| NOpm | |
| CBlackOilOnePhaseIndices | The primary variable and equation indices for the black-oil model |
| 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 |
| 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 |
| NParameters | |
| Ndetail | |
| Chas_name | |
| Chas_name< T, std::void_t< decltype(std::declval< T >().name)> > | |
| CAcceleratorMode | |
| CActionParsingStrictness | |
| CAddCorners | |
| CAllowDistributedWells | |
| CAllowSplittingInactiveWells | |
| CAlternativeWellRateInit | |
| CAmgCoarsenTarget | The target number of DOFs per processor for the parallel algebraic multi-grid solver |
| CCellsX | Grid resolution |
| CCellsY | |
| CCellsZ | |
| CCheckGroupConstraintsInnerWellIterations | |
| CCheckSatfuncConsistency | |
| 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 |
| CConvergenceMonitoring | |
| CConvergenceMonitoringCutOff | |
| CConvergenceMonitoringDecayFactor | |
| CCprReuseInterval | |
| CCprReuseSetup | |
| CCprWeightsThreadParallel | |
| CDamarisDaskFile | |
| CDamarisDedicatedCores | |
| CDamarisDedicatedNodes | |
| CDamarisLimitVariables | |
| CDamarisLogLevel | |
| CDamarisOutputHdfCollective | |
| CDamarisPythonParaviewScript | |
| CDamarisPythonScript | |
| CDamarisSaveMeshToHdf | |
| CDamarisSaveToHdf | |
| CDamarisSharedMemoryName | |
| CDamarisSharedMemorySizeBytes | |
| CDamarisSimName | |
| CDbhpMaxRel | |
| CDebugEmitCellPartition | |
| CDomainSizeX | Domain size |
| CDomainSizeY | |
| CDomainSizeZ | |
| CDpMaxRel | |
| CDsMax | |
| CDwellFractionMax | |
| CEclDeckFileName | |
| CEclOutputDoublePrecision | |
| CEclOutputInterval | |
| CEdgeConformal | |
| CEdgeWeightsMethod | |
| CEnableAdaptiveTimeStepping | |
| CEnableAsyncEclOutput | |
| CEnableAsyncVtkOutput | Determines if the VTK output is written to disk asynchronously |
| CEnableDamarisOutput | |
| CEnableDriftCompensation | |
| CEnableDryRun | |
| CEnableEclOutput | |
| CEnableEsmry | |
| CEnableGravity | Returns whether gravity is considered in the problem |
| CEnableGridAdaptation | Switch to enable or disable grid adaptation |
| CEnableIntensiveQuantityCache | Specify whether all intensive quantities for the grid should be cached in the discretization |
| CEnableOpmRstFile | |
| CEnableStorageCache | Specify whether the storage terms for previous solutions should be cached |
| CEnableTerminalOutput | |
| CEnableThermodynamicHints | Specify whether to use the already calculated solutions as starting values of the intensive quantities |
| CEnableTuning | |
| CEnableVtkOutput | Global switch to enable or disable the writing of VTK output files |
| CEnableWellOperabilityCheck | |
| CEnableWellOperabilityCheckIter | |
| CEnableWriteAllSolutions | |
| CEndTime | The default value for the simulation's end time |
| CExplicitRockCompaction | |
| CExternalPartition | |
| CFlashTolerance | The maximum accepted error of the flash solver Let the flash solver choose its tolerance by default |
| CFlashTwoPhaseMethod | Two-phase flash method |
| CFlashVerbosity | The verbosity level of the flash solver |
| CForceDisableFluidInPlaceOutput | |
| CForceDisableResvFluidInPlaceOutput | |
| CFullTimeStepInitially | |
| CGMResRestart | Number of iterations between solver restarts for the GMRES solver |
| CGpuAwareMpi | |
| CGpuDeviceId | |
| CGridFile | Name of the grid file |
| CGridGlobalRefinements | Property which tells the Vanguard how often the grid should be refined after creation |
| CHyNeConfigFile | |
| CIgnoreKeywords | |
| CIluFillinLevel | |
| CIluRedblack | |
| CIluRelaxation | |
| CIluReorderSpheres | |
| CImbalanceTol | |
| CInitialTimeStepInDays | |
| CInitialTimeStepSize | The default value for the simulation's initial time step size |
| CInjMultDampMult | |
| CInjMultMinDampFactor | |
| CInjMultOscThreshold | |
| CInputSkipMode | |
| CLinearSolver | |
| CLinearSolverAbsTolerance | Maximum accepted error of the norm of the residual |
| CLinearSolverAccelerator | For the CLI options |
| CLinearSolverIgnoreConvergenceFailure | |
| CLinearSolverMaxError | |
| CLinearSolverMaxIter | |
| CLinearSolverMaxIterations | Maximum number of iterations eyecuted by the linear solver |
| CLinearSolverOverlapSize | The size of the algebraic overlap of the linear solver |
| CLinearSolverPrintJsonDefinition | |
| CLinearSolverReduction | |
| CLinearSolverRestart | |
| CLinearSolverTolerance | Maximum accepted error of the solution of the linear solver |
| CLinearSolverVerbosity | Specifies the verbosity of the linear solver |
| CLoadFile | |
| CLoadStep | |
| CLocalDomainsOrderingMeasure | |
| CLocalDomainsPartitioningImbalance | |
| CLocalDomainsPartitioningMethod | |
| CLocalDomainsPartitionWellNeighborLevels | |
| CLocalSolveApproach | |
| CLocalToleranceScalingCnv | |
| CLocalToleranceScalingMb | |
| CLocalWellSolveControlSwitching | |
| CMatrixAddWellContributions | |
| CMaximumNumberOfGroupSwitches | |
| CMaximumNumberOfWellSwitches | |
| CMaximumWaterSaturation | |
| CMaxInnerIterMsWells | |
| CMaxInnerIterWells | |
| CMaxLocalSolveIterations | |
| CMaxNewtonIterationsWithInnerWellIterations | |
| CMaxPressureChangeMsWells | |
| CMaxResidualAllowed | |
| CMaxSinglePrecisionDays | |
| CMaxTemperatureChange | |
| CMaxTimeStepDivisions | The maximum allowed number of timestep divisions for the Newton solver |
| CMaxTimeStepSize | Specify the maximum size of a time integration [s] |
| CMaxWelleqIter | |
| CMaxWellStatusSwitchForWells | |
| CMaxWellStatusSwitchInInnerIterWells | |
| CMetisParams | |
| CMiluVariant | |
| CMinStrictCnvIter | |
| CMinStrictMbIter | |
| CMinTimeStepBasedOnNewtonIterations | |
| CMinTimeStepBeforeShuttingProblematicWellsInDays | |
| CMinTimeStepSize | Specify the minimal size of a time integration [s] |
| CNetworkMaxOuterIterations | |
| CNetworkMaxPressureUpdateInBars | |
| CNetworkMaxStrictOuterIterations | |
| CNetworkMaxSubIterations | |
| CNetworkPressureUpdateDampingFactor | |
| 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 |
| CNewtonMaxRelax | |
| CNewtonMinIterations | |
| CNewtonRelaxationType | |
| 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 |
| CNlddLocalLinearSolver | |
| CNlddLocalLinearSolverMaxIter | |
| CNlddLocalLinearSolverReduction | |
| CNlddNumInitialNewtonIter | |
| CNlddRelativeMobilityChangeTol | |
| CNonlinearSolver | |
| CNumericDifferenceMethod | Specify which kind of method should be used to numerically calculate the partial derivatives of the residual |
| CNumLocalDomains | |
| CNumOverlap | |
| CNumPressurePointsEquil | |
| CNumSatfuncConsistencySamplePoints | |
| CNupcolGroupRateTolerance | |
| COpenclIluParallel | |
| COpenclPlatformId | |
| COutputDir | The directory to which simulation output ought to be written to |
| COutputExtraConvergenceInfo | |
| COutputMode | |
| COwnerCellsFirst | |
| CParameter | A struct holding the key-value pair for a parameter |
| CParameterFile | Set a value for the ParameterFile property |
| CParsingStrictness | |
| 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 |
| CPreconditionerOrder | The order of the sequential preconditioner |
| CPreconditionerRelaxation | The relaxation factor of the preconditioner |
| CPredeterminedTimeStepsFile | By default, do not force any time steps |
| CPreSolveNetwork | |
| CPressureMax | |
| CPressureMin | |
| CPressureScale | |
| CPrintParameters | Print all parameters on startup? |
| CPriVarOscilationThreshold | |
| CProjectSaturations | |
| CPvsVerbosity | The verbosity of the model (0 -> do not print anything, 2 -> spam stdout a lot) |
| CRegularizationFactorWells | |
| CRelaxedLinearSolverReduction | |
| CRelaxedMaxPvFraction | |
| CRelaxedPressureTolMsw | |
| CRelaxedWellFlowTol | |
| CRestartTime | The default value for the simulation's restart time |
| CRestartWritingInterval | |
| CSaveFile | |
| CSaveStep | |
| CScaleLinearSystem | |
| CSchedRestart | |
| CSeparateSparseSourceTerms | |
| CSerialPartitioning | |
| CShutUnsolvableWells | |
| CSlave | |
| CSolverContinueOnConvergenceFailure | |
| CSolverGrowthFactor | |
| CSolverMaxGrowth | |
| CSolverMaxRestarts | |
| CSolverMaxTimeStepInDays | |
| CSolverMinTimeStep | |
| CSolverRestartFactor | |
| CSolverVerbosity | |
| CSolveWelleqInitially | |
| CStrictInnerIterWells | |
| CStrictOuterIterWells | |
| CTemperatureMax | |
| CTemperatureMin | |
| CThreadsPerProcess | Number of threads per process |
| CTimeStepAfterEventInDays | |
| CTimeStepControl | |
| CTimeStepControlDecayDampingFactor | |
| CTimeStepControlDecayRate | |
| CTimeStepControlFileName | |
| CTimeStepControlGrowthDampingFactor | |
| CTimeStepControlGrowthRate | |
| CTimeStepControlMaxReductionTimeStep | |
| CTimeStepControlParameters | |
| CTimeStepControlRejectCompletedStep | |
| CTimeStepControlSafetyFactor | |
| CTimeStepControlTargetIterations | |
| CTimeStepControlTargetNewtonIterations | |
| CTimeStepControlTolerance | |
| CTimeStepControlToleranceTestVersion | |
| CTimeStepVerbosity | |
| CToleranceCnv | |
| CToleranceCnvEnergy | |
| CToleranceCnvEnergyRelaxed | |
| CToleranceCnvRelaxed | |
| CToleranceEnergyBalance | |
| CToleranceEnergyBalanceRelaxed | |
| CToleranceMb | |
| CToleranceMbRelaxed | |
| CTolerancePressureMsWells | |
| CToleranceWellControl | |
| CToleranceWells | |
| CUpdateEquationsScaling | |
| CUseAverageDensityMsWells | |
| CUseGmres | |
| CUseHyNe | |
| CUseImplicitIpr | |
| CUseMultisegmentWell | |
| CUseUpdateStabilization | |
| CVerifyGpuAwareMpi | |
| CVtkWriteAverageMolarMasses | |
| CVtkWriteBiofilmVolumeFraction | |
| CVtkWriteCalciteVolumeFraction | |
| CVtkWriteDensities | |
| CVtkWriteDiffusionCoefficients | |
| CVtkWriteDofIndex | |
| CVtkWriteEffectiveDiffusionCoefficients | |
| CVtkWriteEnthalpies | |
| CVtkWriteEquilibriumConstants | |
| CVtkWriteExtrusionFactor | |
| CVtkWriteFilterVelocities | |
| CVtkWriteFluidEnthalpies | |
| CVtkWriteFluidInternalEnergies | |
| CVtkWriteFractureFilterVelocities | |
| CVtkWriteFractureIntrinsicPermeabilities | |
| CVtkWriteFractureMobilities | |
| CVtkWriteFracturePorosity | |
| CVtkWriteFractureRelativePermeabilities | |
| CVtkWriteFractureSaturations | |
| CVtkWriteFractureVolumeFraction | |
| CVtkWriteFugacities | |
| CVtkWriteFugacityCoeffs | |
| CVtkWriteGasDissolutionFactor | |
| CVtkWriteGasFormationVolumeFactor | |
| CVtkWriteGasSaturationPressure | |
| CVtkWriteInternalEnergies | |
| CVtkWriteIntrinsicPermeabilities | |
| CVtkWriteLiquidMoleFractions | |
| CVtkWriteMassFractions | |
| CVtkWriteMicrobialConcentration | |
| CVtkWriteMobilities | |
| CVtkWriteMolarities | |
| CVtkWriteMoleFractions | |
| CVtkWriteOilFormationVolumeFactor | |
| CVtkWriteOilSaturationPressure | |
| CVtkWriteOilVaporizationFactor | |
| CVtkWriteOxygenConcentration | |
| CVtkWritePhasePresence | |
| CVtkWritePolymerAdsorption | |
| CVtkWritePolymerConcentration | |
| CVtkWritePolymerDeadPoreVolume | |
| CVtkWritePolymerRockDensity | |
| CVtkWritePolymerViscosityCorrection | |
| CVtkWritePorosity | |
| CVtkWritePotentialGradients | |
| CVtkWritePressures | |
| CVtkWritePrimaryVars | |
| CVtkWritePrimaryVarsMeaning | |
| CVtkWriteProcessRank | |
| CVtkWriteRelativePermeabilities | |
| CVtkWriteRockInternalEnergy | |
| CVtkWriteSaturatedGasOilVaporizationFactor | |
| CVtkWriteSaturatedOilGasDissolutionFactor | |
| CVtkWriteSaturationRatios | |
| CVtkWriteSaturations | |
| CVtkWriteSolidInternalEnergy | |
| CVtkWriteSolventDensity | |
| CVtkWriteSolventMobility | |
| CVtkWriteSolventRsw | |
| CVtkWriteSolventSaturation | |
| CVtkWriteSolventViscosity | |
| CVtkWriteTemperature | |
| CVtkWriteThermalConductivity | |
| CVtkWriteTortuosities | |
| CVtkWriteTotalMassFractions | |
| CVtkWriteTotalMoleFractions | |
| CVtkWriteTotalThermalConductivity | |
| CVtkWriteTracerConcentration | |
| CVtkWriteUreaConcentration | |
| CVtkWriteViscosities | |
| CVtkWriteWaterFormationVolumeFactor | |
| CVtkWriteWaterViscosityCorrection | |
| CWaterOnlyThreshold | |
| CWellGroupConstraintsMaxIterations | |
| CZoltanImbalanceTol | |
| CZoltanParams | |
| CZoltanPhgEdgeSizeThreshold | |
| NProperties | |
| 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 | |
| NTag | |
| CAuxModule | |
| NTTag | The generic type tag for problems using the immiscible multi-phase model |
| CAluGridVanguard | |
| CAutoDiffLocalLinearizer | |
| CBlackOilModel | The type tag for the black-oil problems |
| CCpGridVanguard | |
| CDiscreteFractureModel | The generic type tag for problems using the immiscible multi-phase model |
| CEcfvDiscretization | |
| CFiniteDifferenceLocalLinearizer | |
| CFlashModel | The type tag for the isothermal single phase problems |
| CFlowBaseProblem | |
| CFlowBaseProblemBlackoil | |
| CFlowBaseProblemComp | |
| CFlowBaseVanguard | |
| CFlowEarlyBird | |
| CFlowGasWaterProblem | Specialized type tag for gas-water simulations |
| CFlowIstlSolver | |
| CFlowIstlSolverParams | |
| CFlowOnePhaseProblem | Specialized type tag for one phase (water) simulations |
| CFlowProblem | |
| CFlowProblemTPFA | Specialised type tag for simulations that can use the customised assembly process for TPFA discretisation schemes |
| CFvBaseDiscretization | The type tag for models based on the finite volume schemes |
| CFvBaseNewtonMethod | |
| 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 |
| CImplicitModel | Type tag for all fully coupled models |
| CMultiPhaseBaseModel | |
| 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 |
| CNumericModel | Type tag for all models |
| CParallelAmgLinearSolver | |
| CParallelBaseLinearSolver | |
| CParallelBiCGStabLinearSolver | |
| CParallelIstlLinearSolver | |
| CPolyhedralGridVanguard | |
| CPvsModel | The type tag for the isothermal single phase problems |
| CRichards | The type tag for problems discretized using the Richards model |
| CStructuredGridVanguard | |
| CVcfvDiscretization | |
| CVtkBlackOilPolymer | |
| CAquiferModel | |
| CAquiferModel< TypeTag, TTag::FlowBaseProblem > | |
| CAquiferModel< TypeTag, TTag::FlowProblem > | |
| CAvoidElementContext | |
| CAvoidElementContext< TypeTag, TTag::FlowBaseProblem > | |
| CBaseDiscretizationType | |
| CBaseDiscretizationType< TypeTag, TTag::FlowBaseProblem > | |
| CBaseDiscretizationType< TypeTag, TTag::FvBaseDiscretization > | |
| CBaseEpsilon | |
| CBaseEpsilon< TypeTag, TTag::FiniteDifferenceLocalLinearizer > | The base epsilon value for finite difference calculations |
| CBaseLinearizer | Linearizes the global non-linear system of equations |
| CBaseProblem | The type of the base class for all problems which use this model |
| CBaseProblem< TypeTag, TTag::BlackOilModel > | The Problem property |
| CBaseProblem< TypeTag, TTag::DiscreteFractureModel > | The class for the model |
| CBaseProblem< TypeTag, TTag::MultiPhaseBaseModel > | The type of the base base class for actual problems |
| CBaseProblem< TypeTag, TTag::NcpModel > | The type of the base base class for actual problems |
| CBlackoilConserveSurfaceVolume | Enable surface volume scaling |
| CBlackoilConserveSurfaceVolume< TypeTag, TTag::BlackOilModel > | |
| CBlackoilConserveSurfaceVolume< TypeTag, TTag::FlowProblem > | |
| CBlackOilEnergyScalingFactor | The relative weight of the residual of the energy equation compared to the mass residuals |
| 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 | Similarly to the energy equation, a scaling is applied to the urea equation in MICP |
| CBlackOilUreaScalingFactor< TypeTag, TTag::BlackOilModel > | Similarly to the energy equation, the urea equation in MICP is scaled by a factor of 0.1 |
| CBorderListCreator | The class which marks the border indices associated with the degrees of freedom on a process boundary |
| CBorderListCreator< TypeTag, TTag::EcfvDiscretization > | Set the border list creator for to the one of an element based method |
| CBorderListCreator< TypeTag, TTag::FvBaseDiscretization > | Marks the border indices (required for the algebraic overlap stuff) |
| CBorderListCreator< TypeTag, TTag::VcfvDiscretization > | Set the border list creator for vertices |
| CBoundaryContext | The secondary variables of a boundary segment |
| CBoundaryContext< TypeTag, TTag::FvBaseDiscretization > | |
| CBoundaryRateVector | Type of object for specifying boundary conditions |
| CBoundaryRateVector< TypeTag, TTag::BlackOilModel > | BoundaryRateVector property |
| CBoundaryRateVector< TypeTag, TTag::FlashModel > | BoundaryRateVector property |
| CBoundaryRateVector< TypeTag, TTag::FvBaseDiscretization > | Type of object for specifying boundary conditions |
| CBoundaryRateVector< TypeTag, TTag::ImmiscibleModel > | BoundaryRateVector property |
| CBoundaryRateVector< TypeTag, TTag::NcpModel > | BoundaryRateVector property |
| CBoundaryRateVector< TypeTag, TTag::PvsModel > | BoundaryRateVector property |
| CBoundaryRateVector< TypeTag, TTag::Richards > | BoundaryRateVector property |
| CConstraints | The class which represents a constraint degree of freedom |
| CConstraints< TypeTag, TTag::FvBaseDiscretization > | The class which represents constraints |
| CConstraintsContext | The secondary variables of a constraint degree of freedom |
| CConstraintsContext< TypeTag, TTag::FvBaseDiscretization > | |
| CConvergenceWriter | Specifies whether the convergence rate and the global residual gets written out to disk for every Newton iteration |
| CDiscBaseIntensiveQuantities | The part of the intensive quantities which is specific to the spatial discretization |
| CDiscBaseOutputModule | The part of the VTK ouput modules which is specific to the spatial discretization |
| CDiscBaseOutputModule< TypeTag, TTag::EcfvDiscretization > | The base class for the output modules (decides whether to write element or vertex based fields) |
| CDiscBaseOutputModule< TypeTag, TTag::VcfvDiscretization > | The base class for the output modules (decides whether to write element or vertex based fields) |
| CDiscExtensiveQuantities | The part of the extensive quantities which is specific to the spatial discretization |
| CDiscExtensiveQuantities< TypeTag, TTag::FvBaseDiscretization > | |
| CDiscIntensiveQuantities | The discretization specific part of the intensive quantities |
| CDiscIntensiveQuantities< TypeTag, TTag::FvBaseDiscretization > | |
| CDiscLocalResidual | The discretization specific part of the local residual |
| CDiscLocalResidual< TypeTag, TTag::FvBaseDiscretization > | |
| CDiscNewtonMethod | The discretization specific part of he implementing the Newton algorithm |
| CDiscNewtonMethod< TypeTag, TTag::FvBaseNewtonMethod > | |
| CDiscreteFunction | |
| CDiscreteFunction< TypeTag, TTag::FlowBaseProblem > | |
| CDiscreteFunction< TypeTag, TTag::FvBaseDiscretization > | |
| CDiscreteFunctionSpace | The class describing the discrete function space when dune-fem is used, otherwise it points to the stencil class |
| CDiscreteFunctionSpace< TypeTag, TTag::EcfvDiscretization > | |
| CDiscreteFunctionSpace< TypeTag, TTag::VcfvDiscretization > | |
| CDiscretization | The type of the spatial discretization used by the model |
| CDiscretization< TypeTag, TTag::EcfvDiscretization > | The concrete class which manages the spatial discretization |
| CDiscretization< TypeTag, TTag::VcfvDiscretization > | The concrete class which manages the spatial discretization |
| CDofMapper | The mapper to find the global index of a degree of freedom |
| CDofMapper< TypeTag, TTag::EcfvDiscretization > | Mapper for the degrees of freedoms |
| CDofMapper< TypeTag, TTag::VcfvDiscretization > | Mapper for the degrees of freedoms |
| CDummySpaceEcfv | |
| CDummySpaceVcfv | |
| CElementContext | The secondary variables of all degrees of freedom in an element's stencil |
| CElementContext< TypeTag, TTag::FvBaseDiscretization > | The element context |
| CElementEqVector | A vector of holding a quantity for each equation for each DOF of an element |
| CElementEqVector< TypeTag, TTag::FvBaseDiscretization > | The type for storing a residual for an element |
| CElementMapper | The mapper to find the global index of an element |
| CElementMapper< TypeTag, TTag::FvBaseDiscretization > | Mapper for the grid view's elements |
| CEnableApiTracking | |
| CEnableApiTracking< TypeTag, TTag::FlowBaseProblem > | |
| CEnableBioeffects | Enable the ECL-blackoil extension for bioeffects (biofilm/MICP) |
| CEnableBioeffects< TypeTag, TTag::BlackOilModel > | |
| CEnableBioeffects< TypeTag, TTag::FlowBaseProblem > | |
| CEnableBioeffects< TypeTag, TTag::FlowProblem > | |
| CEnableBrine | Enable the ECL-blackoil extension for salt |
| CEnableBrine< TypeTag, TTag::BlackOilModel > | |
| CEnableBrine< TypeTag, TTag::FlowProblem > | |
| CEnableConstraints | Specify whether the some degrees of fredom can be constraint |
| CEnableConstraints< TypeTag, TTag::FvBaseDiscretization > | |
| CEnableConvectiveMixing | Enable convective mixing? |
| CEnableConvectiveMixing< TypeTag, TTag::BlackOilModel > | |
| CEnableConvectiveMixing< TypeTag, TTag::FlowBaseProblem > | |
| CEnableConvectiveMixing< TypeTag, TTag::FlowProblem > | |
| CEnableDebuggingChecks | |
| CEnableDebuggingChecks< TypeTag, TTag::FlowBaseProblem > | |
| CEnableDebuggingChecks< TypeTag, TTag::FlowProblem > | |
| CEnableDiffusion | Enable diffusive fluxes? |
| CEnableDiffusion< TypeTag, TTag::BlackOilModel > | Disable diffusion by default |
| CEnableDiffusion< TypeTag, TTag::FlashModel > | |
| CEnableDiffusion< TypeTag, TTag::FlowBaseProblem > | |
| CEnableDiffusion< TypeTag, TTag::FlowBaseProblemComp > | |
| CEnableDiffusion< TypeTag, TTag::NcpModel > | Disable diffusion by default |
| CEnableDiffusion< TypeTag, TTag::PvsModel > | |
| CEnableDisgasInWater | Enable the ECL-blackoil extension for disolution of gas into water |
| CEnableDisgasInWater< TypeTag, TTag::BlackOilModel > | |
| CEnableDispersion | Enable dispersive fluxes? |
| CEnableDispersion< TypeTag, TTag::BlackOilModel > | Disable dispersion by default |
| CEnableDispersion< TypeTag, TTag::FlowBaseProblem > | |
| CEnableDispersion< TypeTag, TTag::FlowProblem > | |
| CEnableEclipseOutput | Specifies if the simulation should write output files that are compatible with those produced by the commercial Eclipse simulator |
| CEnableEndpointScaling | |
| CEnableEndpointScaling< TypeTag, TTag::FlowBaseProblem > | |
| CEnableEnergy | Specify whether energy should be considered as a conservation quantity or not |
| CEnableEnergy< TypeTag, TTag::BlackOilModel > | |
| CEnableEnergy< TypeTag, TTag::FlashModel > | Disable the energy equation by default |
| CEnableEnergy< TypeTag, TTag::FlowBaseProblem > | |
| CEnableEnergy< TypeTag, TTag::FlowProblem > | |
| CEnableEnergy< TypeTag, TTag::ImmiscibleModel > | Disable the energy equation by default |
| CEnableEnergy< TypeTag, TTag::NcpModel > | Disable the energy equation by default |
| CEnableEnergy< TypeTag, TTag::PvsModel > | Disable the energy equation by default |
| CEnableExperiments | Specify if experimental features should be enabled or not |
| CEnableExperiments< TypeTag, TTag::FlowBaseProblem > | |
| CEnableExperiments< TypeTag, TTag::FvBaseDiscretization > | EWoms is mainly targeted at research, so experimental features are enabled by default |
| CEnableExtbo | Enable the ECL-blackoil extension for extended BO. ("Second gas" - alternative approach) |
| CEnableExtbo< TypeTag, TTag::BlackOilModel > | |
| CEnableExtbo< TypeTag, TTag::FlowBaseProblem > | |
| CEnableFoam | Enable the ECL-blackoil extension for foam |
| CEnableFoam< TypeTag, TTag::BlackOilModel > | |
| CEnableFoam< TypeTag, TTag::FlowBaseProblem > | |
| CEnableFoam< TypeTag, TTag::FlowProblem > | |
| CEnableHysteresis | |
| CEnableHysteresis< TypeTag, TTag::FlowBaseProblem > | |
| CEnableMech | |
| CEnableMech< TypeTag, TTag::FlowBaseProblem > | |
| CEnablePolymer | Enable the ECL-blackoil extension for polymer |
| CEnablePolymer< TypeTag, TTag::BlackOilModel > | |
| CEnablePolymer< TypeTag, TTag::FlowBaseProblem > | |
| CEnablePolymer< TypeTag, TTag::FlowProblem > | |
| CEnablePolymerMW | Enable the tracking polymer molecular weight tracking and related functionalities |
| CEnablePolymerMW< TypeTag, TTag::BlackOilModel > | |
| CEnableSaltPrecipitation | Enable the ECL-blackoil extension for salt precipitation |
| CEnableSaltPrecipitation< TypeTag, TTag::BlackOilModel > | |
| CEnableSaltPrecipitation< TypeTag, TTag::FlowProblem > | |
| CEnableSolvent | Enable the ECL-blackoil extension for solvents. ("Second gas") |
| CEnableSolvent< TypeTag, TTag::BlackOilModel > | |
| CEnableSolvent< TypeTag, TTag::FlowBaseProblem > | |
| CEnableSolvent< TypeTag, TTag::FlowProblem > | |
| CEnableTemperature | Allow the spatial and temporal domains to exhibit non-constant temperature in the black-oil model |
| CEnableTemperature< TypeTag, TTag::BlackOilModel > | By default, the blackoil model is isothermal and does not conserve energy |
| CEnableTemperature< TypeTag, TTag::FlowBaseProblem > | |
| CEnableTemperature< TypeTag, TTag::FlowProblem > | |
| CEnableThermalFluxBoundaries | |
| CEnableThermalFluxBoundaries< TypeTag, TTag::FlowBaseProblem > | |
| CEnableTracerModel | |
| CEnableVapwat | Enable the ECL-blackoil extension for water evaporation |
| CEnableVapwat< TypeTag, TTag::BlackOilModel > | |
| CEnableWater | Enable water? |
| CEnableWater< TypeTag, TTag::MultiPhaseBaseModel > | |
| CEquilGrid | |
| CEquilGrid< TypeTag, TTag::AluGridVanguard > | |
| CEquilGrid< TypeTag, TTag::CpGridVanguard > | |
| CEquilGrid< TypeTag, TTag::PolyhedralGridVanguard > | |
| CEqVector | A vector of holding a quantity for each equation (usually at a given spatial location) |
| CEqVector< TypeTag, TTag::FvBaseDiscretization > | A vector of quanties, each for one equation |
| CEvaluation | Representation of a function evaluation and all necessary derivatives with regard to the intensive quantities of the primary variables |
| CEvaluation< TypeTag, TTag::AutoDiffLocalLinearizer > | Set the function evaluation w.r.t. the primary variables |
| CEvaluation< TypeTag, TTag::FiniteDifferenceLocalLinearizer > | |
| CExtensiveQuantities | Data required to calculate a flux over a face |
| CExtensiveQuantities< TypeTag, TTag::BlackOilModel > | ExtensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::DiscreteFractureModel > | ExtensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::FlashModel > | ExtensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::ImmiscibleModel > | ExtensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::NcpModel > | ExtensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::PvsModel > | ExtensiveQuantities property |
| CExtensiveQuantities< TypeTag, TTag::Richards > | The class for the quantities required for the flux calculation |
| CExtensiveStorageTerm | Specify whether the storage terms use extensive quantities or not |
| 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 |
| CFlashSolver | The type of the flash constraint solver |
| CFlashSolver< TypeTag, TTag::FlashModel > | Use the NCP flash solver by default |
| CFluid | The fluid used by the model |
| CFluid< TypeTag, TTag::ImmiscibleSinglePhaseModel > | |
| CFluidSystem | The fluid systems including the information about the phases |
| CFluidSystem< TypeTag, TTag::BlackOilModel > | Set the fluid system to the black-oil fluid system by default |
| CFluidSystem< TypeTag, TTag::ImmiscibleSinglePhaseModel > | The fluid system to use by default |
| CFluidSystem< TypeTag, TTag::ImmiscibleTwoPhaseModel > | |
| CFluidSystem< TypeTag, TTag::Richards > | The fluid system used by the model |
| CFluxModule | Specifies the relation used for velocity |
| 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) |
| CFluxModule< TypeTag, TTag::FlowBaseProblemBlackoil > | |
| CFluxModule< TypeTag, TTag::MultiPhaseBaseModel > | By default, use the Darcy relation to determine the phase velocity |
| CGasComponentIndex | Index of the component which constitutes the gas |
| CGasComponentIndex< TypeTag, TTag::Richards > | By default, assume that the gas component is the other than the liquid one |
| CGasPhaseIndex | Index of the fluid which represents the non-wetting phase |
| CGasPhaseIndex< TypeTag, TTag::Richards > | By default, assume that the non-liquid phase is gaseos |
| CGlobalEqVector | Vector containing a quantity of for equation for each DOF of the whole grid |
| CGlobalEqVector< TypeTag, TTag::FvBaseDiscretization > | The type for storing a residual for the whole grid |
| CGradientCalculator | Calculates gradients of arbitrary quantities at flux integration points |
| CGradientCalculator< TypeTag, TTag::FlowBaseProblemBlackoil > | |
| CGradientCalculator< TypeTag, TTag::FvBaseDiscretization > | Calculates the gradient of any quantity given the index of a flux approximation point |
| CGradientCalculator< TypeTag, TTag::VcfvDiscretization > | Calculates the gradient of any quantity given the index of a flux approximation point |
| CGrid | The type of the DUNE grid |
| CGrid< TypeTag, TTag::AluGridVanguard > | |
| CGrid< TypeTag, TTag::CpGridVanguard > | |
| CGrid< TypeTag, TTag::PolyhedralGridVanguard > | |
| CGrid< TypeTag, TTag::StructuredGridVanguard > | |
| CGridCommHandleFactory | The class to create grid communication handles |
| CGridCommHandleFactory< TypeTag, TTag::EcfvDiscretization > | The class to create grid communication handles |
| CGridCommHandleFactory< TypeTag, TTag::VcfvDiscretization > | The class to create grid communication handles |
| CGridView | |
| CGridView< TypeTag, TTag::FlowBaseProblem > | |
| CGridView< TypeTag, TTag::NumericModel > | Use the leaf grid view by default |
| CGridViewLevel | Level of the grid view |
| CIndices | Enumerations used by the model |
| CIndices< TypeTag, TTag::BlackOilModel > | The indices required by the model |
| CIndices< TypeTag, TTag::FlashModel > | The indices required by the flash-baseed isothermal compositional model |
| CIndices< TypeTag, TTag::ImmiscibleModel > | The indices required by the isothermal immiscible multi-phase model |
| CIndices< TypeTag, TTag::NcpModel > | The indices required by the compositional NCP model |
| CIndices< TypeTag, TTag::PvsModel > | The indices required by the isothermal PVS model |
| CIndices< TypeTag, TTag::Richards > | The class with all index definitions for the model |
| CIntensiveQuantities | The secondary variables within a sub-control volume |
| CIntensiveQuantities< TypeTag, TTag::BlackOilModel > | IntensiveQuantities property |
| CIntensiveQuantities< TypeTag, TTag::DiscreteFractureModel > | IntensiveQuantities property |
| CIntensiveQuantities< TypeTag, TTag::FlashModel > | IntensiveQuantities property |
| CIntensiveQuantities< TypeTag, TTag::FvBaseDiscretization > | The class representing intensive quantities |
| CIntensiveQuantities< TypeTag, TTag::ImmiscibleModel > | IntensiveQuantities property |
| CIntensiveQuantities< TypeTag, TTag::NcpModel > | IntensiveQuantities property |
| CIntensiveQuantities< TypeTag, TTag::PvsModel > | IntensiveQuantities property |
| CIntensiveQuantities< TypeTag, TTag::Richards > | The class for the intensive quantities |
| CLinearizeNonLocalElements | Specify if elements that do not belong to the local process' grid partition should be skipped |
| 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 |
| 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 |
| CLinearizer | The class which linearizes the non-linear system of equations |
| CLinearizer< TypeTag, TTag::FvBaseDiscretization > | Linearizer for the global system of equations |
| CLinearSolverBackend | The type of the linear solver to be used |
| CLinearSolverBackend< TypeTag, TTag::FlowIstlSolverParams > | |
| CLinearSolverBackend< TypeTag, TTag::ParallelAmgLinearSolver > | |
| CLinearSolverBackend< TypeTag, TTag::ParallelBiCGStabLinearSolver > | |
| CLinearSolverBackend< TypeTag, TTag::ParallelIstlLinearSolver > | |
| CLinearSolverScalar | The floating point type used internally by the linear solver |
| CLinearSolverScalar< TypeTag, TTag::ParallelBaseLinearSolver > | By default use the same kind of floating point values for the linearization and for the linear solve |
| CLinearSolverSplice | |
| CLinearSolverSplice< TypeTag, TTag::FlowProblem > | |
| CLinearSolverSplice< TypeTag, TTag::FvBaseDiscretization > | Use a parallel BiCGStab linear solver by default |
| CLinearSolverWrapper | |
| CLinearSolverWrapper< TypeTag, TTag::ParallelIstlLinearSolver > | |
| CLiquidComponentIndex | Index of the component which constitutes the liquid |
| CLiquidComponentIndex< TypeTag, TTag::Richards > | By default, assume that component which the liquid is made of has the same index as the liquid phase |
| CLiquidPhaseIndex | Index of the fluid which represents the wetting phase |
| CLiquidPhaseIndex< TypeTag, TTag::Richards > | By default, assume that the first phase is the liquid one |
| CLocalLinearizer | The type of the local linearizer |
| CLocalLinearizer< TypeTag, TTag::AutoDiffLocalLinearizer > | |
| CLocalLinearizer< TypeTag, TTag::FiniteDifferenceLocalLinearizer > | |
| CLocalLinearizerSplice | |
| CLocalLinearizerSplice< TypeTag, TTag::FlowBaseProblem > | |
| CLocalLinearizerSplice< TypeTag, TTag::FvBaseDiscretization > | By default, use finite differences to linearize the system of PDEs |
| CLocalResidual | The type of the local residual function |
| CLocalResidual< TypeTag, TTag::BlackOilModel > | Set the local residual function |
| CLocalResidual< TypeTag, TTag::DiscreteFractureModel > | Use the immiscible multi-phase local jacobian operator for the immiscible multi-phase model |
| CLocalResidual< TypeTag, TTag::FlashModel > | Use the FlashLocalResidual function for the flash model |
| CLocalResidual< TypeTag, TTag::ImmiscibleModel > | Use the immiscible multi-phase local jacobian operator for the immiscible multi-phase model |
| CLocalResidual< TypeTag, TTag::NcpModel > | Use the Ncp local jacobian operator for the compositional NCP model |
| CLocalResidual< TypeTag, TTag::PvsModel > | Use the PVS local jacobian operator for the PVS model |
| CLocalResidual< TypeTag, TTag::Richards > | The local residual operator |
| CMaterialLaw | The material law which ought to be used (extracted from the spatial parameters) |
| CMaterialLaw< TypeTag, TTag::FlowBaseProblem > | |
| CMaterialLaw< TypeTag, TTag::FlowBaseProblemComp > | |
| CMaterialLaw< TypeTag, TTag::MultiPhaseBaseModel > | Set the material law to the null law by default |
| CMaterialLawParams | The context material law (extracted from the spatial parameters) |
| CMaterialLawParams< TypeTag, TTag::MultiPhaseBaseModel > | Set the property for the material parameters by extracting it from the material law |
| CModel | The type of the model |
| CModel< TypeTag, TTag::BlackOilModel > | The Model property |
| CModel< TypeTag, TTag::DiscreteFractureModel > | The class for the model |
| CModel< TypeTag, TTag::FlashModel > | Model property |
| CModel< TypeTag, TTag::FlowBaseProblemBlackoil > | |
| CModel< TypeTag, TTag::ImmiscibleModel > | Model property |
| CModel< TypeTag, TTag::NcpModel > | Model property |
| CModel< TypeTag, TTag::PvsModel > | Model property |
| CModel< TypeTag, TTag::Richards > | The global model used |
| CModelParameterGroup | Property which defines the group that is queried for parameters by default |
| CModelParameterGroup< TypeTag, TTag::NumericModel > | Use the global group as default for the model's parameter group |
| CNcpCompositionFromFugacitiesSolver | The themodynamic constraint solver which calculates the composition of any phase given all component fugacities |
| CNcpFugacitiesBaseWeight | The unmodified weight for the fugacity primary variables |
| CNcpFugacitiesBaseWeight< TypeTag, TTag::NcpModel > | The unmodified weight for the fugacity primary variables |
| CNcpPressureBaseWeight | The unmodified weight for the pressure primary variable |
| CNcpPressureBaseWeight< TypeTag, TTag::NcpModel > | The unmodified weight for the pressure primary variable |
| CNcpSaturationsBaseWeight | The weight for the saturation primary variables |
| CNcpSaturationsBaseWeight< TypeTag, TTag::NcpModel > | The weight for the saturation primary variables |
| CNewtonConvergenceWriter | Specifies the type of the class which writes out the Newton convergence |
| CNewtonConvergenceWriter< TypeTag, TTag::FvBaseNewtonMethod > | |
| CNewtonConvergenceWriter< TypeTag, TTag::NewtonMethod > | |
| CNewtonMethod | Specifies the type of the actual Newton method |
| CNewtonMethod< TypeTag, TTag::BlackOilModel > | Use the black-oil specific newton method |
| CNewtonMethod< TypeTag, TTag::FlashModel > | Use the PT flash specific newton method for the flash model |
| CNewtonMethod< TypeTag, TTag::FvBaseNewtonMethod > | |
| CNewtonMethod< TypeTag, TTag::NcpModel > | Use the Ncp specific newton method for the compositional NCP model |
| CNewtonMethod< TypeTag, TTag::NewtonMethod > | |
| CNewtonMethod< TypeTag, TTag::PvsModel > | Use the PVS specific newton method for the PVS model |
| CNewtonMethod< TypeTag, TTag::Richards > | The class of the Newton method |
| CNonlinearSystem | |
| CNonlinearSystem< TypeTag, TTag::FlowBaseProblemBlackoil > | |
| CNonWettingFluid | The fluid used as the non-wetting phase (by default, we set the fluid system to the immiscible one, which requires this property.) |
| CNonWettingFluid< TypeTag, TTag::Richards > | The non-wetting phase used |
| CNonwettingPhase | The non-wetting phase for two-phase models |
| CNonwettingPhase< TypeTag, TTag::ImmiscibleTwoPhaseModel > | |
| CNumComponents | Number of chemical species in the system |
| CNumComponents< TypeTag, TTag::MultiPhaseBaseModel > | Number of chemical species in the system |
| CNumEq | Number of equations in the system of PDEs |
| CNumEq< TypeTag, TTag::MultiPhaseBaseModel > | Set the number of equations to the number of phases |
| CNumPhases | Number of fluid phases in the system |
| CNumPhases< TypeTag, TTag::MultiPhaseBaseModel > | The number of phases is determined by the fluid system |
| COverlap | |
| COverlap< TypeTag, TTag::ParallelBaseLinearSolver > | |
| COverlappingLinearOperator | |
| COverlappingLinearOperator< TypeTag, TTag::ParallelBaseLinearSolver > | |
| COverlappingMatrix | |
| COverlappingMatrix< TypeTag, TTag::ParallelBaseLinearSolver > | |
| COverlappingScalarProduct | |
| COverlappingScalarProduct< TypeTag, TTag::ParallelBaseLinearSolver > | |
| COverlappingVector | |
| COverlappingVector< TypeTag, TTag::ParallelBaseLinearSolver > | |
| CParameterTree | Property which provides a Dune::ParameterTree |
| CParameterTree< TypeTag, TTag::NumericModel > | Set the ParameterTree property |
| CPreconditionerWrapper | Preconditioner used by the linear solver |
| CPreconditionerWrapper< TypeTag, TTag::ParallelBaseLinearSolver > | |
| CPreconditionerWrapper< TypeTag, TTag::ParallelIstlLinearSolver > | |
| CPrimaryVariables | A vector of primary variables within a sub-control volume |
| CPrimaryVariables< TypeTag, TTag::BlackOilModel > | PrimaryVariables property |
| CPrimaryVariables< TypeTag, TTag::DiscreteFractureModel > | PrimaryVariables property |
| CPrimaryVariables< TypeTag, TTag::FlashModel > | PrimaryVariables property |
| CPrimaryVariables< TypeTag, TTag::FvBaseDiscretization > | An object representing a local set of primary variables |
| CPrimaryVariables< TypeTag, TTag::ImmiscibleModel > | PrimaryVariables property |
| CPrimaryVariables< TypeTag, TTag::NcpModel > | PrimaryVariables property |
| CPrimaryVariables< TypeTag, TTag::PvsModel > | PrimaryVariables property |
| CPrimaryVariables< TypeTag, TTag::Richards > | PrimaryVariables property |
| CProblem | The type of the problem |
| CProblem< TypeTag, TTag::FlowBaseProblemBlackoil > | |
| CProblem< TypeTag, TTag::FlowBaseProblemComp > | |
| CPvsMoleFractionsBaseWeight | The basis value for the weight of the mole fraction 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 |
| CPvsPressureBaseWeight< TypeTag, TTag::PvsModel > | The basis value for the weight of the pressure primary variable |
| CPvsSaturationsBaseWeight | The basis value for the weight of the saturation primary variables |
| CPvsSaturationsBaseWeight< TypeTag, TTag::PvsModel > | The basis value for the weight of the saturation primary variables |
| CRateVector | Vector containing volumetric or areal rates of quantities |
| CRateVector< TypeTag, TTag::BlackOilModel > | RateVector property |
| CRateVector< TypeTag, TTag::FlashModel > | RateVector property |
| CRateVector< TypeTag, TTag::FvBaseDiscretization > | A vector for mass/energy rates |
| CRateVector< TypeTag, TTag::ImmiscibleModel > | RateVector property |
| CRateVector< TypeTag, TTag::NcpModel > | RateVector property |
| CRateVector< TypeTag, TTag::PvsModel > | RateVector property |
| CRateVector< TypeTag, TTag::Richards > | RateVector property |
| CScalar | Property to specify the type of scalar values |
| CScalar< TypeTag, TTag::NumericModel > | Set the default type of scalar values to double |
| CSimulator | Manages the simulation time |
| CSimulator< TypeTag, TTag::FvBaseDiscretization > | Set the default type for the time manager |
| CSimulator< TypeTag, TTag::NumericModel > | |
| CSolidEnergyLaw | The material law for the energy stored in the solid matrix |
| CSolidEnergyLaw< TypeTag, TTag::FlowBaseProblem > | |
| CSolidEnergyLaw< TypeTag, TTag::MultiPhaseBaseModel > | Set the energy storage law for the solid to the one which assumes zero heat capacity by default |
| CSolidEnergyLawParams | The parameters of the material law for energy storage of the solid |
| CSolidEnergyLawParams< TypeTag, TTag::MultiPhaseBaseModel > | Extract the type of the parameter objects for the solid energy storage law from the law itself |
| CSolutionVector | Vector containing all primary variables of the grid |
| CSolutionVector< TypeTag, TTag::FvBaseDiscretization > | The type of a solution for the whole grid at a fixed time |
| CSparseMatrixAdapter | The class that allows to manipulate sparse matrices |
| CSparseMatrixAdapter< TypeTag, TTag::FlowIstlSolver > | Set the type of a global jacobian matrix for linear solvers that are based on dune-istl |
| CSparseMatrixAdapter< TypeTag, TTag::ParallelBaseLinearSolver > | Set the type of a global jacobian matrix for linear solvers that are based on dune-istl |
| CSpatialDiscretizationSplice | The splice to be used for the spatial discretization |
| CSpatialDiscretizationSplice< TypeTag, TTag::FlowBaseProblem > | |
| CSpatialDiscretizationSplice< TypeTag, TTag::MultiPhaseBaseModel > | Set the default spatial discretization |
| CSplices | |
| CSplices< TypeTag, TTag::FvBaseDiscretization > | Set the splices for the finite volume discretizations |
| CSplices< TypeTag, TTag::MultiPhaseBaseModel > | Specify the splices of the MultiPhaseBaseModel type tag |
| CStencil | The class describing the stencil of the spatial discretization |
| CStencil< TypeTag, TTag::EcfvDiscretization > | Set the stencil |
| CStencil< TypeTag, TTag::FlowBaseProblem > | |
| CStencil< TypeTag, TTag::VcfvDiscretization > | Set the stencil |
| CThermalConductionLaw | The material law for thermal conduction |
| CThermalConductionLaw< TypeTag, TTag::FlowBaseProblem > | |
| CThermalConductionLaw< TypeTag, TTag::MultiPhaseBaseModel > | Set the thermal conduction law to a dummy one by default |
| CThermalConductionLawParams | The parameters of the material law for thermal conduction |
| CThermalConductionLawParams< TypeTag, TTag::MultiPhaseBaseModel > | Extract the type of the parameter objects for the thermal conduction law from the law itself |
| CThreadManager | The OpenMP threads manager |
| CThreadManager< TypeTag, TTag::FvBaseDiscretization > | The OpenMP threads manager |
| CTimeDiscHistorySize | The history size required by the time discretization |
| CTimeDiscHistorySize< TypeTag, TTag::FvBaseDiscretization > | Set the history size of the time discretization to 2 (for implicit euler) |
| CTracerModel | |
| CTracerModel< TypeTag, TTag::FlowBaseProblem > | |
| CTracerModel< TypeTag, TTag::FlowBaseProblemComp > | |
| CUndefinedProperty | Tag to mark properties as undefined |
| CUseLinearizationLock | Use locking to prevent race conditions when linearizing the global system of equations in multi-threaded mode |
| 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 |
| CUseLinearizationLock< TypeTag, TTag::FvBaseDiscretization > | |
| CUseP1FiniteElementGradients | Use P1 finite-elements gradients instead of two-point gradients |
| CUseP1FiniteElementGradients< TypeTag, TTag::VcfvDiscretization > | Use two-point gradients by default for the vertex centered finite volume scheme |
| CUseTwoPointGradients | |
| CUseTwoPointGradients< TypeTag, TTag::DiscreteFractureModel > | For the discrete fracture model, we need to use two-point flux approximation or it will converge very poorly |
| CUseVolumetricResidual | Specify whether to use volumetric residuals or not |
| CUseVolumetricResidual< TypeTag, TTag::FlowProblem > | |
| CUseVolumetricResidual< TypeTag, TTag::FvBaseDiscretization > | |
| CVanguard | Property which provides a Vanguard (manages grids) |
| CVanguard< TypeTag, TTag::AluGridVanguard > | |
| CVanguard< TypeTag, TTag::CpGridVanguard > | |
| CVanguard< TypeTag, TTag::NumericModel > | |
| CVanguard< TypeTag, TTag::PolyhedralGridVanguard > | |
| CVanguard< TypeTag, TTag::StructuredGridVanguard > | |
| CVertexMapper | The mapper to find the global index of a vertex |
| CVertexMapper< TypeTag, TTag::FvBaseDiscretization > | Mapper for the grid view's vertices |
| CVtkOutputFormat | Specify the format the VTK output is written to disk |
| CVtkOutputFormat< TypeTag, TTag::FvBaseDiscretization > | Set the format of the VTK output to ASCII by default |
| CWellModel | |
| CWellModel< TypeTag, TTag::FlowProblem > | |
| CWettingFluid | The fluid used as the wetting phase (by default, we set the fluid system to the immiscible one, which requires this property.) |
| CWettingFluid< TypeTag, TTag::Richards > | The wetting phase used |
| CWettingPhase | The wetting phase for two-phase models |
| CWettingPhase< TypeTag, TTag::ImmiscibleTwoPhaseModel > | |
| NPybind | |
| CPyBaseSimulator | |
| CPyBlackOilSimulator | |
| CPyFluidState | |
| CPyGasWaterSimulator | |
| CPyMaterialState | |
| CPyOnePhaseSimulator | |
| 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 |
| NReservoirCoupling | |
| CLogger | |
| CPotentials | |
| CSeconds | Utility class for comparing double values representing epoch dates or elapsed time |
| 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 |
| 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 |
| 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 |
| NSerialization | |
| Ndetail | |
| CPacking< false, boost::gregorian::date > | |
| Nwellhelpers | |
| CParallelStandardWellB | A wrapper around the B matrix for distributed wells |
| NWGHelpers | |
| CFractionCalculator | |
| CInjectionTargetCalculator | Based on a group control mode, extract or calculate rates, and provide other conveniences |
| CTargetCalculator | Based on a group control mode, extract or calculate rates, and provide other conveniences |
| CAbstractISTLSolver | Abstract interface for ISTL solvers |
| CActionHandler | Class handling Action support in simulator |
| CAdaptiveSimulatorTimer | Simulation timer for adaptive time stepping |
| CAdaptiveTimeStepping | |
| Caligned_allocator | |
| Crebind | |
| Caligned_allocator< void, Alignment > | |
| Crebind | |
| CALQState | |
| CAluGridVanguard | Helper class for grid instantiation of ECL file-format using problems |
| CAMGHelper | |
| CAMGSmootherArgsHelper | |
| CAMGSmootherArgsHelper< ParallelOverlappingILU0< M, V, V, C > > | |
| CAquiferAnalytical | |
| CAquiferCarterTracy | |
| CAquiferConstantFlux | |
| CAquiferFetkovich | |
| CAquiferInterface | |
| CAquiferNumerical | |
| CBaseAquiferModel | The base class which specifies the API of aquifer models |
| CBaseAuxiliaryModule | Base class for specifying auxiliary equations |
| 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 |
| CBioeffectsContainer | |
| CBioeffectsSolutionContainer | Struct holding MICP extension data |
| CBlackoilAquiferModel | Class for handling the blackoil aquifer model |
| CBlackOilBioeffectsExtensiveQuantities | Provides the bioeffects specific extensive quantities to the generic black-oil module's extensive quantities |
| CBlackOilBioeffectsExtensiveQuantities< TypeTag, false > | |
| CBlackOilBioeffectsIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the bioeffects extension of the black-oil model |
| CBlackOilBioeffectsIntensiveQuantities< TypeTag, false > | |
| CBlackOilBioeffectsModule | Contains the high level supplements required to extend the black oil model by bioeffects |
| CBlackOilBioeffectsParams | Struct holding the parameters for the BlackOilBioeffectsModule class |
| CBlackOilBoundaryRateVector | Implements a boundary vector for the fully implicit black-oil model |
| CBlackOilBrineIntensiveQuantities | |
| CBlackOilBrineIntensiveQuantities< TypeTag, false > | |
| CBlackOilBrineIntensiveQuantities< TypeTag, true > | |
| CBlackOilBrineModule | Contains the high level supplements required to extend the black oil model by brine |
| CBlackOilBrineParams | Struct holding the parameters for the BlackoilBrineModule class |
| CBlackOilConvectiveMixingIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the convective mixing (DRSDTCON) model |
| CBlackOilConvectiveMixingIntensiveQuantities< TypeTag, false > | |
| CBlackOilConvectiveMixingIntensiveQuantities< TypeTag, true > | |
| CBlackOilConvectiveMixingModule | |
| CBlackOilConvectiveMixingModule< TypeTag, false > | |
| CConvectiveMixingModuleParam | |
| CBlackOilConvectiveMixingModule< TypeTag, true > | |
| CConvectiveMixingModuleParam | |
| CBlackOilDarcyExtensiveQuantities | Specifies the extensive quantities for the black-oil model if using Darcy relation |
| CBlackOilDarcyFluxModule | Provides a Darcy flux module for the blackoil model |
| CBlackOilDiffusionExtensiveQuantities | Provides the quantities required to calculate diffusive mass 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. |
| 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. |
| CBlackOilDiffusionModule | Provides the auxiliary methods required for consideration of the diffusion equation |
| 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. |
| CBlackOilDispersionExtensiveQuantities | Provides the quantities required to calculate dispersive mass fluxes |
| CBlackOilDispersionExtensiveQuantities< TypeTag, false > | |
| CBlackOilDispersionExtensiveQuantities< TypeTag, true > | Provides the quantities required to calculate dispersive mass fluxes. |
| CBlackOilDispersionIntensiveQuantities | Provides the volumetric quantities required for the calculation of dispersive fluxes |
| CBlackOilDispersionIntensiveQuantities< TypeTag, false > | |
| CBlackOilDispersionIntensiveQuantities< TypeTag, true > | |
| CBlackOilDispersionModule | Provides the auxiliary methods required for consideration of the dispersion equation |
| 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. |
| CBlackOilEnergyExtensiveQuantities | Provides the energy specific extensive quantities to the generic black-oil module's extensive quantities |
| CBlackOilEnergyExtensiveQuantities< TypeTag, false > | |
| CBlackOilEnergyExtensiveQuantities< TypeTag, true > | |
| CBlackOilEnergyIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the energys extension of the black-oil model |
| CBlackOilEnergyIntensiveQuantities< TypeTag, false > | |
| CBlackOilEnergyIntensiveQuantities< TypeTag, true > | |
| CBlackOilEnergyModule | Contains the high level supplements required to extend the black oil model by energy |
| CBlackOilExtboExtensiveQuantities | Provides the solvent specific extensive quantities to the generic black-oil module's extensive quantities |
| CBlackOilExtboExtensiveQuantities< TypeTag, false > | |
| CBlackOilExtboIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the solvents extension of the black-oil model |
| CBlackOilExtboIntensiveQuantities< TypeTag, false > | |
| CBlackOilExtboIntensiveQuantities< TypeTag, true > | |
| CBlackOilExtboModule | Contains the high level supplements required to extend the black oil model |
| 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 |
| CBlackOilFoamIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the polymers extension of the black-oil model |
| CBlackOilFoamIntensiveQuantities< TypeTag, false > | |
| CBlackOilFoamIntensiveQuantities< TypeTag, true > | |
| CBlackOilFoamModule | Contains the high level supplements required to extend the black oil model to include the effects of foam |
| CBlackOilFoamParams | Struct holding the parameters for the BlackoilFoamModule class |
| CFoamCoefficients | |
| CBlackOilHybridNewton | Hybrid Newton solver extension for the black-oil model |
| CFeatureFlags | |
| 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 |
| 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 |
| 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 |
| CBlackOilPolymerExtensiveQuantities | Provides the polymer specific extensive quantities to the generic black-oil module's extensive quantities |
| CBlackOilPolymerExtensiveQuantities< TypeTag, false > | |
| CBlackOilPolymerExtensiveQuantities< TypeTag, true > | |
| CBlackOilPolymerIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the polymers extension of the black-oil model |
| CBlackOilPolymerIntensiveQuantities< TypeTag, false > | |
| CBlackOilPolymerIntensiveQuantities< TypeTag, true > | |
| CBlackOilPolymerModule | Contains the high level supplements required to extend the black oil model by polymer |
| 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 |
| CBlackOilSolventExtensiveQuantities | Provides the solvent specific extensive quantities to the generic black-oil module's extensive quantities |
| CBlackOilSolventExtensiveQuantities< TypeTag, false > | |
| CBlackOilSolventIntensiveQuantities | Provides the volumetric quantities required for the equations needed by the solvents extension of the black-oil model |
| CBlackOilSolventIntensiveQuantities< TypeTag, false > | |
| CBlackOilSolventIntensiveQuantities< TypeTag, true > | |
| CBlackOilSolventModule | Contains the high level supplements required to extend the black oil model by solvents |
| 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 |
| CBlackoilWellModel | Class for handling the blackoil well model |
| CBlackoilWellModelConstraints | Class for handling constraints for the blackoil well model |
| CBlackoilWellModelGasLift | Class for handling the gaslift in the blackoil well model |
| CBlackoilWellModelGasLiftGeneric | |
| CBlackoilWellModelGeneric | Class for handling the blackoil well model |
| CBlackoilWellModelGuideRates | Class for handling the guide rates in the blackoil well model |
| CBlackoilWellModelNldd | Class for handling the blackoil well model in a NLDD solver |
| CBlackoilWellModelNlddGeneric | |
| CBlackoilWellModelRestart | Class for restarting the blackoil well model |
| CBlackoilWellModelWBP | Class for handling the blackoil well model |
| CBoundaryPressureCallback | Callback class for a phase pressure |
| CCheckDistributedWellConnections | Class checking that all connections are on active cells |
| CCollectDataOnIORank | |
| CCommunicateAboveBelow | Class to facilitate getting values associated with the above/below perforation |
| CComponentName | |
| CCompositionalContainer | |
| CConnectionIndexMap | Connection index mappings |
| CConnFiltrateData | |
| CConnFracStatistics | Collection of fracturing statistics measures at the connection level |
| 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 |
| CConvergenceOutputThread | Encapsulating object for thread processing producer's convergence output requests |
| CImpl | |
| 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 | |
| CConvergenceReportQueue | Communication channel between thread creating output requests and consumer thread writing those requests to a file |
| COutputRequest | Single output request |
| CCopyGatherScatter | |
| CCopyRestrictProlong | |
| CCopyRestrictProlongTraits | |
| CCpGridVanguard | Helper class for grid instantiation of ECL file-format using problems |
| CCubeGridVanguard | Provides a simulator vanguad which creates a regular grid made of quadrilaterals |
| CDamarisWriter | Collects necessary output values and pass them to Damaris server processes |
| CDarcyBaseProblem | Provides the defaults for the parameters required by the Darcy velocity approach |
| CDarcyExtensiveQuantities | Provides the Darcy flux module |
| CDarcyFluxModule | Specifies a flux module which uses the Darcy relation |
| CDarcyIntensiveQuantities | Provides the intensive quantities for the Darcy flux module |
| CDeferredLogger | |
| CMessage | |
| CDensityCallback | Callback class for the density of a phase |
| CDgfVanguard | Provides a simulator vanguard which creates a grid by parsing a Dune Grid Format (DGF) file |
| 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. |
| 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. |
| 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. |
| CDirectionalMobility | |
| 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 |
| CDistributeIndexMapping | |
| CDomainWellModelAsLinearOperator | |
| CDummyGradientCalculator | This is a "dummy" gradient calculator which does not do anything |
| CEcfvBaseOutputModule | Implements the discretization specific parts of writing files |
| CEcfvDiscretization | The base class for the element-centered finite-volume discretization scheme |
| 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 |
| CEclEpsScalingPointsInfo | |
| CEclGenericWriter | |
| CEclWriter | Collects necessary output values and pass it to opm-common's ECL output |
| CElementIndexHandle | Communication handle to scatter the global index |
| CElementIndexScatterHandle | Communication handle to scatter the global index |
| CEmptyRestrictProlong | |
| CEmptyRestrictProlongTraits | |
| 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. |
| 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. |
| 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. |
| CEquilInitializer | Computes the initial condition based on the EQUIL keyword from ECL |
| CExtboContainer | |
| CFeatureSpec | Metadata for a single feature (input or output) |
| CFIBlackOilModel | |
| CFIPContainer | |
| CCo2InGasInput | |
| 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 |
| CFlashNewtonMethod | A Newton solver specific to the PTFlash model |
| CFlashPrimaryVariables | Represents the primary variables used by the compositional flow model based on flash calculations |
| CFlashRateVector | Implements a vector representing rates of conserved quantities. |
| CFlowAluGridVanguard | |
| CFlowBaseVanguard | Helper class for grid instantiation of ECL file-format using problems |
| CFlowGenericProblem | This problem simulates an input file given in the data format used by the commercial ECLiPSE simulator |
| CRockParams | |
| CFlowGenericVanguard | |
| CSimulationModelParams | |
| CFlowLinearSolverParameters | This class carries all parameters for the NewtonIterationBlackoilInterleaved class |
| 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 |
| CForchheimerBaseProblem | Provides the defaults for the parameters required by the Forchheimer velocity approach |
| CForchheimerExtensiveQuantities | Provides the Forchheimer flux module |
| CForchheimerFluxModule | Specifies a flux module which uses the Forchheimer relation |
| CForchheimerIntensiveQuantities | Provides the intensive quantities for the Forchheimer module |
| CFractureMapper | Stores the topology of fractures |
| CFunctionRunnerTasklet | A simple tasklet that runs a function that returns void and does not take any arguments a given number of times |
| 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 |
| CFvBaseDiscretization | The base class for the finite volume discretization schemes |
| CBlockVectorWrapper | |
| CFvBaseDiscretizationFemAdapt | The base class for the finite volume discretization schemes |
| CSerializeHelper | |
| CFvBaseDiscretizationNoAdapt | The base class for the finite volume discretization schemes without adaptation |
| 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 |
| 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 |
| CGasLiftCommon | |
| CGasLiftGroupInfo | |
| CGroupRates | |
| CGasLiftSingleWell | |
| CGasLiftSingleWellGeneric | |
| CGradInfo | |
| CBasicRates | |
| CLimitedRates | |
| COptimizeState | |
| CGasLiftStage2 | |
| COptimizeState | |
| CSurplusState | |
| CGasLiftWellState | |
| CGeneral3rdOrderController | General 3rd order controller |
| CGenericCpGridVanguard | |
| CGenericGuard | A simple class which makes sure that a cleanup function is called once the object is destroyed |
| CGenericOutputBlackoilModule | |
| CGenericThresholdPressure | |
| CGenericTracerModel | |
| CGhostLastMatrixAdapter | Dune linear operator that assumes ghost rows are ordered after interior rows |
| CGlobalCellIndex | |
| CGlobalPerfContainerFactory | A factory for creating a global data representation for distributed wells |
| CGlobalWellInfo | |
| CGpuBridge | GpuBridge acts as interface between opm-simulators with the GpuSolvers |
| 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 |
| 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 |
| CGridCommHandleSum | Data handle for parallel communication which sums up all values are attached to DOFs |
| CGroupEconomicLimitsChecker | |
| CGroupState | |
| CGroupPotential | |
| 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 |
| CHardcodedTimeStepControl | HardcodedTimeStepControl Input generated from summary file using the ert application: |
| CHDF5File | Class handling simple output to HDF5 |
| CHDF5Serializer | Class for (de-)serializing using HDF5 |
| CHipKernels | |
| CHybridNewtonConfig | Configuration for a Hybrid Newton ML model |
| 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 |
| CInterRegFlowMap | Inter-region flow accumulation maps for all region definition arrays |
| CSingleRegion | Minimal representation of a single named region defintion |
| 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 |
| Cis_gpu_matrix | Check if a given operator is a GPU matrix |
| Cis_gpu_operator | Check if a given operator is a GPU operator |
| CIsNumericalAquiferCell | |
| CIsNumericalAquiferCell< Dune::CpGrid > | |
| 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 |
| 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 |
| CISTLSolverRuntimeOptionProxy | ISTLSolverRuntimeOptionProxy selects the appropriate ISTLSolver runtime based on CLI options |
| CLevelCartesianIndexMapper | |
| CLevelCartesianIndexMapper< Dune::ALUGrid< 3, 3, Dune::cube, Dune::nonconforming > > | |
| CLinearizationType | |
| CLinearOperatorExtra | Linear operator wrapper for well model |
| CLogOutputHelper | |
| CLookUpCartesianData | |
| CLookUpCellCentroid | |
| CLookUpData | |
| CMain | |
| CMatrixBlock | |
| CMechContainer | |
| CMixingRateControls | Class handling mixing rate controls for a FlowProblemBlackoil |
| CMolarDensityCallback | Callback class for the molar density of a phase |
| CMoleFractionCallback | Callback class for a mole fraction of a component in a phase |
| CMpiBuffer | Simplifies handling of buffers to be used in conjunction with MPI |
| CMSWellTracerRate | |
| 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 |
| CMultisegmentWell | |
| CMultisegmentWellAssemble | Class handling assemble of the equation system for MultisegmentWell |
| 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 |
| CMultisegmentWellEquationAccess | Class administering assembler access to equation system |
| CMultisegmentWellEquations | |
| CMultisegmentWellEval | |
| CMultisegmentWellGeneric | |
| CMultisegmentWellPrimaryVariables | |
| CMultisegmentWellSegments | |
| 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 |
| CNewTranBaseProblem | Provides the defaults for the parameters required by the transmissibility based volume flux calculation |
| CNewTranExtensiveQuantities | Provides the ECL flux module |
| CNewTranFluxModule | Specifies a flux module which uses ECL transmissibilities |
| CNewTranIntensiveQuantities | Provides the intensive quantities for the ECL flux module |
| CNonlinearSolver | A nonlinear solver class suitable for general fully-implicit models, as well as pressure, transport and sequential models |
| CNonlinearSolverParameters | |
| CNullConvergenceWriter | A convergence writer for the Newton method which does nothing |
| COpenclKernels | |
| 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 |
| CP1FeGradientCalculator | This class calculates gradients of arbitrary quantities at flux integration points using first order finite elements ansatz functions |
| CPackUnPackAquiferData | |
| CPackUnPackBlockData | |
| CPackUnPackCellData | |
| CPackUnpackFlows | |
| CPackUnPackGroupAndNetworkValues | |
| CPackUnpackInterRegFlows | |
| CPackUnPackWBPData | |
| CPackUnPackWellData | |
| CPackUnPackWellTestState | |
| CParallelEclipseState | Parallel frontend to the EclipseState |
| CParallelFieldPropsManager | Parallel frontend to the field properties |
| CParallelNLDDPartitioningZoltan | Partition connectivity graph into non-overlapping domains using the Zoltan graph partitioning software package |
| CParallelOverlappingILU0 | A two-step version of an overlapping Schwarz preconditioner using one step ILU0 as |
| CCRS | |
| CParallelOverlappingILU0Args | |
| CParallelPAvgCalculator | Facility for deriving well-level pressure values from selected block-averaging procedures |
| CParallelPAvgDynamicSourceData | Dynamic source data for block-average pressure calculations |
| CParallelRestrictedOverlappingSchwarz | Block parallel preconditioner |
| 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 |
| CParallelWellInfo | Class encapsulating some information about parallel wells |
| CPerfData | |
| CPerforationData | Static data associated with a well perforation |
| CPerforationRates | |
| CPffGridVector | A random-access container which stores data attached to a grid's degrees of freedom in a prefetch friendly manner |
| CPhaseUsageInfo | |
| CPIDAndIterationCountTimeStepControl | PID controller based adaptive time step control as above that also takes target iterations into account |
| CPIDTimeStepControl | PID controller based adaptive time step control as suggested in: Turek and Kuzmin |
| CPolyhedralGridVanguard | Helper class for grid instantiation of ECL file-format using problems |
| CPolymerSolutionContainer | Struct holding polymer extension data |
| CPreconditionerFactory | This is an object factory for creating preconditioners |
| CPressureBhpTransferPolicy | |
| CPressureCallback | Callback class for a phase pressure |
| CPressureTransferPolicy | |
| CPropertyTree | Hierarchical collection of key/value pairs |
| 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 |
| CPyMain | |
| CQuadrialteralQuadratureGeometry | Quadrature geometry for quadrilaterals |
| CRatioCalculator | |
| 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 |
| CRelativeChangeInterface | RelativeChangeInterface |
| CRelpermDiagnostics | This class is intend to be a relperm diagnostics, to detect wrong input of relperm table and endpoints |
| CReservoirCouplingMaster | |
| CReservoirCouplingSlave | |
| CReservoirCouplingSpawnSlaves | |
| CRestart | Load or save a state of a problem to/from the harddisk |
| CRFTContainer | Collection of cell-level RFT data–i.e., pressures and saturations–in cells intersected by wells |
| 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 |
| CRSTConv | Class computing RPTRST CONV output |
| 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 |
| CSatfuncConsistencyChecks | Platform for running sets of consistency checks against collection of saturation function end-points |
| CCheck | Call-back interface for an individual check |
| CScaler | Represents scaling information for a feature |
| CSegmentState | |
| CSerializableSim | Abstract interface for simulator serialization ops |
| CSimpleIterationCountTimeStepControl | A simple iteration count based adaptive time step control |
| CSimplexGridVanguard | Provides a simulator vanguard which a creates regular grid made of simplices |
| CSimulator | Manages the initializing and running of time dependent problems |
| CSimulatorConvergenceOutput | Class handling convergence history output for a simulator |
| CSimulatorFullyImplicitBlackoil | Simulator for the blackoil model |
| CSimulatorReport | |
| CSimulatorReportSingle | A struct for returning timing data from a simulator to its caller |
| CSimulatorSerializer | Class handling simulator serialization |
| CSimulatorTimer | |
| CSimulatorTimerInterface | Interface class for SimulatorTimer objects, to be improved |
| CSingleWellState | |
| CSparseTable | |
| CStandardPreconditioners | |
| 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 > > > | |
| CStandardPreconditioners< Operator, Dune::Amg::SequentialInformation, typename std::enable_if_t<!Opm::is_gpu_operator_v< Operator > > > | |
| CStandardWell | |
| CStandardWellAssemble | Class handling assemble of the equation system for StandardWell |
| CStandardWellConnections | |
| CProperties | |
| CPressurePropertyFunctions | |
| CDensityPropertyFunctions | |
| CStandardWellEquationAccess | Class administering assembler access to equation system |
| CStandardWellEquations | |
| CStandardWellEval | |
| CStandardWellPrimaryVariables | Class holding primary variables for StandardWell |
| CStepReport | |
| CStructuredGridVanguard | Helper class for grid instantiation of the lens problem |
| CSubDomain | Representing a part of a grid, in a way suitable for performing local solves |
| CSubDomainIndices | Representing a part of a grid, in a way suitable for performing local solves |
| CSupportsFaceTag | |
| CSupportsFaceTag< Dune::CpGrid > | |
| CTaskletInterface | The base class for tasklets |
| CTaskletRunner | Handles where a given tasklet is run |
| CTemperatureCallback | Callback class for temperature |
| CThreadedEntityIterator | Provides an STL-iterator like interface to iterate over the enties of a GridView in OpenMP threaded applications |
| CThreadManager | Simplifies multi-threaded capabilities |
| 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 |
| CTimeStepControlInterface | TimeStepControlInterface |
| CTpfaLinearizer | The common code for the linearizers of non-linear systems of equations |
| CTracerContainer | |
| CTracerModel | A class which handles tracers as specified in by ECL |
| CTracerBatch | |
| CTransBaseProblem | Provides the defaults for the parameters required by the transmissibility based volume flux calculation |
| CTransExtensiveQuantities | Provides the transmissibility based flux module |
| CTransFluxModule | Specifies a flux module which uses transmissibilities |
| CTransform | Represents a transformation applied to a feature |
| CTransIntensiveQuantities | Provides the intensive quantities for the transmissibility based flux module |
| CTransmissibility | |
| CFaceInfo | |
| CUnstructuredGridVanguard | Provides a simulator vanguard which creates a grid by parsing an unstructured grid file |
| 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 |
| CVectorVectorDataHandle | A data handle sending multiple data store in vectors attached to cells |
| 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 |
| 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 |
| CVFPProperties | A thin wrapper class that holds one VFPProdProperties and one VFPInjProperties object |
| CViscosityCallback | Callback class for the viscosity of a phase |
| 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 |
| CVtkTracerModule | VTK output module for the tracer model's parameters |
| CVtkVectorFunction | Provides a vector-valued function using Dune::FieldVectors as elements |
| CWellAssemble | |
| CWellBhpThpCalculator | Class for computing BHP limits |
| CWellConnectionAuxiliaryModule | |
| CWellConstraints | Class for computing well group constraints |
| CWellContainer | |
| 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 |
| CWellContributionsCuda | |
| CWellContributionsOCL | |
| CWellContributionsRocsparse | |
| 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 |
| CWellGroupHelpers | |
| CWellInterface | |
| CWellInterfaceFluidSystem | |
| CWellInterfaceGeneric | |
| COperabilityStatus | |
| CWellInterfaceIndices | |
| CWellModelAsLinearOperator | |
| CWellModelGhostLastMatrixAdapter | Adapter to combine a matrix and another linear operator into a combined linear operator |
| CWellModelMatrixAdapter | Adapter to combine a matrix and another linear operator into a combined linear operator |
| CWellProdIndexCalculator | Collect per-connection static information to enable calculating connection-level or well-level productivity index values when incorporating dynamic phase mobilities |
| CWellState | The state of a set of wells, tailored for use by the fully implicit blackoil simulator |
| CWellTest | Class for performing well tests |
| CWellTracerRate | |
| CWGState | |
| CZoltanPartitioningControl | Control parameters for on-rank subdomain partitioning using Zoltan library |
| 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.17.0