gea-program 0.25.0__tar.gz → 0.26.0__tar.gz

{gea_program-0.25.0/gea_program.egg-info → gea_program-0.26.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gea-program
-Version: 0.25.0
+Version: 0.26.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
@@ -125,7 +125,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (362 checks)
+gea accept                     # the product gate (365 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -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`.
 
+### Slip tendency on the mapped faults
+
+The stress state the site declares - the three gradients and the ambient
+pore pressure with their source, the SHmax azimuth with its source or from
+the World Stress Map records near the well (`add-stress-map wsm2016.csv`,
+`wsm --lat --lon`) - resolved on every mapped fault trace within the radius
+of a well at the depth of its declared interval: the slip tendency at the
+ambient and the increased pore pressure, the pressure to slip, the margin
+left after the increase, worst and best declared case. The dip comes from
+the layer where it states one (the Hennings 2021 BEG/TexNet layers do, and
+publish their own pressure-to-slip, printed beside this arithmetic); UTM and
+state-plane layers are unprojected from their .prj parameters. `set-stress`,
+`slip --well`, `gea slip`; the SRA packet's section 2e; `gea help slip`. A
+statement on declared inputs, not a probability and not a verdict.
+
 ### The catalogue accounted for
 
 `gea catalog --list` is the register of the 52 shipped public datasets: for

{gea_program-0.25.0 → gea_program-0.26.0}/README.md

@@ -86,7 +86,7 @@ gea dashboard --catalog-well volve_f12_f14_production_excerpt:15/9-F-12:10000 --
 gea client-report --report accuracy --out client_report
 gea model-cards --out model_cards
 gea sbom --out sbom
-gea accept                     # the product gate (362 checks)
+gea accept                     # the product gate (365 checks)
 gea help drift                 # the help library, by the job (16 pages; the same text is on every dashboard page)
 gea guide                      # the click-by-click tester guide (docs/TESTER_GUIDE.md)
 gea gui                        # the desktop window (pip install "gea-program[desktop]")
@@ -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`.
 
+### Slip tendency on the mapped faults
+
+The stress state the site declares - the three gradients and the ambient
+pore pressure with their source, the SHmax azimuth with its source or from
+the World Stress Map records near the well (`add-stress-map wsm2016.csv`,
+`wsm --lat --lon`) - resolved on every mapped fault trace within the radius
+of a well at the depth of its declared interval: the slip tendency at the
+ambient and the increased pore pressure, the pressure to slip, the margin
+left after the increase, worst and best declared case. The dip comes from
+the layer where it states one (the Hennings 2021 BEG/TexNet layers do, and
+publish their own pressure-to-slip, printed beside this arithmetic); UTM and
+state-plane layers are unprojected from their .prj parameters. `set-stress`,
+`slip --well`, `gea slip`; the SRA packet's section 2e; `gea help slip`. A
+statement on declared inputs, not a probability and not a verdict.
+
 ### The catalogue accounted for
 
 `gea catalog --list` is the register of the 52 shipped public datasets: for

{gea_program-0.25.0 → gea_program-0.26.0}/gea/__init__.py

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

{gea_program-0.25.0 → gea_program-0.26.0}/gea/__main__.py

@@ -278,6 +278,14 @@ def main(argv=None) -> int:
         p_lp.add_argument("--stream-csv", type=str, default=None, help="also write a historian-style CSV the other commands ingest")
         p_lp.add_argument("--selftest", action="store_true", help="etp: the codec round-trip and a session against the simulated store on the loopback")
 
+    p_sl = sub.add_parser("slip", help="slip tendency on the mapped faults of a layer at a position, from declared gradients: --layer --lat --lon --depth-ft --sv --shmin --shmax (--shmax-azimuth or --wsm)")
+    p_sl.add_argument("--layer", type=str, required=True); p_sl.add_argument("--member", type=str, default=None); p_sl.add_argument("--feature-kind", type=str, choices=["fault", "fold"], default=None)
+    p_sl.add_argument("--lat", type=float, required=True); p_sl.add_argument("--lon", type=float, required=True); p_sl.add_argument("--radius-km", type=float, default=25.0)
+    p_sl.add_argument("--depth-ft", type=float, required=True)
+    p_sl.add_argument("--sv", type=float, required=True); p_sl.add_argument("--shmin", type=float, required=True); p_sl.add_argument("--shmax", type=float, required=True)
+    p_sl.add_argument("--pp", type=float, default=0.433); p_sl.add_argument("--shmax-azimuth", type=float, default=None); p_sl.add_argument("--wsm", type=str, default=None, help="the WSM database CSV: the azimuth from its records within 100 km")
+    p_sl.add_argument("--dips", type=float, nargs="+", default=[60.0, 75.0, 90.0]); p_sl.add_argument("--mu", type=float, nargs="+", default=[0.6]); p_sl.add_argument("--delta-pp", type=float, default=0.0)
+    p_sl.add_argument("--json", action="store_true")
     p_cat = sub.add_parser("catalog", help="the shipped catalogue: --list every entry with what reads it; --unused the carried ones; --check reads every entry; --friction the measured friction envelope; --core the core check; --entry X --info | --stream-csv")
     p_cat.add_argument("--list", action="store_true"); p_cat.add_argument("--unused", action="store_true"); p_cat.add_argument("--check", action="store_true")
     p_cat.add_argument("--friction", action="store_true"); p_cat.add_argument("--core", action="store_true")
@@ -319,7 +327,8 @@ def main(argv=None) -> int:
                                "add-seismic", "refresh-seismic", "remove-seismic", "sar-film", "refresh-all", "add-track", "refresh-track", "remove-track",
                                "seismic-dataset", "seismic-field", "add-site", "sites", "site-report", "remove-site", "rename",
                                "set-well", "sra-define", "sra-report", "associate", "osdu-export", "quakeml-export", "well-identity", "vibration-report",
-                               "add-live-station", "live-fold", "live-run", "month-end", "add-layer", "layers", "remove-layer", "structure", "interval"])
+                               "add-live-station", "live-fold", "live-run", "month-end", "add-layer", "layers", "remove-layer", "structure", "interval",
+                               "set-stress", "add-stress-map", "wsm", "slip"])
     p_ws.add_argument("--stations", type=str, nargs="+", default=None, help="add-track: two or more array station ids of this workspace")
     p_ws.add_argument("--site", type=str, default=None, help="site-report/remove-site: the site id")
     p_ws.add_argument("--api", type=str, default=None, help="set-well: the API number")
@@ -399,6 +408,18 @@ def main(argv=None) -> int:
     p_ws.add_argument("--formation-name", type=str, default=None, help="add-layer: the formation a contours layer maps (Wolfcamp)")
     p_ws.add_argument("--role", type=str, choices=["top", "isopach", "base"], default=None, help="add-layer: what the contours are of that formation: its top elevation, its thickness, or its base")
     p_ws.add_argument("--base-interval-ft", type=float, default=None, help="set-well: base of the disposal interval, ft")
+    p_ws.add_argument("--feature-kind", type=str, choices=["fault", "fold"], default=None, help="add-layer: what every feature of a structure layer is when its attributes do not say")
+    p_ws.add_argument("--sv", type=float, default=None, help="set-stress: vertical stress gradient, psi/ft")
+    p_ws.add_argument("--shmin", type=float, default=None, help="set-stress: minimum horizontal stress gradient, psi/ft")
+    p_ws.add_argument("--shmax", type=float, default=None, help="set-stress: maximum horizontal stress gradient, psi/ft")
+    p_ws.add_argument("--pp", type=float, default=None, help="set-stress: ambient pore-pressure gradient, psi/ft (hydrostatic 0.433 unless declared)")
+    p_ws.add_argument("--shmax-azimuth", type=float, default=None, help="set-stress: SHmax azimuth, degrees from north (or leave it to the stress map)")
+    p_ws.add_argument("--azimuth-source", type=str, default=None, help="set-stress: where the azimuth came from")
+    p_ws.add_argument("--gradients-source", type=str, default=None, help="set-stress: where the gradients came from")
+    p_ws.add_argument("--dips", type=float, nargs="+", default=None, help="set-stress: the dips to run when the layer states none (default 60 75 90)")
+    p_ws.add_argument("--mu", type=float, nargs="+", default=None, help="set-stress: the friction coefficients to run (default 0.6)")
+    p_ws.add_argument("--delta-pp", type=float, default=None, help="set-stress / slip: the pore-pressure increase to judge at, psi")
+    p_ws.add_argument("--depth-ft", type=float, default=None, help="slip: the depth to judge at (default the midpoint of the declared interval)")
     p_ws.add_argument("--depth-ref", type=str, choices=["TVD", "MD"], default=None, help="set-well: the interval depths are true vertical (TVD) or measured (MD) depth")
     p_ws.add_argument("--ref-elev-ft", type=float, default=None, help="set-well: the reference elevation the depths are measured from, ft above sea level")
     p_ws.add_argument("--ref-elev-datum", type=str, choices=["KB", "GL", "DF"], default=None, help="set-well: what that elevation is: kelly bushing, ground level, derrick floor")
@@ -2095,7 +2116,7 @@ def main(argv=None) -> int:
             elif a.action == "add-layer":
                 if not a.layer or not a.name:
                     raise SystemExit("add-layer needs --name <display> and --layer <shapefile zip | folder | .shp>")
-                L = ws.add_layer(a.layer, a.name, actor=a.actor, citation=a.citation, member=a.member, formation=a.formation_name, role=a.role)
+                L = ws.add_layer(a.layer, a.name, actor=a.actor, citation=a.citation, member=a.member, formation=a.formation_name, role=a.role, feature_kind=a.feature_kind)
                 tc = ", ".join(f"{k} {v}" for k, v in list(L["type_counts"].items())[:6])
                 print(f"layer {L['id']} ({L['kind']}): {L['n_features']} {L['shape_type']} features, {L['crs']['kind']} {L['crs'].get('datum') or ''}, extent lon {L['bbox'][0]:.3f}..{L['bbox'][2]:.3f} lat {L['bbox'][1]:.3f}..{L['bbox'][3]:.3f}"
                       + (f"; contour value {L['value_attr']}" if L.get('value_attr') else ''))
@@ -2124,6 +2145,32 @@ def main(argv=None) -> int:
                     for line in L["lines"]:
                         print("    " + line)
                 return 0 if r["status"] == "OK" else 1
+            elif a.action == "set-stress":
+                st = ws.set_stress({"sv_psi_ft": a.sv, "shmin_psi_ft": a.shmin, "shmax_psi_ft": a.shmax, "pp_psi_ft": a.pp, "shmax_azimuth_deg": a.shmax_azimuth,
+                                    "azimuth_source": a.azimuth_source, "gradients_source": a.gradients_source, "dips_deg": a.dips, "mus": a.mu, "delta_pp_psi": a.delta_pp, "note": a.note or ""}, actor=a.actor)
+                print(f"stress: Sv {st['sv_psi_ft']} Shmin {st['shmin_psi_ft']} SHmax {st['shmax_psi_ft']} Pp {st['pp_psi_ft']} psi/ft ({st['gradients_source']}); "
+                      f"SHmax azimuth {st.get('shmax_azimuth_deg', 'from the stress map')} ({st.get('azimuth_source', '')}); dips {st['dips_deg']}; mu {st['mus']}; delta Pp {st['delta_pp_psi']} psi"); return 0
+            elif a.action == "add-stress-map":
+                if not a.file:
+                    raise SystemExit("add-stress-map needs --file <wsm.csv>")
+                r = ws.add_stress_map(a.file, actor=a.actor, citation=a.citation)
+                print(f"stress map: {r['n_records']} records kept as {r['file']} (sha256 {r['sha256'][:16]})"); return 0
+            elif a.action == "wsm":
+                if a.lat is None or a.lon is None:
+                    raise SystemExit("wsm needs --lat --lon [--radius-km]")
+                r = ws.wsm_at(a.lat, a.lon, a.radius_km if a.radius_km is not None else 100.0)
+                print(r.get("statement") or f"{r['status']}: {r.get('note', '')}")
+                for rec in r.get("records", [])[:10]:
+                    print(f"  {rec['distance_km']:7.1f} km  {rec['azimuth']:5.0f} deg  {rec['quality']}  {rec['regime'] or '?':3s}  {rec['type']:4s}  {rec['locality'][:40]}")
+                return 0 if r.get("n") else 1
+            elif a.action == "slip":
+                if not a.well:
+                    raise SystemExit("slip needs --well <id>")
+                r = ws.well_slip(a.well, a.radius_km if a.radius_km is not None else 25.0, delta_pp_psi=a.delta_pp, depth_ft=a.depth_ft, actor=a.actor)
+                print(f"slip {a.well}: {r['status']}")
+                for line in r["lines"]:
+                    print("  " + line)
+                return 0 if r["status"] == "OK" else 1
             elif a.action == "interval":
                 if not a.well:
                     raise SystemExit("interval needs --well <id>")
@@ -2304,6 +2351,33 @@ def main(argv=None) -> int:
             stop.set()
             print("etp-sim: stopped")
         return 0
+    elif a.cmd == "slip":
+        import json as _json
+        from . import shapefile as _SF, slip as _SL, friction_priors as _FP
+        try:
+            L = _SF.read(a.layer, member=a.member)
+        except (ValueError, OSError) as e:
+            raise SystemExit(f"slip: {e}")
+        if a.feature_kind:
+            L.declared_kind = a.feature_kind
+        az, az_src = a.shmax_azimuth, "declared"
+        if az is None and a.wsm:
+            nb = _SL.wsm_nearby(_SL.read_wsm(a.wsm), a.lat, a.lon, 100.0)
+            if not nb["n"]:
+                raise SystemExit("slip: no World Stress Map record of quality A/B/C within 100 km; declare --shmax-azimuth with its source")
+            az, az_src = nb["azimuth_mean"], nb["statement"]
+        if az is None:
+            raise SystemExit("slip: give --shmax-azimuth or --wsm <wsm.csv>")
+        faults = _SL.faults_in_radius(L, a.lat, a.lon, a.radius_km)
+        r = _SL.statement(faults, a.depth_ft, {"sv_psi_ft": a.sv, "shmin_psi_ft": a.shmin, "shmax_psi_ft": a.shmax, "pp_psi_ft": a.pp}, az, tuple(a.dips), tuple(a.mu), a.delta_pp,
+                          sources={"shmax_azimuth": az_src, "gradients": "the command line"})
+        r["friction_envelope"] = _FP.envelope()
+        if a.json:
+            print(_json.dumps(r, indent=1, default=str)); return 0
+        for line in r["lines"]:
+            print(line)
+        print(r["friction_envelope"].get("statement", ""))
+        return 0
     elif a.cmd == "catalog":
         import json as _json
         from . import catalog_register as _CR

{gea_program-0.25.0 → gea_program-0.26.0}/gea/acceptance_tests.py

@@ -6179,7 +6179,7 @@ def section_bo_structure(tmp: str) -> None:
         "counts_and_lines": r["counts_within"] == {"fault": 1, "fold": 1, "other": 0} and f"{g_fault:.2f} km" in ST.lines(r)[0] and "N (" in ST.lines(r)[0] and "North Fault" in ST.lines(r)[0],
         "outside_extent": out_ext["status"] == "OUTSIDE LAYER EXTENT" and "extent" in out_ext["note"] and ST.lines(out_ext)[0].startswith("Layer") and "OUTSIDE LAYER EXTENT" in ST.lines(out_ext)[0],
         "projected_unprojected": Lp.crs["kind"] == "projected" and Lp.crs["zone"] == "TX_CENTRAL" and abs(plat - (lat0 + dlat)) < 1e-6 and abs(plon - lon0) < 1e-6,
-        "refused_by_name": utm_err and "UTM" in utm_err and "Texas State Plane" in utm_err and noprj_err and "no .prj" in noprj_err,
+        "refused_by_name": utm_err and "UTM" in utm_err and "from its parameters" in utm_err and noprj_err and "no .prj" in noprj_err,
         "shx_honoured": Lbad.n == 3 and seq_err and "content length" in seq_err,
     }
     failed1 = [k for k, v in c1.items() if not v]
@@ -7072,6 +7072,208 @@ def section_bs_catalog(tmp: str) -> None:
        + (f" [failed: {', '.join(failed3)}]" if failed3 else ""))
 
 
+def section_bt_slip(tmp: str) -> None:
+    """Section BT - slip tendency on the mapped faults: the stress resolution against its identities, the regime, Ts and
+    the pressure to slip, the World Stress Map reader and the nearby azimuth; a UTM layer unprojected from its .prj
+    parameters with the fault's own dip and a published pressure-to-slip read beside this arithmetic; the workspace's
+    stress state, stress map and statement through the SRA packet, the API, the page, the CLI; the help."""
+    import http.cookiejar
+    import math as _math
+    import subprocess as _sp
+    import urllib.request
+    import urllib.error
+    import zipfile
+    from . import shapefile as SF
+    from . import slip as SL
+    from . import geodesy as GD
+    from . import helplib as H
+    from .telemetry import TelemetryRecorder, TelemetryConfig
+    from .downhole_engine import DownholeEngine, SimulatorConfig
+    from .workspace import Workspace, WorkspaceError
+    from .service import Service, Users
+    pkg = Path(__file__).parent
+    d = Path(tmp, "bt"); d.mkdir()
+
+    # -- BT1: the arithmetic and the stress map -----------------------------------------------------------------------
+    st = SL.stress_at(8000.0, 1.05, 0.65, 0.95)
+    par = SL.resolve(80.0, 90.0, 80.0, st["Sv"], st["Shmin"], st["SHmax"])          # a vertical plane along SHmax: Shmin, no shear
+    per = SL.resolve(170.0, 90.0, 80.0, st["Sv"], st["Shmin"], st["SHmax"])         # across SHmax: SHmax, no shear
+    d45 = SL.resolve(35.0, 90.0, 80.0, st["Sv"], st["Shmin"], st["SHmax"])          # 45 deg: the mean and the half-difference
+    hor = SL.resolve(0.0, 0.0, 80.0, st["Sv"], st["Shmin"], st["SHmax"])            # a horizontal plane: Sv
+    ts = SL.slip_tendency(35.0, 90.0, st, 80.0, 0.6, 500.0)
+    ts_past = SL.slip_tendency(35.0, 90.0, st, 80.0, 0.6, 2000.0)
+    hdr = "ID,SITE,LAT,LON,AZI,TYPE,DEPTH,QUALITY,REGIME,LOCALITY,COUNTRY\n"
+    rows = "".join(f"w{i},S,{31.3 + 0.05 * i},{-103.6 + 0.04 * i},{(75 + 3 * (i % 5)) % 180},BO,2.5,{'ABC'[i % 3]},{'NF' if i % 2 else 'SS'},Delaware,USA\n" for i in range(12))
+    rows += "far,S,35.0,-100.0,10,FMS,3,A,TF,away,USA\nbad,S,31.4,-103.5,999,BO,2,A,NF,x,USA\nlow,S,31.42,-103.5,120,BO,2,E,NF,x,USA\n"
+    wsm_path = str(d / "wsm_like.csv")
+    Path(wsm_path).write_text(hdr + rows, encoding="utf-8")
+    recs = SL.read_wsm(wsm_path)
+    nb = SL.wsm_nearby(recs, 31.42, -103.50, 100.0)
+    nb_none = SL.wsm_nearby(recs, 45.0, -70.0, 50.0)
+    bad_wsm = None
+    try:
+        SL.read_wsm(io_bytes := b"A,B,C\n1,2,3\n")
+    except ValueError as e:
+        bad_wsm = str(e)
+    c1 = {
+        "identities": abs(par[0] - st["Shmin"]) < 1e-3 and abs(par[1]) < 1e-3 and abs(per[0] - st["SHmax"]) < 1e-3 and abs(per[1]) < 1e-3
+                      and abs(d45[0] - (st["SHmax"] + st["Shmin"]) / 2) < 1e-3 and abs(d45[1] - (st["SHmax"] - st["Shmin"]) / 2) < 1e-3 and abs(hor[0] - st["Sv"]) < 1e-3 and abs(hor[1]) < 1e-3,
+        "regime": SL.regime_of(8400, 5200, 7600) == "normal" and SL.regime_of(8000, 5200, 9000) == "strike-slip" and SL.regime_of(5000, 6000, 9000) == "reverse",
+        "tendency": ts["Ts_ambient"] == round(1200.0 / (6400.0 - 3464.0), 3) and ts["pressure_to_slip_psi"] == round(6400.0 - 3464.0 - 1200.0 / 0.6, 1) and ts["margin_after_injection_psi"] == round(ts["pressure_to_slip_psi"] - 500.0, 1)
+                    and ts["status"] == "BELOW THE FRICTION LINE" and ts_past["status"] == "PAST THE FRICTION LINE" and ts_past["Ts_injection"] > ts["Ts_injection"],
+        "wsm": len(recs) == 14 and nb["n"] == 12 and abs(nb["azimuth_mean"] - 80.25) < 0.5 and nb["by_quality"] == {"A": 4, "B": 4, "C": 4} and nb["by_regime"] == {"NF": 6, "SS": 6}
+               and nb["spread_deg_median"] <= 6 and nb_none["n"] == 0 and bad_wsm and "columns" in bad_wsm,
+    }
+    failed1 = [k for k, v in c1.items() if not v]
+    ok(not failed1,
+       "BT1 the stress resolution against its identities (a vertical plane along SHmax feels Shmin and no shear, across it SHmax, at 45 degrees the mean and the "
+       "half-difference, a horizontal plane Sv), Anderson's regime from the ordering, the slip tendency and the pressure to slip by the published arithmetic, "
+       "past the friction line when the increase exceeds it; the World Stress Map CSV read by column name (a 999 azimuth and a D/E quality left out), the "
+       "records within the radius with the axial mean azimuth, spread, counts by quality and regime; no records, and a file without the columns, named"
+       + (f" [failed: {', '.join(failed1)}]" if failed1 else ""))
+
+    # -- BT2: a UTM layer from its .prj parameters, with dip and a published pressure to slip -----------------------------
+    lat1, lon1 = 31.42, -103.50
+    utm13 = GD.utm(13, True, "WGS84")
+    wkt = ('PROJCS["WGS_1984_UTM_Zone_13N",GEOGCS["GCS_WGS_1984",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]],PRIMEM["Greenwich",0.0],'
+           'UNIT["Degree",0.0174532925199433]],PROJECTION["Transverse_Mercator"],PARAMETER["False_Easting",500000.0],PARAMETER["False_Northing",0.0],'
+           'PARAMETER["Central_Meridian",-105.0],PARAMETER["Scale_Factor",0.9996],PARAMETER["Latitude_Of_Origin",0.0],UNIT["Meter",1.0]]')
+
+    def en(lat, lon):
+        p_ = GD.project(lat, lon, utm13)
+        return (p_["easting_m"], p_["northing_m"])
+    kmlat = 1.0 / 111.195
+    kmlon = 1.0 / (111.195 * _math.cos(_math.radians(lat1)))
+    # three faults: one along SHmax (92 deg) 3 km north with dip 62 and a published value; one across it; one 40 km away (outside the radius)
+    feats = [([[en(lat1 + 3 * kmlat, lon1 - 0.05), en(lat1 + 3 * kmlat - 0.1 * kmlat * 0.035 * 0, lon1 + 0.05)]], {"dip": 62.0, "note": "HIGH CONFIDENCE", "Pp2S_MPa": 5.0, "BEARING": 92.0}),
+             ([[en(lat1 - 0.05, lon1 + 6 * kmlon), en(lat1 + 0.05, lon1 + 6 * kmlon)]], {"dip": 85.0, "note": "LOW CONFIDENCE", "Pp2S_MPa": 20.0, "BEARING": 0.0}),
+             ([[en(lat1 + 0.36, lon1 - 0.02), en(lat1 + 0.36, lon1 + 0.02)]], {"dip": 70.0, "note": "FAR", "Pp2S_MPa": 9.0, "BEARING": 90.0})]
+    SF.write(str(d / "utm_faults"), "PolyLine", feats, [("dip", "F", 6, 1), ("note", "C", 20, 0), ("Pp2S_MPa", "F", 10, 4), ("BEARING", "F", 8, 2)], wkt)
+    with zipfile.ZipFile(str(d / "utm_faults.zip"), "w") as z:
+        for ext in (".shp", ".shx", ".dbf", ".prj"):
+            z.write(str(d / ("utm_faults" + ext)), "utm_faults" + ext)
+    L = SF.read(str(d / "utm_faults.zip"))
+    L.declared_kind = "fault"
+    f1 = L.features[0].parts[0][0]
+    faults = SL.faults_in_radius(L, lat1, lon1, 25.0)
+    res = SL.statement(faults, 9000.0, {"sv_psi_ft": 1.05, "shmin_psi_ft": 0.65, "shmax_psi_ft": 0.95, "pp_psi_ft": 0.45}, 92.0, (60.0, 75.0, 90.0), (0.6,), 300.0,
+                       sources={"shmax_azimuth": "the gate", "gradients": "the gate"})
+    along = next(r for r in res["faults"] if r["attrs"].get("note") == "HIGH CONFIDENCE")
+    across = next(r for r in res["faults"] if r["attrs"].get("note") == "LOW CONFIDENCE")
+    lcc_wkt = ('PROJCS["NAD_1983_Texas_Centric_Mapping_System_Lambert",GEOGCS["GCS_North_American_1983",DATUM["D_North_American_1983",SPHEROID["GRS_1980",6378137.0,298.257222101]],'
+               'PRIMEM["Greenwich",0.0],UNIT["Degree",0.0174532925199433]],PROJECTION["Lambert_Conformal_Conic"],PARAMETER["False_Easting",1500000.0],PARAMETER["False_Northing",5000000.0],'
+               'PARAMETER["Central_Meridian",-100.0],PARAMETER["Standard_Parallel_1",27.5],PARAMETER["Standard_Parallel_2",35.0],PARAMETER["Latitude_Of_Origin",18.0],UNIT["Meter",1.0]]')
+    lcc = SF.parse_prj(lcc_wkt)
+    unknown = SF.parse_prj('PROJCS["X",GEOGCS["G",DATUM["D_WGS_1984",SPHEROID["WGS_1984",6378137.0,298.257223563]]],PROJECTION["Mercator"],PARAMETER["Central_Meridian",0.0],UNIT["Meter",1.0]]')
+    c2 = {
+        "unprojected": L.crs["kind"] == "projected" and L.crs["usable"] and "Transverse Mercator on WGS84" in L.crs["how"] and abs(f1[1] - (lat1 + 3 * kmlat)) < 2e-6 and abs(f1[0] - (lon1 - 0.05)) < 2e-6
+                       and lcc["usable"] and lcc["zone_def"]["kind"] == "lcc" and lcc["zone_def"]["lat1"] == 27.5 and not unknown["usable"] and "MERCATOR" in unknown["note"],
+        "faults_found": len(faults) == 2 and along["attrs"]["dip_deg"] == 62.0 and along["attrs"]["published_pressure_to_slip_psi"] == round(5.0 * 145.037738, 1)
+                        and abs(along["distance_km"] - 3.0) < 0.05 and abs(along["strike_deg"] - 90.0) < 1.0 and along["dip_source"] == "the layer" and len(along["cases"]) == 1,
+        "statement": along["worst"]["dip_deg"] == 62.0 and across["worst"]["dip_deg"] == 85.0 and along["angle_to_shmax_deg"] <= 3 and across["angle_to_shmax_deg"] > 85
+                     and along["worst"]["Ts_injection"] > across["worst"]["Ts_injection"] and res["regime"] == "normal"
+                     and along["published"]["pressure_to_slip_psi"] == round(5.0 * 145.037738, 1) and along["published"]["difference_psi"] == round(along["cases"][0]["pressure_to_slip_psi"] - along["published"]["pressure_to_slip_psi"], 1)
+                     and any("The layer publishes 725 psi to slip (Pp2S_MPa)" in ln for ln in res["lines"]) and res["faults"][0] is along,
+    }
+    failed2 = [k for k, v in c2.items() if not v]
+    ok(not failed2,
+       "BT2 a UTM zone 13N layer unprojected from its .prj parameters (Transverse Mercator on WGS84; a Lambert Conformal Conic parsed the same way; a "
+       "Mercator refused by name); the faults within the radius with the layer's own dip and its published pressure-to-slip read as attributes; the trace "
+       "along SHmax ranked first with the higher tendency, its dip from the layer and one case, the published value printed beside this arithmetic with the difference"
+       + (f" [failed: {', '.join(failed2)}]" if failed2 else ""))
+
+    # -- BT3: the workspace, the SRA packet, the API, the page, the CLI, the help -------------------------------------------
+    hist = str(d / "hist.csv")
+    TelemetryRecorder(engine=DownholeEngine(SimulatorConfig()), config=TelemetryConfig(duration_hours=1.0, seed=5)).run().export_csv(hist)
+    wsp = str(d / "ws"); ws = Workspace.create(wsp, "Pad 3", actor="tester")
+    w = ws.add_well_file(hist, display="SWD 1", actor="tester")
+    s0 = ws.well_slip(w["id"], actor="tester")
+    ws.set_well(w["id"], surface={"lat": lat1, "lon": lon1, "datum": "NAD83", "elevation": {"ft": 2950.0, "datum": "KB", "source": "completion report"}}, actor="tester")
+    ws.set_well(w["id"], disposal={"top_interval_ft": 8700.0, "base_interval_ft": 9300.0, "depth_reference": "TVD", "depth_tier": "deep", "channel_pressure": "P_surf_psi",
+                                   "channel_rate": "Q_bpm", "rate_unit": "bbl/min", "bhp_method": "probe", "channel_bhp": "P_bh_psi"}, actor="tester")
+    s1 = ws.well_slip(w["id"], actor="tester")
+    no_src = None
+    try:
+        ws.set_stress({"sv_psi_ft": 1.05, "shmin_psi_ft": 0.65, "shmax_psi_ft": 0.95}, actor="tester")
+    except WorkspaceError as e:
+        no_src = str(e)
+    stx = ws.set_stress({"sv_psi_ft": 1.05, "shmin_psi_ft": 0.65, "shmax_psi_ft": 0.95, "pp_psi_ft": 0.45, "gradients_source": "the gate's declaration", "delta_pp_psi": 300.0}, actor="tester")
+    s2 = ws.well_slip(w["id"], actor="tester")
+    lay = ws.add_layer(str(d / "utm_faults.zip"), "Gate UTM faults", actor="tester", feature_kind="fault", citation="the gate's own layer")
+    bad_fk = None
+    try:
+        ws.add_layer(str(d / "utm_faults.zip"), "Again", actor="tester", feature_kind="contour")
+    except WorkspaceError as e:
+        bad_fk = str(e)
+    s3 = ws.well_slip(w["id"], actor="tester")
+    sm = ws.add_stress_map(wsm_path, actor="tester", citation="WSM-shaped, the gate")
+    s4 = ws.well_slip(w["id"], actor="tester")
+    wsm_q = ws.wsm_at(lat1, lon1, 100.0)
+    site = ws.add_site("Pad 3 site", wells=[w["id"]], actor="tester")
+    ws.sra_define(site["id"], actor="tester", name="Pad 3 SRA", lat=lat1, lon=lon1, radius_km=9.08, plan_date="2026-01-15")
+    pk = ws.write_sra_packet(site["id"], actor="tester")
+    sra_md = open(pk["paths"]["markdown"], encoding="utf-8").read()
+    audit = [a["action"] for a in ws.audit_log()]
+    users = Users(str(Path(wsp, "users.json"))); users.add("op", "operator-pass-1", "operator")
+    svc = Service(wsp, port=0, scheduler=False).start()
+    base_url = svc.url.rstrip("/")
+    opener = urllib.request.build_opener(urllib.request.HTTPCookieProcessor(http.cookiejar.CookieJar()))
+
+    def call(method, path, body=None):
+        req = urllib.request.Request(base_url + path, method=method, data=(json.dumps(body).encode() if body is not None else None))
+        req.add_header("Content-Type", "application/json"); req.add_header("X-GEA-Action", "1")
+        try:
+            with opener.open(req, timeout=120) as rr_:
+                return rr_.status, json.loads(rr_.read())
+        except urllib.error.HTTPError as e:
+            return e.code, json.loads(e.read())
+    try:
+        call("POST", "/api/login", {"name": "op", "password": "operator-pass-1"})
+        st_g, got = call("GET", f"/api/wells/{w['id']}/slip")
+        st_s, stt = call("GET", "/api/stress")
+        st_w, wq = call("GET", f"/api/stress/wsm?lat={lat1}&lon={lon1}")
+        st_d, dec = call("POST", "/api/stress", {"sv_psi_ft": 1.05, "shmin_psi_ft": 0.65, "shmax_psi_ft": 0.95, "gradients_source": "api", "shmax_azimuth_deg": 95.0, "azimuth_source": "api"})
+        st_bad = call("POST", "/api/stress", {"sv_psi_ft": 1.0, "shmin_psi_ft": 0.9, "shmax_psi_ft": 0.5, "gradients_source": "x"})[0]
+        st_p, wrote = call("POST", f"/api/wells/{w['id']}/slip", {"delta_pp_psi": 100.0})
+        import base64 as _b64
+        st_m, mp = call("POST", "/api/stress/map", {"citation": "again", "file": {"filename": "wsm.csv", "content_b64": _b64.b64encode(open(wsm_path, "rb").read()).decode()}})
+    finally:
+        svc.stop()
+    page_src = (pkg / "web" / "app.html").read_text(encoding="utf-8")
+    help_md = (pkg / "help" / "slip.md").read_text(encoding="utf-8")
+    r_cli = _sp.run([sys.executable, "-m", "gea", "workspace", "--path", wsp, "--action", "slip", "--well", w["id"], "--delta-pp", "300"], capture_output=True, text=True)
+    r_wsm = _sp.run([sys.executable, "-m", "gea", "workspace", "--path", wsp, "--action", "wsm", "--lat", str(lat1), "--lon", str(lon1)], capture_output=True, text=True)
+    r_set = _sp.run([sys.executable, "-m", "gea", "workspace", "--path", wsp, "--action", "set-stress", "--sv", "1.05", "--shmin", "0.65", "--shmax", "0.95", "--gradients-source", "cli", "--shmax-azimuth", "92", "--azimuth-source", "cli"], capture_output=True, text=True)
+    r_sa = _sp.run([sys.executable, "-m", "gea", "slip", "--layer", str(d / "utm_faults.zip"), "--feature-kind", "fault", "--lat", str(lat1), "--lon", str(lon1), "--depth-ft", "9000", "--sv", "1.05", "--shmin", "0.65", "--shmax", "0.95",
+                    "--wsm", wsm_path, "--delta-pp", "300"], capture_output=True, text=True)
+    sec2e = sra_md.split("Slip tendency on the mapped faults, from the declared stress state")[1].split("## 2d")[0] if "Slip tendency on the mapped faults" in sra_md else ""
+    c3 = {
+        "refusals_in_order": s0["status"] == "NO SURFACE POSITION" and s1["status"] == "NO STRESS STATE" and no_src and "source" in no_src and s2["status"] == "NO FAULT LAYER"
+                             and bad_fk and "'fault' or 'fold'" in bad_fk and s3["status"] == "NO SHMAX AZIMUTH" and "add-stress-map" in s3["note"],
+        "from_the_map": s4["status"] == "OK" and abs(s4["shmax_azimuth_deg"] - 80.25) < 0.5 and "World Stress Map records within 100 km (12" in s4["azimuth_source"] and s4["depth_ft"] == 9000.0
+                        and s4["depth_how"].startswith("the midpoint") and s4["delta_pp_psi"] == 300.0 and len(s4["layers"]) == 1 and len(s4["layers"][0]["faults"]) == 2
+                        and s4["layers"][0]["faults"][0]["attrs"]["note"] == "HIGH CONFIDENCE" and s4["friction_envelope"]["min"] == 0.21 and sm["n_records"] == 14
+                        and wsm_q["n"] == 12 and wsm_q["citation"] == "WSM-shaped, the gate" and os.path.isfile(Path(wsp, "reports", "wells", w["id"], "slip.json")),
+        "sra_section": "## 2e" in sra_md and "| SWD-1 | Gate UTM faults |" in sec2e and "62 (layer)" in sec2e and "published 725 psi (Pp2S_MPa)" in sec2e and "none from the Permian Basin" in sec2e,
+        "audited": "stress.declare" in audit and "stress_map.add" in audit and audit.count("well.slip") >= 4,
+        "api": st_g == 200 and got["status"] == "OK" and st_s == 200 and stt["stress"]["gradients_source"] == "the gate's declaration" and stt["stress_map"]["n_records"] == 14
+               and st_w == 200 and wq["n"] == 12 and st_d == 200 and dec["shmax_azimuth_deg"] == 95.0 and st_bad == 400 and st_p == 200 and wrote["delta_pp_psi"] == 100.0
+               and wrote["shmax_azimuth_deg"] == 95.0 and st_m == 200 and mp["citation"] == "again",
+        "page": "slipCardHtml" in page_src and "stressCardHtml" in page_src and "/api/stress/map" in page_src and "lyFK" in page_src and "'/slip'" in page_src,
+        "cli": r_cli.returncode == 0 and "Slip tendency at 9,000 ft" in r_cli.stdout and "PAST THE FRICTION LINE" in r_cli.stdout or "BELOW THE FRICTION LINE" in r_cli.stdout
+               and r_wsm.returncode == 0 and "12 World Stress Map record(s)" in r_wsm.stdout and r_set.returncode == 0 and "SHmax azimuth 92.0" in r_set.stdout
+               and r_sa.returncode == 0 and "The layer publishes 725 psi to slip" in r_sa.stdout and "run from 0.21 to 0.9" in r_sa.stdout,
+        "help": any(t["topic"] == "slip" for t in H.topics()) and not H.check("slip") and "does not say the fault exists at depth" in help_md.split("will not call a measurement")[1],
+    }
+    failed3 = [k for k, v in c3.items() if not v]
+    ok(not failed3,
+       "BT3 the workspace: NO SURFACE POSITION, NO STRESS STATE (gradients without a source refused), NO FAULT LAYER (a feature kind that is not fault or fold "
+       "refused), NO SHMAX AZIMUTH naming the stress map, then OK with the azimuth from the map's records near the well and the depth from the declared interval; "
+       "the SRA packet's section 2e with the layer's dip and the published value; audited; the API declares the state, takes the map, answers the records near a "
+       "position and writes the statement; the page cards; `--action slip`, `wsm`, `set-stress` and `gea slip --wsm`; the help"
+       + (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:
@@ -7146,6 +7348,7 @@ def main() -> int:
         section_bq_field_ports(tmp)
         section_br_logs_historian(tmp)
         section_bs_catalog(tmp)
+        section_bt_slip(tmp)
     if _FAILS:
         print(f"[ACCEPTANCE] {len(_FAILS)} FAILURES ({_PASS} passed):")
         for f in _FAILS:

{gea_program-0.25.0 → gea_program-0.26.0}/gea/client_reports.py

@@ -1680,6 +1680,33 @@ def sra_packet_report(pk: dict, evaluated_at: Optional[datetime] = None, program
                 'arithmetic shown, and the declared depth tier (shallow or deep by the base the plan names) is CONSISTENT with the map, INCONSISTENT, or '
                 'NOT RESOLVED. A contour map is read, not interpolated; the completion report is the record of the interval.'],
                 [Table(['Well', 'Status', 'Declared interval', 'Against the mapped tops', 'Depth tier against the map'], irows, 'Interval against the tops')]))
+        slrows = []
+        sl_paras = []
+        for wid, sl in (pk.get('slip') or {}).items():
+            if sl.get('status') != 'OK':
+                slrows.append([wid, '-', '-', sl.get('status'), '-', '-', '-', (sl.get('note') or '')[:160]])
+                continue
+            if not sl_paras:
+                sl_paras.append(f"Stress state: {sl['lines'][0]}" if sl.get('lines') else '')
+            for lay in sl.get('layers', []):
+                for fr in lay.get('faults', [])[:12]:
+                    w_, b_ = fr['worst'], fr['best']
+                    pub = fr.get('published') or {}
+                    slrows.append([wid, lay.get('layer_display') or lay.get('layer_id'), fr.get('name') or fr.get('type') or f"trace {fr['index']}", f"{fr['distance_km']:.2f} km / strike {fr['strike_deg']:g}",
+                                   f"{w_['dip_deg']:g}" + (' (layer)' if fr.get('dip_source') == 'the layer' else ' (declared)'),
+                                   f"{b_['Ts_injection']:.2f}-{w_['Ts_injection']:.2f}", f"{w_['margin_after_injection_psi']:,.0f} to {b_['margin_after_injection_psi']:,.0f}",
+                                   (w_['status'] + (f"; published {pub['pressure_to_slip_psi']:,.0f} psi ({pub['field']})" if pub else ''))[:160]])
+        if slrows:
+            env = next((sl.get('friction_envelope') for sl in pk['slip'].values() if sl.get('friction_envelope')), None)
+            secs.append(Section('2e', 'Slip tendency on the mapped faults, from the declared stress state', [
+                'For each well inside the area, the mapped fault traces within the radius against the stress state the site declared - the three gradients and the '
+                'ambient pore pressure, the SHmax azimuth from the declaration or from the World Stress Map records near the well - at the depth of the declared '
+                'interval and the pore-pressure increase the plan is judged at: the shear and effective normal stress on each plane, the slip tendency, and the '
+                'pore-pressure increase that would bring the plane to the friction line (negative: past it under these inputs). The strike comes from the map; '
+                'the dip from the layer when it states one, otherwise the declared range; the friction coefficient as declared. Where a layer publishes its own '
+                'pressure-to-slip (BEG/TexNet Hennings et al. 2021), that number is printed beside this arithmetic. A statement on declared inputs, not a probability '
+                'and not a verdict.'] + sl_paras + ([env['statement']] if env else []),
+                [Table(['Well', 'Layer', 'Fault', 'Distance / strike', 'Dip', 'Ts (after)', 'Pressure to slip after (psi)', 'Worst case'], slrows[:120], 'Slip tendency')]))
         ef = pk.get('events_faults') or []
         if ef:
             paras = ['The catalogue events inside the area, each against the mapped fault traces of every structure layer: the nearest trace to the epicentre by '

gea_program-0.26.0/gea/help/slip.md

@@ -0,0 +1,11 @@
+# Slip tendency on the mapped faults
+
+> After "how far is the nearest mapped fault" comes "how close to slipping is it, under this injection". The open method (Morris slip tendency; the fault slip potential arithmetic of Walsh and Zoback) is a stress state resolved on a fault plane: the vertical and the two horizontal stresses on the plane, the pore pressure taken off, the shear stress against the friction times the effective normal stress. This program does that arithmetic on inputs the site declares with their sources, on the strikes the map gives and the dips the layer states or the site declares, and prints beside every number what it rests on.
+
+**The command**: `gea workspace --path C:\site --action set-stress --sv 1.05 --shmin 0.65 --shmax 0.95 --pp 0.45 --gradients-source "Lund Snee & Zoback 2018, Delaware Basin" --shmax-azimuth 92 --azimuth-source "WSM 2016 records within 100 km" --dips 60 75 90 --mu 0.6 --delta-pp 300` declares the stress state (psi/ft gradients; the sources required). `--action add-stress-map --file wsm2016.csv --citation "World Stress Map 2016, Heidbach et al., CC BY 4.0"` keeps the WSM database so `--action wsm --lat --lon --radius-km` gives the SHmax azimuth from the records near a position (the axial mean of the A/B/C-quality records with its spread and count) - and a well with no declared azimuth takes it from there, stated. `--action add-layer --name "Hennings 2021 basement faults" --layer Hennings_2021_BSMT_Pp2Slip.zip --feature-kind fault --citation "..."` brings a faults layer whose attributes do not say "fault" (every feature is declared one); a UTM or state-plane layer is unprojected from its .prj parameters. `--action slip --well <id> --radius-km 25 [--delta-pp 300] [--depth-ft 9000]` writes the statement; the well page's "Slip tendency" card and the SRA packet's section 2e carry it. `gea slip --layer faults.zip --lat --lon --depth-ft --sv --shmin --shmax --shmax-azimuth [--wsm wsm2016.csv] --delta-pp` answers for any position without a workspace.
+
+**What it writes**: the stress state at the depth (the midpoint of the declared interval, or the depth given) and the regime its ordering implies; for every mapped fault trace within the radius: its distance, its length-weighted strike and the angle to SHmax, its dip (from the layer's `dip` attribute when present, else each declared dip), the normal and shear stress on the plane, the effective normal stress at the ambient and the increased pore pressure, the slip tendency at both, the pore-pressure increase that brings the plane to the friction line and the margin left after the declared increase - BELOW or PAST THE FRICTION LINE, for the worst and the best declared case; where the layer publishes its own pressure-to-slip (the BEG/TexNet `Pp2S_MPa` of Hennings et al. 2021, computed under their calibrated stress model), that value beside this arithmetic with the difference. The measured friction envelope from the catalogue (`gea catalog --friction`) printed last, so the declared coefficient is seen against measurements. Written to `reports/wells/<id>/slip.json`, audited as `well.slip`; the stress state as `stress.declare`, the map as `stress_map.add`.
+
+**The number to check**: the pressure to slip after the increase on the nearest traces, and the count past the friction line in the worst case against the best - a count that flips between the two is a statement about the declared dip and friction, not about the fault. Where the layer publishes its own value, the difference column: a large one means the declared gradients are not the published model's, and the published model is the one with a paper behind it.
+
+**What this page will not call a measurement**: a stress state - every gradient and the SHmax azimuth are declared with their source, or taken from the World Stress Map with the count and spread printed; nothing is measured here. A dip - a map carries none; the layer's own attribute or the declared range is used and named on the line. A friction coefficient for the fault - Byerlee's 0.6 unless declared, printed against the catalogue's measured 0.21-0.90. A probability of an earthquake - the method gives a pressure margin on a plane under stated assumptions; it does not say the fault exists at depth, is connected, or will slip. An attribution - an event near a trace is a distance, as the structure page says.

{gea_program-0.25.0 → gea_program-0.26.0}/gea/helplib.py

@@ -43,6 +43,7 @@ INDEX: List[tuple] = [
     ('dlis', 'The DLIS log', 'a well log as it is delivered (API RP66 V1), read as the standard lays it out: the frames, the channels, what was skipped; into the strata survey'),
     ('historian', 'The historian pull', 'an operator\'s gauge history out of the PI System through PI Web API, read-only, every value with its archive time and flags'),
     ('field-ports', 'The field ports', 'Modbus RTU on the serial line, DNP3 from the pad RTU, HART-IP from the transmitter itself - read-only, polled, with the stand-ins to rehearse against'),
+    ('slip', 'Slip tendency on the mapped faults', 'the declared stress state resolved on each mapped fault around a well: the slip tendency, the pressure to slip, the World Stress Map as the SHmax source, the published Hennings values beside'),
     ('interval', 'The interval against the mapped tops', 'the declared disposal interval, subsea, beside each formation-top bracket; the depth tier against the mapped base; the catalogue events against the mapped faults'),
     ('sra', 'The Seismicity Response Area', 'the packet an operator inside an SRA puts in front of the Commission'),
     ('osdu', 'The OSDU-shaped export', 'the site as the manifest an operator\'s data platform loads'),

{gea_program-0.25.0 → gea_program-0.26.0}/gea/service.py

@@ -892,7 +892,8 @@ class App:
             try:
                 return self.ws.add_layer(p, str(body.get('display') or os.path.splitext(name)[0]), actor=user['name'],
                                          note=str(body.get('note', '')), citation=str(body.get('citation', '')), member=(str(body['member']) if body.get('member') else None),
-                                         formation=(str(body['formation']) if body.get('formation') else None), role=(str(body['role']) if body.get('role') else None))
+                                         formation=(str(body['formation']) if body.get('formation') else None), role=(str(body['role']) if body.get('role') else None),
+                                         feature_kind=(str(body['feature_kind']) if body.get('feature_kind') else None))
             except (WorkspaceError, ValueError) as e:
                 raise ApiError(409, str(e))
         finally:
@@ -1602,7 +1603,7 @@ def make_handler(app: App):
                                                           **({'live_state': app.live.state(st['id'])} if st.get('live') else {})} for st in app.ws.seismic_stations()],
                                             'site_reports': site})
                 if path == '/api/layers':
-                    return self._json(200, {'layers': app.ws.layers()})
+                    return self._json(200, {'layers': app.ws.layers(), 'stress': app.ws.stress(), 'stress_map': app.ws.stress_map()})
                 if path == '/api/layers/members':
                     raise ApiError(405, 'POST the zip to list its shapefiles')
                 if path.startswith('/api/layers/') and path.endswith('/at'):
@@ -1628,6 +1629,20 @@ def make_handler(app: App):
                         return self._json(200, app.ws.well_interval(wid, float(qs.get('radius_km', ['50'])[0]), actor='page', write=False))
                     except WorkspaceError as e:
                         raise ApiError(404, str(e))
+                if path.startswith('/api/wells/') and path.endswith('/slip'):
+                    wid = path[len('/api/wells/'):-len('/slip')]
+                    try:
+                        return self._json(200, app.ws.well_slip(wid, float(qs.get('radius_km', ['25'])[0]), actor='page', write=False))
+                    except WorkspaceError as e:
+                        raise ApiError(404, str(e))
+                if path == '/api/stress':
+                    return self._json(200, {'stress': app.ws.stress(), 'stress_map': app.ws.stress_map()})
+                if path == '/api/stress/wsm':
+                    try:
+                        lat, lon = float(qs['lat'][0]), float(qs['lon'][0]); rad = float(qs.get('radius_km', ['100'])[0])
+                    except (KeyError, ValueError):
+                        raise ApiError(400, 'lat and lon are needed')
+                    return self._json(200, app.ws.wsm_at(lat, lon, rad))
                 if path == '/api/seismic/live':
                     from .seedlink import EXAMPLE_CONFIG as _SLX
                     return self._json(200, {'stations': app.live.states(), 'example_config': _SLX})
@@ -1815,6 +1830,36 @@ def make_handler(app: App):
                         return self._json(200, app.ws.well_interval(wid, float((body or {}).get('radius_km') or 50.0), actor=user['name']))
                     except WorkspaceError as e:
                         raise ApiError(404, str(e))
+                if path.startswith('/api/wells/') and path.endswith('/slip'):
+                    App.require(user, 'operator')
+                    wid = path[len('/api/wells/'):-len('/slip')]
+                    b = body or {}
+                    try:
+                        return self._json(200, app.ws.well_slip(wid, float(b.get('radius_km') or 25.0), delta_pp_psi=(float(b['delta_pp_psi']) if b.get('delta_pp_psi') is not None else None),
+                                                                depth_ft=(float(b['depth_ft']) if b.get('depth_ft') is not None else None), actor=user['name']))
+                    except WorkspaceError as e:
+                        raise ApiError(404, str(e))
+                if path == '/api/stress':
+                    App.require(user, 'operator')
+                    try:
+                        return self._json(200, app.ws.set_stress(body or {}, actor=user['name']))
+                    except WorkspaceError as e:
+                        raise ApiError(400, str(e))
+                if path == '/api/stress/map':
+                    App.require(user, 'operator')
+                    f = (body or {}).get('file') or {}
+                    tmp_dir = os.path.join(app.ws.path, 'jobs', '_uploads', secrets.token_hex(4))
+                    os.makedirs(tmp_dir, exist_ok=True)
+                    try:
+                        p_ = os.path.join(tmp_dir, 'wsm.csv')
+                        with open(p_, 'wb') as fh:
+                            fh.write(base64.b64decode(f.get('content_b64') or ''))
+                        try:
+                            return self._json(200, app.ws.add_stress_map(p_, actor=user['name'], citation=str((body or {}).get('citation', ''))))
+                        except WorkspaceError as e:
+                            raise ApiError(400, str(e))
+                    finally:
+                        shutil.rmtree(tmp_dir, ignore_errors=True)
                 if path.startswith('/api/wells/') and path.endswith('/declare'):
                     App.require(user, 'operator')
                     wid = path[len('/api/wells/'):-len('/declare')]