Summary requests

Reservoir meaning

Summary requests ask the simulator to write time-series diagnostics. They do not change reservoir physics; they control what results are available for inspection, plotting, and equivalence checks. PetroScript names each quantity, so users ask for field, well, group, completion, aquifer, block, and fluid-in-place region quantities without memorizing vector names.

Common quantities

A quantity is asked for and read by one name in every scope. The scope picks the Flow vector: oil_production_rate is FOPR for the field, WOPR for a well, GOPR for a group.

Name	Field	Well	Group	Unit (FIELD, METRIC)
oil_production_rate	FOPR	WOPR	GOPR	stb/day, sm3/day
water_production_rate	FWPR	WWPR	GWPR	stb/day, sm3/day
gas_production_rate	FGPR	WGPR	GGPR	Mscf/day, sm3/day
liquid_production_rate	FLPR	WLPR	GLPR	stb/day, sm3/day
oil_production_total	FOPT	WOPT	GOPT	stb, sm3
gas_production_total	FGPT	WGPT	GGPT	Mscf, sm3
water_production_total	FWPT	WWPT	GWPT	stb, sm3
water_injection_rate	FWIR	WWIR	GWIR	stb/day, sm3/day
gas_injection_rate	FGIR	WGIR	GGIR	Mscf/day, sm3/day
water_cut	FWCT	WWCT	GWCT	fraction
gas_oil_ratio	FGOR	WGOR	GGOR	Mscf/stb, sm3/sm3
bottom_hole_pressure		WBHP		psia, barsa
tubing_head_pressure		WTHP		psia, barsa
pressure	FPR			psia, barsa (also blocks: BPR, regions: RPR)
oil_in_place	FOIP			stb, sm3 (also regions: ROIP)

ps.help goes both ways. ps.help("WBHP") prints WBHP: the well quantity bottom_hole_pressure and the line that asks for it and reads it: ps.Summary(wells={"*": ["bottom_hole_pressure"]}); run.wells("bottom_hole_pressure"). ps.help("gas_oil_ratio") lists its vector in every scope. Results come back in the model’s units, each frame with a unit column (Units and bare numbers).

From-scratch authoring

State the summary requests as a ps.Summary, each scope’s quantities by name, and give it to the model as summary=. Region-scope quantities name fluid-in-place regions by number, and the matching numbered region map is declared on the model through ps.Regions(fluid_in_place=...):

import numpy as np

import petroscript as ps

summary = ps.Summary(
    field=["oil_production_rate", "water_cut", "oil_in_place", "water_in_place"],
    wells={"PROD1": ["tubing_head_pressure"]},
    blocks={(1, 1, 1): ["oil_saturation"]},
    regions={1: ["pressure"], 2: ["pressure", "oil_in_place"]},
)

model = ps.Model(
    name="SUMMARY_SCOPES",
    units="field",
    start="2020-01-01",
    grid=ps.grid.Cartesian(shape=(2, 2, 1), dx=500.0, dy=500.0, dz=40.0, top=2500.0),
    rock=ps.Rock(porosity=0.25, permeability=120.0, vertical_ratio=1.0),
    fluid=ps.fluid.OilWater(
        oil=ps.pvt.DeadOil(pressure=[14.7, 3500.0], oil_fvf=[1.06, 1.0], oil_viscosity=[1.0, 1.2]),
        water=ps.pvt.Water(
            reference_pressure=3000.0,
            fvf=1.0,
            compressibility=3.0e-6,
            viscosity=0.5,
            viscosibility=0.0,
        ),
        oil_surface_density=53.0,
        water_surface_density=64.0,
    ),
    relperm=[ps.relperm.OilWater(sw=[0.20, 0.80], krw=[0.0, 1.0], krow=[1.0, 0.0], pcow=[0.0, 0.0])],
    regions=ps.Regions(fluid_in_place=np.array([[[1], [1]], [[2], [2]]], dtype=int)),
    initial=ps.initial.Equilibrium(
        datum_depth=2510.0, datum_pressure=3000.0, oil_water_contact=2600.0, gas_oil_contact=0.0
    ),
    wells=[ps.Well(name="PROD1", i=1, j=1), ps.Well(name="INJ1", i=2, j=2)],
    schedule=ps.Schedule(
        report=[ps.Every(30.0, 30.0)],
        events=[
            ps.Event(
                "2020-01-01",
                ps.Perforate(well="PROD1", k=(1, 1), diameter=0.3),
                ps.Perforate(well="INJ1", k=(1, 1), diameter=0.3),
                ps.Produce(well="PROD1", oil_rate=150.0, bhp_limit=1200.0),
                ps.Inject(well="INJ1", phase="water", rate=300.0, bhp_limit=4500.0),
            )
        ],
    ),
    summary=summary,
)

The requested quantities lower to FOPR, FWCT, FOIP, FWIP, WTHP, BOSAT, RPR, and ROIP cards in the SUMMARY section; the vector spelling is a compiler concern.

Add requests to a summary you hold

A loaded deck already asks for its quantities. m.summary.replace(field=[...]), replace(wells={...}) and m.set("summary/field", [...]) replace the whole list or map they name: every request not restated is dropped. To add without dropping, keep what is there (m.set("summary/field", [*m.summary.field, "water_cut"])) or set the one address that changes:

more = model.set("summary/field/oil_production_total", "oil_production_total")   # one more
more = more.set("summary/wells/PROD1",                                           # one well's list
                [*more.summary.wells.get("PROD1", ()), "bottom_hole_pressure", "water_cut"])
assert "oil_production_rate" in more.summary.field                               # still there
assert more.summary.blocks == model.summary.blocks                               # untouched

"*" stands for every well (more.set("summary/wells/*", [...])), and None at an address removes that request.

The summary vector registry

The summary vector family registry names, per scope, every semantic summary quantity and the result vector it reports, so a quantity has a registry cell exactly when ps.Summary can request it.

A registry cell states that the vector is legal, not that every simulator reports it. Vectors a target parses and then reports nothing for keep their name, their lowering, and their importer row; compiling for that target attaches a warning-level target.vector_unemitted issue on the deck’s deck.issues naming each one with the release that measured it, so an ECLIPSE client’s request survives import, edit, and compile unchanged. For OPM Flow those vectors include the field/group water-gas ratios (FWGR, GWGR), the field oil-gas ratio (FOGR), and the field aquifer influx family (FAQR, FAQT, FAQRG, FAQTG).

Economics and statistics

Surface economics and operational statistics are named quantities, not phase selectors: gas sales, consumption, and import; gas lift; well/group efficiency factors; producing/injecting well counts; and well gas voidage rates. They are requested by name, as the physics quantities are:

import petroscript as ps

summary = ps.Summary(
    field=[
        "gas_sales_rate",
        "gas_consumption_rate",
        "producing_well_count",
        "injecting_well_count",
    ]
)

At group scope the same names report GGSR/GGCR/GMWPR/GMWIN, plus efficiency_factor (GEFF). At well scope gas_lift_rate (WGLIR), artificial_lift_quantity (WALQ), efficiency_factor (WEFF), efficiency_factor_product (WEFFG), and the gas voidage rates (gas_voidage_injection_rate / gas_voidage_production_rate) are available. Cumulative well-count totals are documented in the manual but not reported by OPM Flow, so they stay outside the registry and ps.Summary.

EOR and chemistry option vectors

Salt (brine) and solvent transport quantities are named registry quantities at field, group, well, and block scope. They lower to plain SUMMARY vectors and OPM Flow reports them only when the matching physics package (ps.brine.Package, ps.solvent.Package) is in the model’s physics=[...]:

import petroscript as ps

summary = ps.Summary(field=["salt_production_rate", "solvent_injection_rate"])

At group scope salt_production_rate, salt_injection_rate, salt_injection_total, and salt_production_concentration report GSPR/GSIR/GSIT/GSPC; the four solvent names report GNPR/GNPT/GNIR/GNIT. Well scope adds salt_production_total (WSPT) and the same rate/total/concentration names (WSPR, WSIR, WSIT, WSPC, WNPR, WNPT, WNIR, WNIT), and blocks= carries solvent_saturation (BNSAT). salt_in_place (FSIP) is field-only.

A passive tracer’s vectors are stated by the tracer’s name and the scope, shaped as history= is: ps.Summary(tracers={"WT1": {"field": ["production_rate"], "wells": {"P1": ["production_total"]}}}) reports the name-qualified vectors (FTPRWT1, WTPTWT1), six quantities at each scope (production_rate, production_total, injection_rate, injection_total, production_concentration, injection_concentration). A tracer the model declares must back tracers=; undeclared_tracers= keeps a name a deck asks for and declares nothing behind (Flow runs it and writes no column).

The polymer and MICP vectors are the scopes’ own quantity names: polymer_<measure> (polymer_injection_rate is FCIR/GCIR/WCIR, polymer_adsorbed_mass is FCAD/RCAD) and <component>_<measure> from the MICP component’s word (microbes_in_place is FMMIP/RMMIP/BMMIP, urea_injection_total is FMUIT/GMUIT/WMUIT/CMUIT, and urea_injection_total_per_completion is CMUITL). MICP group scope reports cumulative totals only (GMMIT … GMUPT). Group-scope MICP rates, foam summary vectors, salt/solvent in-place variants beyond FSIP/BNSAT, tracer in-place and group vectors, oil API tracking, and the block polymer concentration family are documented in the manual but either unreported or natively rejected by OPM Flow, so they stay outside ps.Summary.

Write frequency and restart output

Summary data is written for every simulator timestep by default. The write policy on ps.Summary controls that frequency as reservoir intent: write_frequency="report_steps_only" keeps only the report-step rows, write_interval=days thins output to at most one timestep per interval (report steps are always kept), and write_frequency="every_timestep" states the default explicitly. A report-steps-only policy already skips every sub-report timestep, so a model stating it with write_interval is refused (summary.write_policy.conflict).

Restart output has the same intent-level controls on ps.Output: the schedule’s printed report can request restart data at every report time with print=["restart_frequency=level"], and periodic restart output is thinned with restart=["basic=3", "frequency=n"] (every n-th report step; basic levels 4 and 5 thin by years and months).

import petroscript as ps

model = ps.Model(
    name="REPORT_POLICY",
    units="field",
    start="2020-01-01",
    grid=ps.grid.Cartesian(shape=(2, 2, 1), dx=500.0, dy=500.0, dz=40.0, top=2500.0),
    rock=ps.Rock(porosity=0.25, permeability=120.0, vertical_ratio=1.0),
    fluid=ps.fluid.OilWater(
        oil=ps.pvt.DeadOil(pressure=[14.7, 3500.0], oil_fvf=[1.06, 1.0], oil_viscosity=[1.0, 1.2]),
        water=ps.pvt.Water(
            reference_pressure=3000.0,
            fvf=1.0,
            compressibility=3.0e-6,
            viscosity=0.5,
            viscosibility=0.0,
        ),
        oil_surface_density=53.0,
        water_surface_density=64.0,
    ),
    relperm=[ps.relperm.OilWater(sw=[0.20, 0.80], krw=[0.0, 1.0], krow=[1.0, 0.0], pcow=[0.0, 0.0])],
    initial=ps.initial.Equilibrium(
        datum_depth=2510.0, datum_pressure=3000.0, oil_water_contact=2600.0, gas_oil_contact=0.0
    ),
    wells=[ps.Well(name="PROD1", i=1, j=1), ps.Well(name="INJ1", i=2, j=2)],
    schedule=ps.Schedule(
        report=[ps.Every(30.0, 30.0)],
        events=[
            ps.Event(
                "2020-01-01",
                ps.Perforate(well="PROD1", k=(1, 1), diameter=0.3),
                ps.Perforate(well="INJ1", k=(1, 1), diameter=0.3),
                ps.Produce(well="PROD1", oil_rate=150.0, bhp_limit=1200.0),
                ps.Inject(well="INJ1", phase="water", rate=300.0, bhp_limit=4500.0),
            )
        ],
    ),
    summary=ps.Summary(field=["oil_production_rate"], write_frequency="report_steps_only"),
    output=ps.Output(print=["wells", "restart_frequency=1"], restart=["basic=3", "frequency=2"]),
)

Print-file report content in the schedule section is silenced with ps.Output(print=["no_reports"]), which cannot be combined with other print requests.

CO2 and hydrogen storage vectors

Storage-model quantities are named registry quantities that OPM Flow reports when a ps.storage.Package (CO2 or hydrogen) is in the model’s physics=[...]. The stored-gas mass flow names (gas_mass_injection_rate, gas_mass_injection_total, gas_mass_production_rate, gas_mass_production_total) exist at field, group, and well scope (FGMIR/GGMIR/WGMIR and the IT/PR/PT spellings):

import petroscript as ps

summary = ps.Summary(field=["gas_mass_injection_rate", "gas_mass_dissolved"])

The stored-gas state partition is reported at field, region, and block scope (F*/R*/B*): gas_mass_in_place (GMIP), gas_mass_in_gas_phase (GMGP), gas_mass_dissolved (GMDS), the residual-trapping partition (gas_mass_trapped_effective/gas_mass_untrapped_effective for GMST/ GMUS, gas_mass_trapped_maximum/gas_mass_untrapped_maximum for GMTR/ GMMO, gas_mass_immobile_by_relperm/gas_mass_mobile_by_relperm for GKTR/GKMO), the molar partition (gas_moles_immobile/gas_moles_mobile for GCDI/GCDM, gas_moles_immobile_by_relperm/ gas_moles_mobile_by_relperm for GKDI/GKDM, gas_moles_dissolved for WCD), and the water split (vaporized_water_in_place for WIPG, liquid_water_in_place for WIPL). Region scope takes fluid-in-place region numbers (regions={n: [...]}), and block scope takes cell tuples. The connection flow spellings (CGMIR … CGMPT, CGMIRL … CGMPTL) belong to the connection scope — see “Connection summary vectors” below.

Thermal, segment, network, and user-defined vectors

Thermal energy accounting extends the existing well heat quantities to field and group scope: produced_heat_rate/produced_heat_total and injected_heat_rate/injected_heat_total report FTPRHEA/FTPTHEA/ FTIRHEA/FTITHEA at field scope and the GT*HEA spellings at group scope. Flow reports them only when the model carries a ps.thermal.Package.

Multisegment wells expose a segment scope: segments={(well, number): [...]} names a segment of the well’s ps.wells.Segments tree and takes the segment flow, pressure-drop, holdup, density, viscosity, and ratio quantities (SOFR, SGFR, SWFR, SPR, SPRD, SPRDF, SPRDH, SPRDA, SOHF, SGHF, SWHF, SMDEN, SODEN, SOVIS, SWCT, SGOR, and the remaining registry cells). Each request lowers to one 'WELL' segment / record, and validation checks every segment against the scheduled segment trees. segments={well: [...]} states a well’s whole segment axis instead, and lowers to the 'WELL' / record the deck writes for it; validation checks the well but has no member to check, the width covering segments the well declares later as well.

Production-network node pressures are group-scope quantities: network_node_pressure (GPR) and network_node_pressure_end_of_timestep (GNETPR); Flow reports them when an extended network is scheduled. Filter-cake filtrate accounting is a well-scope pair: filtrate_volume_injection_rate/filtrate_volume_injection_total (WINJFVR/WINJFVT). Scheduled user-defined quantities export to the summary with user_defined={name: [...]} for FU_* (field) and WU_* (well) names, and performance=True remains the macro for the Flow runtime diagnostics family (PERFORMA).

The example below uses both: ps.actions.field().oil_production_rate is a typed expression quantity (here in the user-defined quantity FU_OPLIM), while "produced_heat_rate" in a ps.Summary requests an output time series:

import petroscript as ps

# Expression quantity: feeds a user-defined-quantity expression.
oil_limit = ps.actions.UserQuantity(
    name="FU_OPLIM", expression=ps.actions.field().oil_production_rate * 0.9
)

# Output requests: name result time series on the summary.
summary = ps.Summary(
    field=["produced_heat_rate", "injected_heat_total"],
    wells={"*": ["filtrate_volume_injection_rate"]},
    groups={"G1": ["network_node_pressure"]},
    segments={("PROD1", 1): ["pressure"], ("PROD1", 2): ["pressure", "oil_flow_rate"]},
    user_defined={oil_limit.name: []},
    performance=True,
)

Connection summary vectors

Well connections addressed by grid coordinates form their own summary scope, distinct from the numbered completion scope: connections={(well, i, j, k): [...]} names one physical cell connection of one well.

The connection scope carries the stored-gas mass flow quantities (gas_mass_injection_rate/..._total, gas_mass_production_rate/..._total for CGMIR/CGMIT/CGMPR/CGMPT, with _per_completion variants for the completion-lumped CGMIRL…CGMPTL spellings; Flow reports them under an active storage feature body) and the filter-cake formation-damage family (filtrate_volume_injection_rate/..._total for CINJFVR/CINJFVT plus filter_cake_skin, filter_cake_radius, filter_cake_width, filter_cake_permeability, filter_cake_porosity, and filter_cake_area_open_to_flow for CFCSKIN/CFCRAD/CFCWIDTH/CFCPERM/ CFCPORO/CFCAOF; Flow reports them when filter-cake injection damage is scheduled). Each request lowers to one 'WELL' I J K / record per connection, and validation checks that the well is scheduled (summary.connections.unknown_well) and that the coordinates name a cell inside one of the well’s declared completion intervals (summary.connections.unknown_connection):

import petroscript as ps

cake_cell = ("INJ1", 2, 2, 1)  # the well, then the connection's cell (i, j, k)

summary = ps.Summary(
    connections={
        cake_cell: [
            "filtrate_volume_injection_rate",
            "filter_cake_skin",
            "gas_mass_injection_rate",
        ]
    }
)

The plain flow quantities are here too — oil_production_total, gas_injection_total, gas_production_rate and water_production_rate for COPT, CGIT, CGPR and CWPR — alongside the three production rates read over LUMPED completions, whose mnemonics are the connection ones with an L suffix: oil_production_rate_per_completion, gas_production_rate_per_completion and water_production_rate_per_completion for COPRL, CGPRL and CWPRL.

pressure is the pressure at the connection, and its mnemonic CPR is the one word in this vocabulary that spells two different constructs. In RUNSPEC, CPR switches the linear solver’s constrained-pressure-residual preconditioner on and is a run instruction (ps.Numerics(constrained_pressure_residual=True)); in SUMMARY it is this request. Nothing about the word tells them apart, so the importer reads the section the card was written in and never guesses, and a CPR in any third section is refused in both their names.

User quantities that read a summary vector

A user-defined quantity’s formula may read a summary vector as an operand, and the operand may name the ONE OBJECT it is read over. Which kind of object that is follows from the scope, and each is the model’s own typed value rather than a name: a well at well scope (ps.actions.well(well).water_cut, WWCT 'PROD1'), a group at group scope (ps.actions.group(group).efficiency_factor, GEFF 'G1'), and a fluid-in-place region at region scope (ps.actions.region(2).oil_in_place, ROIP 2). A region operand may also name the FIP set its region belongs to (ps.actions.region(2, fluid_in_place_set="RE2")), which the mnemonic carries as three characters after a five-character padded base — ROIP_RE2 is the oil in place of the RE2 set. The set is held by name and the spelling is re-derived, exactly as the region summary REQUEST holds it.

A formula may also read a quantity the schedule defines FURTHER DOWN. There is no definition above it to point at, and what such a formula reads is whatever the name is carrying when the run evaluates it, so the reference is the name:

import petroscript as ps

early = ps.actions.UserQuantity(
    name="FU_EARLY", expression=ps.actions.UserQuantity.read("FU_LATE") * 2
)

The name still has to be one the schedule declares somewhere. A name nothing ever defines is refused (schedule.udq.reference_unresolved), and the deck’s own statement order survives the compile — moving the definition above its use would be a different schedule.

PetroScript API

Summary

ps.Summary is the vectors a run records, as data: ps.Summary(field=[...], wells={well or "*": [...]}, groups=..., regions={number: [...]}, blocks={(i, j, k): [...]}), each quantity by its name; a deck’s mnemonic ("FOPR") is refused naming its name (oil_production_rate). The model holds it as Model.summary, each scope’s requests in the order stated.

Field quantities

field=[...] names field-wide quantities. Names include oil_production_rate, oil_production_total, water_production_rate, water_production_total, gas_production_rate, gas_production_total, the injection family (oil_injection_rate, oil_injection_total, water_injection_rate, water_injection_total, gas_injection_rate, gas_injection_total), gas_oil_ratio, gas_liquid_ratio, water_cut, liquid_production_rate, liquid_production_total, pressure, oil_recovery_efficiency, the reservoir-volume family (reservoir_volume_production_rate, reservoir_volume_production_total, reservoir_volume_injection_rate, reservoir_volume_injection_total), and each phase’s in-place quantity (oil_in_place, water_in_place, gas_in_place). Every phase’s rate, total and in-place quantity is its own name; there is no selector over a list of phases.

Well quantities

wells={member: [...]} names well quantities for a well’s name, a pattern ("P*", the wells it matches when Flow reads it) or "*", every well, which writes the deck’s whole-well record. Names include bottom_hole_pressure, block_average_pressure (with _four_point, _five_point, and _nine_point variants driven by the ps.wells.PressureAveraging statement), tubing_head_pressure, gas_oil_ratio, gas_liquid_ratio, water_gas_ratio, oil_gas_ratio, liquid_production_rate, the per-phase names (oil_production_rate/oil_production_total, water_production_rate/ water_production_total, gas_production_rate/gas_production_total, and the *_injection_rate/*_injection_total counterparts), plus well potential/control diagnostics such as oil_production_potential, water_production_potential, gas_production_potential, productivity_index, control_mode, and reservoir_volume_production_rate. A well the model does not declare is refused (summary.wells.unknown); undeclared_wells keeps a name a deck asks for and declares nothing behind.

The segment and connection scopes carry the same width one level down, over the members of a single well: segments={well: [...]} asks for every segment the well declares and connections={well: [...]} for every connection it holds, each written back as the deck writes it — a record naming the well and nothing after it. segments={"*": [...]} is the whole-population form, the record with no members in it. A width is not the list of members standing when the request is read: a well that declares another segment, or is perforated again, after a time card reports under the width and would not under an enumeration.

Completion quantities

completions={(well, i, j, k1, k2): [...]} names completion-level diagnostics for one perforated interval of a well, matched against the well’s declared completions before compiling: the user names the completion interval, not a summary vector row.

Names include oil_production_rate, oil_production_total, water_production_rate, water_production_total, gas_production_rate, gas_production_total, water_injection_rate, water_injection_total, gas_injection_rate, gas_injection_total, liquid_production_total, water_cut, and gas_oil_ratio.

Connection quantities

connections={(well, i, j, k): [...]} names coordinate-connection diagnostics, and connections={well: [...]} states the whole connection axis of the well it names instead of enumerating its cells. Names are the stored-gas mass flow quantities (with their _per_completion variants) and the filter-cake formation-damage family listed under “Connection summary vectors”.

Output report controls

ps.Summary(run_summary=True) requests an ASCII run-summary report in addition to the binary summary output produced by the simulator. separate_reports=True requests separated report output where the target supports that convention. These describe desired result artifacts; they do not create reservoir variables or alter simulation controls.

Group quantities

groups={member: [...]} names operating-group diagnostics for a group’s name or "*", every group. Names include oil_production_rate, oil_production_total, water_production_rate, water_production_total, gas_production_rate, gas_production_total, the injection family (oil_injection_rate, oil_injection_total, water_injection_rate, water_injection_total, gas_injection_rate, gas_injection_total), liquid_production_rate, liquid_production_total, water_cut, gas_oil_ratio, control_mode, and the reservoir-volume family (reservoir_volume_production_rate, reservoir_volume_production_total, reservoir_volume_injection_rate, reservoir_volume_injection_total).

A group name nothing declares is not refused: OPM Flow runs such a deck, warns Request for missing group <name> in <vector> and writes no column, so an imported deck’s request is kept as the name it states through undeclared_groups={name: [...]} and reported at info level (summary.groups.undeclared). Authored models name the groups they declare.

Region quantities

regions={number: [...]} names fluid-in-place region diagnostics over the numbered FIPNUM map declared through ps.Regions(fluid_in_place=...); "*" asks for every region. Names are pressure, each phase’s in-place quantity (oil_in_place, water_in_place, gas_in_place), and the phase rates and totals (oil_production_rate, water_injection_total, and the rest). A member ("ABC", 2) reads region 2 of the named set ABC instead, which counts its own regions.

How far a request may reach is set by what the model declares, not by which cells carry a region number: a model reserving three regions answers the third even where no cell reaches it. A request past that count, or one naming a set the model never declares, is not refused — OPM Flow runs such a deck, drops those columns with a warning and completes — so it is reported at info level (summary.regions.undeclared, summary.regions.set_undeclared) and kept as stated.

Block quantities

blocks={(i, j, k): [...]} names grid cells for block quantities. Names include pressure, oil_saturation, gas_saturation, water_saturation, solution_gas_oil_ratio, and each phase’s in-place quantity.

Aquifer quantities

aquifers={number: [...]} (or "*") names aquifer-wide diagnostics for the analytic aquifers attached to the model. Names include water_flow_rate and water_flow_total. These requests observe aquifer exchange with the reservoir; they do not create or configure aquifers.

Units and shapes

Summary selectors use one-based well/block semantics matching the deck. Output vectors inherit the simulator’s units for the active deck unit system.

Validation and common mistakes

Common mistakes are naming a well the model does not declare (summary.wells.unknown), requesting block vectors outside the grid (summary.blocks.out_of_bounds), spelling a deck mnemonic ("FOPR") where the quantity’s name (oil_production_rate) belongs, and treating summary vectors as controls.

Lowers to

Current status: emitted now for the implemented summary quantities.

Quantity names lower to vector names as compiler output:

• Field oil production rate -> FOPR.
• Field oil production total -> FOPT.
• Field water production rate -> FWPR.
• Field gas injection rate/total -> FGIR and FGIT.
• Field gas production rate/total -> FGPR and FGPT.
• Field gas-oil ratio -> FGOR.
• Field average pressure -> FPR.
• Well bottom-hole pressure -> WBHP.
• Well block-average pressures -> WBP, WBP4, WBP5, and WBP9.
• Well productivity/injectivity index -> WPI.
• Well gas-oil ratio -> WGOR.
• Well phase rates -> injector/producer vectors such as WOIR, WOPR, WWIR, WWPR, WGIR, and WGPR.
• Field reservoir-volume production rate -> FVPR.
• Well phase totals -> injector/producer vectors such as WOIT, WOPT, WWIT, WWPT, WGIT, and WGPT.
• Well potential/control/reservoir-volume diagnostics -> WOPP, WWPP, WGPP, WMCTL, and WVPR.
• Completion diagnostics -> vectors such as WOPRL, WOPTL, WWPRL, WWPTL, WGPRL, WGPTL, WWIRL, WWITL, WGIRL, WGITL, WLPTL, WWCTL, and WGORL.
• Group production/control/reservoir-volume diagnostics -> GOPR, GWPR, GGPR, GLPR, GLPT, GWCT, GGOR, GMCTP, GVPR, GVPT, GVIR, and GVIT.
• Group phase quantities -> vectors such as GOPT, GWPT, GGPT, GOIR, GOIT, GWIR, GWIT, GGIR, and GGIT.
• Field liquid/ratio/in-place/recovery diagnostics -> FLPR, FLPT, FWCT, FGLR, FOIP, FGIP, FWIP, FOE, FVPT, FVIR, and FVIT.
• Field phase quantities -> vectors such as FWPT, FOIR, FOIT, FWIR, and FWIT.
• Well head-pressure/liquid/ratio diagnostics -> WTHP, WLPR, WGLR, WWGR, and WOGR.
• Block pressure -> BPR.
• Block saturations -> BOSAT, BGSAT, and BWSAT.
• Block in-place and solution ratio -> BOIP, BGIP, BWIP, and BRS.
• Region diagnostics -> RPR, ROIP, RGIP, RWIP, and the region phase quantities ROPR, ROPT, RWPR, RWPT, RGPR, RGPT, ROIR, ROIT, RWIR, RWIT, RGIR, and RGIT.
• Aquifer water flow rate -> AAQR.
• Aquifer water flow total -> AAQT.
• ASCII run summary and separated report controls -> RUNSUM and SEPARATE.

Additional summary vectors in OPM/ECLIPSE decks are future/unsupported until a quantity name and lowerer are added.