gea-program 0.79.0__tar.gz → 0.81.0__tar.gz

{gea_program-0.79.0/gea_program.egg-info → gea_program-0.81.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.79.0
+Version: 0.81.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
@@ -476,7 +476,17 @@ reasons and the confidence of each choice. A position filter (since
 0.78.0) places the bit in the layer the way a geosteerer does, from the
 gamma and the deep-resistivity distance against the model, and the screen
 draws the band it puts the layer in. The driller accepts, rejects or
-records what was done instead, by name; every recommendation, answer and
+records what was done instead, by name. The third dimension (since
+0.80.0): the lateral has an azimuth, the agent's sixth choice is where to
+aim it and the recommendation reads as one toolface; the layer is a surface with
+a dip across the plan line as well as along it, the hole is placed by
+minimum curvature through the surveys' azimuths, the corridor the lease
+and the offset wells leave the hole is in the twin and on the screen's
+plan view, and the config's model carries the plan's azimuth, the cross
+dip and the corridor. A vibration index read off the surface torque,
+weight and hook load (since 0.81.0) stands in for the downhole tool a
+string does not carry, and the record says which the agent read. Every
+recommendation, answer and
 command is on record with its hash, and GEA pulls the records into the
 well from the **Drill string** tab's card (`gea workspace --path C:\site
 --action driller-pull --box http://192.168.1.60:8790 --well SWD-1`). The
@@ -830,7 +840,7 @@ unsigned, the key hand-overs - and shows the reports as they were signed. A
 reader made from the workspace knows the site's key fingerprints, so it
 says whether a dossier is the site's; it allows no network request, and it
 leaves the trusted time-stamp to `verify_dossier.py`. For a client who wants
-it installed, every release also carries `GEA-Reader-Setup-0.79.0.exe`: GEA
+it installed, every release also carries `GEA-Reader-Setup-0.81.0.exe`: GEA
 Reader as a Windows program of its own - its own icon and taskbar button,
 Check with GEA Reader on a dossier's right-click menu, fingerprints the client
 saves kept on that computer, nothing of GEA-Program. `gea help reader`.
@@ -1595,7 +1605,7 @@ attaches the zips to the GitHub release of that tag.
 
 ### The Windows installer
 
-Every release also carries `GEA-Program-Setup-0.79.0.exe` (for 0.79.0): the
+Every release also carries `GEA-Program-Setup-0.81.0.exe` (for 0.81.0): the
 same Windows kit installed like any Windows program, for the signed-in user
 alone and with no administrator rights (`%LOCALAPPDATA%\Programs\GEA-Program`).
 It asks for the site workspace (an existing one such as `C:\site` is used as
@@ -1614,7 +1624,7 @@ it, removes the program and leaves the workspace. Silent, for a site's
 software deployment:
 
 ```
-GEA-Program-Setup-0.79.0.exe /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /WORKSPACE="C:\site" /SITENAME="Pad 3" /TASKS="desktopicon"
+GEA-Program-Setup-0.81.0.exe /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /WORKSPACE="C:\site" /SITENAME="Pad 3" /TASKS="desktopicon"
 ```
 
 The setup is built by Inno Setup 6 from `tools/installer.iss` in the same

{gea_program-0.79.0 → gea_program-0.81.0}/README.md

@@ -437,7 +437,17 @@ reasons and the confidence of each choice. A position filter (since
 0.78.0) places the bit in the layer the way a geosteerer does, from the
 gamma and the deep-resistivity distance against the model, and the screen
 draws the band it puts the layer in. The driller accepts, rejects or
-records what was done instead, by name; every recommendation, answer and
+records what was done instead, by name. The third dimension (since
+0.80.0): the lateral has an azimuth, the agent's sixth choice is where to
+aim it and the recommendation reads as one toolface; the layer is a surface with
+a dip across the plan line as well as along it, the hole is placed by
+minimum curvature through the surveys' azimuths, the corridor the lease
+and the offset wells leave the hole is in the twin and on the screen's
+plan view, and the config's model carries the plan's azimuth, the cross
+dip and the corridor. A vibration index read off the surface torque,
+weight and hook load (since 0.81.0) stands in for the downhole tool a
+string does not carry, and the record says which the agent read. Every
+recommendation, answer and
 command is on record with its hash, and GEA pulls the records into the
 well from the **Drill string** tab's card (`gea workspace --path C:\site
 --action driller-pull --box http://192.168.1.60:8790 --well SWD-1`). The
@@ -791,7 +801,7 @@ unsigned, the key hand-overs - and shows the reports as they were signed. A
 reader made from the workspace knows the site's key fingerprints, so it
 says whether a dossier is the site's; it allows no network request, and it
 leaves the trusted time-stamp to `verify_dossier.py`. For a client who wants
-it installed, every release also carries `GEA-Reader-Setup-0.79.0.exe`: GEA
+it installed, every release also carries `GEA-Reader-Setup-0.81.0.exe`: GEA
 Reader as a Windows program of its own - its own icon and taskbar button,
 Check with GEA Reader on a dossier's right-click menu, fingerprints the client
 saves kept on that computer, nothing of GEA-Program. `gea help reader`.
@@ -1556,7 +1566,7 @@ attaches the zips to the GitHub release of that tag.
 
 ### The Windows installer
 
-Every release also carries `GEA-Program-Setup-0.79.0.exe` (for 0.79.0): the
+Every release also carries `GEA-Program-Setup-0.81.0.exe` (for 0.81.0): the
 same Windows kit installed like any Windows program, for the signed-in user
 alone and with no administrator rights (`%LOCALAPPDATA%\Programs\GEA-Program`).
 It asks for the site workspace (an existing one such as `C:\site` is used as
@@ -1575,7 +1585,7 @@ it, removes the program and leaves the workspace. Silent, for a site's
 software deployment:
 
 ```
-GEA-Program-Setup-0.79.0.exe /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /WORKSPACE="C:\site" /SITENAME="Pad 3" /TASKS="desktopicon"
+GEA-Program-Setup-0.81.0.exe /VERYSILENT /SUPPRESSMSGBOXES /NORESTART /WORKSPACE="C:\site" /SITENAME="Pad 3" /TASKS="desktopicon"
 ```
 
 The setup is built by Inno Setup 6 from `tools/installer.iss` in the same

{gea_program-0.79.0 → gea_program-0.81.0}/gea/__init__.py

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

{gea_program-0.79.0 → gea_program-0.81.0}/gea/acceptance_tests.py

@@ -16566,6 +16566,7 @@ def section_dv_driller(tmp: str) -> None:
             time.sleep(0.2)
         s_ov, _ = call("/api/answer", {"what": "override", "by": "tester", "note": "held", "override": {"build_deg_100ft": 0.0, "wob_klb": 25}})
         md = drl.feed.snapshot()["state"]["hole_depth"]
+        drl.cfg["limits"]["vibration_index"] = 5.0                       # the section's end alone ends this arming: the vibration index the feed now derives (0.81.0) may cross 1.2 in the shale
         s_long, _ = call("/api/arm", {"by": "tester", "to_md": md + 5000})
         s_arm, armed = call("/api/arm", {"by": "tester", "to_md": md + 150})
         t_end = time.monotonic() + 30
@@ -16698,7 +16699,7 @@ def section_dv_driller(tmp: str) -> None:
                 e_ = inf["estimate"]; truth = inf["lithology"]
                 guess = max(("above", e_["p_above"]), ("in", e_["p_in"]), ("below", e_["p_below"]), key=lambda x: x[1])[0]
                 conf[truth][guess] += 1; n_steps += 1
-                errs.append(abs(e_["d_top"] - (lt.tvd - sc.layer_top(lt.vs))))
+                errs.append(abs(e_["d_top"] - (lt.tvd - sc.layer_top(lt.vs, getattr(lt, "y", 0.0)))))
     right = sum(conf[k][k] for k in conf); total = sum(sum(v.values()) for v in conf.values())
     # a filter told nothing but the gamma of a flat layer sits where the model says; told a boundary, it moves
     f1 = PF.PositionFilter(9000.0, 0.0, 40.0, 60.0, 130.0, 115.0, seed=3)
@@ -16841,6 +16842,349 @@ def section_dw_shadow(tmp: str) -> None:
        "refuses the wrong well; the card, the workspace command and the help page carry it" + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
 
 
+def section_dx_third_dimension(tmp: str) -> None:
+    """Section DX - the third dimension of GEA Driller: the directional arithmetic (minimum curvature, the dogleg of a
+    build and a turn, the toolface), the twin in the plan's frame (the turn, the layer as a surface, the corridor,
+    an older five-choice action), the filter's cross dip; the rig side (the bit placed from surveys with azimuths,
+    the twin as the rig publishing the azimuth, a decision with the turn and the toolface, an override with a turn,
+    the limit on both together, the config's refusals, the screen, the help); the policy with six heads holding the
+    corridor on the held-out scenes, and shadow mode judging the turn with the record's azimuth and not without.
+    The sixth choice is where to aim the azimuth (left of the plan, along it, right of it); the tool turns toward it
+    at its own rate, as a directional driller holds the azimuth he is given."""
+    import importlib
+    import math as _m
+    from . import driller_link as DL
+    from . import helplib as H
+    pkg = Path(__file__).parent
+    d = Path(tmp, "dx"); d.mkdir()
+    prog = DL.program()
+    if prog is None:
+        ok(True, "DX the driller's program (gea-driller) is not installed beside GEA in this install; nothing to check here")
+        return
+    if prog["env"] and prog["env"] not in sys.path:
+        sys.path.insert(0, prog["env"])
+    T = importlib.import_module("gea_driller.twin"); G = importlib.import_module("gea_driller.geometry"); PF = importlib.import_module("gea_driller.position")
+    P = importlib.import_module("gea_driller.policy"); A = importlib.import_module("gea_driller.advisor"); C = importlib.import_module("gea_driller.config")
+    S = importlib.import_module("gea_driller.service"); R = importlib.import_module("gea_driller.rig"); SH = importlib.import_module("gea_driller.shadow")
+    np_ = importlib.import_module("numpy")
+    # -- DX1 the arithmetic, the twin, the filter -----------------------------------------------------------------------------
+    dn, de, dv, dl = G.min_curvature(90.0, 30.0, 90.0, 30.0, 1000.0)
+    _, _, dv_b, dl_b = G.min_curvature(90.0, 0.0, 91.5, 0.0, 100.0)
+    _, _, _, dl_t = G.min_curvature(90.0, 0.0, 90.0, 2.0, 100.0)
+    _, _, _, dl_t60 = G.min_curvature(60.0, 0.0, 60.0, 2.0, 100.0)
+    lh = T.Lateral(T.Scene(3)); lh.reset(); lt = T.Lateral(T.Scene(3)); lt.reset(); l5 = T.Lateral(T.Scene(3)); l5.reset()
+    for _ in range(8):
+        lh.step(T.HOLD_ACTION); lt.step((2, 1, 1, 1, 0, 2)); l5.step((2, 1, 1, 1, 0))
+    sc = T.Scene(3)
+    cross = (sc.layer_top(500.0, 100.0) - sc.layer_top(500.0, 0.0)) - 100.0 * _m.tan(_m.radians(sc.cross_dip_deg))
+    # a hole aimed right of the plan and never brought back leaves the corridor and is lost
+    lw = T.Lateral(T.Scene(9)); lw.scene.corridor_ft = 50.0; lw.reset()
+    while not lw.done and lw.steps < 400:
+        lw.step((2, 1, 1, 1, 0, 2))
+    try:
+        T.full_action((1, 2, 3)); short_refused = False
+    except ValueError:
+        short_refused = True
+    # the filter: with a cross dip in the model, the top moves with the offset; the cross dip is read only across the plan line
+    f_along = PF.PositionFilter(9000.0, 0.0, 40.0, 60.0, 130.0, 115.0, seed=3, model_cross_dip_deg=2.0)
+    f_across = PF.PositionFilter(9000.0, 0.0, 40.0, 60.0, 130.0, 115.0, seed=3, model_cross_dip_deg=2.0)
+    for k in range(40):
+        f_along.predict(30.0, 0.0); f_along.update(9020.0, 60.0)                      # along the plan: the gamma in the layer, nothing learnt of the cross dip
+        f_across.predict(0.0, 10.0); f_across.update(9020.0 + 10.0 * (k + 1) * _m.tan(_m.radians(1.0)), 62.0, 4.0)   # across: the top tracks a real cross dip of 1 degree, the tool says so
+    e_along = f_along.estimate(9020.0); e_across = f_across.estimate(9020.0 + 400.0 * _m.tan(_m.radians(1.0)))
+    top_shift = float(f_along.model_top(0.0, 100.0) - f_along.model_top(0.0, 0.0))
+    c1 = {
+        "straight": abs(dn - 1000.0 * _m.cos(_m.radians(30.0))) < 1e-6 and abs(de - 500.0) < 1e-6 and abs(dv) < 1e-6 and abs(dl) < 1e-9,
+        "dogleg": abs(dl_b - 1.5) < 1e-9 and abs(dl_t - 2.0) < 1e-6 and abs(dl_t60 - 2.0 * _m.sin(_m.radians(60.0))) < 0.02 and abs(dv_b + 100.0 * _m.sin(_m.radians(0.75))) < 0.05,
+        "toolface": abs(G.toolface_of(1.5, 0.0, 90.0)) < 1e-9 and abs(G.toolface_of(0.0, 2.0, 90.0) - 90.0) < 1e-9 and abs(G.toolface_of(-1.5, 0.0, 90.0) - 180.0) < 1e-9
+                    and abs(G.toolface_of(0.0, -2.0, 90.0) - 270.0) < 1e-9 and abs(G.dls_of(3.0, 4.0, 90.0) - 5.0) < 1e-9,
+        "turns": lt.az > lh.az + 1.5 and lt.y > lh.y + 5.0 and 2.5 < lt.az - lh.az < 6.0 and abs(T.turn_toward(4.0, 0.0) - 2.0) < 1e-9 and abs(T.turn_toward(0.0, 0.5) + 0.75) < 1e-9,
+        "surface": abs(cross) < 1.0 + sc.und_amp and T.Scene(1).cross_dip_deg != T.Scene(2).cross_dip_deg and "cross_dip_deg" in sc.describe() and "corridor_ft" in sc.describe(),
+        "lost": lw.done and lw.ended == "outside the corridor" and lw.summary()["lost"] and lw.max_offset > lw.scene.corridor_ft + T.CORRIDOR_END_FT and any("outside the corridor" in e for e in lw.events),
+        "five_choices": abs(l5.az - lh.az) < 1e-9 and abs(l5.y - lh.y) < 1e-9 and short_refused and len(T.ACTION_SIZES) == 6 and T.ACTION_NAMES[-1] == "aim",
+        "obs": len(T.OBS_NAMES) == T.OBS_SIZE == 34 == lt.observe().shape[0] and all(np_.isfinite(lt.observe())) and "offset_right_of_plan" in T.OBS_NAMES,
+        "filter": abs(top_shift - 100.0 * _m.tan(_m.radians(2.0))) < 1e-9 and abs(e_along["cross_dip_deg"] - 2.0) < 0.3 and e_along["cross_dip_sigma"] > 0.3
+                  and abs(e_across["cross_dip_deg"] - 1.0) < 0.6 and e_across["cross_dip_sigma"] < e_along["cross_dip_sigma"],
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "DX1 minimum curvature lands a straight hole 30° off the plan where the sine says, a build's dogleg is the build and a turn's counts by the inclination's sine, "
+       "the toolface of a build is up and of a turn is right; in the twin an aim right of the plan turns the hole toward it at the tool's rate and swings it to the "
+       "right, the layer's top moves across the plan line by the cross dip, a hole aimed out of the corridor is lost and says so, a five-choice action is taken aimed "
+       "along the plan and a shorter one refused, "
+       "the observation is 34 named and finite; the filter moves the model's top by its cross dip and reads the cross dip only across the plan line"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+    # -- DX2 the rig side --------------------------------------------------------------------------------------------------------
+    shipped = P.Policy.load(S.SHIPPED_POLICY)
+    cfg = json.loads(json.dumps(C.EXAMPLE)); cfg["output"]["dir"] = str(d / "rig"); cfg["status"]["port"] = 0; cfg["status"]["bind"] = "127.0.0.1"
+    cfg["rig"]["transport"] = "sim"; cfg["model"]["plan_azimuth_deg"] = 40.0; cfg["model"]["corridor_ft"] = 120.0; cfg["model"]["cross_dip_deg"] = 1.0
+    cfg = C.check(cfg)
+    heel_tvd0 = float(cfg["model"]["heel_tvd_ft"])                    # the twin as the rig rewrites the model block in place below
+    try:
+        C.check(json.loads(json.dumps(cfg)) | {"model": {**cfg["model"], "cross_dip_deg": 20.0}}); cross_refused = False
+    except C.ConfigError:
+        cross_refused = True
+    try:
+        C.check(json.loads(json.dumps(cfg)) | {"model": {**cfg["model"], "corridor_ft": 2.0}}); corridor_refused = False
+    except C.ConfigError:
+        corridor_refused = True
+    # the bit placed from surveys: a feed that holds 90 degrees at the plan's azimuth plus 30 for 600 ft
+    feed = R.Feed(cfg); feed.state.update({"hole_depth": 10800.0, "gamma": 60.0, "continuous_inc": 90.0, "continuous_azi": 70.0}); feed.last_utc = time.time(); feed.connected = True
+    for md_ in (10200.0, 10290.0, 10380.0, 10470.0, 10560.0, 10650.0):
+        feed.add_survey(md_, 90.0, 70.0, "test")
+    adv = A.Advisor(cfg, shipped, feed, A.Records(cfg))
+    obs_, ctx = adv.observation(feed.snapshot())
+    rec = adv.decide(feed.snapshot())
+    words_turn = adv._words(1.5, 25.0, 120.0, 500.0, "drill", {"inc": 90.0, "bed": 0.1, "balling": 0.0, "plan_az": 40.0}, {}, 2.0)
+    words_aim = adv._words(1.5, 25.0, 120.0, 500.0, "drill", {"inc": 90.0, "bed": 0.1, "balling": 0.0, "plan_az": 40.0}, {}, 2.0, 4.0)
+    words_hold = adv._words(0.0, 25.0, 120.0, 500.0, "drill", {"inc": 90.0, "bed": 0.1, "balling": 0.0, "plan_az": 40.0}, {}, 0.0, 0.0)
+    ov = adv._action_of({"turn_deg_100ft": -2.0, "build_deg_100ft": 1.5}, [2, 1, 1, 1, 0])
+    # the limit holds the build and the turn together: a 4 deg/100 ft limit on a 3 build with a 2 turn clips both
+    cfg_l = json.loads(json.dumps(cfg)); cfg_l["limits"]["max_dls_deg_100ft"] = 3.0
+    adv_l = A.Advisor(C.check(cfg_l), shipped, feed, A.Records(cfg_l))
+    rl = adv_l.decide(feed.snapshot())
+    # the twin as the rig publishes the azimuth and the plan view has what it needs
+    drl = S.Driller(cfg, policy=shipped, twin_seed=11, twin_pace_s=0.5)
+    drl.start()
+    try:
+        t_end = time.monotonic() + 20
+        while time.monotonic() < t_end and len(drl.advisor.history) < 2:
+            time.sleep(0.2)
+        live = drl.live(); snap = drl.feed.snapshot()
+        import urllib.request
+        with urllib.request.urlopen(drl.url + "/live", timeout=5) as r_:
+            screen = r_.read().decode("utf-8")
+        cur = dict(drl.advisor.history[-1]) if drl.advisor.history else None
+    finally:
+        drl.stop()
+    sv_text = Path(cfg["output"]["dir"], "surveys.csv").read_text(encoding="utf-8")
+    c2 = {
+        "placed": abs(ctx["vs"] - 600.0 * _m.cos(_m.radians(30.0))) < 0.5 and abs(ctx["y"] - 600.0 * _m.sin(_m.radians(30.0))) < 0.5 and abs(ctx["az"] - 30.0) < 1e-9
+                  and abs(ctx["tvd"] - heel_tvd0) < 0.5 and ctx["corridor"] == 120.0 and obs_.shape[0] == T.OBS_SIZE and abs(obs_[29] * 50.0 - ctx["y"]) < 1e-6,
+        "decision": rec is not None and rec["recommend"].get("aim_deg") in T.AIM_CHOICES and abs(rec["recommend"]["turn_deg_100ft"]) <= T.TURN_RATE + 1e-9
+                    and abs(rec["recommend"]["turn_deg_100ft"] - T.turn_toward(rec["recommend"]["aim_deg"], 30.0)) < 1e-6 and rec["recommend"]["steer_az"] in ("hold", "turn right", "turn left")
+                    and abs(rec["recommend"]["aim_azimuth_deg"] - (40.0 + rec["recommend"]["aim_deg"])) < 1e-9
+                    and 0.0 <= rec["recommend"]["toolface_deg"] < 360.0 and any("plan line" in r_ for r_ in rec["reasons"]) and "aim" in " ".join(rec["reasons"]) and len(rec["action"]) == 6,
+        "words": "turn right 2.0°/100 ft" in words_turn and "toolface 53°" in words_turn and "Build +1.5" in words_turn and words_hold.startswith("Hold angle and azimuth")
+                 and "aim 4° right of the plan (azimuth 44.0°), turning right 2.0°/100 ft" in words_aim,
+        "override": ov == (3, 1, 1, 1, 0, 0),
+        "limit": rl is not None and G.dls_of(rl["recommend"]["build_deg_100ft"], rl["recommend"]["turn_deg_100ft"], 90.0) <= 3.0 + 1e-9,
+        "refusals": cross_refused and corridor_refused,
+        "twin_rig": snap["state"].get("continuous_azi") is not None and live["plan_azimuth_deg"] is not None and live["model"]["corridor_ft"] > 0 and live["path"] and "y" in live["path"][-1]
+                    and live["advisor"]["position"] is not None and "true_y" in live["twin"] and cur is not None and "turn_deg_100ft" in cur["recommend"]
+                    and all(s_.get("azi") is not None for s_ in snap["surveys"]),
+        "screen": "The plan view" in screen and "drawPlan" in screen and "turn_deg_100ft" in screen and "off the plan line" in screen and 'placeholder="aim' in screen,
+        "surveys_file": "azimuth_deg" in sv_text.splitlines()[0] and len(sv_text.splitlines()) >= 2 and sv_text.splitlines()[1].split(",")[2] not in ("", "0.00"),
+        "help": not H.check("driller") and "The third dimension" in (pkg / "help" / "driller.md").read_text(encoding="utf-8") and "plan view" in (pkg / "help" / "tutorial" / "28-driller-office.md").read_text(encoding="utf-8"),
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "DX2 the advisor places the bit from surveys 30° off the plan where the arithmetic says (along, right, depth), a decision carries the aim, the turn it asks "
+       "from where the hole points and the toolface, with the azimuth and the corridor among its reasons, the words name a build and an aim as one toolface, an "
+       "override takes the aim or the turn made, the DLS limit "
+       "holds the build and the turn together, a cross dip and a corridor out of range are refused, the twin as the rig publishes the azimuth and surveys with it, "
+       "the screen carries the plan view, and the help and the tutorial say so" + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+    # -- DX3 the policy and shadow mode -------------------------------------------------------------------------------------------
+    ev = P.evaluate(P.policy_act_fn(shipped), range(20), "agent"); tb = P.evaluate(T.textbook_action, range(20), "textbook")
+    lat_az = str(d / "lat_az.csv"); lat_no = str(d / "lat_no.csv")
+    info = SH.twin_lateral(lat_az, seed=5, act_fn=P.policy_act_fn(shipped)); SH.twin_lateral(lat_no, seed=5, act_fn=P.policy_act_fn(shipped), with_azimuth=False)
+    sc5 = info["scene"]
+    model5 = {"layer_top_tvd_ft": sc5["layer_top_heel_ft"], "thickness_ft": sc5["thickness_ft"], "dip_deg": sc5["dip_deg"], "cross_dip_deg": sc5["cross_dip_deg"],
+              "gamma_in": sc5["gamma_in_above_below"][0], "gamma_above": sc5["gamma_in_above_below"][1], "gamma_below": sc5["gamma_in_above_below"][2],
+              "heel_md_ft": info["heel_md"], "plan_azimuth_deg": sc5["plan_azimuth_deg"], "corridor_ft": sc5["corridor_ft"]}
+    r_az = SH.run(lat_az, shipped, model=model5, out_dir=str(d / "sh_az"), well="Twin 5"); r_no = SH.run(lat_no, shipped, model=model5, well="Twin 5")
+    md_az = Path(r_az["paths"]["md"]).read_text(encoding="utf-8")
+    c3 = {
+        "heads": list(shipped.to_json()["action_sizes"]) == list(T.ACTION_SIZES) and shipped.to_json()["obs_size"] == 34 and int(shipped.meta.get("trained_steps", 0)) >= 1000000,
+        "corridor": ev["corridor_pct"] >= 90.0 and ev["lost"] == 0 and ev["max_offset_ft"] < 200.0,
+        "textbook_corridor": tb["corridor_pct"] >= 95.0 and tb["lost"] == 0,
+        "layer": ev["in_layer_pct"] > tb["in_layer_pct"] and ev["reward"] > tb["reward"],
+        "shadow_turn": r_az["summary"]["azimuth_in_record"] and r_az["summary"]["turn_agree_pct"] is not None and r_az["summary"]["turn_agree_pct"] >= 30.0
+                       and (r_az["summary"]["turn_oppose_pct"] or 0.0) <= 30.0 and "The turn (right, hold or left" in md_az,
+        "shadow_without": not r_no["summary"]["azimuth_in_record"] and r_no["summary"]["turn_agree_pct"] is None and all(x["actual"]["turn"] is None for x in r_no["decisions"]),
+        "model_through": r_az["model"]["plan_azimuth_deg"] == sc5["plan_azimuth_deg"] and r_az["model"]["cross_dip_deg"] == sc5["cross_dip_deg"],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       f"DX3 the shipped policy has six heads over 34 observations; on twenty held-out scenes it keeps {ev['corridor_pct']:.0f}% of the hole in the corridor "
+       f"(none lost, {ev['in_layer_pct']:.0f}% in the layer against the textbook's {tb['in_layer_pct']:.0f}%, SIMULATION) and the textbook holds the corridor; shadow mode "
+       f"judges the turn from a record with the azimuth ({r_az['summary']['turn_agree_pct'] or 0:.0f}% agreeing) and leaves it unjudged without one, and a given model's "
+       "plan azimuth and cross dip go through" + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+
+def section_dy_vibration(tmp: str) -> None:
+    """Section DY - the vibration index from the feed: the index off the surface channels (a steady feed near zero, a
+    torque swinging as the twin's limit swings it reading the limit, a weight swinging reading lateral, the statistics
+    path equal to the samples path, pooled statistics, a window without torque or weight reading nothing); on the twin
+    the derived index tracking the twin's own; the rig side (the twin as the rig publishing the surface channels and
+    no downhole index, the advisor reading the derived one and saying so, the downhole item winning, a feed with
+    neither reading none, the loop disarming on the derived index, the screen, the help); GEA's side (the lateral
+    file from the self-test export with the statistics, the replay reading the stick-slip stretch over the limit
+    and the advisor easing there, a record without the statistics unjudged, the card)."""
+    import http.cookiejar
+    import importlib
+    import math as _m
+    import urllib.error
+    import urllib.request
+    from . import driller_link as DL
+    from . import edr as E
+    from . import helplib as H
+    from .service import Service, Users
+    from .workspace import Workspace
+    pkg = Path(__file__).parent
+    d = Path(tmp, "dy"); d.mkdir()
+    prog = DL.program()
+    if prog is None:
+        ok(True, "DY the driller's program (gea-driller) is not installed beside GEA in this install; nothing to check here")
+        return
+    if prog["env"] and prog["env"] not in sys.path:
+        sys.path.insert(0, prog["env"])
+    T = importlib.import_module("gea_driller.twin"); V = importlib.import_module("gea_driller.vibration"); P = importlib.import_module("gea_driller.policy")
+    A = importlib.import_module("gea_driller.advisor"); C = importlib.import_module("gea_driller.config"); S = importlib.import_module("gea_driller.service")
+    R = importlib.import_module("gea_driller.rig"); SH = importlib.import_module("gea_driller.shadow")
+    np_ = importlib.import_module("numpy")
+    # -- DY1 the index --------------------------------------------------------------------------------------------------------
+    tt = np_.arange(60)
+    steady = {"torque": 10 + 0.02 * np_.sin(tt), "rpm": 120 + 0 * tt, "wob": 25 + 0.05 * np_.cos(tt), "hkld": 175 - 0.05 * np_.cos(tt), "spp": 2800 + 0 * tt}
+    ss = {"torque": 10 * (1 + 0.48 * np_.sin(2 * _m.pi * tt / 8)), "rpm": 120 + 0 * tt, "wob": 25 + 0 * tt, "hkld": 175 + 0 * tt, "spp": 2800 + 0 * tt}
+    lat = {"torque": 10 + 0 * tt, "rpm": 120 + 0 * tt, "wob": 25 * (1 + 0.24 * np_.sin(2 * _m.pi * tt / 5)), "hkld": 175 - 25 * 0.24 * np_.sin(2 * _m.pi * tt / 5), "spp": 2800 + 0 * tt}
+    v0 = V.index(steady); v1 = V.index(ss); v2 = V.index(lat)
+    v1s = V.index_from_stats(V.stats(ss))
+    pooled = V.index_from_stats(V.combine_stats([V.stats({k: v[:30] for k, v in ss.items()}), V.stats({k: v[30:] for k, v in ss.items()})]))
+    none = V.index({"rpm": 120 + 0 * tt, "spp": 2800 + 0 * tt})
+    short = V.index({k: v[:5] for k, v in ss.items()})
+    # on the twin: the derived index against the twin's own, step by step over twenty scenes
+    tr, de = [], []
+    for sd in range(20):
+        lt = T.Lateral(T.Scene(sd)); o = lt.reset()
+        while not lt.done:
+            o, _, _, inf = lt.step(T.textbook_action(o))
+            if inf.get("conditioning") != "drill":
+                continue
+            smp = [lt.surface_sample() for _ in range(20)]
+            v = V.index({"torque": [x["torque"] for x in smp], "rpm": [x["rpm"] for x in smp], "wob": [x["wob"] for x in smp], "hkld": [x["hookload"] for x in smp], "spp": [x["spp"] for x in smp]})
+            tr.append(lt.vib); de.append(v["index"])
+    tr_, de_ = np_.array(tr), np_.array(de)
+    corr = float(np_.corrcoef(tr_, de_)[0, 1]); agree = float(((tr_ > T.VIB_LIMIT) == (de_ > T.VIB_LIMIT)).mean())
+    c1 = {
+        "steady": v0 is not None and v0["index"] < 0.1,
+        "stick_slip": v1 is not None and abs(v1["index"] - 1.2) < 0.08 and v1["kind"] == "stick-slip" and abs(v1["torque_amplitude"] - 0.48) < 0.03,
+        "lateral": v2 is not None and abs(v2["index"] - 1.2) < 0.1 and v2["kind"] == "lateral" and v2["stick_slip"] < 0.1,
+        "paths": v1s["index"] == v1["index"] and abs(pooled["index"] - v1["index"]) < 0.08,
+        "nothing": none is None and short is None,
+        "twin": len(tr) > 1500 and corr > 0.95 and agree >= 0.95 and float(np_.median(np_.abs(tr_ - de_))) < 0.05,
+        "words": "stick-slip" in V.words(v1, 1.2) and "over the limit" in V.words(v1, 1.0) and "over the limit" not in V.words(v0, 1.2),
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       f"DY1 the vibration index off the surface channels: a steady feed reads {v0['index'] if v0 else 'none'}, a torque swinging ±48% reads {v1['index'] if v1 else 'none'} as stick-slip, "
+       f"a weight swinging ±24% reads {v2['index'] if v2 else 'none'} as lateral, the statistics path equals the samples path and pooled windows agree, a window without torque "
+       f"or weight reads nothing; on twenty twin scenes the derived index tracks the twin's own (correlation {corr:.3f}, the limit's crossings agreeing {100 * agree:.0f}%, "
+       "SIMULATION - the twin's calibration, not a string's)" + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+    # -- DY2 the rig side ---------------------------------------------------------------------------------------------------------
+    shipped = P.Policy.load(S.SHIPPED_POLICY)
+    cfg = json.loads(json.dumps(C.EXAMPLE)); cfg["output"]["dir"] = str(d / "rig"); cfg["status"]["port"] = 0; cfg["status"]["bind"] = "127.0.0.1"
+    cfg["rig"]["transport"] = "sim"; cfg["closed_loop"]["allowed"] = True; cfg["closed_loop"]["stale_s"] = 30
+    cfg = C.check(cfg)
+    try:
+        C.check(json.loads(json.dumps(cfg)) | {"rig": {**cfg["rig"], "vibration_window_s": 2}}); win_refused = False
+    except C.ConfigError:
+        win_refused = True
+    drl = S.Driller(cfg, policy=shipped, twin_seed=11, twin_pace_s=0.6)
+    drl.start()
+    try:
+        t_end = time.monotonic() + 25
+        while time.monotonic() < t_end and len(drl.advisor.history) < 3:
+            time.sleep(0.2)
+        snap = drl.feed.snapshot(); live = drl.live()
+        cur = dict(drl.advisor.history[-1]) if drl.advisor.history else None
+        md = snap["state"].get("hole_depth")
+        rq = urllib.request.Request(drl.url + "/api/arm", data=json.dumps({"by": "tester", "to_md": md + 400}).encode(), headers={"Content-Type": "application/json"}, method="POST")
+        with urllib.request.urlopen(rq, timeout=5) as r_:
+            armed = json.load(r_)
+        drl.cfg["limits"]["vibration_index"] = 0.01                      # the limit lowered under the loop: the derived index crosses it at the next look
+        t_end = time.monotonic() + 8
+        while time.monotonic() < t_end and drl.advisor.armed is not None:
+            time.sleep(0.2)
+        drl.cfg["limits"]["vibration_index"] = 1.2
+        last = drl.advisor.arm_log[-1]
+        with urllib.request.urlopen(drl.url + "/live", timeout=5) as r_:
+            screen = r_.read().decode("utf-8")
+    finally:
+        drl.stop()
+    # the downhole item wins; a feed with neither reads none
+    feed = R.Feed(cfg); feed.state.update({"hole_depth": 10500.0, "gamma": 60.0, "continuous_inc": 90.0, "vibration": 1.7}); feed.last_utc = time.time(); feed.connected = True
+    for k in range(30):
+        feed.window.append(float(k), torque=10 * (1 + 0.1 * _m.sin(k)), rpm=120.0, wob=25.0, hkld=175.0, spp=2800.0)
+    v_tool = A.Advisor.vibration_of(feed.snapshot())
+    feed.state["vibration"] = None
+    v_der = A.Advisor.vibration_of(feed.snapshot())
+    feed2 = R.Feed(cfg); feed2.state.update({"hole_depth": 10500.0, "gamma": 60.0}); feed2.last_utc = time.time(); feed2.connected = True
+    v_none = A.Advisor.vibration_of(feed2.snapshot())
+    adv2 = A.Advisor(cfg, shipped, feed2, A.Records(json.loads(json.dumps(cfg)) | {"output": {"dir": str(d / "rig2")}}))
+    rec2 = adv2.decide(feed2.snapshot())
+    decs = [json.loads(l) for l in open(d / "rig" / "decisions.jsonl", encoding="utf-8")]
+    c2 = {
+        "twin_rig": snap["state"].get("torque") is not None and snap["state"].get("hookload") is not None and snap["state"].get("vibration") is None and snap.get("vibration") is not None
+                    and snap["vibration"]["index"] > 0 and snap.get("window_n", 0) >= 10 and abs(snap["vibration"]["index"] - drl.feed.lat.vib) < 0.25,
+        "advisor": cur is not None and cur["context"]["vibration_source"] == V.SOURCE and cur["context"]["vibration"] > 0 and any("derived from the surface data" in r_ for r_ in cur["reasons"])
+                   and live["vibration"]["source"] == V.SOURCE and live["vibration"]["parts"]["kind"] in ("stick-slip", "lateral"),
+        "wins": v_tool[0] == 1.7 and v_tool[1] == "the downhole tool" and v_der[1] == V.SOURCE and 0 < v_der[0] < 1.0,
+        "none": v_none[0] == 0.0 and v_none[1].startswith("none") and rec2 is not None and any("vibration unread" in r_ for r_ in rec2["reasons"]),
+        "disarms": armed.get("ok") and last["event"] == "disarmed" and "vibration" in last["reason"] and "surface data" in last["reason"],
+        "records": any((x.get("context") or {}).get("vibration_source") == V.SOURCE for x in decs),
+        "screen": "from surface data" in screen and "downhole tool" in screen,
+        "refusal": win_refused,
+        "help": not H.check("driller") and "The vibration index from the feed" in (pkg / "help" / "driller.md").read_text(encoding="utf-8")
+                and "surface" in (pkg / "help" / "tutorial" / "29-driller-rig.md").read_text(encoding="utf-8"),
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "DY2 the twin as the rig publishes the surface torque, weight and hook load and no downhole index; the feed's window gives the derived index close to the "
+       "twin's own, the advisor reads it and says so in its reasons, the records and the screen; the downhole tool's item wins when it comes, a feed with neither "
+       "reads none and says so; the closed loop disarms on the derived index crossing the limit; a window too short is refused; the help and the tutorial say so"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+    # -- DY3 GEA's side: the lateral file with the statistics, the replay over the limit, the card ---------------------------------------
+    ws = Workspace.create(str(d / "ws"), "Pad 3 vibration", actor="tester")
+    exp = E.selftest(str(d), 3000)
+    w = ws.add_well_file(exp["path"], display="Well EDR", actor="tester")
+    lat_csv = str(d / "lat.csv")
+    info = DL.lateral_from_edr(ws, w["id"], lat_csv)
+    head = Path(lat_csv).read_text(encoding="utf-8").splitlines()[0].split(",")
+    rec = DL.shadow(ws, w["id"], actor="tester")
+    sm = rec["summary"]
+    # the twin's lateral with and without the statistics
+    tw_csv = str(d / "tw.csv"); tw_no = str(d / "tw_no.csv")
+    tinfo = SH.twin_lateral(tw_csv, seed=5, act_fn=P.policy_act_fn(shipped)); SH.twin_lateral(tw_no, seed=5, act_fn=P.policy_act_fn(shipped), with_stats=False)
+    r_tw = SH.run(tw_csv, shipped, well="Twin 5"); r_no = SH.run(tw_no, shipped, well="Twin 5")
+    tv = dict(tinfo["true_vibration"]); mds = np_.array(sorted(tv))
+    tvv = np_.array([tv[m_] for m_ in mds])
+    def true_over(md_):                                           # the twin's own index averaged over the 30 ft the replay's window pooled
+        j0, j1 = int(np_.searchsorted(mds, md_ - 30.0)), int(np_.searchsorted(mds, md_, side="right"))
+        return float(tvv[j0:j1].mean()) if j1 > j0 else float("nan")
+    pairs = np_.array([(x["vibration"], true_over(x["md"])) for x in r_tw["decisions"] if x["vibration"] is not None])
+    pairs = pairs[np_.isfinite(pairs[:, 1])]
+    corr_tw = float(np_.corrcoef(pairs[:, 0], pairs[:, 1])[0, 1]) if len(pairs) > 10 else 0.0
+    md_text = Path(ws.reports_dir, rec["report"]["md"]).read_text(encoding="utf-8")
+    app_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    c3 = {
+        "lateral_file": all(c in head for c in DL.LATERAL_STATS) and info["vibration_rows"] >= 1000,
+        "over_limit": sm["vibration_in_record"] and sm["vibration_over_limit_pct"] is not None and 5.0 <= sm["vibration_over_limit_pct"] <= 40.0 and sm["vibration_mean"] > 0.3
+                      and sm["eased_when_over_pct"] is not None and sm["eased_when_over_pct"] >= 50.0,
+        "report": "stood over the limit" in md_text and "| Vib |" in md_text,
+        "twin_lateral": r_tw["summary"]["vibration_in_record"] and len(pairs) > 50 and corr_tw > 0.7 and float(np_.median(np_.abs(pairs[:, 0] - pairs[:, 1]))) < 0.12,
+        "without": not r_no["summary"]["vibration_in_record"] and r_no["summary"]["vibration_over_limit_pct"] is None and all(x["vibration"] is None for x in r_no["decisions"]),
+        "selftest_export": any(abs(float(r_.split(",")[12]) - 10.0) > 4.0 for r_ in Path(exp["path"]).read_text(encoding="utf-8").splitlines()[1:] if r_.split(",")[12] not in ("",)),
+        "card": "Vibration over limit" in app_src and "eased" in app_src,
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       f"DY3 GEA's lateral file carries the surface channels' statistics per foot ({info['vibration_rows']} feet of them from the self-test export), the replay reads the "
+       f"stick-slip stretch over the limit at {sm['vibration_over_limit_pct'] or 0:.0f}% of the decisions and the advisor eases there {sm['eased_when_over_pct'] or 0:.0f}% of the "
+       f"time, the report says so; on the twin's lateral the replayed index tracks the twin's own (correlation {corr_tw:.2f}); a record without the statistics is unjudged; "
+       "the card carries the column" + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
+
+
 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:
@@ -16971,6 +17315,8 @@ def main() -> int:
         section_du_tutorial(tmp)
         section_dv_driller(tmp)
         section_dw_shadow(tmp)
+        section_dx_third_dimension(tmp)
+        section_dy_vibration(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.79.0 → gea_program-0.81.0}/gea/driller_link.py

@@ -281,6 +281,11 @@ def wells_with_records(ws) -> List[dict]:
 # -- shadow mode: a drilled well of this workspace replayed through the advisor ---------------------------------------------
 
 LATERAL_COLUMNS = ('md_ft', 'tvd_ft', 'gamma_api', 'wob_klb', 'rpm', 'flow_gpm', 'rop_ft_hr', 'spp_psi', 'hours')
+# per foot, the surface channels' mean and RMS about it over the seconds since the foot before (since 0.81.0): what the
+# driller's vibration index is read off when the string had no downhole tool - the same names the driller's program reads
+LATERAL_STATS = ('torque_mean', 'torque_rms', 'rpm_mean', 'rpm_rms', 'wob_mean', 'wob_rms', 'hkld_mean', 'hkld_rms', 'spp_mean', 'spp_rms')
+_STAT_CH = {'torque': 'torque', 'rpm': 'rpm', 'wob': 'wob', 'hkld': 'hkld', 'spp': 'spp'}
+_STAT_MIN = 5                     # seconds of a foot at least; the index pools the feet of a decision
 
 
 def lateral_from_edr(ws, well_id: str, out_csv: str) -> dict:
@@ -296,7 +301,7 @@ def lateral_from_edr(ws, well_id: str, out_csv: str) -> dict:
     if not src or not E.is_edr(src):
         raise ValueError(f"{well_id} has no drilling-recorder export (an EDR CSV) under its sources")
     st = E.read(src)
-    ch = {k: E._ch(st, k) for k in ('hole', 'tvd', 'gamma', 'wob', 'rpm', 'flow', 'rop', 'spp', 'onb')}
+    ch = {k: E._ch(st, k) for k in ('hole', 'tvd', 'gamma', 'wob', 'rpm', 'flow', 'rop', 'spp', 'onb', 'torque', 'hkld')}
     hole = ch['hole']
     if hole is None or ch['tvd'] is None:
         raise ValueError('the export carries no hole depth or no interpolated TVD; the lateral cannot be placed')
@@ -308,32 +313,47 @@ def lateral_from_edr(ws, well_id: str, out_csv: str) -> dict:
     n = len(hole)
     rows = []
     seen = set(); g_acc = []
+    s_acc = {k: [] for k in _STAT_CH}
     for i in range(n):
         h = hole[i]
         if h is None or (isinstance(h, float) and (h != h)) or not keep_h[i]:
             continue
         if ch['gamma'] is not None and not (ch['gamma'][i] != ch['gamma'][i]):
             g_acc.append(float(ch['gamma'][i]))
+        for k, c in _STAT_CH.items():
+            v = _v(ch[c], i)
+            if v == v:                                               # not NaN
+                s_acc[k].append(v)
         foot = int(h)
         if foot in seen:
             continue
         seen.add(foot)
         tvd = ch['tvd'][i]
-        rows.append({'md_ft': float(h), 'tvd_ft': float(tvd) if not (tvd != tvd) else float('nan'),
-                     'gamma_api': float(sorted(g_acc)[len(g_acc) // 2]) if g_acc else float('nan'),
-                     'wob_klb': _v(ch['wob'], i), 'rpm': _v(ch['rpm'], i), 'flow_gpm': _v(ch['flow'], i), 'rop_ft_hr': _v(ch['rop'], i), 'spp_psi': _v(ch['spp'], i),
-                     'hours': float(secs[i]) / 3600.0})
-        g_acc = []
+        row = {'md_ft': float(h), 'tvd_ft': float(tvd) if not (tvd != tvd) else float('nan'),
+               'gamma_api': float(sorted(g_acc)[len(g_acc) // 2]) if g_acc else float('nan'),
+               'wob_klb': _v(ch['wob'], i), 'rpm': _v(ch['rpm'], i), 'flow_gpm': _v(ch['flow'], i), 'rop_ft_hr': _v(ch['rop'], i), 'spp_psi': _v(ch['spp'], i),
+               'hours': float(secs[i]) / 3600.0}
+        for k in _STAT_CH:
+            a = s_acc[k]
+            if len(a) >= _STAT_MIN:
+                m = sum(a) / len(a)
+                row[f'{k}_mean'] = m; row[f'{k}_rms'] = (sum((x - m) ** 2 for x in a) / len(a)) ** 0.5
+            else:
+                row[f'{k}_mean'] = float('nan'); row[f'{k}_rms'] = float('nan')
+        rows.append(row)
+        g_acc = []; s_acc = {k: [] for k in _STAT_CH}
     if len(rows) < 100:
         raise ValueError(f'the export yields only {len(rows)} feet of new hole; a lateral is thousands')
     rows.sort(key=lambda r: r['md_ft'])
     os.makedirs(os.path.dirname(out_csv), exist_ok=True)
+    cols = list(LATERAL_COLUMNS) + list(LATERAL_STATS)
     with open(out_csv, 'w', encoding='utf-8', newline='') as f:
-        w = _csv.DictWriter(f, fieldnames=list(LATERAL_COLUMNS)); w.writeheader()
+        w = _csv.DictWriter(f, fieldnames=cols); w.writeheader()
         for r in rows:
-            w.writerow({c: ('' if (isinstance(r[c], float) and r[c] != r[c]) or r[c] is None else f'{r[c]:.3f}') for c in LATERAL_COLUMNS})
+            w.writerow({c: ('' if (isinstance(r[c], float) and r[c] != r[c]) or r[c] is None else f'{r[c]:.3f}') for c in cols})
     rows.sort(key=lambda r: r['md_ft'])
     return {'rows': len(rows), 'source': src, 'md_from': rows[0]['md_ft'], 'md_to': rows[-1]['md_ft'], 'gamma_rows': sum(1 for r in rows if r['gamma_api'] == r['gamma_api']),
+            'vibration_rows': sum(1 for r in rows if r['torque_mean'] == r['torque_mean'] or r['wob_mean'] == r['wob_mean']),
             'seconds': int(n), 'excluded_rows': int((~keep_h).sum()), 'depth_events': {k: len(v) for k, v in de.items() if isinstance(v, list)}}
 
 

{gea_program-0.79.0 → gea_program-0.81.0}/gea/edr.py

@@ -748,8 +748,10 @@ def selftest(tmp: str, rows_per_section: int = 3000) -> dict:
                 if on:
                     depth += 600.0 / 3600.0                     # 600 ft/h while on bottom (a self-test cadence, not a rig's)
                 tvd = depth if depth < 2000.0 else 2000.0 + (depth - 2000.0) * 0.02   # a lateral past 2,000 ft
+                # a stretch of stick-slip in the lateral: the surface torque swinging ±60% with an eight-second period (since 0.81.0)
+                tq = 10.0 * (1.0 + 0.6 * math.sin(2 * math.pi * i / 8.0)) if (s == 2 and 1000 <= i < 2000 and on) else 10.0
                 row = [t.strftime('%Y/%m/%d'), t.strftime('%H:%M:%S'), f'{depth:.1f}', f'{depth - (0 if on else 30):.1f}', '600.00' if on else '0.00',
-                       '20.0' if on else '0.0', '60.00' if on else '0.00', '2500.00', '150.0', '400.00', '500.00', '50.00', '10.000', str(on),
+                       '20.0' if on else '0.0', '60.00' if on else '0.00', '2500.00', '150.0', '400.00', '500.00', '50.00', f'{tq:.3f}', str(on),
                        '-999.25' if s == 0 else f'{(45.0 if depth < 2300.0 else 115.0) + (i % 7):.2f}', '100', '0.00' if i % 500 == 0 else '45.00', '' if (i % 10 == 0) else f'{tvd:.2f}']
                 w.writerow(row); t += timedelta(seconds=1)
     st = read(p)

{gea_program-0.79.0 → gea_program-0.81.0}/gea/help/IT_SECURITY.md

@@ -180,7 +180,10 @@ declared extras.
   feed, a crossed limit or the section's end; this version's only downlink
   keeps every command on record and sends none. The records carry no
   secret; GEA pulls them checked against their hashes. The twin as the rig
-  on the office PC binds to 127.0.0.1 only.
+  on the office PC binds to 127.0.0.1 only. Since 0.80.0 the records carry
+  the hole's azimuth and its offset from the plan line, as the surveys
+  give them - a position, not a coordinate: the plan's azimuth and the
+  heel are in the rig PC's config, no surface location is.
 
 ## What it records