My Project
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  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  Aquancon
 
class  Aqudims
 
struct  AquiferCellProps
 
class  AquiferConfig
 
class  AquiferCT
 
class  AquiferDimensions
 
class  Aquifetp
 
class  AqutabTable
 
class  AutoICD
 
class  BCConfig
 
class  Box
 
class  BoxManager
 
class  BrineDensityTable
 
class  ColumnSchema
 
class  CompletedCells
 
class  Connection
 
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  Deck
 
class  DeckItem
 
class  DeckKeyword
 
class  DeckOutput
 
class  DeckRecord
 
class  DeckSection
 
class  DeckTree
 
class  DeckValue
 
class  DeckView
 
struct  DENSITYRecord
 
struct  DensityTable
 
class  DenT
 
struct  DiffCoeffRecord
 
struct  DiffCoeffTable
 
class  Dimension
 
class  EclHysterConfig
 
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 the reservoir state and the well state of a blackoil simulation to disk using the Eclipse binary format. More...
 
class  EclipsePRTLog
 
class  EclipseState
 
class  EDITSection
 
class  EndpointScaling
 
class  EnkrvdTable
 
class  EnptvdTable
 
class  Eqldims
 
class  Equil
 
class  EquilRecord
 
class  ErrorGuard
 
class  Events
 
class  Fault
 
class  FaultCollection
 
class  FaultFace
 
class  FieldProps
 
class  FieldPropsManager
 
class  FileDeck
 
struct  FlatTable
 
class  FlatTableWithCopy
 
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
 
class  GasLiftOpt
 
class  GasvisctTable
 
class  GConSale
 
class  GConSump
 
class  GPMaint
 
struct  GRAVITYRecord
 
struct  GravityTable
 
class  GridDims
 
class  GridProperty
 
class  GRIDSection
 
class  Group
 
class  GroupOrder
 
class  GTNode
 
class  GuideRate
 
class  GuideRateConfig
 
class  GuideRateModel
 
class  ImkrvdTable
 
class  ImportContainer
 
class  ImptvdTable
 
class  InfoLogger
 
class  InitConfig
 
class  Inplace
 
class  IOConfig
 
class  IOrderSet
 
class  JFunc
 
class  JouleThomson
 
class  KeywordGenerator
 
class  KeywordLoader
 
class  KeywordLocation
 
class  KeywordSize
 
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  LinearSolverProblem
 
class  LogBackend
 Abstract interface class for log backends. More...
 
class  Logger
 
class  MapAxes
 
class  MaterialLawProblem
 
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  MiscTable
 
class  MonotCubicInterpolator
 Class to represent a one-dimensional function f with single-valued argument x. More...
 
class  MsfnTable
 
struct  MULTREGTRecord
 
class  MULTREGTScanner
 
class  NameOrder
 
class  NetworkDims
 
class  NextStep
 
class  NNC
 
struct  NNCdata
 
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
 
struct  NumericalAquiferCell
 
struct  NumericalAquiferConnection
 
class  NumericalAquifers
 
class  NumericalProblem
 
class  Nupcol
 
class  OilVaporizationProperties
 
class  OilvisctTable
 
class  OpmInputError
 
class  OpmLog
 
class  OrderedMap
 A map with iteration in the order of insertion. More...
 
class  OutputWriter
 Interface for writing non-compositional (blackoil, two-phase) simulation state to files. More...
 
class  OverburdTable
 
class  Parameter
 
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  ParseContext
 
class  Parser
 The hub of the parsing process. More...
 
class  ParserItem
 
class  ParserKeyword
 
class  ParserRecord
 
class  PAvg
 
class  PAvgCalculator
 
class  PAvgCalculatorCollection
 
class  PbvdTable
 
class  PdvdTable
 
class  PermfactTable
 
class  Phases
 
struct  PlmixparRecord
 
struct  PlmixparTable
 
class  PlyadsTable
 
class  PlydhflfTable
 
class  PlymaxTable
 
class  PlymwinjTable
 
class  PlyrockTable
 
class  PlyshlogTable
 
class  PlyviscTable
 
struct  PlyvmhRecord
 
struct  PlyvmhTable
 
class  PmiscTable
 
class  PolyInjTable
 
class  PROPSSection
 
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  RawString
 
class  Regdims
 
class  REGIONSSection
 
class  RegulaFalsi
 
class  RegulaFalsiBisection
 
struct  RegularSegment
 
class  RestartKey
 
class  RestartValue
 
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  SatFuncControls
 
struct  SatFuncLETRecord
 
class  Schedule
 
class  ScheduleBlock
 
class  ScheduleDeck
 
class  ScheduleGrid
 
struct  ScheduleRestartInfo
 
class  SCHEDULESection
 
class  ScheduleState
 
struct  ScheduleStatic
 
class  Segment
 
class  Serializer
 Class for (de-)serializing. More...
 
class  SgcwmisTable
 
class  SgfnTable
 
struct  SgofletTable
 
class  SgofTable
 
class  SgwfnTable
 
struct  ShrateRecord
 
struct  ShrateTable
 
class  SICD
 
class  SimpleMessageFormatter
 A simple formatter capable of adding message prefixes and colors. More...
 
class  SimpleTable
 
class  SimulationConfig
 
struct  SimulatorUpdate
 
class  SingleNumericalAquifer
 
class  SkprpolyTable
 
class  SkprwatTable
 
class  SlgofTable
 
class  Sof2Table
 
class  Sof3Table
 
class  SOLUTIONSection
 
class  SolventDensityTable
 
class  SorwmisTable
 
class  SparseVector
 A SparseVector stores a vector with possibly many empty elements as efficiently as possible. More...
 
class  SpecheatTable
 
class  SpecrockTable
 
class  SsfnTable
 
struct  StandardCond
 
struct  Stone1exRecord
 
struct  Stone1exTable
 
class  StreamLog
 
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  ThresholdPressure
 
struct  ThrowOnError
 
class  TimerLog
 
class  TimeStampUTC
 
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
 
struct  Tuning
 
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  UniformTableLinear
 This class uses linear interpolation to compute the value (and its derivative) of a function f sampled at uniform points. More...
 
class  UnitSystem
 
class  Valve
 
class  VFPInjTable
 
class  VFPProdTable
 Class for reading data from a VFPPROD (vertical flow performance production) table. More...
 
struct  VISCREFRecord
 
struct  ViscrefTable
 
struct  WarnAndContinueOnError
 
struct  WATDENTRecord
 
struct  WatdentTable
 
class  WatvisctTable
 
class  Well
 
struct  WellBrineProperties
 
class  WellConnections
 
class  Welldims
 
class  WellEconProductionLimits
 
struct  WellFoamProperties
 
class  WellGroupEvents
 
class  WellMatcher
 
struct  WellMICPProperties
 
struct  WellPolymerProperties
 
class  WellSegmentDims
 
class  WellSegments
 
class  WellTestConfig
 
class  WellTestState
 
class  WellTracerProperties
 
class  WellType
 
class  WList
 
class  WListManager
 
class  WriteRestartFileEvents
 
class  WVFPEXP
 
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 > > >
 
typedef std::map< std::pair< int, int >, const MULTREGTRecord * > MULTREGTSearchMap
 
typedef std::tuple< size_t, FaceDir::DirEnum, double > MULTREGTConnection
 
using Map = std::unordered_map< std::string, std::size_t >
 

Enumerations

enum class  Section {
  RUNSPEC , GRID , EDIT , PROPS ,
  REGIONS , SOLUTION , SUMMARY , SCHEDULE
}
 
enum  DeckChecks { SectionTopology = 0x0001 , KeywordSection = 0x0002 , UnknownKeywords = 0x0004 , AllChecks = 0xffff }
 
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  BCType { RATE , FREE }
 
enum class  BCComponent {
  OIL , GAS , WATER , SOLVENT ,
  POLYMER , NONE
}
 
enum  ParserKeywordSizeEnum {
  SLASH_TERMINATED = 0 , FIXED = 1 , OTHER_KEYWORD_IN_DECK = 2 , UNKNOWN = 3 ,
  FIXED_CODE = 4 , DOUBLE_SLASH_TERMINATED = 5
}
 
enum  ParserKeywordActionEnum { INTERNALIZE = 0 , IGNORE = 1 , IGNORE_WARNING = 2 , THROW_EXCEPTION = 3 }
 
enum class  ICDStatus { OPEN , SHUT }
 
enum class  ScheduleTimeType { START = 0 , DATES = 1 , TSTEP = 2 , RESTART = 3 }
 
enum class  InjectorType { WATER = 1 , GAS = 2 , OIL = 3 , MULTI = 4 }
 
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
}
 
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 , 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 , 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  type_tag {
  unknown = 0 , integer = 1 , string = 2 , raw_string = 3 ,
  fdouble = 4 , uda = 5
}
 

Functions

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)
 
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. More...
 
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 &type)
 
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)
 
template<typename T >
std::decay< T >::type uppercase (T &&x)
 
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)
 
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)
 
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)
 
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=AllChecks)
 
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)
 
Phase get_phase (const std::string &)
 
std::ostream & operator<< (std::ostream &, const Phase &)
 
bool operator== (const AquiferDimensions &lhs, const AquiferDimensions &rhs)
 
SummaryConfigNode::Category parseKeywordCategory (const std::string &keyword)
 
SummaryConfigNode::Type parseKeywordType (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)
 
const std::string ParserKeywordActionEnum2String (ParserKeywordActionEnum enumValue)
 
const std::string ParserKeywordSizeEnum2String (ParserKeywordSizeEnum enumValue)
 
ParserKeywordSizeEnum ParserKeywordSizeEnumFromString (const std::string &stringValue)
 
ParserKeywordActionEnum ParserKeywordActionEnumFromString (const std::string &stringValue)
 
std::ostream & operator<< (std::ostream &, const ParserItem::item_size &)
 
std::ostream & operator<< (std::ostream &, const ParserKeyword &)
 
std::ostream & operator<< (std::ostream &, const ParserRecord &)
 
int maxGroupSize (const Schedule &sched, const std::size_t step)
 
void checkConsistentArrayDimensions (const EclipseState &es, const Schedule &sched, const ParseContext &ctxt, ErrorGuard &guard)
 
Group::GroupType operator| (Group::GroupType lhs, Group::GroupType rhs)
 
Group::GroupType operator& (Group::GroupType lhs, Group::GroupType rhs)
 
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 rhs)
 
UDQASTNode operator* (double lhs, const UDQASTNode &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)
 
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::ostream & operator<< (std::ostream &os, const Well::Status &st)
 
std::ostream & operator<< (std::ostream &os, const Well::ProducerCMode &cm)
 
std::ostream & operator<< (std::ostream &os, const Well::InjectorCMode &cm)
 
std::optional< int > getCompletionNumberFromGlobalConnectionIndex (const WellConnections &connections, const std::size_t global_index)
 
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 > ()
 
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 = "="
 
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.

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

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

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

◆ correct_parameter_tag()

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

return

◆ 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.