From df352a645015e1553413fbc565d27c840aeb596f Mon Sep 17 00:00:00 2001 From: patnr Date: Thu, 17 Sep 2026 09:24:27 +0200 Subject: [PATCH 1/2] Simulator: MiniRes, a two-phase forward model that needs nothing installed MiniRes (https://github.com/patnr/MiniRes) is a pure-Python, two-phase (water/oil) TPFA reservoir simulator: no binary, no licence, no deck, no scratch folder. Wrapping it gives PET a *physical* forward model that a tutorial, a test or CI can run anywhere -- where until now the only models that ran unattended were analytical ones. The wrapper satisfies `ForwardSimulator` as it stands; nothing in the ensemble or the schemes needed changing. Each member runs on its own deepcopy of the model, so it parallelizes through `p_map` unchanged (MiniRes drops its cached pressure preconditioner on copy, which is what makes that safe). Three conventions are the wrapper's own, since MiniRes is agnostic about them, and its module docstring states them: report points are step indices (MiniRes takes a uniform dt); `field_order` reconciles MiniRes's C-major grid with the Fortran ordering the rest of PET's tooling assumes; and data types are named as Eclipse summary vectors (WOPR:PRD1, FWIR, ...) so observed-data files and datatype filters need no adaptation. Unknown quantities and unknown well names are refused when the simulator is built, not mid-forecast. With `compute_adjoints`, it also returns each datum's sensitivity to the state, so the adjoint-based analyses get their first field-scale case: MiniRes differentiates its own time stepper, one backward sweep per datum. Covered for WWCT/WWPR/WOPR at rate-controlled wells; a BHP-controlled well's rate is itself a function of the state, so it is refused rather than silently wrong. The tests check the sensitivities against central differences. MiniRes is an optional dependency: it requires Python >= 3.12, whereas PET supports 3.10, so it is a `[minires]` extra and the tests skip without it. Co-Authored-By: Claude Opus 5 (1M context) --- pyproject.toml | 5 + src/simulator/minires.py | 349 +++++++++++++++++++++++++++++++ tests/test_minires_sim.py | 139 ++++++++++++ tests/test_simulator_protocol.py | 19 +- 4 files changed, 511 insertions(+), 1 deletion(-) create mode 100644 src/simulator/minires.py create mode 100644 tests/test_minires_sim.py diff --git a/pyproject.toml b/pyproject.toml index 0c70892..2ae54bc 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -46,6 +46,11 @@ dependencies = [ pet = "pet_cli.__main__:main" [project.optional-dependencies] +minires = [ + # Pure-Python two-phase TPFA simulator, ref src/simulator/minires.py. + # Optional: it needs Python >= 3.12, whereas PET supports 3.10. + "minires>=0.3.2", +] dev = [ "pytest", "pytest-cov", diff --git a/src/simulator/minires.py b/src/simulator/minires.py new file mode 100644 index 0000000..80fbaa1 --- /dev/null +++ b/src/simulator/minires.py @@ -0,0 +1,349 @@ +"""Forward simulator backed by MiniRes, a two-phase (water/oil) TPFA reservoir simulator. + +MiniRes (https://github.com/patnr/MiniRes) is a pure-Python toy simulator: no +binary, no licence, no deck, no scratch folder. It is therefore the cheapest +way to drive PET with actual two-phase flow -- in a tutorial, in CI, or as the +reference case when developing a scheme -- rather than with an ODE. + +Install it alongside PET with ``pip install PET[minires]``. + +The simulator section of the config configures it, e.g. + + [simulator] + reporttype = "steps" + reportpoint = [2, 4, 6, 8, 10] + datatype = ["WWCT:PRD1", "WOPR:PRD1", "FWIR"] + dt = 0.025 + parallel = 1 + + [simulator.model] + Nx = 32 + Ny = 32 + por = 0.2 + [[simulator.model.wells]] + name = "INJ1" + xy = [0.1, 0.1] + rate = 1.0 + [[simulator.model.wells]] + name = "PRD1" + xy = [0.9, 0.9] + rate = -1.0 + +``[simulator.model]`` is passed to ``minires.ResSim`` as it stands (its +``wells`` are MiniRes well records), less the permeability, which is what the +ensemble state supplies, one field per member. + +Conventions, all of which this module owns -- MiniRes itself is agnostic: + +- **Report points** are *step indices*, ``1 .. nSteps``, since MiniRes takes a + uniform ``dt``. Use ``reporttype = "steps"``. A dated case can map them with + ``reportdates``. +- **Field ordering.** MiniRes is C-major (x is the first axis); Eclipse, and + hence most of PET's tooling, is Fortran-ordered. ``field_order`` (default + ``"C"``) says which the *state vector* is in, and is applied on the way in + and on the way out (the adjoint). +- **Data types** are named as Eclipse's summary vectors, ``:`` + for a well and ```` for the field, so observed-data files, + ``datatype`` filters and localization tooling need no adaptation. Rates are + positive as produced/injected, and areal (MiniRes has no thickness). +- **Units** are whatever the config poses the model in. Set ``cdarcy = 0.008527`` + in ``[simulator.model]`` for metric (m, day, bar, mD, cP), as Eclipse does. +""" + +import logging +from copy import deepcopy +from dataclasses import fields as dataclass_fields + +import numpy as np +import pandas as pd + +__all__ = ["MiniRes"] + +logger = logging.getLogger(__name__) + +WELL_QUANTITIES = ("WOPR", "WWPR", "WLPR", "WWIR", "WWCT", "WBHP") +"""Per-well quantities: oil/water/liquid production rate, water injection rate, water cut, BHP.""" + +FIELD_QUANTITIES = ("FOPR", "FWPR", "FWIR", "FOPT", "FWPT", "FWIT") +"""Field rates and their cumulatives.""" + +DIFFERENTIABLE = ("WOPR", "WWPR", "WWCT") +"""The quantities :meth:`MiniRes.run_fwd_sim` can also produce an adjoint for.""" + + +def build_model(spec: dict): + """Build the ``minires.ResSim`` that ``[simulator.model]`` describes. + + ``por`` and ``active`` may be given as scalars; the wells are MiniRes well + records (``xy``/``path``, ``rate``/``bhp``, ``rw``/``WI``, ``name``). + """ + from minires import ResSim + + spec = deepcopy(dict(spec)) + known = {f.name for f in dataclass_fields(ResSim)} + unknown = set(spec) - known + if unknown: + raise ValueError( + f"Unknown key(s) in [simulator.model]: {sorted(unknown)}. " + f"The section is passed to minires.ResSim, whose parameters are {sorted(known)}." + ) + + # K is the state, not a config item: whatever is given here is only the shape's stand-in. + model = ResSim(**{k: v for k, v in spec.items() if k not in ("por", "active", "wells")}) + for key in ("por", "active"): + if key in spec: # ResSim broadcasts a scalar K, but not these + val = spec[key] + setattr(model, key, np.full(model.shape, val) if np.isscalar(val) else val) + model.wells = spec.get("wells", []) + return model + + +class MiniRes: + """PET forward simulator: one MiniRes run per ensemble member. + + Satisfies :class:`ensemble.protocols.ForwardSimulator`. Every member runs + on its own ``deepcopy`` of the model, so nothing is shared and the class is + picklable -- which is what ``parallel > 1`` (``p_map``) requires. MiniRes + drops its cached pressure preconditioner on copy for exactly this reason. + + Parameters + ---------- + input_dict : dict + The parsed ``[simulator]`` section. Keys: + + - ``dt``: the time step. Required. + - ``reportpoint``: the step indices to report at. Required. + - ``reporttype``: the index's name (default ``"steps"``). + - ``reportdates``: optional labels to report *under* instead of the step + indices, e.g. dates, one per report point. + - ``datatype``: the summary vectors to report, ref the module docstring. + - ``model``: what :func:`build_model` takes. + - ``state_variable``: the ensemble state that supplies the permeability + (default ``"permx"``). + - ``log_perm``: whether that state is :math:`\\log K` (default ``True``). + - ``field_order``: the state vector's grid ordering, ``"C"`` (default) + or ``"F"``. + - ``s0``: initial water saturation, a scalar or a field (default ``0``). + - ``compute_adjoints``: also return each datum's sensitivity to the + state (default ``False``), ref :meth:`adjoint_frame`. + - ``levels``: per-fidelity overrides of the above, for multilevel runs, + selected by ``setup_fwd_run(level=...)``. + - ``parallel``, ``hpc``: read by the ensemble, not by this class. + """ + + def __init__(self, input_dict: dict): + self.input_dict = input_dict + self.levels = input_dict.get("levels", None) + self._configure(input_dict) + + # ------------------------------------------------------------------ + # Configuration + # ------------------------------------------------------------------ + def _configure(self, cfg: dict) -> None: + """Internalize one configuration -- the whole of it, or one fidelity level's.""" + for required in ("dt", "reportpoint", "datatype"): + assert required in cfg, f"'{required}' is missing from the simulator config" + + self.dt = float(cfg["dt"]) + self.report = [int(r) for r in cfg["reportpoint"]] + self.report_type = cfg.get("reporttype", "steps") + self.nSteps = max(self.report) + + # The label the records are indexed by: the step, or what the config renames it to + labels = cfg.get("reportdates", self.report) + assert len(labels) == len(self.report), "'reportdates' must have one label per report point" + self.true_order = [self.report_type, list(labels)] + self.true_prim = self.true_order + self.l_prim = list(range(len(self.report))) + + self.datatype = list(cfg["datatype"]) + self.all_data_types = self.datatype + self.compute_adjoints = bool(cfg.get("compute_adjoints", False)) + + self.state_variable = cfg.get("state_variable", "permx") + self.log_perm = bool(cfg.get("log_perm", True)) + self.field_order = cfg.get("field_order", "C") + assert self.field_order in ("C", "F"), "'field_order' must be 'C' or 'F'" + + self.model = build_model(cfg.get("model", {})) + self.S0 = np.full(self.model.Nxy, 0.0) + np.ravel(cfg.get("s0", 0.0)) + self._parse_datatypes() + + def _parse_datatypes(self) -> None: + """Split each data type into ``(quantity, well)``, checking it against the model.""" + names = list(self.model.wells.names or []) + self._parsed = [] + for dtype in self.datatype: + quantity, _, well = dtype.partition(":") + if well: + if quantity not in WELL_QUANTITIES: + raise ValueError(f"Unknown well quantity '{quantity}' in '{dtype}'. Known: {WELL_QUANTITIES}.") + if well not in names: + raise ValueError(f"'{dtype}' names no well of the model. Its wells are {names}.") + self._parsed.append((quantity, names.index(well))) + else: + if quantity not in FIELD_QUANTITIES: + raise ValueError(f"Unknown field quantity '{quantity}'. Known: {FIELD_QUANTITIES}.") + self._parsed.append((quantity, None)) + + if self.compute_adjoints: + bad = [d for d, (q, w) in zip(self.datatype, self._parsed) if q not in DIFFERENTIABLE] + if bad: + raise NotImplementedError( + f"compute_adjoints is on, but {bad} are not among the differentiated " + f"quantities {DIFFERENTIABLE}. Seed minires.tlm.adjoint by hand for others." + ) + + def setup_fwd_run(self, level=None, **kwargs) -> None: + """Select the fidelity ``level``'s configuration, when the config gives ``levels``.""" + if self.levels is None or level is None: + return + cfg = {**self.input_dict, **self.levels[level]} + self._configure(cfg) + + # ------------------------------------------------------------------ + # One member + # ------------------------------------------------------------------ + def run_fwd_sim(self, state: dict, member_index: int = 0, **kwargs): + """Simulate one realisation; return its records (and adjoint), or ``False`` if it failed.""" + model = deepcopy(self.model) + try: + self.set_permeability(model, state) + SS, PP = model.sim(self.dt, self.nSteps, self.S0, pbar=False) + except Exception: + logger.exception("MiniRes failed on member %s; it will be replaced.", member_index) + return False + + records = self.records(model, SS) + if self.compute_adjoints: + return records, self.adjoint_frame(model, SS, PP) + return records + + def set_permeability(self, model, state: dict) -> None: + """Write the member's field into the model, as its (isotropic) permeability.""" + if self.state_variable not in state: + raise KeyError( + f"The state has no '{self.state_variable}' (it has {sorted(state)}). " + f"Name the permeability state with 'state_variable' in the simulator config." + ) + field = np.asarray(state[self.state_variable], dtype=float).ravel() + if field.size != model.Nxy: + raise ValueError(f"'{self.state_variable}' has {field.size} values, but the grid has {model.Nxy} cells.") + field = field.reshape(model.shape, order=self.field_order) + model.K = np.exp(field) if self.log_perm else field + + # ------------------------------------------------------------------ + # Reporting + # ------------------------------------------------------------------ + def well_report(self, model, SS: np.ndarray) -> dict: + """Every reportable quantity, as ``(nWell or 1, nSteps)`` arrays, from the run's well operation. + + MiniRes reports one *total* rate per completion (signed: positive + injects). The phase split is the cell's fractional flow -- the same + ``Fluid.fractional_flow`` the transport uses -- and the completions are + summed into wells by ``Wells.group``. + """ + wells = model.wells + cells = model.xy2ind(wells.xy[:, 0], wells.xy[:, 1]) + rates = np.asarray(wells.actual_rates) # (nComp, nSteps) + fw = model.fluid.fractional_flow(SS[1:][:, cells]).T # (nComp, nSteps), end of step + produced = np.where(rates < 0, -rates, 0.0) + injected = np.where(rates > 0, rates, 0.0) + + group = np.arange(wells.nComp) if wells.group is None else np.asarray(wells.group) + + def by_well(per_completion): + out = np.zeros((wells.nWell, per_completion.shape[1])) + np.add.at(out, group, per_completion) + return out + + report = { + "WWPR": by_well(produced * fw), + "WOPR": by_well(produced * (1 - fw)), + "WLPR": by_well(produced), + "WWIR": by_well(injected), + } + with np.errstate(invalid="ignore", divide="ignore"): + report["WWCT"] = np.where(report["WLPR"] > 0, report["WWPR"] / report["WLPR"], 0.0) + # A wellbore's completions share one BHP, so the first of each well's is the well's + first = np.zeros(wells.nWell, int) + first[group[::-1]] = np.arange(wells.nComp)[::-1] + report["WBHP"] = np.asarray(wells.actual_bhp)[first] + + for field, well in (("FOPR", "WOPR"), ("FWPR", "WWPR"), ("FWIR", "WWIR")): + report[field] = report[well].sum(0, keepdims=True) + for cum, rate in (("FOPT", "FOPR"), ("FWPT", "FWPR"), ("FWIT", "FWIR")): + report[cum] = np.cumsum(report[rate], axis=1) * self.dt + return report + + def records(self, model, SS: np.ndarray) -> list: + """One dict per report point, keyed by data type -- what the ensemble collects.""" + report = self.well_report(model, SS) + out = [] + for step in self.report: + row = {} + for dtype, (quantity, well) in zip(self.datatype, self._parsed): + series = report[quantity] + row[dtype] = np.array([series[0 if well is None else well, step - 1]]) + out.append(row) + return out + + # ------------------------------------------------------------------ + # Adjoints + # ------------------------------------------------------------------ + def adjoint_frame(self, model, SS: np.ndarray, PP: np.ndarray) -> pd.DataFrame: + """Each datum's sensitivity to the state, as the frame the ensemble stacks into ``(nd, nx, ne)``. + + MiniRes's adjoint (``minires.tlm``) gives the gradient of *one* scalar + per backward sweep, at about the cost of one simulation -- so a full + Jacobian costs one sweep per datum. That is affordable on the grids this + simulator is for, and is what PET's adjoint-based analyses want. + + Only quantities that are a function of the saturation at the well's + cells are covered (:data:`DIFFERENTIABLE`), and only at rate-controlled + completions, whose rate is then a constant of the objective. A + BHP-controlled well's rate is itself a function of ``(S, P)``; that + derivative has to be worked into the seed by hand, so it is refused + rather than silently dropped. + """ + from minires import tlm + + wells = model.wells + cells = model.xy2ind(wells.xy[:, 0], wells.xy[:, 1]) + group = np.arange(wells.nComp) if wells.group is None else np.asarray(wells.group) + rates = np.asarray(wells.actual_rates) + report = self.well_report(model, SS) + + rows = [] + for step in self.report: + row = {} + for dtype, (quantity, well) in zip(self.datatype, self._parsed): + seed = np.zeros((self.nSteps + 1, model.Nxy)) + k = step # the datum is the end of step `step`, i.e. SS[step] + for comp in np.flatnonzero(group == well): + if np.isfinite(wells.at_time("bhp", np.nan, min(k, self.nSteps) - 1)[comp]): + raise NotImplementedError( + f"'{dtype}' is on BHP control; its rate is itself a function of the state. " + "Seed minires.tlm.adjoint by hand for it." + ) + s = SS[k][cells[comp]] + dfw = model.fluid.dfractional_flow(np.array([s]))[0] + produced = max(-rates[comp, k - 1], 0.0) + if quantity == "WWPR": + seed[k, cells[comp]] += produced * dfw + elif quantity == "WOPR": + seed[k, cells[comp]] -= produced * dfw + elif quantity == "WWCT": + liquid = report["WLPR"][well, k - 1] + seed[k, cells[comp]] += produced * dfw / liquid if liquid > 0 else 0.0 + + grad = tlm.adjoint(model, self.dt, SS, PP, seed) + dlogK = grad.logK.sum(0) # isotropic: the state feeds both components + if not self.log_perm: + dlogK = dlogK / model.K[0] + row[dtype] = dlogK.ravel(order=self.field_order) + rows.append(row) + + frame = pd.DataFrame(rows, index=self.true_order[1]) + frame.index.name = self.report_type + return frame diff --git a/tests/test_minires_sim.py b/tests/test_minires_sim.py new file mode 100644 index 0000000..b379553 --- /dev/null +++ b/tests/test_minires_sim.py @@ -0,0 +1,139 @@ +"""The MiniRes wrapper: the protocol, the state/report mappings, and the adjoint.""" + +import pickle + +import numpy as np +import pytest + +from ensemble import ForwardSimulator + +pytest.importorskip("minires", reason="pip install PET[minires]") + +from simulator.minires import MiniRes # noqa: E402 + +NX = NY = 8 + + +def config(**kwargs): + cfg = { + "dt": 0.05, + "reportpoint": [2, 4, 6], + "reporttype": "steps", + "datatype": ["WWCT:PRD1", "WOPR:PRD1", "FWIR"], + "model": { + "Nx": NX, "Ny": NY, "por": 0.2, + "wells": [ + {"name": "INJ1", "xy": [0.05, 0.05], "rate": 1.0}, + {"name": "PRD1", "xy": [0.95, 0.95], "rate": -1.0}, + ], + }, + } + cfg.update(kwargs) + return cfg + + +def a_field(seed=1, scale=0.5): + return scale * np.random.default_rng(seed).standard_normal(NX * NY) + + +def test_it_satisfies_the_forward_simulator_protocol(): + assert isinstance(MiniRes(config()), ForwardSimulator) + + +def test_it_pickles_as_the_parallel_forecast_requires(): + assert isinstance(pickle.loads(pickle.dumps(MiniRes(config()))), MiniRes) + + +def test_the_records_are_one_dict_per_report_point_keyed_by_data_type(): + sim = MiniRes(config()) + records = sim.run_fwd_sim({"permx": a_field()}, 0) + assert len(records) == len(sim.report) + for row in records: + assert set(row) == set(sim.datatype) + assert all(np.shape(v) == (1,) for v in row.values()) + + +def test_the_same_state_gives_the_same_records(): + sim = MiniRes(config()) + state = {"permx": a_field()} + first, second = sim.run_fwd_sim(state, 0), sim.run_fwd_sim(state, 1) + for a, b in zip(first, second): + for key in a: + assert a[key] == b[key] + + +def test_a_member_the_simulator_cannot_run_comes_back_as_False(): + """`False`, not an exception: the ensemble replaces the member and carries on.""" + sim = MiniRes(config()) + assert sim.run_fwd_sim({"permx": np.zeros(NX * NY + 1)}, 0) is False + assert sim.run_fwd_sim({"not_the_state": np.zeros(NX * NY)}, 0) is False + + +def test_the_state_is_the_log_permeability_in_the_declared_grid_ordering(): + field = a_field() + for order in ("C", "F"): + sim = MiniRes(config(field_order=order)) + model = sim.model + sim.set_permeability(model, {"permx": field}) + np.testing.assert_allclose(model.K[0], np.exp(field.reshape(model.shape, order=order))) + np.testing.assert_allclose(model.K[1], model.K[0]) # isotropic + + sim = MiniRes(config(log_perm=False)) + sim.set_permeability(sim.model, {"permx": np.abs(field)}) + np.testing.assert_allclose(sim.model.K[0], np.abs(field).reshape(sim.model.shape)) + + +def test_the_water_cut_is_the_produced_water_over_the_produced_liquid(): + sim = MiniRes(config()) + records = sim.run_fwd_sim({"permx": a_field()}, 0) + for row in records: + assert 0 <= row["WWCT:PRD1"][0] <= 1 + # The producer's liquid rate is its rate spec, so the cut and the oil rate agree + assert row["WOPR:PRD1"][0] == pytest.approx(1.0 - row["WWCT:PRD1"][0]) + assert records[0]["FWIR"][0] == pytest.approx(1.0) # the injector, unsplit + + +def test_an_unknown_data_type_is_refused_when_the_simulator_is_built(): + with pytest.raises(ValueError, match="Unknown well quantity"): + MiniRes(config(datatype=["WXYZ:PRD1"])) + with pytest.raises(ValueError, match="names no well"): + MiniRes(config(datatype=["WWCT:NOSUCH"])) + + +def test_a_fidelity_level_reconfigures_the_model(): + sim = MiniRes(config(levels=[{"dt": 0.05}, {"dt": 0.01}])) + sim.setup_fwd_run(level=1) + assert sim.dt == 0.01 + sim.setup_fwd_run(level=0) + assert sim.dt == 0.05 + + +class TestAdjoints: + """`compute_adjoints` gives each datum's sensitivity to the state, checked against a difference.""" + + def test_the_frame_is_indexed_by_report_point_and_holds_one_row_per_state(self): + sim = MiniRes(config(compute_adjoints=True, datatype=["WWCT:PRD1"])) + _records, adjoint = sim.run_fwd_sim({"permx": a_field()}, 0) + assert adjoint.index.name == sim.report_type + assert list(adjoint.index) == sim.report + assert all(np.shape(cell) == (NX * NY,) for cell in adjoint["WWCT:PRD1"]) + + @pytest.mark.parametrize("datatype", ["WWCT:PRD1", "WWPR:PRD1", "WOPR:PRD1"]) + def test_it_agrees_with_a_central_difference(self, datatype): + cfg = config(compute_adjoints=True, datatype=[datatype], reportpoint=[4, 6]) + cfg["model"]["cached_precond"] = False # spare the difference the iteration's noise + sim = MiniRes(cfg) + rng = np.random.default_rng(0) + x, v, eps = a_field(), rng.standard_normal(NX * NY), 1e-6 + + _records, adjoint = sim.run_fwd_sim({"permx": x}, 0) + plus = sim.run_fwd_sim({"permx": x + eps * v}, 0)[0] + minus = sim.run_fwd_sim({"permx": x - eps * v}, 0)[0] + + for i, step in enumerate(sim.report): + difference = (plus[i][datatype][0] - minus[i][datatype][0]) / (2 * eps) + assert adjoint.loc[step, datatype] @ v == pytest.approx(difference, rel=1e-4) + + def test_a_quantity_it_cannot_differentiate_is_refused_rather_than_dropped(self): + with pytest.raises(NotImplementedError, match="not among the differentiated"): + MiniRes(config(compute_adjoints=True, datatype=["FWIR"])) diff --git a/tests/test_simulator_protocol.py b/tests/test_simulator_protocol.py index fda2f54..baba7c6 100644 --- a/tests/test_simulator_protocol.py +++ b/tests/test_simulator_protocol.py @@ -8,6 +8,22 @@ SIM_CONFIG = {"reporttype": "steps", "reportpoint": [1, 2, 3], "datatype": ["x"]} +MINIRES_CONFIG = { + "reporttype": "steps", + "reportpoint": [1, 2, 3], + "dt": 0.1, + "datatype": ["FWIR"], + "model": {"Nx": 4, "Ny": 4, "wells": [{"name": "W", "xy": [0.5, 0.5], "bhp": 1.0}]}, +} + + +def make_minires(): + """MiniRes is an optional dependency (``pip install PET[minires]``).""" + pytest.importorskip("minires") + from simulator.minires import MiniRes + + return MiniRes(MINIRES_CONFIG) + @pytest.mark.parametrize( "make", @@ -16,8 +32,9 @@ lambda: nonlin_onedimmodel(SIM_CONFIG), lambda: noSimulation(SIM_CONFIG), lambda: VanDerPolOscillator({}), + make_minires, ], - ids=["lin_1d", "nonlin_onedimmodel", "noSimulation", "VanDerPolOscillator"], + ids=["lin_1d", "nonlin_onedimmodel", "noSimulation", "VanDerPolOscillator", "MiniRes"], ) def test_bundled_simulators_satisfy_the_protocol(make): assert isinstance(make(), ForwardSimulator) From 2dd029544131af31f97407068a2db0493d50723d Mon Sep 17 00:00:00 2001 From: patnr Date: Thu, 17 Sep 2026 09:24:40 +0200 Subject: [PATCH 2/2] Tutorials: history matching a waterflood, with no simulator to install The same ESMDA loop as the TinyBox tutorial, on a 16x16 five-spot run by MiniRes: `pip install PET[minires]` and it runs -- no OPM, no deck, no external data. `make_case.py` draws the "true" log-permeability from the config's own prior and runs MiniRes on it, so the observations are made where the reader can see them (a twin experiment). Committed with its outputs, as the other notebooks are (mkdocs-jupyter does not execute). It plots the truth with MiniRes's own `plt_field`, the misfit per iteration, the truth/prior/posterior fields on one colour scale, and the water-cut match per producer. ~18 s to run, 100 members over 3 ESMDA steps. Co-Authored-By: Claude Opus 5 (1M context) --- docs/tutorials/README.md | 1 + docs/tutorials/pipt/MiniRes/CONFIG_ESMDA.toml | 70 ++ docs/tutorials/pipt/MiniRes/data.csv | 7 + docs/tutorials/pipt/MiniRes/make_case.py | 51 ++ docs/tutorials/pipt/MiniRes/priormean.npz | Bin 0 -> 2312 bytes docs/tutorials/pipt/MiniRes/truth.npz | Bin 0 -> 2312 bytes .../pipt/MiniRes/tutorial_minires.ipynb | 804 ++++++++++++++++++ docs/tutorials/pipt/MiniRes/var.csv | 7 + 8 files changed, 940 insertions(+) create mode 100644 docs/tutorials/pipt/MiniRes/CONFIG_ESMDA.toml create mode 100644 docs/tutorials/pipt/MiniRes/data.csv create mode 100644 docs/tutorials/pipt/MiniRes/make_case.py create mode 100644 docs/tutorials/pipt/MiniRes/priormean.npz create mode 100644 docs/tutorials/pipt/MiniRes/truth.npz create mode 100644 docs/tutorials/pipt/MiniRes/tutorial_minires.ipynb create mode 100644 docs/tutorials/pipt/MiniRes/var.csv diff --git a/docs/tutorials/README.md b/docs/tutorials/README.md index b4f552b..427fb06 100644 --- a/docs/tutorials/README.md +++ b/docs/tutorials/README.md @@ -5,6 +5,7 @@ Here are some tutorials. ## Running PIPT and POPT - [`tutorial_pipt.ipynb`](pipt/TinyBox/tutorial_pipt): Tutorial for running PIPT +- [`tutorial_minires.ipynb`](pipt/MiniRes/tutorial_minires): The same, with a forward model that needs nothing installed -- a MiniRes waterflood - [`tutorial_popt.ipynb`](popt/5Spot/tutorial_popt): Tutorial for running POPT ## Data structures diff --git a/docs/tutorials/pipt/MiniRes/CONFIG_ESMDA.toml b/docs/tutorials/pipt/MiniRes/CONFIG_ESMDA.toml new file mode 100644 index 0000000..368177c --- /dev/null +++ b/docs/tutorials/pipt/MiniRes/CONFIG_ESMDA.toml @@ -0,0 +1,70 @@ +[ensemble] + ne = 100 + state = "permx" # log-permeability, one value per grid cell + + [ensemble.prior_permx] + vario = "sph" + mean = "priormean.npz" + var = 1.0 + range = 5.0 + aniso = 1.0 + angle = 0.0 + grid = [16, 16, 1] + +[dataassim] + savefolder = "Results" + scheme = "esmda" + analysis = "approx" + energy = 99.0 + obsname = "steps" + data = "data.csv" + datavar = "var.csv" + savedata = ["ensemble_misfit"] + + # ESMDA settings + [dataassim.mda] + tot_assim_steps = 3 + inflation_param = [3, 3, 3] + +[simulator] + # The report points are *step indices*: MiniRes takes a uniform dt. + dt = 0.025 + reporttype = "steps" + reportpoint = [2, 4, 6, 8, 10, 12] + parallel = 1 + datatype = [ + "WWCT:PRD1", "WWCT:PRD2", "WWCT:PRD3", "WWCT:PRD4", + "WOPR:PRD1", "WOPR:PRD2", "WOPR:PRD3", "WOPR:PRD4", + ] + + # Passed to minires.ResSim as it stands -- less the permeability, + # which is what the ensemble state supplies, one field per member. + [simulator.model] + Nx = 16 + Ny = 16 + por = 0.2 + + [[simulator.model.wells]] + name = "INJ1" + xy = [0.5, 0.5] + rate = 1.0 + + [[simulator.model.wells]] + name = "PRD1" + xy = [0.05, 0.05] + rate = -0.25 + + [[simulator.model.wells]] + name = "PRD2" + xy = [0.95, 0.05] + rate = -0.25 + + [[simulator.model.wells]] + name = "PRD3" + xy = [0.05, 0.95] + rate = -0.25 + + [[simulator.model.wells]] + name = "PRD4" + xy = [0.95, 0.95] + rate = -0.25 diff --git a/docs/tutorials/pipt/MiniRes/data.csv b/docs/tutorials/pipt/MiniRes/data.csv new file mode 100644 index 0000000..d3019c3 --- /dev/null +++ b/docs/tutorials/pipt/MiniRes/data.csv @@ -0,0 +1,7 @@ +steps,WWCT:PRD1,WWCT:PRD2,WWCT:PRD3,WWCT:PRD4,WOPR:PRD1,WOPR:PRD2,WOPR:PRD3,WOPR:PRD4 +2,0.015235853987721568,-0.05199920531202478,0.03752255979032287,0.0470282358195607,0.15244824056730816,0.1848910246568841,0.25639202015836426,0.23418787038282088 +4,-0.0006616316175194097,-0.04265219637867901,0.04397906690243332,0.37986283178125513,0.25325692831363705,0.30636206034840163,0.2733731750727793,0.12179206810338616 +6,0.7121617362686763,-0.04794413004144995,0.7997165437846246,0.8058189238661145,0.06732583255659913,0.21595352277980293,0.12217855975388625,0.0401947210427031 +8,0.7975451683203961,0.10294571650886156,0.9101860547384159,0.916591579588462,0.06589624072266154,0.2414029516420759,0.13618973117833594,0.005099405088204681 +10,0.8651076650607917,0.6923317350907747,0.956140474899063,0.9865003950070657,0.021622676738664103,0.024737083276081456,-0.022559436727134008,0.05001669429847978 +12,0.9665251856623154,0.8433864077844226,0.9132882369878853,0.9576057423100545,0.023493671181500596,0.05687725624415992,0.0569305083093295,0.024680358399554493 diff --git a/docs/tutorials/pipt/MiniRes/make_case.py b/docs/tutorials/pipt/MiniRes/make_case.py new file mode 100644 index 0000000..cc85a16 --- /dev/null +++ b/docs/tutorials/pipt/MiniRes/make_case.py @@ -0,0 +1,51 @@ +"""Make this tutorial's synthetic case: a truth, and observations of it. + +A twin experiment: the "true" permeability is itself a draw from the prior that +``CONFIG_ESMDA.toml`` specifies, MiniRes is run on it, and the well reports are +perturbed by the observation noise. Nothing external is needed -- which is the +point of this tutorial's simulator. + + python make_case.py +""" + +from copy import deepcopy + +import numpy as np +import pandas as pd + +from input_output import read_config +from misc.sampling import random_stream +from misc.structures.layout import StateLayout +from pipt.misc_tools.extract_tools import extract_prior_info +from simulator.minires import MiniRes + +SIGMA = 0.05 # observation noise (absolute, on both the water cut and the oil rate) + +kwda, kwsim, kwens = read_config.read("CONFIG_ESMDA.toml") +nx, ny, _ = kwens["prior_permx"]["grid"] + +# The prior's mean: a flat log-permeability field. Also fixes the state's length. +np.savez("priormean.npz", permx=np.zeros(nx * ny)) + +# The truth: one draw from that prior +truth, _ = StateLayout.from_prior_info( + extract_prior_info(deepcopy(kwens)), 1, rng=random_stream(7), save=False +) +truth = truth[:, 0] +np.savez("truth.npz", permx=truth) + +# The observations: MiniRes on the truth, plus noise +records = MiniRes(kwsim).run_fwd_sim({"permx": truth}, 0) +report = kwsim["reportpoint"] + +data = pd.DataFrame([{k: float(v[0]) for k, v in row.items()} for row in records], index=report) +data += SIGMA * np.random.default_rng(42).standard_normal(data.shape) +data.index.name = kwsim["reporttype"] +data.to_csv("data.csv") + +var = pd.DataFrame({col: [f"['abs', {SIGMA**2}]"] * len(report) for col in data.columns}, index=report) +var.index.name = data.index.name +var.to_csv("var.csv") + +print(f"Wrote priormean.npz, truth.npz, data.csv, var.csv ({data.shape[0]} report points" + f" x {data.shape[1]} data types)") diff --git a/docs/tutorials/pipt/MiniRes/priormean.npz b/docs/tutorials/pipt/MiniRes/priormean.npz new file mode 100644 index 0000000000000000000000000000000000000000..526f7f8af60ab20c96f4fe5f0f7713b0327df708 GIT binary patch literal 2312 zcmWIWW@gc4fB;1XO)=%$|Dk}BL4=_owJ5hjFR!4IkwJi=fdirpMo;z&^$mz*WGG{( zR!>PSPA*cnQc$-^vryMjP*2M*Dk)0Li_b4gNd<|!CFT^T0>z6n5(`p+d<`R0GaXGG zg<1u&0T;8K`=XJiH*ZI88U*FgH<4v=XoMAxvOG`*)$~w&H zzcq)XMDnFGyaHBw`v#Ip^GM;d|62QxCr}-1Y5T||e^M~Th3b2|i_4GAEH2-f&>+uW<)VkMiGIV;i99q9XC2_7OVPy|g6ltixOM z!c>dU4u$47v zn9EwI@7IRenOFTz(D-;d;+i%`?jsIb#vT_WBI-SNt2?;33%qs&&(*)d!~A1z*@qtS zQLJ@A6tid$n~Z0&wW(hr<{je(V{8;GTdtqG%jAJ^<8HTiZwElPqw+21@oOY+S1A)R zTJgY4@v)_H0$jn6tamAx!W8X_9X)HvOq!mQH0?Qo^9Ktm>7E1dqxN13y{8n_u1BUA zyyPNt(3Zk_RStp4nbK1f7LK`&-Q2ae0q=Jft0^$JAg?pK-Pn_Wh7dV!hTb5QRQZK)SuR&Hfs@B+j=cHEN}#M)q_F`;zn?BIVbrUDoZoYw5jmHd44=Kg7giloK+qgntj2GeuLF(JO z@Ceymqd;JyY(fU#s~>9@9W5O-DMxF|sDP<`1VkM*-?IDm1l+5&*j;gV5~A{*`eGZ# z;mzXD8&1m%!9tzV?9q@a7;C!g?IT94(*#oAm|iFyBGBDG zpX*8VqrjvxR`L@MB&1^G?b8Q9B9_|{d8i+>Ghw{iLJaxt;u_6`(-7}fsUDar1d7?~ z6=#wNFtYJAwsv5F+N4qB;Zv_5M^)Ea;gO^Twb~=b5~tvf$o3fJU^9U3{kR>6x-fv! zuzzjR2zr}!uC4g(8)_(=`mN7_!1G^}MX|XAsyK0P`NbC@SG^*|I_MLU{HPr3Ssm!{ z#?YQ>(hcc!%5>dn795U^TjBQlJG7fo#+EZa!^L~m=iD>eQP!=Zo4t7eTJpjtT=|`_ zx8v%Ee>LZz!6lEPu_Z(3h7wmqgaBo>)Ngy%DaPtA(~0>{gt&0W>+{))63ov6mE{L% zaML(YB+m!-V_F+o zs}};sFEk~#v|~ZR*rpRts&Tc=R;#Ql9JnVM+46n%D5|B&(?sDT_%<*wH*{M+=G8kN z5TE;jsvATUxy@skGtyT(H7>^RsW)ZR^dFe)vaB_{dI-Y{!jz-0)1h$d^rf$Bih=ft z9XC_R2eDaV!zYmZFx8^!;y}+xfsOpH$PG~fJ2vyb87z4hTYRC)sYc=#OR{mZ`zQVauM6p^(skB zz5#2Mx&j;Pf(5+~(h!3Ni)T5x5MW=pGt0z)2OUv0?E8Jb=&(*;Y4>da_R|w%eb*P^ z=|NKx!%l<|U!Qw-%x!`&KU?{8{RDcPz1yTITZ2TnVVCwp79@ak;jq#R2wi_l^^T52j#PxFZ@B2y^B@r@y-@9VdSB6GKZp+RG7_BU z0V~z+R94)3s7{Q$VXM)IN{UX6VarFbGu~Uh{&OFy7Ph<2)2YXiUA&0}=~vOgTn1dZ zJg6PHrafVr3S)0y(I0pcIQU$&FTq@Za!)zHl$$`ilAv-8<}kV_1t)pWVdIPUmn%#) z1<;(SI7?ZcfXi=ftOF1BfOqlqwhazkY`&OLaL$yA%U+D`G56r0|8dVrmnH&38LfoW z2@W2T4)ULV&4T6M$lkJ(op3nnxK+X=;%v{IsuhP0VTFuLbhlwY)_kNkJlp#n#pIf_ zGY(NGWiGMso#7BP>QNhKog|=bT~^7vfo|BnG_-x?2QJvj>MmV8+KnF%bcyEkCh`6Y zYRa`4hq^j;sIx literal 0 HcmV?d00001 diff --git a/docs/tutorials/pipt/MiniRes/tutorial_minires.ipynb b/docs/tutorials/pipt/MiniRes/tutorial_minires.ipynb new file mode 100644 index 0000000..f9d1dc9 --- /dev/null +++ b/docs/tutorials/pipt/MiniRes/tutorial_minires.ipynb @@ -0,0 +1,804 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "571e2c17", + "metadata": {}, + "source": [ + "# History matching a waterflood, with no simulator to install\n", + "\n", + "This tutorial runs the same ESMDA loop as [`tutorial_pipt.ipynb`](../TinyBox/tutorial_pipt),\n", + "but its forward model is [MiniRes](https://github.com/patnr/MiniRes) -- a pure-Python,\n", + "two-phase (water/oil) TPFA reservoir simulator. There is no binary to install, no licence,\n", + "no deck and no scratch folder: `pip install PET[minires]` and the cell below runs.\n", + "\n", + "The case is a 16x16 five-spot: one injector at the centre, four producers in the corners,\n", + "all on rate control. The unknown is the log-permeability field (256 values). The\n", + "observations are the water cut and oil rate at each producer, at six report points --\n", + "made by `make_case.py`, which draws a 'true' field from the prior and runs MiniRes on it\n", + "(a twin experiment).\n", + "\n", + "The wrapper is `simulator.minires.MiniRes`; its module docstring documents the\n", + "conventions it owns (report points as step indices, the grid ordering, the\n", + "Eclipse-style data-type names, and units)." + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "d039fab1", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-21T13:44:04.163369Z", + "iopub.status.busy": "2026-09-21T13:44:04.163281Z", + "iopub.status.idle": "2026-09-21T13:44:05.477461Z", + "shell.execute_reply": "2026-09-21T13:44:05.476970Z" + } + }, + "outputs": [], + "source": [ + "import matplotlib.pyplot as plt\n", + "import numpy as np\n", + "\n", + "from pipt import ESMDA # the assimilation scheme\n", + "from simulator.minires import MiniRes # the simulator we want to use\n", + "from input_output import read_config # the config reader\n", + "from misc.structures import PETDataFrame\n", + "from misc.read_input_csv import DataReader" + ] + }, + { + "cell_type": "markdown", + "id": "a2b958bf", + "metadata": {}, + "source": [ + "## The config\n", + "\n", + "`[simulator.model]` is passed to `minires.ResSim` as it stands -- the grid, the porosity\n", + "and the wells -- less the permeability, which is what the ensemble state supplies, one\n", + "field per member." + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "729fc2da", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-21T13:44:05.478670Z", + "iopub.status.busy": "2026-09-21T13:44:05.478530Z", + "iopub.status.idle": "2026-09-21T13:44:05.796379Z", + "shell.execute_reply": "2026-09-21T13:44:05.795851Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "[ensemble]\r\n", + " ne = 100\r\n", + " state = \"permx\" # log-permeability, one value per grid cell\r\n", + "\r\n", + " [ensemble.prior_permx]\r\n", + " vario = \"sph\"\r\n", + " mean = \"priormean.npz\"\r\n", + " var = 1.0\r\n", + " range = 5.0\r\n", + " aniso = 1.0\r\n", + " angle = 0.0\r\n", + " grid = [16, 16, 1]\r\n", + "\r\n", + "[dataassim]\r\n", + " savefolder = \"Results\"\r\n", + " scheme = \"esmda\"\r\n", + " analysis = \"approx\"\r\n", + " energy = 99.0\r\n", + " obsname = \"steps\"\r\n", + " data = \"data.csv\"\r\n", + " datavar = \"var.csv\"\r\n", + " savedata = [\"ensemble_misfit\"]\r\n", + "\r\n", + " # ESMDA settings\r\n", + " [dataassim.mda]\r\n", + " tot_assim_steps = 3\r\n", + " inflation_param = [3, 3, 3]\r\n", + "\r\n", + "[simulator]\r\n", + " # The report points are *step indices*: MiniRes takes a uniform dt.\r\n", + " dt = 0.025\r\n", + " reporttype = \"steps\"\r\n", + " reportpoint = [2, 4, 6, 8, 10, 12]\r\n", + " parallel = 1\r\n", + " datatype = [\r\n", + " \"WWCT:PRD1\", \"WWCT:PRD2\", \"WWCT:PRD3\", \"WWCT:PRD4\",\r\n", + " \"WOPR:PRD1\", \"WOPR:PRD2\", \"WOPR:PRD3\", \"WOPR:PRD4\",\r\n", + " ]\r\n", + "\r\n", + " # Passed to minires.ResSim as it stands -- less the permeability,\r\n", + " # which is what the ensemble state supplies, one field per member.\r\n", + " [simulator.model]\r\n", + " Nx = 16\r\n", + " Ny = 16\r\n", + " por = 0.2\r\n", + "\r\n", + " [[simulator.model.wells]]\r\n", + " name = \"INJ1\"\r\n", + " xy = [0.5, 0.5]\r\n", + " rate = 1.0\r\n", + "\r\n", + " [[simulator.model.wells]]\r\n", + " name = \"PRD1\"\r\n", + " xy = [0.05, 0.05]\r\n", + " rate = -0.25\r\n", + "\r\n", + " [[simulator.model.wells]]\r\n", + " name = \"PRD2\"\r\n", + " xy = [0.95, 0.05]\r\n", + " rate = -0.25\r\n", + "\r\n", + " [[simulator.model.wells]]\r\n", + " name = \"PRD3\"\r\n", + " xy = [0.05, 0.95]\r\n", + " rate = -0.25\r\n", + "\r\n", + " [[simulator.model.wells]]\r\n", + " name = \"PRD4\"\r\n", + " xy = [0.95, 0.95]\r\n", + " rate = -0.25\r\n" + ] + } + ], + "source": [ + "!cat CONFIG_ESMDA.toml" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "00968def", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-21T13:44:05.798285Z", + "iopub.status.busy": "2026-09-21T13:44:05.798155Z", + "iopub.status.idle": "2026-09-21T13:44:05.813616Z", + "shell.execute_reply": "2026-09-21T13:44:05.813146Z" + } + }, + "outputs": [ + { + "data": { + "text/plain": [ + "ResSim(\n", + " Lx: 1.0\n", + " Ly: 1.0\n", + " Nx: 16\n", + " Ny: 16\n", + " name: 'Unnamed'\n", + " cdarcy: 1.0\n", + " fluid: Fluid(\n", + " vw: 1.0\n", + " vo: 1.0\n", + " swc: 0.0\n", + " sor: 0.0\n", + " nw: 2.0\n", + " no: 2.0\n", + " krw0: 1.0\n", + " kro0: 1.0\n", + " )\n", + " ct: 0.0\n", + " cached_precond: True\n", + " K: array([[[1., 1., ..., 1., 1.],\n", + " [1., 1., ..., 1., 1.],\n", + " ...,\n", + " [1., 1., ..., 1., 1.],\n", + " [1., 1., ..., 1., 1.]],\n", + "\n", + " [[1., 1., ..., 1., 1.],\n", + " [1., 1., ..., 1., 1.],\n", + " ...,\n", + " [1., 1., ..., 1., 1.],\n", + " [1., 1., ..., 1., 1.]]], shape=(2, 16, 16))\n", + " por: array([[0.2, 0.2, ..., 0.2, 0.2],\n", + " [0.2, 0.2, ..., 0.2, 0.2],\n", + " ...,\n", + " [0.2, 0.2, ..., 0.2, 0.2],\n", + " [0.2, 0.2, ..., 0.2, 0.2]], shape=(16, 16))\n", + " active: array([[ True, True, ..., True, True],\n", + " [ True, True, ..., True, True],\n", + " ...,\n", + " [ True, True, ..., True, True],\n", + " [ True, True, ..., True, True]], shape=(16, 16))\n", + " wells: Wells(\n", + " xy: array([[0.53125, 0.53125],\n", + " [0.03125, 0.03125],\n", + " [0.96875, 0.03125],\n", + " [0.03125, 0.96875],\n", + " [0.96875, 0.96875]])\n", + " rates: array([[ 1. ],\n", + " [-0.25],\n", + " [-0.25],\n", + " [-0.25],\n", + " [-0.25]])\n", + " bhp: None\n", + " WI: None\n", + " group: array([0, 1, 2, 3, 4])\n", + " names: ['INJ1', 'PRD1', 'PRD2', 'PRD3', 'PRD4']\n", + " actual_rates: None\n", + " actual_bhp: None\n", + " )\n", + ")" + ] + }, + "execution_count": 3, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "kwda, kwsim, kwens = read_config.read('CONFIG_ESMDA.toml')\n", + "sim = MiniRes(kwsim)\n", + "sim.model" + ] + }, + { + "cell_type": "markdown", + "id": "68d2f929", + "metadata": {}, + "source": [ + "## The truth\n", + "\n", + "MiniRes brings its own plotting, so the field and its wells can be shown without\n", + "any extra tooling. This is the field the observations were made on; the ensemble\n", + "does not know it." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "5ae33429", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-21T13:44:05.814789Z", + "iopub.status.busy": "2026-09-21T13:44:05.814694Z", + "iopub.status.idle": "2026-09-21T13:44:05.980045Z", + "shell.execute_reply": "2026-09-21T13:44:05.979687Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "truth = np.load('truth.npz')['permx']\n", + "\n", + "fig, ax = plt.subplots(figsize=(5, 4.2))\n", + "sim.model.plt_field(ax, truth, wells=True, finalize=False)\n", + "ax.set_title('True log-permeability')\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "39d47947", + "metadata": {}, + "source": [ + "## Run the assimilation\n", + "\n", + "Exactly as in the other tutorials -- the simulator is the only thing that differs.\n", + "100 members, 3 ESMDA steps: a few seconds." + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "e5c5207f", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-21T13:44:05.981240Z", + "iopub.status.busy": "2026-09-21T13:44:05.981159Z", + "iopub.status.idle": "2026-09-21T13:44:14.585944Z", + "shell.execute_reply": "2026-09-21T13:44:14.585447Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:05 : =========== Running Data Assimilation - ESMDA ===========\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/para/D/DPhil/PET-minires/src/misc/structures/structures.py:73: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", + " df = pd.read_csv(filepath, **kwargs)\n", + "/Users/para/D/DPhil/PET-minires/src/misc/structures/structures.py:73: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", + " df = pd.read_csv(filepath, **kwargs)\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "2026-09-21\u250215:44:08 : \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:08 : \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:08 : \u2502 Iteration \u2502 Status \u2502 Data Misfit \u2502 Change (%) \u2502 \u03b1 \u2502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:08 : \u251c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:08 : \u2502 0 \u2502 Success \u2502 6.916e+02 \u2502 \u2502 \u2502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:08 : \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:08 : \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:08 : [approx_update] Performing update....\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "2026-09-21\u250215:44:10 : \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:10 : \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:10 : \u2502 Iteration \u2502 Status \u2502 Data Misfit \u2502 Change (%) \u2502 \u03b1 \u2502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:10 : \u251c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:10 : \u2502 1 \u2502 Success \u2502 1.920e+02 \u2502 -72.24 \u2502 3 \u2502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:10 : \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:10 : \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:10 : [approx_update] Performing update....\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "2026-09-21\u250215:44:12 : \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:12 : \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:12 : \u2502 Iteration \u2502 Status \u2502 Data Misfit \u2502 Change (%) \u2502 \u03b1 \u2502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:12 : \u251c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:12 : \u2502 2 \u2502 Success \u2502 1.223e+02 \u2502 -36.29 \u2502 3 \u2502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:12 : \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:12 : \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:12 : [approx_update] Performing update....\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "\n", + "2026-09-21\u250215:44:14 : \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:14 : \u250c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u252c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2510\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:14 : \u2502 Iteration \u2502 Status \u2502 Data Misfit \u2502 Change (%) \u2502 \u03b1 \u2502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:14 : \u251c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u253c\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2524\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:14 : \u2502 3 \u2502 Success \u2502 1.085e+02 \u2502 -11.28 \u2502 3 \u2502\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:14 : \u2514\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2534\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2518\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:14 : \n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:14 : Maximum iterations reached without convergence.\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:14 : \n", + " Stopped without convergence. Obj. function reduced from 691.6 to 108.5\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2026-09-21\u250215:44:14 : Assimilation finished after 3 iteration(s): Maximum number of iterations reached\n" + ] + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "data misfit: 691.6 -> 108.5\n" + ] + } + ], + "source": [ + "np.random.seed(10)\n", + "res = ESMDA.assimilate(kwda, kwens, MiniRes(kwsim))\n", + "print(f'data misfit: {res.prior_data_misfit:.1f} -> {res.data_misfit:.1f}')" + ] + }, + { + "cell_type": "markdown", + "id": "089ce9de", + "metadata": {}, + "source": [ + "## The misfit, per iteration" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "9b4e1425", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-21T13:44:14.587264Z", + "iopub.status.busy": "2026-09-21T13:44:14.587161Z", + "iopub.status.idle": "2026-09-21T13:44:14.800409Z", + "shell.execute_reply": "2026-09-21T13:44:14.799910Z" + } + }, + "outputs": [ + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "from pathlib import Path\n", + "\n", + "misfit, it = [], 0\n", + "while (file := Path(f'Results/assimilation_result_{it}.npz')).exists():\n", + " misfit.append(np.load(file)['ensemble_misfit'])\n", + " it += 1\n", + "\n", + "fig, ax = plt.subplots(figsize=(6, 3.6))\n", + "ax.boxplot(misfit, positions=range(len(misfit)), widths=0.5, patch_artist=True,\n", + " boxprops=dict(facecolor='#4C78A8', alpha=0.3), medianprops=dict(color='#D62728'))\n", + "ax.set(xlabel='Iteration', ylabel='Data misfit', yscale='log')\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "aade2202", + "metadata": {}, + "source": [ + "## The fields\n", + "\n", + "The ensemble mean before and after. With 100 members, 48 data and 256 unknowns and no\n", + "localization, the posterior mean picks up the large-scale flow paths between the injector\n", + "and the producers, not the fine structure." + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "72575b4c", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-21T13:44:14.801550Z", + "iopub.status.busy": "2026-09-21T13:44:14.801442Z", + "iopub.status.idle": "2026-09-21T13:44:14.961883Z", + "shell.execute_reply": "2026-09-21T13:44:14.961491Z" + } + }, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "corr(mean, truth): prior 0.169 -> posterior 0.313\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "prior = np.load('prior_ensemble.npz')['permx']\n", + "post = np.asarray(res.x)\n", + "\n", + "levels = np.linspace(-3, 3, 13) # one colour scale for all three panels\n", + "fig, axs = plt.subplots(1, 3, figsize=(14, 3.6))\n", + "for i, (ax, field, title) in enumerate(zip(axs, [truth, prior.mean(1), post.mean(1)],\n", + " ['Truth', 'Prior mean', 'Posterior mean'])):\n", + " sim.model.plt_field(ax, field, levels=levels, wells=(i == 0), colorbar=(i == 2), finalize=False)\n", + " ax.set_title(title)\n", + "fig.tight_layout()\n", + "\n", + "print('corr(mean, truth): prior %.3f -> posterior %.3f'\n", + " % (np.corrcoef(prior.mean(1), truth)[0, 1], np.corrcoef(post.mean(1), truth)[0, 1]))" + ] + }, + { + "cell_type": "markdown", + "id": "7865ab23", + "metadata": {}, + "source": [ + "## The data match\n", + "\n", + "The prior and posterior forecasts that the run saved, against the observations." + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "19fe68b2", + "metadata": { + "execution": { + "iopub.execute_input": "2026-09-21T13:44:14.963290Z", + "iopub.status.busy": "2026-09-21T13:44:14.963171Z", + "iopub.status.idle": "2026-09-21T13:44:15.165415Z", + "shell.execute_reply": "2026-09-21T13:44:15.165014Z" + } + }, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/para/D/DPhil/PET-minires/src/misc/structures/structures.py:73: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", + " df = pd.read_csv(filepath, **kwargs)\n", + "/Users/para/D/DPhil/PET-minires/src/misc/structures/structures.py:73: UserWarning: Could not infer format, so each element will be parsed individually, falling back to `dateutil`. To ensure parsing is consistent and as-expected, please specify a format.\n", + " df = pd.read_csv(filepath, **kwargs)\n" + ] + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "reader = DataReader({'data': 'data.csv', 'datavar': 'var.csv'})\n", + "data = reader.get_data()\n", + "std = np.sqrt(reader.get_variance(data))\n", + "\n", + "forecasts = {}\n", + "for label, file in [('Prior', 'prior_forecast.pkl'), ('Posterior', 'posterior_forecast.pkl')]:\n", + " frame = PETDataFrame.from_pickle(f'Results/{file}')\n", + " frame.is_ensemble = True\n", + " forecasts[label] = frame\n", + "\n", + "fig, axs = plt.subplots(1, 4, figsize=(15, 3.4), sharex=True, sharey=True)\n", + "for ax, well in zip(axs, ['PRD1', 'PRD2', 'PRD3', 'PRD4']):\n", + " key = f'WWCT:{well}'\n", + " for (label, frame), color in zip(forecasts.items(), ['tab:blue', 'tab:orange']):\n", + " ens = np.asarray(frame[key].tolist())\n", + " ax.fill_between(frame.index, ens.min(1), ens.max(1), color=color, alpha=0.4, label=label)\n", + " ax.errorbar(data.index, data[key], yerr=2 * std[key], fmt='o', color='k', capsize=3,\n", + " label=r'Data $\\pm$ 2$\\sigma$')\n", + " ax.set(title=well, xlabel='Step')\n", + "axs[0].set_ylabel('Water cut')\n", + "axs[0].legend(loc='upper left', fontsize=8)\n", + "fig.tight_layout()\n" + ] + }, + { + "cell_type": "markdown", + "id": "56a58267", + "metadata": {}, + "source": [ + "## What else this simulator can do here\n", + "\n", + "- **Adjoints.** Set `compute_adjoints = true` in `[simulator]` and the wrapper returns each\n", + " datum's sensitivity to the state as well, so the analyses take the adjoint-based path\n", + " instead of the ensemble covariance. MiniRes differentiates its own time stepper\n", + " (`minires.tlm`), one backward sweep per datum, each about the cost of one simulation.\n", + " Covered for `WWCT`/`WWPR`/`WOPR` at rate-controlled wells.\n", + "- **Multilevel.** `[[simulator.levels]]` entries override the config per fidelity level;\n", + " `setup_fwd_run(level=...)` selects one, e.g. a coarser `dt`.\n", + "- **Wells** may be BHP-controlled (`bhp` in place of `rate`), multi-completion (`path`),\n", + " or aquifer contacts; inactive cells (`active`) cut the grid to an outline.\n", + "- **Units**: set `cdarcy = 0.008527` in `[simulator.model]` to pose the case in metric\n", + " (m, day, bar, mD, cP), as Eclipse does. Rates are then areal (per unit thickness)." + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.12.0" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} \ No newline at end of file diff --git a/docs/tutorials/pipt/MiniRes/var.csv b/docs/tutorials/pipt/MiniRes/var.csv new file mode 100644 index 0000000..9fe26d7 --- /dev/null +++ b/docs/tutorials/pipt/MiniRes/var.csv @@ -0,0 +1,7 @@ +steps,WWCT:PRD1,WWCT:PRD2,WWCT:PRD3,WWCT:PRD4,WOPR:PRD1,WOPR:PRD2,WOPR:PRD3,WOPR:PRD4 +2,"['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]" +4,"['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]" +6,"['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]" +8,"['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]" +10,"['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]" +12,"['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]","['abs', 0.0025000000000000005]"