gea-program 0.49.0__tar.gz → 0.50.0__tar.gz

{gea_program-0.49.0 → gea_program-0.50.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.49.0
+Version: 0.50.0
 Summary: GEA-Program: downhole gauge monitoring - canonical measurement records, quality rules, drift evaluation with a re-fit change log, well-test validation, alarm management, model cards, store-and-forward, monthly SLA measurement, FAT/SAT protocols and a dashboard, generated from live objects in the client's reporting outline.
 Author: Daniel T. Murphy
 License: MPL-2.0
@@ -648,6 +648,21 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### Plan vs actual and the survey tools
+
+Each well against its directional plan: at every survey station, how far
+it is from the plan - high or low, right or left, in the plan's own frame -
+against the survey's own uncertainty in that direction; the bit projected
+below the last survey; the one arc back to the plan, with its dogleg
+severity and toolface. Each well's survey program names the tool that
+surveyed each run, weighed by the ISCWSA MWD Rev 5.11 model (checked
+against all 144 rows of the ISCWSA's own Rev 5 example) or one of 21 OWSG
+tool-code models on its weighting functions - MWD and EMS with the standard,
+high- or low-resolution geomagnetic model or in-field referencing. Wells not
+yet drilled are checked for collision along their plans, a well being
+drilled along its survey and then its plan, and the Collision tab draws the
+travelling cylinder. The **Plan vs actual** tab, `gea plan`, `gea help plan`.
+
 ### Well collision checks
 
 Every well scanned against every other: at each point of one well, the

{gea_program-0.49.0 → gea_program-0.50.0}/README.md

@@ -609,6 +609,21 @@ against it; `gea seedlink --config ... --hello` prints what a server says of
 itself; `gea help seedlink`. A TexNet station is served by EarthScope at
 `rtserve.iris.washington.edu:18000`, network `TX`.
 
+### Plan vs actual and the survey tools
+
+Each well against its directional plan: at every survey station, how far
+it is from the plan - high or low, right or left, in the plan's own frame -
+against the survey's own uncertainty in that direction; the bit projected
+below the last survey; the one arc back to the plan, with its dogleg
+severity and toolface. Each well's survey program names the tool that
+surveyed each run, weighed by the ISCWSA MWD Rev 5.11 model (checked
+against all 144 rows of the ISCWSA's own Rev 5 example) or one of 21 OWSG
+tool-code models on its weighting functions - MWD and EMS with the standard,
+high- or low-resolution geomagnetic model or in-field referencing. Wells not
+yet drilled are checked for collision along their plans, a well being
+drilled along its survey and then its plan, and the Collision tab draws the
+travelling cylinder. The **Plan vs actual** tab, `gea plan`, `gea help plan`.
+
 ### Well collision checks
 
 Every well scanned against every other: at each point of one well, the

{gea_program-0.49.0 → gea_program-0.50.0}/gea/__init__.py

@@ -123,7 +123,7 @@ from .profile_catalog import (
     read_pangaea_txt,
 )
 
-__version__ = "0.49.0"
+__version__ = "0.50.0"
 __all__ = [
     "aging_rate", "rate_psi_yr", "accuracy_psi",
     "Sensor", "SimulatorConfig", "DownholeEngine",

{gea_program-0.49.0 → gea_program-0.50.0}/gea/__main__.py

@@ -604,6 +604,24 @@ def main(argv=None) -> int:
     p_co.add_argument("--actor", type=str, default="cli")
     p_co.add_argument("--json", action="store_true")
 
+    p_pl = sub.add_parser("plan", help="a well against its plan: the distance high/low and right/left at each survey, the bit projected, the arc back to the plan; the survey program's tool models")
+    p_pl.add_argument("--workspace", type=str, default=None)
+    p_pl.add_argument("--well", type=str, default=None)
+    p_pl.add_argument("--attach", type=str, default=None, help="attach FILE as the well's plan (CSV, Excel or WITSML)")
+    p_pl.add_argument("--azimuth-reference", type=str, default=None, help="with --attach: true, grid or magnetic")
+    p_pl.add_argument("--md-unit", type=str, default="ft", help="with --attach: ft or m")
+    p_pl.add_argument("--grid", type=str, default=None, help="with a grid azimuth reference: the grid (e.g. UTM14N)")
+    p_pl.add_argument("--declination", type=str, default=None, help="with a magnetic azimuth reference: the declination used")
+    p_pl.add_argument("--remove", action="store_true", help="take the well's plan off it")
+    p_pl.add_argument("--program", type=str, default=None, help="the survey program: 'MWD+SRGM' or '0-1500:MWD+SRGM, 1500-:MWD+IFR1' (metres)")
+    p_pl.add_argument("--bit-offset", type=str, default=None, help="survey sensor to bit, m")
+    p_pl.add_argument("--lookahead", type=str, default=None, help="how far ahead the arc back rejoins the plan, m")
+    p_pl.add_argument("--source", type=str, default="", help="where the plan or the program came from")
+    p_pl.add_argument("--models", action="store_true", help="list the tool models")
+    p_pl.add_argument("--write", action="store_true", help="write the well's report")
+    p_pl.add_argument("--actor", type=str, default="cli")
+    p_pl.add_argument("--json", action="store_true")
+
     p_rt = sub.add_parser("rig-time", help="what the rig did each second of the drilling record - drilling, connections, trips, the slips - and the time lost against the pad's own best")
     p_rt.add_argument("--workspace", type=str, required=True)
     p_rt.add_argument("--well", type=str, default=None, help="with --write: one well's report (without it, the pad's)")
@@ -2422,6 +2440,49 @@ def main(argv=None) -> int:
             raise SystemExit(f"collision: {e.args[0] if e.args else e}")
         print(_json.dumps({k: v for k, v in r.items()}, default=str) if a.json else _CO.text(r))
         return 0
+    elif a.cmd == "plan":
+        import json as _json
+        from . import wellplan as _PL
+        from . import wellpos as _WP
+        from .cli import _safe_stdout
+        from .workspace import Workspace, WorkspaceError
+        _safe_stdout()
+        try:
+            if a.models:
+                for m_ in _WP.model_list():
+                    print(f"{m_['name']:<18} {m_['id']:<14} {m_['terms']:>2} terms  {m_['family']:<10} {m_['long_name']}" + ("  (default)" if m_['default'] else ""))
+                return 0
+            if not a.workspace:
+                raise ValueError("--workspace is needed")
+            ws = Workspace(a.workspace)
+            if (a.attach or a.remove or a.program or a.bit_offset is not None or a.lookahead is not None or a.write) and not a.well:
+                raise ValueError("--well is needed")
+            if a.attach:
+                with open(a.attach, "rb") as f_:
+                    r_ = _PL.attach(ws, a.well, os.path.basename(a.attach), f_.read(), a.actor, a.azimuth_reference or "", a.md_unit, a.grid,
+                                    float(a.declination) if a.declination else None, a.source)
+                print(f"plan attached to {a.well}: {r_['stations']} stations, {r_['md_range_m'][0]:,.1f} to {r_['md_range_m'][1]:,.1f} m MD ({r_['azimuth_reference']} north)")
+                return 0
+            if a.remove:
+                _PL.remove(ws, a.well, a.actor)
+                print(f"plan removed from {a.well}")
+                return 0
+            if a.program or a.bit_offset is not None or a.lookahead is not None:
+                s_ = _PL.set_well(ws, a.actor, a.well, _PL.parse_program(a.program) if a.program else None, a.bit_offset, a.lookahead, a.source)
+                print(f"{a.well}: " + ", ".join(f"{p_['model']} to {p_['to_md_m']:,.0f} m" if p_['to_md_m'] is not None else f"{p_['model']} to TD" for p_ in s_['program'])
+                      + f"; the bit {s_['bit_offset_m']:g} m below the survey sensor; back to the plan {s_['lookahead_m']:g} m ahead")
+                return 0
+            if a.write:
+                r_ = _PL.write_report(ws, __version__, a.well, a.actor)
+                print(f"wrote {r_['report_id']}: {r_['paths']['html']}")
+                if r_['paths'].get('pdf'):
+                    print(f"  printable: {r_['paths']['pdf']}")
+                return 0
+            r = _PL.page(ws, a.well)
+        except (KeyError, ValueError, OSError, WorkspaceError) as e:
+            raise SystemExit(f"plan: {e.args[0] if e.args else e}")
+        print(_json.dumps(r, default=str) if a.json else _PL.text(r))
+        return 0
     elif a.cmd == "rig-time":
         import json as _json
         from . import rig_state as _RS

{gea_program-0.49.0 → gea_program-0.50.0}/gea/acceptance_tests.py

@@ -11165,7 +11165,8 @@ def section_cr_collision(tmp: str) -> None:
     fld = {"declination_deg": 6.0, "dip_deg": 60.0, "total_nT": 48000.0}
     md = [0.0, 500.0, 1000.0, 2000.0]
     mk = lambda i, x, inc=(0, 0, 0, 0), az=(0, 0, 0, 0), y=0.0: {"id": i, "display": i, "md": md, "inc": list(inc), "az": list(az), "x0": x, "y0": y,
-                                                          "ref_elev_m": 0.0, "field": fld, "hole_in": 8.5}
+                                                          "ref_elev_m": 0.0, "field": fld, "hole_in": 8.5,
+                                                          "program": [{"to_md_m": None, "model": WP.REV4}]}
     rule = {**CO.DEFAULTS}
     A, B = CO.prepare(mk("A", 0.0)), CO.prepare(mk("B", 10.0))
     sAB, sBA = CO.scan(A, B, rule), CO.scan(B, A, rule)
@@ -11207,7 +11208,7 @@ def section_cr_collision(tmp: str) -> None:
     c3 = {
         "wells": len(v["wells"]) == 3 and len(v["pairs"]) == 6 and abs(wl["15/9-F-10"]["td_md_m"] - 5300.1) < 0.1
                  and all(abs(x["field"]["declination_deg"] - 1.12) < 0.05 for x in v["wells"]) and all("grid convergence" in x["azimuth_note"] for x in v["wells"]),
-        "worst": w_["level"] == "BELOW 1.0" and abs(w_["min_sf"] - 0.29) < 0.01 and {w_["reference_name"], w_["offset_name"]} == {"15/9-F-5", "15/9-F-10"}
+        "worst": w_["level"] == "BELOW 1.0" and abs(w_["min_sf"] - 0.062) < 0.01 and {w_["reference_name"], w_["offset_name"]} == {"15/9-F-5", "15/9-F-10"}
                  and abs(w_["at_md_m"] - 250) < 15 and abs(w_["distance_m"] - 1.20) < 0.05,
         "order": [p["min_sf"] for p in v["pairs"]] == sorted(p["min_sf"] for p in v["pairs"]) and all(len(p["profile"]["md_m"]) == len(p["profile"]["sf"]) for p in v["pairs"]),
         "ellipses": wl["15/9-F-10"]["td_ellipse_1sigma"]["major_m"] > wl["15/9-F-5"]["td_ellipse_1sigma"]["major_m"] > wl["NO 15/9-F-4"]["td_ellipse_1sigma"]["major_m"] > 1.0,
@@ -11296,6 +11297,254 @@ def section_cr_collision(tmp: str) -> None:
        + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
 
 
+def section_cs_plan_and_tools(tmp: str) -> None:
+    """Section CS - plan against actual, the survey tools and the travelling cylinder: the ISCWSA MWD Rev 5.11 model
+    checked against all 144 rows of the ISCWSA's own Rev 5 example, with the OWSG tool-code models on its weighting
+    functions; survey programs weighing each run by its tool; a well against its plan - high or low, right or left,
+    against the survey's own uncertainty - the bit projected and the arc back, each checked by construction; planned
+    wells in the collision check and the travelling cylinder's directions; the API, the CLI, the report, the dossier,
+    the tabs and the help."""
+    import base64 as _b64
+    import http.cookiejar
+    import math as _m
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import zipfile as _zf
+    import numpy as _np
+    from . import collision as CO
+    from . import dossier as DZ
+    from . import edr as E
+    from . import helplib as H
+    from . import well3d as W
+    from . import wellplan as WPL
+    from . import wellpos as WP
+    from . import xlsx_read as XR
+    from .workspace import Workspace
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "planvs"); d.mkdir()
+
+    # -- CS1 the Rev 5.11 model against the ISCWSA's example; the OWSG models ---------------------------------------------
+    ex5 = WP.check_example_rev5()
+    ex4 = WP.check_example()
+    t8 = ex5["totals"]["8000"]
+    ms = WP.models()
+    ml = WP.model_list()
+    sv = json.loads((pkg / "reference" / "iscwsa_rev5_example.json").read_text(encoding="utf-8"))["survey"]
+    md_, inc_, az_ = (_np.array(sv[k], float) for k in ("md", "inc", "azi"))
+    tvd_ = WP.min_curve_tvd(md_, inc_, az_)
+    at = lambda name: WP.program_uncertainty(md_, inc_, az_, tvd_, -4.0, 72.0, 50000.0, [{"to_md_m": None, "model": name}])["cov"][-1]
+    c_s, c_i, c_h = at("MWD+SRGM"), at("MWD+IFR1"), at("MWD+HRGM")
+    owsg = json.loads((pkg / "reference" / "owsg_tool_models.json").read_text(encoding="utf-8"))
+    c1 = {
+        "example": ex5["rows"] == 144 and ex5["sources"] == 35 and not ex5["disagree"] and ex5["worst_relative"] < 5e-5 and ex5["depths_m"] == [1200, 2100, 5100, 8000],
+        "totals": abs(t8[0] - 8518.67) < 0.01 and abs(t8[1] - 711.20) < 0.01 and abs(t8[2] - 513.29) < 0.01 and abs(t8[3] + 2244.33) < 0.01,
+        "rev4_kept": ex4["rows"] == 112 and not ex4["disagree"],
+        "models": len(ms) == 22 and WP.DEFAULT_MODEL == "MWD+SRGM" and sum(1 for m in ml if m["default"]) == 1 and WP.REV4 in ms
+                  and all(len(m["terms"]) >= 27 for m in ms.values()) and {"MWD+IFR1", "MWD+IFR2+SAG", "MWD+HRGM", "EMS+SRGM", "MWD+LRGM+SAG"} <= set(ms),
+        "magnitudes": ms["MWD+SRGM"]["terms"]["DEC-OS"][1] == 0.24 * _m.pi / 180 and ms["MWD+SRGM"]["terms"]["DEC-OS"][2] == "global"
+                      and ms["MWD+IFR1"]["terms"]["DEC-CI"][2] == "global" and ms["MWD+SRGM"]["terms"]["DEC-U"][2] == "well",
+        "grades": c_i[0, 0] + c_i[1, 1] < c_h[0, 0] + c_h[1, 1] < c_s[0, 0] + c_s[1, 1],
+        "attribution": "ISCWSA" in ex5["source"] and "Apache" in ex5["license"] and "OWSG" in owsg["source"] and "Apache" in owsg["license"] and len(owsg["models"]) == 21,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "CS1 the ISCWSA MWD Rev 5.11 model - the surface tie-on, the course-length terms, the enhanced sag and misalignments, the "
+       "declination split well-wide and field-wide - recomputing all 144 rows of the ISCWSA's own Rev 5 example (35 sources and the "
+       "total at four depths) to five significant figures; the Rev 4 example still whole; 21 OWSG tool-code models on the same "
+       "weighting functions with their magnitudes and propagation as published, in-field referencing tighter than the high-resolution "
+       "model and that tighter than the standard; the source and licence of both carried"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- CS2 survey programs ------------------------------------------------------------------------------------------------
+    one = WP.program_terms(md_, inc_, az_, tvd_, -4.0, 72.0, 50000.0, [{"to_md_m": None, "model": "MWD+SRGM"}])
+    two = WP.program_terms(md_, inc_, az_, tvd_, -4.0, 72.0, 50000.0, [{"to_md_m": 2100.0, "model": "MWD+SRGM"}, {"to_md_m": None, "model": "MWD+SRGM"}])
+    mix = WP.program_uncertainty(md_, inc_, az_, tvd_, -4.0, 72.0, 50000.0, [{"to_md_m": 2100.0, "model": "MWD+SRGM"}, {"to_md_m": None, "model": "MWD+IFR1"}])
+    p1, P1, _ = WP.covariances(one)
+    p2, P2, _ = WP.covariances(two)
+    k21 = int(_np.flatnonzero(md_ == 2100)[0])
+    refused = 0
+    for bad in ([{"to_md_m": None, "model": "NOPE"}], [{"to_md_m": 900, "model": "MWD+SRGM"}, {"to_md_m": 800, "model": "MWD+SRGM"}],
+                [{"to_md_m": None, "model": "MWD+SRGM"}, {"to_md_m": None, "model": "MWD+IFR1"}], []):
+        try:
+            WPL.check_program([dict(x) for x in bad])
+        except ValueError:
+            refused += 1
+    c2 = {
+        "same_above": _np.allclose(P1[: k21 + 1], P2[: k21 + 1], rtol=1e-12, atol=1e-12),
+        "keys": "DEC-OS" in two and "DEC-U" in two and "ABZ@1" in two and "ABZ@2" in two and "ABZ" not in two and two["DEC-OS"]["shared"] and not two["DEC-U"]["shared"],
+        "runs_independent": not _np.allclose(P1[-1], P2[-1]),
+        "ifr_below": mix["cov"][-1][0, 0] + mix["cov"][-1][1, 1] < P1[-1][0, 0] + P1[-1][1, 1] and mix["model"] == "MWD+SRGM then MWD+IFR1",
+        "parse": WPL.parse_program("0-1500:MWD+SRGM, 1500-:MWD+IFR1") == [{"to_md_m": 1500.0, "model": "MWD+SRGM"}, {"to_md_m": None, "model": "MWD+IFR1"}]
+                 and WPL.parse_program("MWD+HRGM") == [{"to_md_m": None, "model": "MWD+HRGM"}],
+        "refused": refused == 4,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "CS2 survey programs: each station weighed by the run that surveyed it - above the change, two runs of one tool read as one; "
+       "below it a run's own errors start again while the well's and the field's run through; in-field referencing below the "
+       "change tightens the well at TD; a program with an unknown tool, depths out of order or an open run before the last refused"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- CS3 a well against its plan, by construction -----------------------------------------------------------------------
+    fld = {"declination_deg": 6.0, "dip_deg": 60.0, "total_nT": 48000.0}
+    prog = [{"to_md_m": None, "model": "MWD+SRGM"}]
+    mds = [float(x) for x in range(0, 1501, 30)]
+    inc30 = [0.0 if m_ < 300 else min(30.0, (m_ - 300) * 0.1) for m_ in mds]      # builds 3 deg/30 m from 300 m, holds 30 from 600 m
+    az90 = [90.0] * len(mds)
+    plan = {"md": mds, "incl": inc30, "azi": az90, "slot": [0.0, 0.0], "ref_elev_m": 0.0}
+    act = {"md": mds[:41], "incl": inc30[:41], "azi": az90[:41], "slot": [0.0, 0.0], "ref_elev_m": 0.0}   # drilled to 1,200 m of a 1,500 m plan
+    left = WPL.compare({**act, "slot": [0.0, 5.0]}, plan, fld, prog, 15.0, 30.0)                  # the well 5 m north of a plan heading east
+    up = WPL.compare({**act, "ref_elev_m": 3.0}, plan, fld, prog, 15.0, 30.0)                     # the well 3 m above the plan
+    same = WPL.compare(act, plan, fld, prog, 15.0, 30.0)
+    done = WPL.compare(plan, plan, fld, prog, 15.0, 30.0)
+    bld = WPL.compare({"md": mds[:15], "incl": inc30[:15], "azi": az90[:15], "slot": [0.0, 0.0], "ref_elev_m": 0.0}, plan, fld, prog, 15.0, 30.0)
+    la, lu = left["last"], up["last"]
+    phi = _m.atan2(5.0, 30.0)
+    dls_hand = _m.degrees(2 * phi) / (_m.hypot(30.0, 5.0) * phi / _m.sin(phi)) * 30.0
+    c3 = {
+        "left": abs(la["right_m"] + 5.0) < 0.01 and abs(la["high_m"]) < 0.01 and abs(la["distance_m"] - 5.0) < 0.01 and abs(la["d_inc_deg"]) < 0.01,
+        "high": abs(lu["high_m"] - 1.5) < 0.01 and abs(lu["right_m"]) < 0.01,
+        "sigma": la["sigma_right_m"] > 0 and abs(la["n_sigma"] - 5.0 / la["sigma_right_m"]) < 0.02 and same["worst"]["distance_m"] < 0.01,
+        "bit": abs(bld["bit"]["inc_deg"] - (inc30[14] + 1.5)) < 1e-6 and abs(bld["bit"]["build_deg_30m"] - 3.0) < 1e-6 and bld["bit"]["md_m"] == mds[14] + 15.0
+               and bld["bit"]["distance_m"] < 0.05,
+        "steer": abs(left["steer"]["toolface_deg"] - 90.0) < 0.5 and abs(left["steer"]["dls_deg_30m"] - dls_hand) < 0.05 and same["steer"]["dls_deg_30m"] < 0.05
+                 and done["steer"]["dls_deg_30m"] is None and "past the plan" in done["steer"]["note"] and done["bit"]["past_plan_td"],
+        "views": len(left["views"]["actual"]["n"]) == 41 and abs(left["views"]["actual"]["n"][0] - 5.0) < 1e-6,
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "CS3 a well against its plan, each figure by construction (drilled to 1,200 m of a 1,500 m plan): a well 5 m north of a plan heading east is 5 m left; 3 m above a "
+       "30-degree hold is 1.5 m high; each set against the survey's standard deviation in its direction; the bit projected 15 m "
+       "holding a 3 deg/30 m build lands on the plan that builds the same; the arc back from 5 m left to the plan 30 m ahead turns "
+       "right (toolface 90) at the severity computed by hand, a well on its plan needs none, and a well at the plan's TD has no plan ahead to steer to"
+       + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+    # -- CS4 planned wells in the collision check; the travelling cylinder --------------------------------------------------
+    mk = lambda i, x, inc, az, prog_=None: {"id": i, "display": i, "md": [0.0, 500.0, 1000.0, 2000.0], "inc": list(inc), "az": list(az), "x0": x, "y0": 0.0,
+                                            "ref_elev_m": 0.0, "field": fld, "hole_in": 8.5, **({"program": prog_} if prog_ else {})}
+    R1, O1 = CO.prepare(mk("R", 0.0, (0, 0, 0, 0), (0, 0, 0, 0))), CO.prepare(mk("O", 10.0, (0, 0, 0, 0), (0, 0, 0, 0)))
+    R2, O2 = CO.prepare(mk("R", 0.0, (45, 45, 45, 45), (0, 0, 0, 0))), CO.prepare(mk("O", 10.0, (45, 45, 45, 45), (0, 0, 0, 0), [{"to_md_m": None, "model": WP.REV4}]))
+    s1, s2 = CO.scan(R1, O1, CO.DEFAULTS), CO.scan(R2, O2, CO.DEFAULTS)
+    ev = E.selftest_events(str(d))
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    ids = []
+    for i, n in enumerate(("Well A", "Well B", "Well C")):
+        w = ws.add_well_file(ev["path"], display=n, actor="tester"); ids.append(w["id"])
+        ws.set_well(w["id"], surface={"lat": 31.42, "lon": -104.10 + 0.00008 * i, "datum": "NAD83", "elevation": {"ft": 3000.0, "datum": "KB", "source": "test plat"}}, actor="tester")
+    tab = lambda pts: "MD (ft),Inc (deg),Azi (deg)\n" + "\n".join(f"{a},{b},{c}" for a, b, c in pts) + "\n"
+    sur_a = [(m_, 0.0 if m_ < 1500 else min(40.0, (m_ - 1500) * 0.02), 95.0) for m_ in range(0, 4001, 100)]
+    plan_a = [(m_, 0.0 if m_ < 1500 else min(45.0, (m_ - 1500) * 0.02), 95.0) for m_ in range(0, 7001, 250)]
+    W.attach_trajectory(ws, ids[0], "a.csv", tab(sur_a).encode(), "tester", "true", "ft", None, None, None, "MWD report (test)")
+    W.attach_trajectory(ws, ids[1], "b.csv", tab([(m_, 0.0 if m_ < 1200 else min(50.0, (m_ - 1200) * 0.025), 265.0) for m_ in range(0, 5001, 100)]).encode(),
+                        "tester", "true", "ft", None, None, None, "MWD report (test)")
+    XR.write_simple(str(d / "planC.xlsx"), [["MD (ft)", "Inc (deg)", "Azi (deg)"]] + [[m_, 0.0 if m_ < 800 else min(40.0, (m_ - 800) * 0.02), 5.0] for m_ in range(0, 6001, 500)])
+    WPL.attach(ws, ids[0], "planA.csv", tab(plan_a).encode(), "tester", "true", "ft", None, None, "well plan rev 1 (test)")
+    WPL.attach(ws, ids[2], "planC.xlsx", (d / "planC.xlsx").read_bytes(), "tester", "true", "ft", None, None, "well plan rev 0 (test)")
+    pg = CO.page(ws)
+    wl = {w_["id"]: w_ for w_ in pg["wells"]}
+    sc3 = W.workspace_scene(ws)
+    c4 = {
+        "vertical_north": all(a_ == 90.0 for a_ in s1["profile"]["tc_deg"]) and all(s1["profile"]["tc_north"]),
+        "high_side": all(abs(a_ - 90.0) < 0.5 for a_, nn in zip(s2["profile"]["tc_deg"], s2["profile"]["tc_north"]) if not nn) and not s2["profile"]["tc_north"][-1]
+                     and s2["min_sf"] > 0 and abs(s2["distance_m"] - 10.0) < 1e-6,
+        "planned": len(pg["wells"]) == 3 and wl[ids[2]]["basis"] == "plan" and wl[ids[2]]["display"].endswith("(plan)") and "30 m" in wl[ids[2]]["basis_note"]
+                   and wl[ids[0]]["basis"] == "survey + plan" and abs(wl[ids[0]]["td_md_m"] - 7000 * 0.3048) < 0.5 and len(pg["pairs"]) == 6 and not pg["left_out"],
+        "scene": [p_["id"] for p_ in sc3["planned"]] == [ids[0], ids[2]] and [w_["id"] for w_ in sc3["wells"]] == ids[:2]
+                 and any(x["id"] == ids[2] and "a plan" in x["why"] for x in sc3["not_placed"]),
+        "models": all(w_["model"] == "MWD+SRGM" for w_ in pg["wells"]),
+    }
+    failed4 = [k for k, v in c4.items() if not v]
+    ok(not failed4,
+       "CS4 the travelling cylinder's directions - a neighbour due east of a vertical well at 90 from north, of a well heading north "
+       "at 45 degrees at 90 from its high side (with one well on the Rev 4 model and one on Rev 5.11, their shared errors those both "
+       "carry); a well not yet drilled checked along its plan (an Excel plan), weighed as surveyed every 30 m; a well being drilled "
+       "along its survey and then its plan to TD; the 3D scene carrying the plans"
+       + (f" [failed: {', '.join(failed4)}]" if failed4 else ""))
+
+    # -- CS5 the API, the CLI, the report, the dossier, the tabs and the help ----------------------------------------------
+    Users(str(Path(wsp, "users.json"))).add("v", "viewer-pass-1", "viewer"); Users(str(Path(wsp, "users.json"))).add("op", "op-pass-123", "operator")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+
+    def opener(name, pw_):
+        o = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+        rq = urllib.request.Request(base_url + "/api/login", method="POST", data=json.dumps({"name": name, "password": pw_}).encode())
+        rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1"); o.open(rq, timeout=30)
+        return o
+
+    def call(o, method, path, body=None):
+        rq = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        if method == "POST":
+            rq.add_header("Content-Type", "application/json"); rq.add_header("X-GEA-Action", "1")
+        try:
+            with o.open(rq, timeout=120) as rr_:
+                return rr_.status, json.loads(rr_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+    plan_b = _b64.b64encode(tab([(m_, 0.0 if m_ < 1200 else min(55.0, (m_ - 1200) * 0.025), 262.0) for m_ in range(0, 6001, 300)]).encode()).decode()
+    try:
+        V, O = opener("v", "viewer-pass-1"), opener("op", "op-pass-123")
+        s_vp, vp = call(V, "GET", "/api/plan?well=" + ids[0])
+        s_tm, tm = call(V, "GET", "/api/tool-models")
+        s_va, _ = call(V, "POST", "/api/plan/attach", {"well_id": ids[1], "filename": "b.csv", "content_b64": plan_b, "azimuth_reference": "true", "source": "x"})
+        s_ns, _ = call(O, "POST", "/api/plan/attach", {"well_id": ids[1], "filename": "b.csv", "content_b64": plan_b, "azimuth_reference": "true", "source": ""})
+        s_nr, _ = call(O, "POST", "/api/plan/attach", {"well_id": ids[1], "filename": "b.csv", "content_b64": plan_b, "azimuth_reference": "", "source": "plan"})
+        s_oa, oa = call(O, "POST", "/api/plan/attach", {"well_id": ids[1], "filename": "b.csv", "content_b64": plan_b, "azimuth_reference": "true", "md_unit": "ft", "source": "plan rev 1 (test)"})
+        s_bp, _ = call(O, "POST", "/api/plan/settings", {"well_id": ids[1], "program": "0-500:NOPE", "source": "p"})
+        s_op, op_ = call(O, "POST", "/api/plan/settings", {"well_id": ids[1], "program": "0-500:MWD+SRGM, 500-:MWD+IFR1", "bit_offset_m": "18", "source": "survey program rev 1 (test)"})
+        s_bo, _ = call(O, "POST", "/api/plan/settings", {"well_id": ids[1], "bit_offset_m": 500})
+        s_pb, pb = call(V, "GET", "/api/plan?well=" + ids[1])
+        s_vw, _ = call(V, "POST", "/api/plan/write", {"well_id": ids[1]})
+        s_ow, ow = call(O, "POST", "/api/plan/write", {"well_id": ids[1]})
+        s_rm, _ = call(O, "POST", "/api/plan/remove", {"well_id": ids[1]})
+        s_r2, _ = call(O, "POST", "/api/plan/remove", {"well_id": ids[1]})
+        s_co, co = call(V, "GET", "/api/collision")
+    finally:
+        svc.stop()
+    cli_m = _sp.run([sys.executable, "-m", "gea", "plan", "--models"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_p = _sp.run([sys.executable, "-m", "gea", "plan", "--workspace", wsp, "--well", ids[0], "--program", "MWD+HRGM", "--source", "program (test)"], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_t = _sp.run([sys.executable, "-m", "gea", "plan", "--workspace", wsp, "--well", ids[0]], capture_output=True, text=True, cwd=str(pkg.parent))
+    cli_w = _sp.run([sys.executable, "-m", "gea", "plan", "--workspace", wsp, "--well", ids[0], "--write"], capture_output=True, text=True, cwd=str(pkg.parent))
+    from . import __version__ as _ver
+    dz = DZ.build(ws, "tester", _ver, None)
+    names = _zf.ZipFile(Path(ws.reports_dir, dz["path"])).namelist()
+    audit = Path(ws.audit_path).read_text(encoding="utf-8")
+    pdf = Path(ws.reports_dir, "wells", ids[0], "plan_vs_actual.pdf")
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c5 = {
+        "api": s_vp == 200 and vp["comparison"] is not None and s_tm == 200 and len(tm["models"]) == 22 and tm["default"] == "MWD+SRGM"
+               and s_va == 403 and s_ns == 400 and s_nr == 400 and s_oa == 200 and oa["stations"] == 21 and s_bp == 400 and s_op == 200
+               and op_["program"][1]["model"] == "MWD+IFR1" and op_["bit_offset_m"] == 18.0 and s_bo == 400 and s_pb == 200 and pb["comparison"]["bit"]["offset_m"] == 18.0
+               and pb["comparison"]["model"] == "MWD+SRGM then MWD+IFR1" and s_vw == 403 and s_ow == 200 and ow["report_id"].startswith("PVA-")
+               and s_rm == 200 and s_r2 == 404 and s_co == 200 and any(w_["model"] == "MWD+SRGM then MWD+IFR1" for w_ in co["wells"]),
+        "cli": cli_m.returncode == 0 and "MWD+SRGM" in cli_m.stdout and "(default)" in cli_m.stdout and "ISCWSA MWD Rev4" in cli_m.stdout
+               and cli_p.returncode == 0 and "MWD+HRGM to TD" in cli_p.stdout and cli_t.returncode == 0 and "the bit projected" in cli_t.stdout
+               and "tools: MWD+HRGM" in cli_t.stdout and cli_w.returncode == 0 and "plan_vs_actual" in cli_w.stdout,
+        "report": pdf.exists() and PR_read_ok(pdf) and "report.plan_vs_actual" in audit and "well.plan" in audit and "well.plan_removed" in audit and "survey_program.declare" in audit,
+        "dossier": bool(names) and f"declarations/wells/{ids[0]}/plan/planA.csv" in names and "declarations/wellpath/survey_program.json" in names
+                   and "results/collision.json" in names and f"results/plan_vs_actual/{ids[0]}.json" in names,
+        "page": all(x in page_src for x in ("VIEWS.plan", "['#/plan', 'Plan vs actual']", "/api/plan/attach", "/api/plan/settings", "coCylinder", "#coTcRef", "pvDev")),
+        "help": not H.check("plan") and not H.check("collision") and H.VIEW_TOPIC.get("plan") == "plan" and "travelling cylinder" in (pkg / "help" / "collision.md").read_text(encoding="utf-8"),
+    }
+    failed5 = [k for k, v in c5.items() if not v]
+    ok(not failed5,
+       "CS5 on the API (anyone reads a well against its plan and the tool models; only an operator attaches a plan - its source and "
+       "azimuth reference required - declares a survey program - an unknown tool or a bit offset past 100 m refused - writes the "
+       "report or takes the plan off), the CLI (the models, a program, the comparison, the report), the report as PDF, a signed "
+       "dossier carrying the plans, the programs and both checks, the tabs and the help"
+       + (f" [failed: {', '.join(failed5)}]" if failed5 else ""))
+
+
+def PR_read_ok(path) -> bool:
+    from . import pdf_report as PR
+    try:
+        return bool(PR.read(Path(path).read_bytes())["ok"])
+    except Exception:
+        return False
+
+
 def main() -> int:
     print("GEA-Program - ACCEPTANCE SUITE (the product gate)")
     # a handle a job subprocess still holds at the end must not turn a finished gate into a traceback on Windows:
@@ -11395,6 +11644,7 @@ def main() -> int:
         section_cp_rig_time(tmp)
         section_cq_tied_together(tmp)
         section_cr_collision(tmp)
+        section_cs_plan_and_tools(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.49.0 → gea_program-0.50.0}/gea/collision.py

@@ -1,7 +1,9 @@
 """Well collision checks: how close each well's path comes to its neighbours, against how well both are known.
 
 Two wells drilled from one pad start metres apart. Each well's position is known only as well as its survey: the
-error model (`wellpos`, ISCWSA MWD Rev 4) gives each station's covariance, growing with depth. This module scans every
+error model (`wellpos`: the tool models of the well's survey program, ISCWSA MWD Rev 5.11 unless declared) gives each
+station's covariance, growing with depth. A well not yet drilled is checked along its plan (`wellplan`), weighed as if
+surveyed every 30 m; a well being drilled along its survey and then its plan below it. This module scans every
 well against every other in three dimensions and answers, along the reference well, with the separation factor of the
 ISCWSA collision-avoidance rule (Sawaryn et al., "Well-Collision-Avoidance Separation Rule", SPE Drilling &
 Completion 34(1), 2019):
@@ -46,6 +48,8 @@ RULE_SOURCE = ('the ISCWSA separation rule (Sawaryn et al., Well-Collision-Avoid
                'surface margin 0.3 m and project-ahead 0.5 m as recommended) and the ISCWSA eBook\'s levels (Separation Rules: report below 4.0, '
                'approach limit 1.5, revise below 1.25, dispensation below 1.0)')
 _LOCK = threading.Lock()
+TC_NORTH_BELOW_DEG = 5.0          # the travelling cylinder's angle from north while the reference is within this of vertical
+PLANNED_STATION_M = 30.0          # a plan weighed as if surveyed every 30 m (one stand)
 
 
 def _path(ws) -> str:
@@ -113,7 +117,7 @@ def prepare(w: dict, step_m: float = 10.0) -> dict:
     p = W3.Path(md, inc, az, w['x0'], w['y0'], w.get('ref_elev_m') or 0.0, 0.0)
     az_true = (az + w.get('az_true_offset_deg', 0.0)) % 360.0
     f = w['field']
-    u = WP.well_uncertainty(md, inc, az_true, p.tvd, f['declination_deg'], f['dip_deg'], f['total_nT'])
+    u = WP.program_uncertainty(md, inc, az_true, p.tvd, f['declination_deg'], f['dip_deg'], f['total_nT'], w.get('program'))
     r = math.radians(-w.get('az_true_offset_deg', 0.0))  # true north -> the frame's north
     R = np.array([[math.cos(r), -math.sin(r), 0.0], [math.sin(r), math.cos(r), 0.0], [0.0, 0.0, 1.0]])
     C = np.einsum('ij,kjl,ml->kim', R, u['cov'], R)
@@ -125,7 +129,14 @@ def prepare(w: dict, step_m: float = 10.0) -> dict:
     t = ((grid - md[j]) / np.where(md[j + 1] > md[j], md[j + 1] - md[j], 1.0)).clip(0.0, 1.0)
     Ci = C[j] * (1 - t)[:, None, None] + C[j + 1] * t[:, None, None]
     Gi = {k: v[j] * (1 - t)[:, None] + v[j + 1] * t[:, None] for k, v in G.items()}
+    tng = np.gradient(pos, grid, axis=0) if len(grid) > 1 else np.array([[0.0, 0.0, 1.0]])
+    tng = tng / np.maximum(np.linalg.norm(tng, axis=1), 1e-12)[:, None]
+    inc_g = np.degrees(np.arccos(np.clip(tng[:, 2], -1.0, 1.0)))
+    az_g = np.arctan2(tng[:, 1], tng[:, 0])
+    hs = np.stack([np.cos(np.radians(inc_g)) * np.cos(az_g), np.cos(np.radians(inc_g)) * np.sin(az_g), -np.sin(np.radians(inc_g))], axis=1)
+    rt = np.stack([-np.sin(az_g), np.cos(az_g), np.zeros(len(grid))], axis=1)
     return {**w, 'grid_md': grid, 'pos': pos, 'cov': Ci, 'glob': Gi, 'radius_m': w.get('hole_in', DEFAULTS['hole_in']) * 0.0254 / 2.0,
+            'grid_inc': inc_g, 'hs': hs, 'rt': rt, 'model': u['model'],
             'stations_cov': C, 'stations_md': md, 'td_ellipse': WP.ellipse(C[-1], 1.0)}
 
 
@@ -157,13 +168,19 @@ def scan(ref: dict, off: dict, rule: dict) -> dict:
         Cr = ref['cov'][i]
         X = np.zeros((3, 3))
         for g_, sr in ref['glob'].items():                   # what both wells share moves them together
+            if g_ not in off['glob']:
+                continue
             so = off['glob'][g_][jj] * (1 - f) + off['glob'][g_][jj + 1] * f
             X += np.outer(sr[i], so)
         var = float(n @ (Cr + Co - X - X.T) @ n)
         sig = math.sqrt(max(var, 0.0))
         sf = (D - ref['radius_m'] - off['radius_m'] - sm) / (k * math.sqrt(sig * sig + spa * spa))
         md_o = float(off['grid_md'][jj] * (1 - f) + off['grid_md'][jj + 1] * f)
-        out.append((float(ref['grid_md'][i]), float(a[2]), md_o, D, sig, sf))
+        if ref['grid_inc'][i] < TC_NORTH_BELOW_DEG:              # near vertical: the bearing from north
+            ang = math.degrees(math.atan2(float(n[1]), float(n[0]))) % 360.0
+        else:                                                     # clockwise from the reference's high side
+            ang = math.degrees(math.atan2(float(n @ ref['rt'][i]), float(n @ ref['hs'][i]))) % 360.0
+        out.append((float(ref['grid_md'][i]), float(a[2]), md_o, D, sig, sf, ang))
     arr = np.array(out)
     i_min = int(np.argmin(arr[:, 5]))
     low = arr[:, 5] < float(rule.get('report_below', 4.0))
@@ -180,7 +197,9 @@ def scan(ref: dict, off: dict, rule: dict) -> dict:
             'distance_m': round(float(mn[3]), 3), 'sigma_m': round(float(mn[4]), 3), 'level': lv, 'why': why, 'sections': sections,
             'closest_m': round(float(arr[:, 3].min()), 3), 'closest_at_md_m': round(float(arr[int(np.argmin(arr[:, 3])), 0]), 1),
             'profile': {'md_m': [round(float(x), 1) for x in arr[:, 0]], 'sf': [round(float(min(x, 99.0)), 3) for x in arr[:, 5]],
-                        'distance_m': [round(float(x), 2) for x in arr[:, 3]], 'sigma_m': [round(float(x), 3) for x in arr[:, 4]]}}
+                        'distance_m': [round(float(x), 2) for x in arr[:, 3]], 'sigma_m': [round(float(x), 3) for x in arr[:, 4]],
+                        'offset_md_m': [round(float(x), 1) for x in arr[:, 2]], 'tc_deg': [round(float(x), 1) for x in arr[:, 6]],
+                        'tc_north': [bool(x < TC_NORTH_BELOW_DEG) for x in ref['grid_inc']]}}
 
 
 def _runs(mask):
@@ -199,16 +218,18 @@ def analyse(wells: List[dict], rule: dict, title: str = '') -> dict:
     pairs.sort(key=lambda p: p['min_sf'])
     wl = [{'id': w['id'], 'display': w['display'], 'td_md_m': round(float(w['stations_md'][-1]), 1), 'n_stations': int(len(w['stations_md'])),
            'hole_in': w.get('hole_in', DEFAULTS['hole_in']), 'field': w['field'], 'td_ellipse_1sigma': w['td_ellipse'],
-           'slot': [round(float(w['x0']), 2), round(float(w['y0']), 2)], 'field_note': w.get('field_note', ''), 'azimuth_note': w.get('azimuth_note', '')}
+           'slot': [round(float(w['x0']), 2), round(float(w['y0']), 2)], 'field_note': w.get('field_note', ''), 'azimuth_note': w.get('azimuth_note', ''),
+           'model': w['model'], 'basis': w.get('basis', 'survey'), 'basis_note': w.get('basis_note', '')}
           for w in prep]
     worst = pairs[0] if pairs else None
     return {'title': title, 'rule': {k: rule[k] for k in ('k', 'surface_margin_m', 'sigma_pa_m') if k in rule}, 'rule_source': rule.get('rule_source') or RULE_SOURCE,
             'wells': wl, 'pairs': pairs, 'worst': {k: v for k, v in (worst or {}).items() if k != 'profile'} or None,
             'levels': [{'below': lim, 'level': name, 'meaning': why} for lim, name, why in LEVELS],
-            'model': 'ISCWSA MWD Rev 4 (every well; a tool of another grade is another model)',
+            'model': 'each well by its survey program\'s tool models (ISCWSA MWD Rev 5.11, MWD+SRGM, unless declared)',
             'not_a_measurement': ['the wells\' true positions: an uncertainty is what the survey tool\'s published error model allows, not a measured miss',
                                   'a probability of collision: the separation factor is a rule\'s ratio, and the operator\'s standard says what it permits',
-                                  'the hole size when it is not declared (8-1/2 in by default), and the casing beyond it']}
+                                  'the hole size when it is not declared (8-1/2 in by default), and the casing beyond it',
+                                  'a plan\'s position: a well not yet drilled is checked along its plan, weighed as if surveyed every 30 m by its program\'s tools']}
 
 
 # -- the scenes -----------------------------------------------------------------------------------------------------------
@@ -243,8 +264,11 @@ def workspace_wells(ws) -> Tuple[List[dict], List[dict]]:
     sc = W3.workspace_scene(ws)
     s = settings(ws)
     left = list(sc.get('not_placed') or [])
+    from . import wellplan as WPL
     out = []
-    for w in sc['wells']:
+    plans = {p['id']: p for p in sc.get('planned') or []}
+    entries = [(w, 'survey') for w in sc['wells']] + [(p, 'plan') for p in plans.values() if not p['surveyed']]
+    for w, basis in entries:
         wid = w['id']
         wr = ws.well(wid)
         surf = wr.get('surface') or {}
@@ -256,16 +280,40 @@ def workspace_wells(ws) -> Tuple[List[dict], List[dict]]:
         except Exception:
             pass
         f = GM.field(float(surf.get('lat')), float(surf.get('lon')), 0.0, when or datetime.now(timezone.utc).date())
-        st = w['stations']
-        out.append({'id': wid, 'display': w['name'], 'md': st['md'], 'inc': st['incl'], 'az': st['azi'], 'az_true_offset_deg': 0.0,
+        st = dict(w['stations'])
+        note = ''
+        if basis == 'plan':                                # a well not yet drilled: its plan, weighed as surveyed every stand
+            st = _densify(st, PLANNED_STATION_M)
+            note = f'the plan ({w["source"]}), weighed as surveyed every {PLANNED_STATION_M:g} m'
+        elif wid in plans and plans[wid]['td_md'] > float(st['md'][-1]) + 1.0:    # drilling: the survey, then the plan below it
+            pl = _densify(plans[wid]['stations'], PLANNED_STATION_M)
+            below = [i for i, m in enumerate(pl['md']) if m > float(st['md'][-1]) + 1.0]
+            st = {k: list(st[k]) + [pl[k][i] for i in below] for k in ('md', 'incl', 'azi')}
+            basis = 'survey + plan'
+            note = f'surveyed to {w["stations"]["md"][-1]:,.1f} m, the plan below it'
+        prog = WPL.well_settings(ws, wid)['program']
+        out.append({'id': wid, 'display': w['name'] + (' (plan)' if basis == 'plan' else ''), 'md': st['md'], 'inc': st['incl'], 'az': st['azi'], 'az_true_offset_deg': 0.0,
+                    'program': prog, 'basis': basis, 'basis_note': note,
                     'x0': float(w['slot'][0]), 'y0': float(w['slot'][1]), 'ref_elev_m': float(w['ref_elev_m']),
                     'field': {'declination_deg': round(f['declination_deg'], 3), 'dip_deg': round(f['dip_deg'], 3), 'total_nT': round(f['total_nT'], 1)},
                     'hole_in': s['holes_in'].get(wid, DEFAULTS['hole_in']),
                     'field_note': f"WMM2025 at the well for {f['decimal_year']:.2f}" + (f" ({f['note']})" if f['note'] else ''),
                     'azimuth_note': w['azimuth']['applied']})
+    placed = {x['id'] for x in out}
+    left = [x for x in left if x['id'] not in placed]
     return out, left
 
 
+def _densify(st: dict, step: float) -> dict:
+    """A plan's stations with one added every `step` metres between them, on its arcs (as a survey would see it)."""
+    from . import well3d as W3
+    from . import wellplan as WPL
+    p = W3.Path(st['md'], st['incl'], st['azi'], 0.0, 0.0, 0.0, 0.0)
+    mds = sorted(set(np.round(np.concatenate([p.md, np.arange(p.md[0], p.md[-1], step)]), 3).tolist()))
+    dirs = [WPL._interp_dir(p, m) for m in mds]
+    return {'md': mds, 'incl': [d[0] for d in dirs], 'azi': [d[1] for d in dirs]}
+
+
 def page(ws, scene: str = 'workspace') -> dict:
     rule = settings(ws)
     if scene == 'volve' or ws is None:
@@ -277,7 +325,7 @@ def page(ws, scene: str = 'workspace') -> dict:
         res = analyse(wells, rule, ws.manifest.get('name') or 'this workspace') if len(wells) >= 2 else {
             'title': ws.manifest.get('name') or 'this workspace', 'wells': [], 'pairs': [], 'worst': None, 'rule': {k: rule[k] for k in ('k', 'surface_margin_m', 'sigma_pa_m')},
             'rule_source': rule.get('rule_source') or RULE_SOURCE, 'levels': [{'below': lim, 'level': name, 'meaning': why} for lim, name, why in LEVELS],
-            'model': 'ISCWSA MWD Rev 4', 'not_a_measurement': [],
+            'model': 'each well by its survey program\'s tool models', 'not_a_measurement': [],
             'detail': f"{len(wells)} well(s) have a surface position, a reference elevation and a survey; a check needs two"}
         res['left_out'] = left
     else: