My Project
Loading...
Searching...
No Matches
Opm Namespace Reference

This class implements a small container which holds the transmissibility mulitpliers for all the faces in the grid. More...

Namespaces

namespace  cmp
 In the namespace cmp are implemented functions for approximate comparison of double values based on absolute and relative difference.
 
namespace  DifferentiateOutputTable
 Apply piecewise linear differentiation (i.e., compute slopes) on a set of dependent variables in a linearised output table.
 
namespace  prefix
 Conversion prefix for units.
 
namespace  RawConsts
 Consts used in the non semantic, raw parsing of the eclipse file.
 
namespace  unit
 Definition of various units.
 

Classes

class  Actdims
 
class  ActiveGridCells
 Simple class capturing active cells of a grid. More...
 
class  ActiveIndexByColumns
 Special purpose mapping facility to handle the output code's need to enumerate the active cells by columns (layer ID (K) cycling fastest, followed by J, followed by I) for aquifer connections. More...
 
class  Air
 A simple class implementing the fluid properties of air. More...
 
class  Aquancon
 
class  Aqudims
 
struct  AquiferCellProps
 
class  AquiferConfig
 
class  AquiferCT
 
class  AquiferDimensions
 
class  AquiferFlux
 
class  Aquifetp
 
class  AqutabTable
 
class  AutoICD
 
class  BaseFluidSystem
 The base class for all fluid systems. More...
 
class  BCConfig
 
class  BCProp
 
class  BlackOilDefaultIndexTraits
 The class which specifies the default phase and component indices for the black-oil fluid system. More...
 
class  BlackOilFluidState
 Implements a "tailor-made" fluid state class for the black-oil model. More...
 
class  BlackOilFluidSystem
 A fluid system which uses the black-oil model assumptions to calculate termodynamically meaningful quantities. More...
 
class  Box
 
class  BoxManager
 
class  Brine
 A class for the brine fluid properties. More...
 
class  BrineCO2FluidSystem
 A two-phase fluid system with water and CO2. More...
 
class  BrineCo2Pvt
 This class represents the Pressure-Volume-Temperature relations of the liquid phase for a CO2-Brine system. More...
 
class  BrineDensityTable
 
class  BrineDynamic
 A class for the brine fluid properties. More...
 
class  BrineH2Pvt
 This class represents the Pressure-Volume-Temperature relations of the liquid phase for a H2-Brine system. More...
 
class  BrooksCorey
 Implementation of the Brooks-Corey capillary pressure <-> saturation relation. More...
 
class  BrooksCoreyParams
 Specification of the material parameters for the Brooks-Corey constitutive relations. More...
 
class  C1
 Properties of pure molecular methane $C_1$. More...
 
class  C10
 Properties of pure molecular n-Decane $C_10$. More...
 
class  Carfin
 
class  CarfinManager
 
class  CO2
 A class for the CO2 fluid properties. More...
 
class  Co2BrineFluidSystem
 A two phase two component system with components co2 brine. More...
 
class  Co2GasPvt
 This class represents the Pressure-Volume-Temperature relations of the gas phase for CO2. More...
 
class  Co2StoreConfig
 
class  ColumnSchema
 
class  CompletedCells
 
class  Component
 Abstract base class of a pure chemical species. More...
 
class  CompositionalConfig
 
class  CompositionalFluidState
 Represents all relevant thermodynamic quantities of a multi-phase, multi-component fluid system assuming thermodynamic equilibrium. More...
 
class  CompositionalFluidState< Scalar, FluidSystem, false >
 
class  CompositionalFluidState< Scalar, FluidSystem, true >
 
class  CompositionFromFugacities
 Calculates the chemical equilibrium from the component fugacities in a phase. More...
 
class  ComputeFromReferencePhase
 Computes all quantities of a generic fluid state if a reference phase has been specified. More...
 
class  ConditionalStorage
 A simple class which only stores a given member attribute if a boolean condition is true. More...
 
class  ConditionalStorage< false, T >
 
class  Connection
 
class  ConstantCompressibilityBrinePvt
 This class represents the Pressure-Volume-Temperature relations of the gas phase without vaporized oil. More...
 
class  ConstantCompressibilityOilPvt
 This class represents the Pressure-Volume-Temperature relations of the oil phase without dissolved gas and constant compressibility/"viscosibility". More...
 
class  ConstantCompressibilityWaterPvt
 This class represents the Pressure-Volume-Temperature relations of the gas phase without vaporized oil. More...
 
class  Constants
 A central place for various physical constants occuring in some equations. More...
 
class  ConstantSolidHeatCapLaw
 Implements a solid energy storage law which assumes constant heat capacity. More...
 
class  ConstantSolidHeatCapLawParams
 The default implementation of a parameter object for the solid energy storage law which assumes constant heat capacity. More...
 
struct  ContinueOnError
 
class  CoordMapper
 
class  CounterLog
 Provides a simple sytem for log message which are found by the Parser/Deck/EclipseState classes during processing the deck. More...
 
class  DeadOilPvt
 This class represents the Pressure-Volume-Temperature relations of the oil phase without dissolved gas. More...
 
class  Deck
 
class  DeckItem
 
class  DeckKeyword
 
class  DeckOutput
 
class  DeckRecord
 
class  DeckSection
 
class  DeckTree
 
class  DeckValue
 
class  DeckView
 
struct  DENSITYRecord
 
struct  DensityTable
 
class  DenT
 
struct  DiffCoeffGasRecord
 
struct  DiffCoeffGasTable
 
struct  DiffCoeffRecord
 
struct  DiffCoeffTable
 
struct  DiffCoeffWatRecord
 
struct  DiffCoeffWatTable
 
class  Dimension
 
struct  DirectionalMaterialLawParams
 
class  DNAPL
 A simple implementation of a dense non-aqueous phase liquid (DNAPL). More...
 
class  DryGasPvt
 This class represents the Pressure-Volume-Temperature relations of the gas phase without vaporized oil. More...
 
class  DryHumidGasPvt
 This class represents the Pressure-Volume-Temperature relations of the gas phase with vaporized water. More...
 
class  EclDefaultMaterial
 Implements the default three phase capillary pressure law used by the ECLipse simulator. More...
 
class  EclDefaultMaterialParams
 Default implementation for the parameters required by the default three-phase capillary pressure model used by Eclipse. More...
 
class  EclEpsConfig
 Specifies the configuration used by the endpoint scaling code. More...
 
class  EclEpsGridProperties
 Collects all grid properties which are relevant for end point scaling. More...
 
class  EclEpsScalingPoints
 Represents the points on the X and Y axis to be scaled if endpoint scaling is used. More...
 
struct  EclEpsScalingPointsInfo
 This structure represents all values which can be possibly used as scaling points in the endpoint scaling code. More...
 
class  EclEpsTwoPhaseLaw
 This material law takes a material law defined for unscaled saturation and converts it to a material law defined on scaled saturations. More...
 
class  EclEpsTwoPhaseLawParams
 A default implementation of the parameters for the material law adapter class which implements ECL endpoint scaling. More...
 
class  EclHeatcrLaw
 Implements the volumetric interior energy relations of rock used by ECL. More...
 
class  EclHeatcrLawParams
 The default implementation of a parameter object for the ECL thermal law. More...
 
class  EclHysterConfig
 
class  EclHysteresisConfig
 Specifies the configuration used by the ECL kr/pC hysteresis code. More...
 
class  EclHysteresisTwoPhaseLaw
 This material law implements the hysteresis model of the ECL file format. More...
 
class  EclHysteresisTwoPhaseLawParams
 A default implementation of the parameters for the material law which implements the ECL relative permeability and capillary pressure hysteresis. More...
 
class  EclipseConfig
 
class  EclipseGrid
 About cell information and dimension: The actual grid information is held in a pointer to an ERT ecl_grid_type instance. More...
 
class  EclipseGridInspector
 A class for inspecting the contents of an eclipse file. More...
 
class  EclipseIO
 A class to write reservoir and well states of a blackoil simulation to disk. More...
 
class  EclipsePRTLog
 
class  EclipseState
 
class  EclMaterialLawManager
 Provides an simple way to create and manage the material law objects for a complete ECL deck. More...
 
class  EclMultiplexerMaterial
 Implements a multiplexer class that provides all three phase capillary pressure laws used by the ECLipse simulator. More...
 
class  EclMultiplexerMaterialParams
 Multiplexer implementation for the parameters required by the multiplexed three-phase material law. More...
 
class  EclSolidEnergyLawMultiplexer
 Provides the energy storage relation of rock. More...
 
class  EclSolidEnergyLawMultiplexerParams
 The default implementation of a parameter object for the ECL thermal law. More...
 
class  EclSpecrockLaw
 Implements the volumetric interior energy relations of rock used by ECL. More...
 
class  EclSpecrockLawParams
 The default implementation of a parameter object for the ECL thermal law based on SPECROCK. More...
 
class  EclStone1Material
 Implements the second phase capillary pressure/relperm law suggested by Stone as used by the ECLipse simulator. More...
 
class  EclStone1MaterialParams
 Default implementation for the parameters required by the three-phase capillary pressure/relperm Stone 2 model used by Eclipse. More...
 
class  EclStone2Material
 Implements the second phase capillary pressure/relperm law suggested by Stone as used by the ECLipse simulator. More...
 
class  EclStone2MaterialParams
 Default implementation for the parameters required by the three-phase capillary pressure/relperm Stone 2 model used by Eclipse. More...
 
class  EclThcLaw
 Implements the total thermal conductivity and rock enthalpy relations used by ECL. More...
 
class  EclThcLawParams
 The default implementation of a parameter object for the thermal conduction law based on the THC* keywords from ECL. More...
 
class  EclThconrLaw
 Implements the total thermal conductivity relations specified by the ECL THCONR. More...
 
class  EclThconrLawParams
 The default implementation of a parameter object for the thermal conduction law based on the THCONR keyword from ECL. More...
 
class  EclThermalConductionLawMultiplexer
 Implements the total thermal conductivity and rock enthalpy relations used by ECL. More...
 
class  EclThermalConductionLawMultiplexerParams
 The default implementation of a parameter object for the ECL thermal law. More...
 
class  EclThermalLawManager
 Provides an simple way to create and manage the thermal law objects for a complete ECL deck. More...
 
class  EclTwoPhaseMaterial
 Implements a multiplexer class that provides ECL saturation functions for twophase simulations. More...
 
class  EclTwoPhaseMaterialParams
 Implementation for the parameters required by the material law for two-phase simulations. More...
 
class  EDITSection
 
class  EffToAbsLaw
 This material law takes a material law defined for effective saturations and converts it to a material law defined on absolute saturations. More...
 
class  EffToAbsLawParams
 A default implementation of the parameters for the adapter class to convert material laws from effective to absolute saturations. More...
 
class  EndpointScaling
 
class  EnkrvdTable
 
class  EnptvdTable
 
class  EnsureFinalized
 Default implementation for asserting finalization of parameter objects. More...
 
class  Eqldims
 
class  EquilContainer
 
class  EquilRecord
 
class  ErrorGuard
 
class  Events
 
class  FastSmallVector
 An implementation of vector/array based on small object optimization. More...
 
class  Fault
 
class  FaultCollection
 
class  FaultFace
 
class  FieldProps
 
class  FieldPropsManager
 
class  FileDeck
 
struct  FilterCake
 
class  FIPConfig
 Class holding FIP configuration from RPTSOL/RPTSCHED keyword. More...
 
class  FIPRegionStatistics
 Basic descriptive statistics about a model's fluid-in-place regions. More...
 
struct  FlatTable
 
class  FlatTableWithCopy
 
class  FluidStateEquilibriumTemperatureModule
 Module for the modular fluid state which stores the temperatures explicitly and assumes thermal equilibrium. More...
 
class  FluidStateExplicitCompositionModule
 Module for the modular fluid state which stores the phase compositions explicitly in terms of mole fractions. More...
 
class  FluidStateExplicitDensityModule
 Module for the modular fluid state which stores the densities explicitly. More...
 
class  FluidStateExplicitEnthalpyModule
 Module for the modular fluid state which stores the enthalpies explicitly. More...
 
class  FluidStateExplicitFugacityModule
 Module for the modular fluid state which stores the phase fugacity coefficients explicitly. More...
 
class  FluidStateExplicitPressureModule
 Module for the modular fluid state which stores the pressures explicitly. More...
 
class  FluidStateExplicitSaturationModule
 Module for the modular fluid state which stores the saturations explicitly. More...
 
class  FluidStateExplicitTemperatureModule
 Module for the modular fluid state which stores the temperatures explicitly. More...
 
class  FluidStateExplicitViscosityModule
 Module for the modular fluid state which stores the viscosities explicitly. More...
 
class  FluidStateImmiscibleCompositionModule
 Module for the modular fluid state which provides the phase compositions assuming immiscibility. More...
 
class  FluidStateImmiscibleFugacityModule
 Module for the modular fluid state which stores the phase fugacity coefficients explicitly assuming immiscibility. More...
 
class  FluidStateNullCompositionModule
 Module for the modular fluid state which does not store the compositions but throws std::logic_error instead. More...
 
class  FluidStateNullDensityModule
 Module for the modular fluid state which does not the densities but throws std::logic_error instead. More...
 
class  FluidStateNullEnthalpyModule
 Module for the modular fluid state which does not store the enthalpies but returns 0 instead. More...
 
class  FluidStateNullFugacityModule
 Module for the modular fluid state which does not store the fugacities but throws std::logic_error instead. More...
 
class  FluidStateNullPressureModule
 Module for the modular fluid state which does not the pressures but throws std::logic_error instead. More...
 
class  FluidStateNullSaturationModule
 Module for the modular fluid state which does not the saturations but throws std::logic_error instead. More...
 
class  FluidStateNullTemperatureModule
 Module for the modular fluid state which does not the temperatures but throws std::logic_error instead. More...
 
class  FluidStateNullViscosityModule
 Module for the modular fluid state which does not the viscosities but throws std::logic_error instead. More...
 
class  FluidThermalConductionLaw
 Implements a thermal conduction law which just takes the conductivity of a given fluid phase. More...
 
class  FluidThermalConductionLawParams
 Parameters for the thermal conduction law which just takes the conductivity of a given fluid phase. More...
 
class  FoamadsTable
 
class  FoamConfig
 Foam behaviour data for all SATNUM regions. More...
 
class  FoamData
 Foam behaviour data for a single SATNUM region. More...
 
class  FoammobTable
 
struct  fortran_double
 
class  GasLiftGroup
 
class  GasLiftOpt
 
class  GasLiftWell
 
class  GasPhase
 Represents the gas phase of a single (pseudo-) component. More...
 
class  GasPvtMultiplexer
 This class represents the Pressure-Volume-Temperature relations of the gas phase in the black-oil model. More...
 
class  GasPvtThermal
 This class implements temperature dependence of the PVT properties of gas. More...
 
class  GasvisctTable
 
class  GConSale
 
class  GConSump
 
class  GenericOilGasFluidSystem
 A two phase system that can contain NumComp components. More...
 
class  GPMaint
 
struct  GRAVITYRecord
 
struct  GravityTable
 
class  GridDims
 
class  GridProperty
 
class  GRIDSection
 
class  Group
 
class  GroupEconProductionLimits
 
class  GroupOrder
 
class  GsfTable
 
class  GTNode
 
class  GuideRate
 
class  GuideRateConfig
 
class  GuideRateModel
 
class  H2
 Properties of pure molecular hydrogen $H_2$. More...
 
class  H2GasPvt
 This class represents the Pressure-Volume-Temperature relations of the gas phase for H2. More...
 
class  H2O
 Material properties of pure water $H_2O$. More...
 
class  H2OAirFluidSystem
 A fluid system with a liquid and a gaseous phase and water and air as components. More...
 
class  H2OAirMesityleneFluidSystem
 A fluid system with water, gas and NAPL as phases and water, air and mesitylene (DNAPL) as components. More...
 
class  H2OAirXyleneFluidSystem
 A fluid system with water, gas and NAPL as phases and water, air and NAPL (contaminant) as components. More...
 
class  H2ON2FluidSystem
 A two-phase fluid system with water and nitrogen as components. More...
 
class  H2ON2LiquidPhaseFluidSystem
 A liquid-phase-only fluid system with water and nitrogen as components. More...
 
class  HandlerContext
 
class  IdealGas
 Relations valid for an ideal gas. More...
 
class  ImkrvdTable
 
class  ImmiscibleFlash
 Determines the pressures and saturations of all fluid phases given the total mass of all components. More...
 
class  ImmiscibleFluidState
 Represents all relevant thermodynamic quantities of a multi-phase, multi-component fluid system assuming thermodynamic equilibrium. More...
 
class  ImmiscibleFluidState< Scalar, FluidSystem, false >
 
class  ImmiscibleFluidState< Scalar, FluidSystem, true >
 
class  ImportContainer
 
class  ImptvdTable
 
class  InfoLogger
 
class  InitConfig
 
struct  InjMult
 
class  Inplace
 
class  IntervalTabulated2DFunction
 Implements a function that depends on two variables. More...
 
class  IOConfig
 
class  IOrderSet
 
class  JFunc
 
class  JouleThomson
 
class  KeywordGenerator
 
class  KeywordHandlers
 Singleton class for Keyword handlers in Schedule. More...
 
class  KeywordLoader
 
class  KeywordLocation
 
class  KeywordSize
 
class  LgrCollection
 
class  LinearisedOutputTable
 Manage tables of column data, possibly with sub-tables, all with equal number of rows (i.e., with padding), and possibly with multiple tables pertaining to multiple subsets (i.e., cell regions). More...
 
class  LinearMaterial
 Implements a linear saturation-capillary pressure relation. More...
 
class  LinearMaterialParams
 Reference implementation of params for the linear M-phase material material. More...
 
class  LinearSolverProblem
 
class  LiquidPhase
 Represents the liquid phase of a single (pseudo-) component. More...
 
class  LiveOilPvt
 This class represents the Pressure-Volume-Temperature relations of the oil phas with dissolved gas. More...
 
class  LNAPL
 A simple implementation of a LNAPL, e.g. More...
 
class  LogBackend
 Abstract interface class for log backends. More...
 
class  Logger
 
class  MapAxes
 
class  MaterialLawProblem
 
struct  MathToolbox
 
struct  MathToolbox< DenseAd::Evaluation< ValueT, numVars, staticSize > >
 
struct  MechBCValue
 
class  Mesitylene
 Component for Mesitylene. More...
 
class  MessageFormatterInterface
 Abstract interface for message formatting classes. More...
 
class  MessageLimiter
 Handles limiting the number of messages with the same tag. More...
 
class  MessageLimits
 
class  MICPpara
 
class  MiscibleMultiPhaseComposition
 Computes the composition of all phases of a N-phase, N-component fluid system assuming that all N phases are present. More...
 
class  MiscTable
 
class  MMPCAuxConstraint
 Specifies an auxiliary constraint for the MiscibleMultiPhaseComposition constraint solver. More...
 
class  ModularFluidState
 Represents all relevant thermodynamic quantities of a multi-phase, multi-component fluid system assuming thermodynamic equilibrium. More...
 
class  MonotCubicInterpolator
 Class to represent a one-dimensional function f with single-valued argument x. More...
 
struct  MonoThrowHandler
 A functor for handling a monostate in a visitor overload set. More...
 
class  MsfnTable
 
struct  MULTREGTRecord
 
class  MULTREGTScanner
 
class  N2
 Properties of pure molecular nitrogen $N_2$. More...
 
class  NameOrder
 
class  NcpFlash
 Determines the phase compositions, pressures and saturations given the total mass of all components. More...
 
class  NetworkDims
 
class  NextStep
 
class  NNC
 
struct  NNCdata
 
class  NonEquilibriumFluidState
 Represents all relevant thermodynamic quantities of a multi-phase, multi-component fluid system not assuming thermodynamic equilibrium. More...
 
class  NonEquilibriumFluidState< Scalar, FluidSystem, false >
 
class  NonEquilibriumFluidState< Scalar, FluidSystem, true >
 
class  NonuniformTableLinear
 This class uses linear interpolation to compute the value (and its derivative) of a function f sampled at possibly nonuniform points. More...
 
class  NotImplemented
 
class  NullComponent
 A component that only throws exceptions. More...
 
class  NullMaterial
 Implements a dummy linear saturation-capillary pressure relation which just disables capillary pressure. More...
 
class  NullMaterialParams
 Reference implementation of params for the linear M-phase material material. More...
 
class  NullMaterialTraits
 A generic traits class which does not provide any indices. More...
 
class  NullParameterCache
 A parameter cache which does nothing. More...
 
class  NullSolidEnergyLaw
 Implements a solid energy storage law which just returns 0. More...
 
class  NullThermalConductionLaw
 Implements a dummy law for thermal conduction to which isothermal models can fall back to. More...
 
struct  NumericalAquiferCell
 
struct  NumericalAquiferConnection
 
class  NumericalAquifers
 
class  NumericalProblem
 
class  Nupcol
 
class  OilPvtMultiplexer
 This class represents the Pressure-Volume-Temperature relations of the oil phase in the black-oil model. More...
 
class  OilPvtThermal
 This class implements temperature dependence of the PVT properties of oil. More...
 
class  OilVaporizationProperties
 
class  OilvisctTable
 
class  OpmInputError
 
class  OpmLog
 
class  OrderedMap
 A map with iteration in the order of insertion. More...
 
class  OverburdTable
 
class  Parameter
 
class  ParameterCacheBase
 The base class of the parameter caches of fluid systems. More...
 
class  ParameterGroup
 ParameterGroup is a class that is used to provide run-time parameters. More...
 
struct  ParameterMapItem
 The parameter handlig system is structured as a tree, where each node inhertis from ParameterMapItem. More...
 
struct  ParameterMapItemTrait
 
struct  ParameterMapItemTrait< bool >
 
struct  ParameterMapItemTrait< double >
 
struct  ParameterMapItemTrait< int >
 
struct  ParameterMapItemTrait< ParameterGroup >
 
struct  ParameterMapItemTrait< std::string >
 
struct  ParameterRequirementAnd
 
struct  ParameterRequirementMemberOf
 
struct  ParameterRequirementNegative
 
struct  ParameterRequirementNone
 
struct  ParameterRequirementNonEmpty
 
struct  ParameterRequirementNonNegative
 
struct  ParameterRequirementNonPositive
 
struct  ParameterRequirementNonZero
 
struct  ParameterRequirementPositive
 
struct  ParameterRequirementProbability
 
class  ParkerLenhard
 Implements the Parker-Lenhard twophase p_c-Sw hysteresis model. More...
 
class  ParkerLenhardParams
 Default parameter class for the Parker-Lenhard hysteresis model. More...
 
class  ParseContext
 
class  Parser
 The hub of the parsing process. More...
 
class  ParserItem
 
class  ParserKeyword
 
class  ParserRecord
 
class  PAvg
 
class  PAvgCalculator
 Facility for deriving well-level pressure values from selected block-averaging procedures. More...
 
class  PAvgCalculatorCollection
 Collection of WBPn calculation objects, one for each well. More...
 
class  PAvgDynamicSourceData
 Dynamic source data for block-average pressure calculations. More...
 
class  PbvdTable
 
class  PcfactTable
 
class  PdvdTable
 
class  PengRobinson
 Implements the Peng-Robinson equation of state for liquids and gases. More...
 
class  PengRobinsonMixture
 Implements the Peng-Robinson equation of state for a mixture. More...
 
class  PengRobinsonParams
 Stores and provides access to the Peng-Robinson parameters. More...
 
class  PengRobinsonParamsMixture
 The mixing rule for the oil and the gas phases of the SPE5 problem. More...
 
class  PermfactTable
 
class  Phases
 
class  PiecewiseLinearTwoPhaseMaterial
 Implementation of a tabulated, piecewise linear capillary pressure law. More...
 
class  PiecewiseLinearTwoPhaseMaterialParams
 Specification of the material parameters for a two-phase material law which uses a table and piecewise constant interpolation. More...
 
struct  PlmixparRecord
 
struct  PlmixparTable
 
class  PLScanningCurve
 Represents a scanning curve in the Parker-Lenhard hysteresis model. More...
 
class  PlyadsTable
 
class  PlydhflfTable
 
class  PlymaxTable
 
class  PlymwinjTable
 
class  PlyrockTable
 
class  PlyshlogTable
 
class  PlyviscTable
 
struct  PlyvmhRecord
 
struct  PlyvmhTable
 
class  PmiscTable
 
class  PolyInjTable
 
class  Ppcwmax
 
struct  PpcwmaxRecord
 
class  PressureOverlayFluidState
 This is a fluid state which allows to set the fluid pressures and takes all other quantities from an other fluid state. More...
 
class  PROPSSection
 
class  PTFlash
 Determines the phase compositions, pressures and saturations given the total mass of all components for the chiwoms problem. More...
 
class  PTFlashParameterCache
 Specifies the parameter cache used by the SPE-5 fluid system. More...
 
struct  PVCDORecord
 
struct  PvcdoTable
 
class  PvdgTable
 
class  PvdoTable
 
class  PvdsTable
 
class  PvtgTable
 
class  PvtgwoTable
 
class  PvtgwTable
 
class  PvtoTable
 
class  PvtsolTable
 
struct  PVTWRecord
 
class  PvtwsaltTable
 
struct  PvtwTable
 
class  PvtxTable
 
class  Python
 
class  PythonInterp
 
class  RawKeyword
 
class  RawRecord
 Class representing the lowest level of the Raw datatypes, a record. More...
 
class  RawString
 
class  Regdims
 
class  RegionSetMatchResult
 Result Set From RegionSetMatcher's Matching Process. More...
 
class  REGIONSSection
 
class  RegulaFalsi
 
class  RegulaFalsiBisection
 
class  RegularizedBrooksCorey
 Implementation of the regularized Brooks-Corey capillary pressure / relative permeability <-> saturation relation. More...
 
class  RegularizedBrooksCoreyParams
 Parameters that are necessary for the regularization of the Brooks-Corey capillary pressure model. More...
 
class  RegularizedVanGenuchten
 Implementation of the regularized van Genuchten's capillary pressure / relative permeability <-> saturation relation. More...
 
class  RegularizedVanGenuchtenParams
 Parameters that are necessary for the regularization of VanGenuchten "material law". More...
 
struct  RegularSegment
 
class  RestartKey
 
class  RestartValue
 
struct  ReturnEval_
 
class  RFTConfig
 
class  Rock2dTable
 
class  Rock2dtrTable
 
class  RockConfig
 
struct  ROCKRecord
 
struct  RockTable
 
class  RocktabTable
 
class  RockwnodTable
 
class  RPTConfig
 
class  RSTConfig
 
class  RsvdTable
 
class  RtempvdTable
 
class  Runspec
 
class  RUNSPECSection
 
class  RvvdTable
 
class  RvwvdTable
 
class  RwgsaltTable
 
class  SaltpvdTable
 
class  SaltsolTable
 
class  SaltvdTable
 
class  SatCurveMultiplexer
 Implements a multiplexer class that provides LET curves and piecewise linear saturation functions. More...
 
class  SatCurveMultiplexerParams
 Specification of the material parameters for the saturation function multiplexer. More...
 
class  SatFuncControls
 
struct  SatFuncLETRecord
 
class  SaturationOverlayFluidState
 This is a fluid state which allows to set the fluid saturations and takes all other quantities from an other fluid state. More...
 
class  Schedule
 
class  ScheduleBlock
 
class  ScheduleDeck
 
struct  ScheduleDeckContext
 
class  ScheduleGrid
 
struct  ScheduleRestartInfo
 
class  SCHEDULESection
 
class  ScheduleState
 
struct  ScheduleStatic
 
class  Segment
 
struct  SegmentIndex
 
class  Serializer
 Class for (de-)serializing. More...
 
class  SgcwmisTable
 
class  SgfnTable
 
struct  SgofletTable
 
class  SgofTable
 
class  SgwfnTable
 
struct  ShrateRecord
 
struct  ShrateTable
 
class  SICD
 
class  SimpleCO2
 A simplistic class representing the $CO_2$ fluid properties. More...
 
class  SimpleH2
 Properties of pure molecular hydrogen $H_2$. More...
 
class  SimpleH2O
 A simple version of pure water. More...
 
class  SimpleHuDuanH2O
 A simple version of pure water with density from Hu et al. More...
 
class  SimpleMessageFormatter
 A simple formatter capable of adding message prefixes and colors. More...
 
class  SimpleModularFluidState
 Represents all relevant thermodynamic quantities of a multi-phase, multi-component fluid system assuming thermodynamic equilibrium. More...
 
class  SimpleTable
 
class  SimulationConfig
 
struct  SimulatorUpdate
 This struct is used to communicate back from the Schedule::applyAction() what needs to be updated in the simulator when execution is returned to the simulator code. More...
 
struct  SingleAquiferFlux
 
class  SingleNumericalAquifer
 
class  SinglePhaseFluidSystem
 A fluid system for single phase models. More...
 
class  SkprpolyTable
 
class  SkprwatTable
 
class  SlgofTable
 
class  Sof2Table
 
class  Sof3Table
 
class  SOLUTIONSection
 
class  SolventDensityTable
 
class  SolventPvt
 This class represents the Pressure-Volume-Temperature relations of the "second" gas phase in the of ECL simulations with solvents. More...
 
class  SomertonThermalConductionLaw
 Implements the Somerton law of thermal conductivity in a porous medium. More...
 
class  SomertonThermalConductionLawParams
 The default implementation of a parameter object for the Somerton thermal conduction law. More...
 
class  SorwmisTable
 
class  Source
 
class  SparseVector
 A SparseVector stores a vector with possibly many empty elements as efficiently as possible. More...
 
class  Spe5FluidSystem
 The fluid system for the oil, gas and water phases of the SPE5 problem. More...
 
class  Spe5ParameterCache
 Specifies the parameter cache used by the SPE-5 fluid system. More...
 
class  SpecheatTable
 
class  SpecrockTable
 
class  Spline
 Class implementing cubic splines. More...
 
class  SplineTwoPhaseMaterial
 Implementation of a tabulated capillary pressure and relperm law which uses spline curves as interpolation functions. More...
 
class  SplineTwoPhaseMaterialParams
 Specification of the material parameters for a two-phase material law which uses a table and spline-based interpolation. More...
 
class  SsfnTable
 
struct  StandardCond
 
class  StarToken
 
struct  Stone1exRecord
 
struct  Stone1exTable
 
class  StreamLog
 
class  StressEquilRecord
 
class  SummaryConfig
 
class  SummaryConfigNode
 
class  SUMMARYSection
 
class  SummaryState
 
class  SwfnTable
 
struct  SwofletTable
 
class  SwofTable
 
class  Tabdims
 
class  TableColumn
 
class  TableContainer
 
class  TableIndex
 
class  TableManager
 
class  Tables
 
class  TableSchema
 
class  Tabulated1DFunction
 Implements a linearly interpolated scalar function that depends on one variable. More...
 
class  TabulatedComponent
 A generic class which tabulates all thermodynamic properties of a given component. More...
 
class  TemperatureOverlayFluidState
 This is a fluid state which allows to set the fluid temperatures and takes all other quantities from an other fluid state. More...
 
class  ThreeComponentFluidSystem
 A two phase three component fluid system with components CO2, Methane and NDekan. More...
 
class  ThreePhaseMaterialTraits
 A generic traits class for three-phase material laws. More...
 
class  ThreePhaseParkerVanGenuchten
 Implementation of three-phase capillary pressure and relative permeability relations proposed by Parker and van Genuchten. More...
 
class  ThreePhaseParkerVanGenuchtenParams
 Specification of the material params for the three-phase van Genuchten capillary pressure model. More...
 
class  ThresholdPressure
 
struct  ThrowOnError
 
class  TimerLog
 
class  TimeStampUTC
 
class  TimeSteppingBreakdown
 
class  TLMixpar
 
struct  TlmixparRecord
 
struct  TlmixparTable
 
struct  TLMixRecord
 
class  TlpmixpaTable
 
class  TooManyIterations
 
class  TracerConfig
 
class  Tracers
 
class  TracerVdTable
 A class that contains tracer concentration vs depth table. More...
 
class  TransMult
 
class  TridiagonalMatrix
 Provides a tridiagonal matrix that also supports non-zero entries in the upper right and lower left. More...
 
struct  Tuning
 
class  TwoPhaseImmiscibleFluidSystem
 A fluid system for two-phase models assuming immiscibility and thermodynamic equilibrium. More...
 
class  TwoPhaseLETCurves
 Implementation of the LET curve saturation functions. More...
 
class  TwoPhaseLETCurvesParams
 Specification of the material parameters for the LET constitutive relations. More...
 
class  TwoPhaseMaterialTraits
 A generic traits class for two-phase material laws. More...
 
class  UDAValue
 
class  UDQActive
 
class  UDQAssign
 
class  UDQASTNode
 
class  UDQBinaryFunction
 
class  UDQConfig
 
class  UDQContext
 
class  UDQDefine
 
class  UDQDims
 
class  UDQFunction
 
class  UDQFunctionTable
 
class  UDQIndex
 
class  UDQInput
 
class  UDQParams
 
class  UDQScalar
 
class  UDQScalarFunction
 
class  UDQSet
 
class  UDQState
 
class  UDQToken
 
class  UDQUnaryElementalFunction
 
class  UDT
 
class  UniformTableLinear
 This class uses linear interpolation to compute the value (and its derivative) of a function f sampled at uniform points. More...
 
class  UniformTabulated2DFunction
 Implements a scalar function that depends on two variables and which is sampled on an uniform X-Y grid. More...
 
class  UniformXTabulated2DFunction
 Implements a scalar function that depends on two variables and which is sampled uniformly in the X direction, but non-uniformly on the Y axis-. More...
 
class  Unit
 A component where all quantities are fixed at 1.0. More...
 
class  UnitSystem
 
class  Valve
 
struct  ValveUDAEval
 
class  VanGenuchten
 Implementation of the van Genuchten capillary pressure - saturation relation. More...
 
class  VanGenuchtenParams
 Specification of the material parameters for the van Genuchten constitutive relations. More...
 
class  VFPInjTable
 
class  VFPProdTable
 Class for reading data from a VFPPROD (vertical flow performance production) table. More...
 
class  ViscosityModels
 
struct  VISCREFRecord
 
struct  ViscrefTable
 
struct  VisitorOverloadSet
 Helper struct for for generating visitor overload sets. More...
 
class  WagHysteresisConfig
 
struct  WarnAndContinueOnError
 
struct  WATDENTRecord
 
struct  WatdentTable
 
class  WaterPvtMultiplexer
 This class represents the Pressure-Volume-Temperature relations of the water phase in the black-oil model. More...
 
class  WaterPvtThermal
 This class implements temperature dependence of the PVT properties of water. More...
 
class  WatvisctTable
 
class  WDFAC
 
class  Well
 
struct  WellBrineProperties
 
class  WellConnections
 
class  Welldims
 
class  WellEconProductionLimits
 
struct  WellFoamProperties
 
class  WellGroupEvents
 
struct  WellInjectionControls
 
class  WellMatcher
 
struct  WellMICPProperties
 
struct  WellPolymerProperties
 
struct  WellProductionControls
 
class  WellSegmentDims
 
class  WellSegments
 
class  WellTestConfig
 
class  WellTestState
 
class  WellTracerProperties
 
class  WellType
 
class  WelSegsSet
 
class  WetGasPvt
 This class represents the Pressure-Volume-Temperature relations of the gas phas with vaporized oil. More...
 
class  WetHumidGasPvt
 This class represents the Pressure-Volume-Temperature relations of the gas phase with vaporized oil and vaporized water. More...
 
class  WList
 
class  WListManager
 
class  WriteRestartFileEvents
 
class  WsfTable
 
class  WVFPDP
 
class  WVFPEXP
 
class  Xylene
 Component for Xylene. More...
 
class  ZcornMapper
 

Typedefs

typedef std::shared_ptr< TimerLogTimerLogPtr
 
typedef std::shared_ptr< const TimerLogTimerLogConstPtr
 
using time_point = std::chrono::time_point< std::chrono::system_clock, std::chrono::duration< int64_t, std::ratio< 1, 1000 > > >
 
using AQUFETP = ParserKeywords::AQUFETP
 
using AQUNUM = ParserKeywords::AQUNUM
 
using AQUCON = ParserKeywords::AQUCON
 
using Equil = EquilContainer< EquilRecord >
 
using StressEquil = EquilContainer< StressEquilRecord >
 
using BC = ParserKeywords::BCCON
 
using BCKEY = ParserKeywords::BCPROP
 
using AICD = ParserKeywords::WSEGAICD
 
using SOURCEKEY = ParserKeywords::SOURCE
 
using FS = BlackOilFluidSystem< double, BlackOilDefaultIndexTraits >
 

Enumerations

enum class  Section {
  RUNSPEC , GRID , EDIT , PROPS ,
  REGIONS , SOLUTION , SUMMARY , SCHEDULE
}
 
enum  DeckChecks { SectionTopology = 0x0001 , KeywordSection = 0x0002 , UnknownKeywords = 0x0004 , AllChecks = 0xffff }
 
enum class  SaltMixingType { NONE , MICHAELIDES }
 
enum class  LiquidMixingType { NONE , IDEAL , DUANSUN }
 
enum class  GasMixingType { NONE , IDEAL }
 
enum class  MinpvMode { Inactive = 1 , EclSTD = 2 }
 
enum class  PinchMode {
  ALL = 1 , TOPBOT = 2 , TOP = 3 , GAP = 4 ,
  NOGAP = 5
}
 
enum class  Phase {
  OIL = 0 , GAS = 1 , WATER = 2 , SOLVENT = 3 ,
  POLYMER = 4 , ENERGY = 5 , POLYMW = 6 , FOAM = 7 ,
  BRINE = 8 , ZFRACTION = 9
}
 
enum class  InputErrorAction {
  THROW_EXCEPTION = 0 , WARN = 1 , IGNORE = 2 , EXIT1 = 3 ,
  DELAYED_EXIT1 = 4
}
 
enum  ParserKeywordSizeEnum {
  SLASH_TERMINATED = 0 , FIXED = 1 , OTHER_KEYWORD_IN_DECK = 2 , UNKNOWN = 3 ,
  FIXED_CODE = 4 , DOUBLE_SLASH_TERMINATED = 5 , SPECIAL_CASE_ROCK = 6
}
 
enum  ParserKeywordActionEnum { INTERNALIZE = 0 , IGNORE = 1 , IGNORE_WARNING = 2 , THROW_EXCEPTION = 3 }
 
enum class  BCType {
  RATE , FREE , DIRICHLET , THERMAL ,
  CLOSED , NONE
}
 
enum class  BCMECHType { FREE , FIXED , NONE }
 
enum class  BCComponent {
  OIL , GAS , WATER , SOLVENT ,
  POLYMER , NONE
}
 
enum class  ICDStatus { OPEN , SHUT }
 
enum class  WellSegmentCompPressureDrop { HFA = 0 , HF_ = 1 , H__ = 2 }
 
enum class  ScheduleTimeType { START = 0 , DATES = 1 , TSTEP = 2 , RESTART = 3 }
 
enum class  InjectorType { WATER = 1 , GAS = 2 , OIL = 3 , MULTI = 4 }
 
enum class  SourceComponent {
  OIL , GAS , WATER , SOLVENT ,
  POLYMER , NONE
}
 
enum class  UDQVarType {
  NONE = 0 , SCALAR = 1 , CONNECTION_VAR = 2 , FIELD_VAR = 3 ,
  REGION_VAR = 4 , SEGMENT_VAR = 5 , AQUIFER_VAR = 6 , BLOCK_VAR = 7 ,
  WELL_VAR = 8 , GROUP_VAR = 9 , TABLE_LOOKUP = 10
}
 
enum class  UDQTokenType {
  error = 0 , number = 1 , open_paren = 2 , close_paren = 3 ,
  comp_expr = 6 , ecl_expr = 7 , binary_op_add = 8 , binary_op_sub = 9 ,
  binary_op_div = 10 , binary_op_mul = 11 , binary_op_pow = 12 , binary_op_uadd = 13 ,
  binary_op_umul = 14 , binary_op_umin = 15 , binary_op_umax = 16 , binary_cmp_eq = 17 ,
  binary_cmp_ne = 18 , binary_cmp_le = 19 , binary_cmp_ge = 20 , binary_cmp_lt = 21 ,
  binary_cmp_gt = 22 , elemental_func_randn = 23 , elemental_func_randu = 24 , elemental_func_rrandn = 25 ,
  elemental_func_rrandu = 26 , elemental_func_abs = 27 , elemental_func_def = 28 , elemental_func_exp = 29 ,
  elemental_func_idv = 30 , elemental_func_ln = 31 , elemental_func_log = 32 , elemental_func_nint = 33 ,
  elemental_func_sorta = 34 , elemental_func_sortd = 35 , elemental_func_undef = 36 , scalar_func_sum = 37 ,
  scalar_func_avea = 38 , scalar_func_aveg = 39 , scalar_func_aveh = 40 , scalar_func_max = 41 ,
  scalar_func_min = 42 , scalar_func_norm1 = 43 , scalar_func_norm2 = 44 , scalar_func_normi = 45 ,
  scalar_func_prod = 46 , table_lookup = 47 , table_lookup_start = 48 , table_lookup_end = 49 ,
  end = 100
}
 
enum class  UDQAction { ASSIGN , DEFINE , UNITS , UPDATE }
 
enum class  UDQUpdate { ON , OFF , NEXT }
 
enum class  UDAControl {
  WCONPROD_ORAT , WCONPROD_WRAT , WCONPROD_GRAT , WCONPROD_LRAT ,
  WCONPROD_RESV , WCONPROD_BHP , WCONPROD_THP , WCONPROD_LIFT ,
  WCONINJE_RATE , WCONINJE_RESV , WCONINJE_BHP , WCONINJE_THP ,
  GCONPROD_OIL_TARGET , GCONPROD_WATER_TARGET , GCONPROD_GAS_TARGET , GCONPROD_LIQUID_TARGET ,
  GCONINJE_SURFACE_MAX_RATE , GCONINJE_RESV_MAX_RATE , GCONINJE_TARGET_REINJ_FRACTION , GCONINJE_TARGET_VOID_FRACTION ,
  WELTARG_ORAT , WELTARG_WRAT , WELTARG_GRAT , WELTARG_LRAT ,
  WELTARG_RESV , WELTARG_BHP , WELTARG_THP , WELTARG_LIFT
}
 
enum class  UDAKeyword {
  WCONPROD , WCONINJE , WELTARG , GCONINJE ,
  GCONPROD
}
 
enum class  ConnectionOrder { DEPTH , INPUT , TRACK }
 
enum class  WellStatus { OPEN = 1 , STOP = 2 , SHUT = 3 , AUTO = 4 }
 
enum class  WellInjectorCMode : int {
  RATE = 1 , RESV = 2 , BHP = 4 , THP = 8 ,
  GRUP = 16 , CMODE_UNDEFINED = 512
}
 
enum class  WellProducerCMode : int {
  NONE = 0 , ORAT = 1 , WRAT = 2 , GRAT = 4 ,
  LRAT = 8 , CRAT = 16 , RESV = 32 , BHP = 64 ,
  THP = 128 , GRUP = 256 , CMODE_UNDEFINED = 1024
}
 
enum class  WellWELTARGCMode {
  ORAT = 1 , WRAT = 2 , GRAT = 3 , LRAT = 4 ,
  CRAT = 5 , RESV = 6 , BHP = 7 , THP = 8 ,
  VFP = 9 , LIFT = 10 , GUID = 11
}
 
enum class  WellGuideRateTarget {
  OIL = 0 , WAT = 1 , GAS = 2 , LIQ = 3 ,
  COMB = 4 , WGA = 5 , CVAL = 6 , RAT = 7 ,
  RES = 8 , UNDEFINED = 9
}
 
enum class  WellGasInflowEquation { STD = 0 , R_G = 1 , P_P = 2 , GPP = 3 }
 
enum class  type_tag {
  unknown = 0 , integer = 1 , string = 2 , raw_string = 3 ,
  fdouble = 4 , uda = 5
}
 
enum class  EclTwoPhaseSystemType { GasOil , OilWater , GasWater }
 Specified which fluids are involved in a given twophase material law for endpoint scaling.
 
enum class  EclMultiplexerApproach {
  Default , Stone1 , Stone2 , TwoPhase ,
  OnePhase
}
 
enum class  EclTwoPhaseApproach { GasOil , OilWater , GasWater }
 
enum class  SatCurveMultiplexerApproach { PiecewiseLinear , LET }
 
enum class  GasPvtApproach {
  NoGas , DryGas , DryHumidGas , WetHumidGas ,
  WetGas , ThermalGas , Co2Gas , H2Gas
}
 
enum class  OilPvtApproach {
  NoOil , LiveOil , DeadOil , ConstantCompressibilityOil ,
  ThermalOil , BrineCo2 , BrineH2
}
 
enum class  WaterPvtApproach {
  NoWater , ConstantCompressibilityBrine , ConstantCompressibilityWater , ThermalWater ,
  BrineCo2 , BrineH2
}
 
enum class  EclSolidEnergyApproach { Undefined , Heatcr , Specrock , Null }
 
enum class  EclThermalConductionApproach { Undefined , Thconr , Thc , Null }
 

Functions

std::string demangle (const char *mangled_symbol)
 Returns demangled name of symbol.
 
std::string unique_path (const std::string &input)
 
template<typename T >
void buildUniformMonotoneTable (const std::vector< double > &xv, const std::vector< T > &yv, const int samples, UniformTableLinear< T > &table)
 
int tableIndex (const std::vector< double > &table, double x)
 Returns an index in an ordered table such that x is between table[j] and table[j+1].
 
std::pair< double, int > linearInterpolationSlope (const std::vector< double > &xv, const std::vector< double > &yv, const double x)
 
double linearInterpolationDerivative (const std::vector< double > &xv, const std::vector< double > &yv, double x)
 
double linearInterpolation (const std::vector< double > &xv, const std::vector< double > &yv, double x)
 
double linearInterpolationNoExtrapolation (const std::vector< double > &xv, const std::vector< double > &yv, double x)
 
double linearInterpolation (const std::vector< double > &xv, const std::vector< double > &yv, double x, int &ix1)
 
template<typename FI >
bool isNondecreasing (const FI beg, const FI end)
 Detect if a sequence is nondecreasing.
 
template<class Functor >
void bracketZero (const Functor &f, const double x0, const double dx, double &a, double &b)
 Attempts to find an interval bracketing a zero by successive enlargement of search interval.
 
template<typename T >
std::ostream & operator<< (std::ostream &os, const UniformTableLinear< T > &t)
 
std::string correct_parameter_tag (const ParameterMapItem &item)
 
std::string correct_type (const Parameter &parameter, const std::string &param_type)
 
template<>
std::string ParameterGroup::to_string< std::string > (const std::string &val)
 
std::pair< std::string, std::string > splitParam (const std::string &name)
 
bool shmatch (const std::string &pattern, const std::string &symbol)
 
template<typename T , typename U >
U & uppercase (const T &src, U &dst)
 
std::vector< std::string > split_string (const std::string &input, char delimiter)
 
std::vector< std::string > split_string (const std::string &input, const std::string &delimiters)
 
std::string format_double (double d)
 
std::optional< double > try_parse_double (const std::string &token)
 
template<typename T >
std::string ltrim_copy (const T &s)
 
template<typename T >
std::string rtrim_copy (const T &s)
 
template<typename T >
std::string trim_copy (const T &s)
 
template<typename T >
void replaceAll (T &data, const T &toSearch, const T &replace)
 
template void replaceAll (std::string &, const std::string &, const std::string &)
 
template std::string ltrim_copy (const std::string &)
 
template std::string rtrim_copy (const std::string &)
 
template std::string trim_copy (const std::string &)
 
template std::string trim_copy (const EclIO::PaddedOutputString< 4 > &)
 
template std::string & uppercase (const std::string &, std::string &)
 
template std::string & uppercase (const std::string_view &, std::string &)
 
template<typename T >
std::decay< T >::type uppercase (T &&x)
 
TimeStampUTC operator+ (const TimeStampUTC &lhs, std::chrono::duration< double > delta)
 
std::time_t asTimeT (const TimeStampUTC &tp)
 
std::time_t asLocalTimeT (const TimeStampUTC &tp)
 
time_point asTimePoint (const TimeStampUTC &tp)
 
template<class... Ts>
 VisitorOverloadSet (Ts...) -> VisitorOverloadSet< Ts... >
 Deduction guide for visitor overload sets.
 
std::ostream & operator<< (std::ostream &os, const Deck &deck)
 
template<>
const std::vector< std::string > & DeckItem::value_ref< std::string > () const
 
std::ostream & operator<< (std::ostream &os, const DeckItem &item)
 
template std::string DeckItem::get< std::string > (size_t) const
 
template void DeckItem::push_backDummyDefault< std::string > (std::size_t)
 
template const std::vector< std::string > & DeckItem::getData< std::string > () const
 
std::ostream & operator<< (std::ostream &os, const DeckKeyword &keyword)
 
std::ostream & operator<< (std::ostream &os, const DeckRecord &record)
 
std::pair< std::size_t, std::size_t > index_pair (const Deck &deck, const std::string &section)
 
template<>
bool DeckValue::is_compatible< std::string > () const
 
template<>
bool UDAValue::is< std::string > () const
 
std::ostream & operator<< (std::ostream &stream, const UDAValue &uda_value)
 
std::vector< int > analyticAquiferIDs (const AquiferConfig &cfg)
 
std::vector< int > numericAquiferIDs (const AquiferConfig &cfg)
 
bool checkDeck (const Deck &deck, const Parser &parser, const ParseContext &parseContext, ErrorGuard &errorGuard, size_t enabledChecks)
 
template<class MapType >
void apply_tran (const std::unordered_map< std::string, Fieldprops::TranCalculator > &tran, const MapType &double_data, std::size_t active_size, const std::string &keyword, std::vector< double > &data)
 
template void apply_tran (const std::unordered_map< std::string, Fieldprops::TranCalculator > &, const std::unordered_map< std::string, Fieldprops::FieldData< double > > &, std::size_t, const std::string &, std::vector< double > &)
 
template void apply_tran (const std::unordered_map< std::string, Fieldprops::TranCalculator > &, const std::map< std::string, Fieldprops::FieldData< double > > &, std::size_t, const std::string &, std::vector< double > &)
 
std::array< int, 3 > readDims (const DeckKeyword &keyword)
 
std::ostream & operator<< (std::ostream &os, const MinpvMode &mm)
 
std::string PinchMode2String (const PinchMode enumValue)
 
PinchMode PinchModeFromString (const std::string &stringValue)
 
std::ostream & operator<< (std::ostream &os, const PinchMode pm)
 
void readKeywordCarfin (const DeckRecord &deckRecord, CarfinManager &carfinManager)
 
void setKeywordBox (const DeckRecord &deckRecord, BoxManager &boxManager)
 
Phase get_phase (const std::string &str)
 
std::ostream & operator<< (std::ostream &stream, const Phase &p)
 
bool operator== (const AquiferDimensions &lhs, const AquiferDimensions &rhs)
 
std::size_t declaredMaxRegionID (const Runspec &rspec)
 
SummaryConfigNode::Type parseKeywordType (std::string keyword)
 
SummaryConfigNode::Category parseKeywordCategory (const std::string &keyword)
 
bool operator== (const SummaryConfigNode &lhs, const SummaryConfigNode &rhs)
 
bool operator< (const SummaryConfigNode &lhs, const SummaryConfigNode &rhs)
 
bool operator!= (const SummaryConfigNode &lhs, const SummaryConfigNode &rhs)
 
bool operator<= (const SummaryConfigNode &lhs, const SummaryConfigNode &rhs)
 
bool operator> (const SummaryConfigNode &lhs, const SummaryConfigNode &rhs)
 
bool operator>= (const SummaryConfigNode &lhs, const SummaryConfigNode &rhs)
 
void updateFile (const std::string &newContent, const std::string &filename)
 
void write_file (const std::string &content, const std::string &file, bool verbose, std::string desc="source")
 
std::ostream & operator<< (std::ostream &os, const InputErrorAction action)
 
void assertFullDeck (const ParseContext &context)
 
std::string ParserKeywordSizeEnum2String (ParserKeywordSizeEnum enumValue)
 
ParserKeywordSizeEnum ParserKeywordSizeEnumFromString (const std::string &stringValue)
 
std::string ParserKeywordActionEnum2String (ParserKeywordActionEnum enumValue)
 
ParserKeywordActionEnum ParserKeywordActionEnumFromString (const std::string &stringValue)
 
template<>
const std::string & ParserItem::value_ref< std::string > () const
 
std::ostream & operator<< (std::ostream &stream, const ParserItem::item_size &sz)
 
std::ostream & operator<< (std::ostream &stream, const ParserItem &item)
 
std::ostream & operator<< (std::ostream &stream, const ParserKeyword &kw)
 
std::ostream & operator<< (std::ostream &stream, const ParserRecord &rec)
 
bool isStarToken (const std::string_view &token, std::string &countString, std::string &valueString)
 
template<>
int readValueToken< int > (std::string_view view)
 
template<>
double readValueToken< double > (std::string_view view)
 
template<>
std::string readValueToken< std::string > (std::string_view view)
 
template<>
RawString readValueToken< RawString > (std::string_view view)
 
template<>
UDAValue readValueToken< UDAValue > (std::string_view view)
 
template<class T >
readValueToken (std::string_view)
 
class __attribute__ ((visibility("default"))) PyRunModule
 
int maxGroupSize (const Schedule &sched, const std::size_t step)
 
void checkConsistentArrayDimensions (const EclipseState &es, const Schedule &sched, const ParseContext &ctxt, ErrorGuard &guard)
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getGasLiftOptHandlers ()
 Obtain a list of gasliftopt keyword handlers.
 
Group::GroupType operator| (Group::GroupType lhs, Group::GroupType rhs)
 
Group::GroupType operator& (Group::GroupType lhs, Group::GroupType rhs)
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getGroupHandlers ()
 Obtain a list of group keyword handlers.
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getGuideRateHandlers ()
 Obtain a list of guiderate keyword handlers.
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getMixingRateControlHandlers ()
 Obtain a list of mixing rate control keyword handlers.
 
template<class ICD >
std::map< std::string, std::vector< std::pair< int, ICD > > > fromWSEG (const DeckKeyword &wseg)
 
template<>
ICDStatus from_int (int int_status)
 
template<>
int to_int (ICDStatus status)
 
template<typename T >
from_int (int int_status)
 
template<typename T >
int to_int (T status)
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getMSWHandlers ()
 Obtain a list of MSW keyword handlers.
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getNetworkHandlers ()
 Obtain a list of network keyword handlers.
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getRXXHandlers ()
 Obtain a list of RFT/RPT/RST keyword handlers.
 
std::ostream & operator<< (std::ostream &os, const Schedule &sched)
 
const std::string InjectorType2String (InjectorType enumValue)
 
InjectorType InjectorTypeFromString (const std::string &stringValue)
 
std::ostream & operator<< (std::ostream &stream, const SummaryState &st)
 
UDQASTNode operator* (const UDQASTNode &lhs, double sign_factor)
 
UDQASTNode operator* (double lhs, const UDQASTNode &rhs)
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getUDQHandlers ()
 Obtain a list of UDQ keyword handlers.
 
std::unique_ptr< UDQASTNodeparseUDQExpression (const UDQParams &udq_params, UDQVarType target_type, const std::string &target_var, const KeywordLocation &location, const std::vector< UDQToken > &tokens_, const ParseContext &parseContext, ErrorGuard &errors)
 
UDQScalar operator+ (const UDQScalar &lhs, const UDQScalar &rhs)
 
UDQScalar operator+ (const UDQScalar &lhs, double rhs)
 
UDQScalar operator+ (double lhs, const UDQScalar &rhs)
 
UDQScalar operator- (const UDQScalar &lhs, const UDQScalar &rhs)
 
UDQScalar operator- (const UDQScalar &lhs, double rhs)
 
UDQScalar operator- (double lhs, const UDQScalar &rhs)
 
UDQScalar operator* (const UDQScalar &lhs, const UDQScalar &rhs)
 
UDQScalar operator* (const UDQScalar &lhs, double rhs)
 
UDQScalar operator* (double lhs, const UDQScalar &rhs)
 
UDQScalar operator/ (const UDQScalar &lhs, const UDQScalar &rhs)
 
UDQScalar operator/ (const UDQScalar &lhs, double rhs)
 
UDQScalar operator/ (double lhs, const UDQScalar &rhs)
 
UDQSet operator+ (const UDQSet &lhs, const UDQSet &rhs)
 
UDQSet operator+ (const UDQSet &lhs, double rhs)
 
UDQSet operator+ (double lhs, const UDQSet &rhs)
 
UDQSet operator- (const UDQSet &lhs, const UDQSet &rhs)
 
UDQSet operator- (const UDQSet &lhs, double rhs)
 
UDQSet operator- (double lhs, const UDQSet &rhs)
 
UDQSet operator* (const UDQSet &lhs, const UDQSet &rhs)
 
UDQSet operator* (const UDQSet &lhs, double rhs)
 
UDQSet operator* (double lhs, const UDQSet &rhs)
 
UDQSet operator/ (const UDQSet &lhs, const UDQSet &rhs)
 
UDQSet operator/ (const UDQSet &lhs, double rhs)
 
UDQSet operator/ (double lhs, const UDQSet &rhs)
 
std::ostream & operator<< (std::ostream &, const Well::WellInjectionProperties &)
 
std::ostream & operator<< (std::ostream &, const Well::WellProductionProperties &)
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getWellCompletionHandlers ()
 Obtain a list of well completion keyword handlers.
 
std::optional< int > getCompletionNumberFromGlobalConnectionIndex (const WellConnections &connections, const std::size_t global_index)
 
std::string WellStatus2String (WellStatus enumValue)
 
WellStatus WellStatusFromString (const std::string &stringValue)
 
std::ostream & operator<< (std::ostream &os, const WellStatus &st)
 
std::string WellInjectorCMode2String (WellInjectorCMode enumValue)
 
WellInjectorCMode WellInjectorCModeFromString (const std::string &stringValue)
 
std::ostream & operator<< (std::ostream &os, const WellInjectorCMode &cm)
 
std::string WellProducerCMode2String (WellProducerCMode enumValue)
 
WellProducerCMode WellProducerCModeFromString (const std::string &stringValue)
 
std::ostream & operator<< (std::ostream &os, const WellProducerCMode &cm)
 
WellWELTARGCMode WellWELTARGCModeFromString (const std::string &string_value)
 
std::string WellGuideRateTarget2String (WellGuideRateTarget enumValue)
 
WellGuideRateTarget WellGuideRateTargetFromString (const std::string &stringValue)
 
std::string WellGasInflowEquation2String (WellGasInflowEquation enumValue)
 
WellGasInflowEquation WellGasInflowEquationFromString (const std::string &stringValue)
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getWellHandlers ()
 Obtain a list of well keyword handlers.
 
std::vector< std::pair< std::string, KeywordHandlers::handler_function > > getWellPropertiesHandlers ()
 Obtain a list of well properties keyword handlers.
 
std::string tag_name (type_tag x)
 
template<typename T >
type_tag get_type ()
 
template<>
type_tag get_type< int > ()
 
template<>
type_tag get_type< double > ()
 
template<>
type_tag get_type< std::string > ()
 
template<>
type_tag get_type< RawString > ()
 
template<>
type_tag get_type< UDAValue > ()
 
template<class Scalar , class Evaluation >
Evaluation henryIAPWS (Scalar E, Scalar F, Scalar G, Scalar H, const Evaluation &temperature)
 The Henry constants in liquid water using the IAPWS 2004 formulation.
 
template<class Evaluation >
Evaluation blank (const Evaluation &x)
 
template<class Evaluation , class Scalar >
Evaluation constant (const Scalar &value)
 
template<class Evaluation , class Scalar >
Evaluation constant (unsigned numDeriv, const Scalar &value)
 
template<class Evaluation , class Scalar >
Evaluation constant (const Evaluation &x, const Scalar &value)
 
template<class Evaluation , class Scalar >
Evaluation variable (unsigned numDeriv, const Scalar &value, unsigned idx)
 
template<class Evaluation , class Scalar >
Evaluation variable (const Evaluation &x, const Scalar &value, unsigned idx)
 
template<class Evaluation , class Scalar >
Evaluation variable (const Scalar &value, unsigned idx)
 
template<class ResultEval , class Evaluation >
auto decay (const Evaluation &value) -> decltype(MathToolbox< Evaluation >::template decay< ResultEval >(value))
 
template<class Evaluation >
auto getValue (const Evaluation &val) -> decltype(MathToolbox< Evaluation >::value(val))
 
template<class Evaluation >
auto scalarValue (const Evaluation &val) -> decltype(MathToolbox< Evaluation >::scalarValue(val))
 
template<class Evaluation1 , class Evaluation2 >
ReturnEval_< Evaluation1, Evaluation2 >::type max (const Evaluation1 &arg1, const Evaluation2 &arg2)
 
template<class Evaluation1 , class Evaluation2 >
ReturnEval_< Evaluation1, Evaluation2 >::type min (const Evaluation1 &arg1, const Evaluation2 &arg2)
 
template<class Evaluation >
Evaluation abs (const Evaluation &value)
 
template<class Evaluation >
Evaluation tan (const Evaluation &value)
 
template<class Evaluation >
Evaluation atan (const Evaluation &value)
 
template<class Evaluation1 , class Evaluation2 >
ReturnEval_< Evaluation1, Evaluation2 >::type atan2 (const Evaluation1 &value1, const Evaluation2 &value2)
 
template<class Evaluation >
Evaluation sin (const Evaluation &value)
 
template<class Evaluation >
Evaluation asin (const Evaluation &value)
 
template<class Evaluation >
Evaluation sinh (const Evaluation &value)
 
template<class Evaluation >
Evaluation asinh (const Evaluation &value)
 
template<class Evaluation >
Evaluation cos (const Evaluation &value)
 
template<class Evaluation >
Evaluation acos (const Evaluation &value)
 
template<class Evaluation >
Evaluation cosh (const Evaluation &value)
 
template<class Evaluation >
Evaluation acosh (const Evaluation &value)
 
template<class Evaluation >
Evaluation sqrt (const Evaluation &value)
 
template<class Evaluation >
Evaluation exp (const Evaluation &value)
 
template<class Evaluation >
Evaluation log (const Evaluation &value)
 
template<class Evaluation >
Evaluation log10 (const Evaluation &value)
 
template<class Evaluation1 , class Evaluation2 >
ReturnEval_< Evaluation1, Evaluation2 >::type pow (const Evaluation1 &base, const Evaluation2 &exp)
 
template<class Evaluation >
bool isfinite (const Evaluation &value)
 
template<class Evaluation >
bool isnan (const Evaluation &value)
 
template<class Scalar >
Scalar arithmeticMean (Scalar x, Scalar y)
 Computes the arithmetic average of two values.
 
template<class Scalar >
Scalar geometricMean (Scalar x, Scalar y)
 Computes the geometric average of two values.
 
template<class Scalar >
Scalar harmonicMean (Scalar x, Scalar y)
 Computes the harmonic average of two values.
 
template<class Scalar , class SolContainer >
unsigned invertLinearPolynomial (SolContainer &sol, Scalar a, Scalar b)
 Invert a linear polynomial analytically.
 
template<class Scalar , class SolContainer >
unsigned invertQuadraticPolynomial (SolContainer &sol, Scalar a, Scalar b, Scalar c)
 Invert a quadratic polynomial analytically.
 
template<class Scalar , class SolContainer >
unsigned invertCubicPolynomial (SolContainer *sol, Scalar a, Scalar b, Scalar c, Scalar d)
 Invert a cubic polynomial analytically.
 
template<class Scalar , class SolContainer >
unsigned cubicRoots (SolContainer *sol, Scalar a, Scalar b, Scalar c, Scalar d)
 Invert a cubic polynomial analytically.
 
void resetLocale ()
 
template<class Scalar , unsigned staticSize>
DenseAd::Evaluation< Scalar, -1, staticSize > constant (int numDerivatives, const Scalar &value)
 
template<class Scalar , unsigned staticSize>
DenseAd::Evaluation< Scalar, -1, staticSize > variable (int numDerivatives, const Scalar &value, unsigned idx)
 
template<class FluidState >
unsigned getPvtRegionIndex_ (typename std::enable_if< HasMember_pvtRegionIndex< FluidState >::value, const FluidState & >::type fluidState)
 
template<class FluidState >
unsigned getPvtRegionIndex_ (typename std::enable_if<!HasMember_pvtRegionIndex< FluidState >::value, const FluidState & >::type)
 
template<class FluidSystem , class FluidState , class LhsEval >
auto getInvB_ (typename std::enable_if< HasMember_invB< FluidState >::value, const FluidState & >::type fluidState, unsigned phaseIdx, unsigned) -> decltype(decay< LhsEval >(fluidState.invB(phaseIdx)))
 
template<class FluidSystem , class FluidState , class LhsEval >
LhsEval getInvB_ (typename std::enable_if<!HasMember_invB< FluidState >::value, const FluidState & >::type fluidState, unsigned phaseIdx, unsigned pvtRegionIdx)
 
template<class FluidState >
auto getSaltConcentration_ (typename std::enable_if< HasMember_saltConcentration< FluidState >::value, const FluidState & >::type fluidState)
 
template<class FluidState >
auto getSaltConcentration_ (typename std::enable_if<!HasMember_saltConcentration< FluidState >::value, const FluidState & >::type)
 
template<class FluidState >
auto getSaltSaturation_ (typename std::enable_if< HasMember_saltSaturation< FluidState >::value, const FluidState & >::type fluidState)
 
template<class FluidState >
auto getSaltSaturation_ (typename std::enable_if<!HasMember_saltSaturation< FluidState >::value, const FluidState & >::type)
 
ActiveIndexByColumns buildColumnarActiveIndexMappingTables (const EclipseGrid &grid)
 Build natural->columnar active cell index mapping from an EclipseGrid instance.
 

Variables

const std::string ID_true = "true"
 
const std::string ID_false = "false"
 
const std::string ID_xmltag__param_grp = "ParameterGroup"
 
const std::string ID_xmltag__param = "Parameter"
 
const std::string ID_param_type__bool = "bool"
 
const std::string ID_param_type__int = "int"
 
const std::string ID_param_type__float = "double"
 
const std::string ID_param_type__string = "string"
 
const std::string ID_param_type__file = "file"
 
const std::string ID_param_type__cmdline = "cmdline"
 
const std::string ID_path_root = ""
 
const std::string ID_delimiter_path = "/"
 
const std::string ID_comment = "//"
 
const std::string ID_delimiter_assignment = "="
 
const std::unordered_map< std::string, std::size_t > section_index
 
constexpr int NUM_PHASES_IN_ENUM = static_cast<int>(Phase::ZFRACTION) + 1
 

Detailed Description

This class implements a small container which holds the transmissibility mulitpliers for all the faces in the grid.

The unit sets emplyed in ECLIPSE, in particular the FIELD units, are quite inconsistent.

Encapsulation of the DATUM* familiy of SOLUTION section keywords which specify depths against which to compute depth corrected cell (block), region, and field-level pressures/potentials.

The multipliers in this class are built up from the transmissibility modifier keywords:

{MULTX , MULTX- , MULTY , MULTY- , MULTZ , MULTZ-, MULTFLT , MULTREGT}

This information goes into the definition of summary keywords [FRB]PP[OGW].

Ideally one should choose units for a set of base quantities like Mass,Time and Length and then derive the units for e.g. pressure and flowrate in a consisten manner. However that is not the case; for instance in the metric system we have:

[Length] = meters [time] = days [mass] = kg

This should give:

[Pressure] = [mass] / ([length] * [time]^2) = kg / (m * days * days)

Instead pressure is given in Bars. When it comes to FIELD units the number of such examples is long.

Function Documentation

◆ arithmeticMean()

template<class Scalar >
Scalar Opm::arithmeticMean ( Scalar  x,
Scalar  y 
)
inline

Computes the arithmetic average of two values.

This uses the usual definition of the arithmethic mean:

\[
 <a(x,y)> = (x+y)/2
\]

◆ correct_parameter_tag()

std::string Opm::correct_parameter_tag ( const ParameterMapItem item)
Todo:
Doc me!
Parameters

return

◆ cubicRoots()

template<class Scalar , class SolContainer >
unsigned Opm::cubicRoots ( SolContainer *  sol,
Scalar  a,
Scalar  b,
Scalar  c,
Scalar  d 
)

Invert a cubic polynomial analytically.

The polynomial is defined as

\[ p(x) = a\; x^3 + + b\;x^3 + c\;x + d \]

This method returns the number of solutions which are in the real numbers. The "sol" argument contains the real roots of the cubic polynomial in order with the smallest root first.

Parameters
solContainer into which the solutions are written
aThe coefficient for the cubic term
bThe coefficient for the quadratic term
cThe coefficient for the linear term
dThe coefficient for the constant term

◆ demangle()

std::string Opm::demangle ( const char *  mangled_symbol)

Returns demangled name of symbol.

Non-demangled name is return if demangling is not supported

◆ geometricMean()

template<class Scalar >
Scalar Opm::geometricMean ( Scalar  x,
Scalar  y 
)
inline

Computes the geometric average of two values.

This uses the usual definition of the geometric mean:

\[
 <a(x,y)> = \sqrt{x^2 + y^2}
\]

◆ harmonicMean()

template<class Scalar >
Scalar Opm::harmonicMean ( Scalar  x,
Scalar  y 
)
inline

Computes the harmonic average of two values.

This uses the usual definition of the harmonic mean:

\[
 <a(x,y)> = \frac{2}{1/x + 1/y}
\]

◆ henryIAPWS()

template<class Scalar , class Evaluation >
Evaluation Opm::henryIAPWS ( Scalar  E,
Scalar  F,
Scalar  G,
Scalar  H,
const Evaluation &  temperature 
)
inline

The Henry constants in liquid water using the IAPWS 2004 formulation.

This function calculates $K_D$, see:

IAPWS: "Guideline on the Henry's Constant and Vapor-Liquid Distribution Constant for Gases in H2O and D2O at High Temperatures" http://www.iapws.org/relguide/HenGuide.pdf

◆ invertCubicPolynomial()

template<class Scalar , class SolContainer >
unsigned Opm::invertCubicPolynomial ( SolContainer *  sol,
Scalar  a,
Scalar  b,
Scalar  c,
Scalar  d 
)

Invert a cubic polynomial analytically.

The polynomial is defined as

\[ p(x) = a\; x^3 + + b\;x^3 + c\;x + d \]

This method teturns the number of solutions which are in the real numbers. The "sol" argument contains the real roots of the cubic polynomial in order with the smallest root first.

Parameters
solContainer into which the solutions are written
aThe coefficient for the cubic term
bThe coefficient for the quadratic term
cThe coefficient for the linear term
dThe coefficient for the constant term

◆ invertLinearPolynomial()

template<class Scalar , class SolContainer >
unsigned Opm::invertLinearPolynomial ( SolContainer &  sol,
Scalar  a,
Scalar  b 
)

Invert a linear polynomial analytically.

The polynomial is defined as

\[ p(x) = a\; x + b \]

This method Returns the number of solutions which are in the real numbers, i.e. 1 except if the slope of the line is 0.

Parameters
solContainer into which the solutions are written
aThe coefficient for the linear term
bThe coefficient for the constant term

◆ invertQuadraticPolynomial()

template<class Scalar , class SolContainer >
unsigned Opm::invertQuadraticPolynomial ( SolContainer &  sol,
Scalar  a,
Scalar  b,
Scalar  c 
)

Invert a quadratic polynomial analytically.

The polynomial is defined as

\[ p(x) = a\; x^2 + + b\;x + c \]

This method teturns the number of solutions which are in the real numbers. The "sol" argument contains the real roots of the parabola in order with the smallest root first.

Parameters
solContainer into which the solutions are written
aThe coefficient for the quadratic term
bThe coefficient for the linear term
cThe coefficient for the constant term

◆ isNondecreasing()

template<typename FI >
bool Opm::isNondecreasing ( const FI  beg,
const FI  end 
)

Detect if a sequence is nondecreasing.

Template Parameters
FIa forward iterator whose value type has operator< defined.
Parameters
begstart of sequence
endone-beyond-end of sequence
Returns
false if there exists two consecutive values (v1, v2) in the sequence for which v2 < v1, else returns true.

◆ tableIndex()

int Opm::tableIndex ( const std::vector< double > &  table,
double  x 
)
inline

Returns an index in an ordered table such that x is between table[j] and table[j+1].

If x is out of bounds, it returns a clamped index

Variable Documentation

◆ section_index

const std::unordered_map<std::string, std::size_t> Opm::section_index
Initial value:
= {
{"RUNSPEC", 0},
{"GRID", 1},
{"EDIT", 2},
{"PROPS", 3},
{"REGIONS", 4},
{"SOLUTION", 5},
{"SUMMARY", 6},
{"SCHEDULE", 7}
}