Plan points 18 to 26, 30, 39, 40 and the point 37 housekeeping: - greyed zones per target, vertical scale without the zones to ignore, Fit all, mm by default with a px switch, Support view, Expand (one row per category); - cleaned curves: cut in the zones to ignore, raw data kept there in thin grey; - target02 to target05 count as targets; smoothing questions answered; - categories.py sorts in slices with 3 days of history by default; - the pumping script points to ~/monitoring-dashboard and skips diff images; - CLAUDE.md back under 200 lines; a case page is named after its case. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
251 lines
15 KiB
Python
251 lines
15 KiB
Python
"""Maquette de la page Explore, onglets View et Diagnosis (D-053, D-054), Displacements (sauts et tendances, D-055) et Journal ;
|
||
spec : vues-deplacements/maquette/spec.md.
|
||
|
||
Lit l'export « advanced » d'un dossier de station avec l'outil donnees.py de l'agent (positions, error_value) et son
|
||
export horaire (déplacements en mm), liste les images et les captures de la plateforme, puis remplit
|
||
explore_template.html. Écrit out/vues_deplacements_<STATION>.html (<cas> pour un dossier de cas) et l'ouvre dans le navigateur.
|
||
Usage : python3 vues-deplacements/maquette/explore.py [dossier de station] (défaut : le cas NORDEND d'octobre 2026)
|
||
"""
|
||
import csv
|
||
import html
|
||
import json
|
||
import os
|
||
import statistics
|
||
import sys
|
||
from datetime import datetime, timezone
|
||
from pathlib import Path
|
||
from urllib.parse import quote
|
||
from zoneinfo import ZoneInfo
|
||
|
||
HERE = Path(__file__).resolve().parent
|
||
ROOT = HERE.parents[1]
|
||
OUT = ROOT / "out"
|
||
DEFAULT = ROOT / "vues-deplacements" / "cas" / "2026-10_NORDEND" / "NORDEND"
|
||
sys.path.insert(0, str(ROOT / "src"))
|
||
sys.path.insert(0, str(ROOT / "agents" / "diagnostic" / "outils"))
|
||
sys.path.insert(0, str(ROOT / "vues-deplacements" / "journal"))
|
||
from common.page import AUTOSCALE_Y_JS, open_html # noqa: E402 (bascule seule sur .venv si plotly manque)
|
||
import donnees # noqa: E402 (lecture des exports, bibliothèque standard)
|
||
import categories # noqa: E402 (onglet Journal : détecteurs et classement en événements)
|
||
|
||
COLUMNS = ("error_value", "corr_x", "corr_y") # grandeurs de l'export « advanced » gardées pour la page, en plus de x, y
|
||
KINDS = ("global_ref", "ref", "target") # ordre des lignes : références de la compensation, local reference, cibles
|
||
MARGIN_PX = 150 # marge autour des capteurs, zoom de départ de l'image (spec §1)
|
||
HOURLY_TZ = ZoneInfo("Europe/Zurich") # horodatage de l'export horaire : heure suisse, sans fuseau (docs/domaine/colonnes-des-deplacements.md)
|
||
CAPTURES = {"time_series": ("01", "02", "03"), "advanced": ("04", "05")} # captures de cas/<cas>/plateforme/ par onglet
|
||
# Onglet Displacements (D-055, vues-deplacements/contexte/detection-d-anomalies.md) : sauts et tendances. Seuils provisoires,
|
||
# sans source, réglés sur les jeux de la note ; à revoir avec d'autres cas.
|
||
WINDOW = 24 # heures de part et d'autre d'un saut : une journée entière absorbe le cycle jour et nuit
|
||
STEP_H = 2 # un saut se fait en 2 h au plus (le pas de PR17 à 02:30 tombe entre deux moyennes horaires)
|
||
ABRUPT = 8 # brutal : changement sur STEP_H heures ≥ ABRUPT fois le changement habituel de la cible sur STEP_H heures
|
||
SIZE = 1.4 # notable : ce qui dure (médiane des 24 h après − des 24 h avant) ≥ SIZE fois l'amplitude journalière ;
|
||
# retour vertical de PR17 le 12/10 à 1,45, PR03 à 1,2 (seuil 3 avant : ce retour n'apparaissait pas)
|
||
TREND_DAYS = 5 # jours UTC (≥ 20 heures mesurées) au minimum pour une tendance
|
||
TREND_SIZE = 1 # tendance : dérive sur la période ≥ TREND_SIZE fois l'amplitude journalière…
|
||
TREND_STEADY = 0.6 # …et régulière : tau de Kendall des niveaux journaliers ≥ 0,6 (en valeur absolue)
|
||
TOGETHER_S = 6 * 3600 # sauts à moins de 6 h l'un de l'autre (de proche en proche) : un même événement
|
||
|
||
|
||
def hourly(path):
|
||
"""Export horaire -> déplacements en mm de chaque cible, heure par heure, en UTC (début de l'heure) ;
|
||
les références n'y sont pas."""
|
||
with open(path, newline="") as f:
|
||
rows = list(csv.DictReader(f))
|
||
if not rows:
|
||
return {"times": [], "sensors": {}}
|
||
num = lambda v: float(v) if v and v.strip() else None # noqa: E731
|
||
names = sorted(c[:-len("_vertical_displacement")] for c in rows[0] if c.endswith("_vertical_displacement"))
|
||
times = [datetime.fromisoformat(r["timestamp"]).replace(tzinfo=HOURLY_TZ) for r in rows]
|
||
return {"times": [donnees.iso(t) for t in times],
|
||
"sensors": {n.strip(): {"h": [num(r[f"{n}_horizontal_displacement"]) for r in rows], # NIEDERHORN : « …_C09\r »
|
||
"v": [num(r[f"{n}_vertical_displacement"]) for r in rows]} for n in names}}
|
||
|
||
|
||
def daily(s):
|
||
"""[(t, v)…] -> {jour UTC: [v…]}, jours d'au moins 20 heures mesurées."""
|
||
days = {}
|
||
for t, v in s:
|
||
days.setdefault(t[:10], []).append(v)
|
||
return {d: vs for d, vs in days.items() if len(vs) >= 20}
|
||
|
||
|
||
def find_jumps(s, swing):
|
||
"""Sauts d'une série [(t, v)…] : un changement brutal sur STEP_H heures qui dure (même sens, au moins sa moitié et
|
||
SIZE fois l'amplitude journalière, sur WINDOW heures) ; le plus net par ±WINDOW heures. -> [(index du début, saut)]"""
|
||
d = [s[i + STEP_H][1] - s[i][1] for i in range(len(s) - STEP_H)]
|
||
usual = statistics.median(abs(x) for x in d)
|
||
med = lambda a, b: statistics.median(v for _, v in s[a:b]) # noqa: E731
|
||
c = {}
|
||
for i in range(WINDOW - 1, len(s) - STEP_H - WINDOW + 1):
|
||
if not usual or abs(d[i]) < ABRUPT * usual:
|
||
continue
|
||
lasting = med(i + STEP_H, i + STEP_H + WINDOW) - med(i - WINDOW + 1, i + 1)
|
||
if d[i] * lasting > 0 and abs(lasting) >= max(abs(d[i]) / 2, SIZE * swing):
|
||
c[i] = lasting
|
||
found = []
|
||
while c:
|
||
i = max(c, key=lambda i: abs(c[i]))
|
||
found.append((i, c[i]))
|
||
c = {j: x for j, x in c.items() if abs(j - i) >= WINDOW}
|
||
return sorted(found)
|
||
|
||
|
||
def find_trend(s, jumps):
|
||
"""Tendance d'une série, sauts retirés pour le calcul seulement : pente de Theil-Sen (mm par jour) et tau de Kendall
|
||
des médianes journalières. -> (pente, tau, [(jour, médiane)…], ordonnée à l'origine de la droite) ou None sous
|
||
TREND_DAYS jours."""
|
||
kept = [(t, v - sum(j for i, j in jumps if k >= i + STEP_H)) for k, (t, v) in enumerate(s)
|
||
if not any(i < k < i + STEP_H for i, _ in jumps)]
|
||
m = sorted((datetime.fromisoformat(d).toordinal(), statistics.median(vs)) for d, vs in daily(kept).items())
|
||
if len(m) < TREND_DAYS:
|
||
return None
|
||
pairs = [(a, b) for k, a in enumerate(m) for b in m[k + 1:]]
|
||
slope = statistics.median((b[1] - a[1]) / (b[0] - a[0]) for a, b in pairs)
|
||
tau = sum((b[1] > a[1]) - (b[1] < a[1]) for a, b in pairs) / len(pairs)
|
||
return slope, tau, m, statistics.median(v - slope * x for x, v in m)
|
||
|
||
|
||
def noon(day):
|
||
"""Jour (ordinal) -> son midi UTC, où la page place le niveau du jour."""
|
||
return donnees.iso(datetime.fromordinal(day).replace(hour=12, tzinfo=timezone.utc))
|
||
|
||
|
||
def trend_line(s, jumps, m, slope, a):
|
||
"""Droite de Theil-Sen de find_trend, du midi du premier jour à celui du dernier, sauts remis : alignée sur la courbe
|
||
brute, elle marche d'un saut à chaque saut mis de côté. -> [[instant, mm]…]"""
|
||
steps = [(s[i][0], s[i + STEP_H][0], j) for i, j in jumps]
|
||
t0, t1 = noon(m[0][0]), noon(m[-1][0])
|
||
|
||
def at(t):
|
||
d = datetime.fromisoformat(t)
|
||
return a + slope * (d.toordinal() + (d.hour - 12) / 24 + d.minute / 1440) + sum(j for _, e, j in steps if e <= t)
|
||
return [[t, at(t)] for t in [t0, *(t for b, e, _ in steps if t0 < b and e < t1 for t in (b, e)), t1]]
|
||
|
||
|
||
def regime_changes(hr):
|
||
"""Déplacements horaires (sortie de hourly) -> (événements de sauts, tendances), données inchangées. Pour chaque cible
|
||
et chaque axe : tous les sauts brutaux qui durent (find_jumps), puis la tendance du reste (find_trend), gardée si la
|
||
dérive sur la période dépasse TREND_SIZE amplitudes journalières et va régulièrement dans le même sens. Des sauts à
|
||
moins de TOGETHER_S de proche en proche font un seul événement : plusieurs cibles qui sautent ensemble ne sont pas
|
||
plusieurs anomalies (règle du mode commun, CLAUDE.md)."""
|
||
found, trends = [], []
|
||
for name, axes in hr["sensors"].items():
|
||
for key, axis in (("h", "horizontal"), ("v", "vertical")):
|
||
# ponytail: fenêtres comptées en heures mesurées, un trou les allonge
|
||
s = [(t, v) for t, v in zip(hr["times"], axes[key]) if v is not None]
|
||
if len(s) < 3 * WINDOW:
|
||
continue
|
||
swings = [max(vs) - min(vs) for vs in daily(s).values()]
|
||
swing = statistics.median(swings) if swings else 0
|
||
if not swing:
|
||
continue
|
||
jumps = find_jumps(s, swing)
|
||
last = statistics.median(v for _, v in s[-WINDOW:])
|
||
for i, j in jumps:
|
||
before = statistics.median(v for _, v in s[i - WINDOW + 1:i + 1])
|
||
found.append({"target": name, "axis": axis, "t": s[i][0], "t2": s[i + STEP_H][0], "jump": j,
|
||
"swing": swing, "left": last - before, "before": before, "after": before + j,
|
||
"w0": s[i - WINDOW + 1][0], "w1": s[i + STEP_H + WINDOW - 1][0]}) # fenêtres des niveaux
|
||
trend = find_trend(s, jumps)
|
||
if not trend:
|
||
continue
|
||
slope, tau, m, a = trend
|
||
days = m[-1][0] - m[0][0]
|
||
if abs(slope) * days >= TREND_SIZE * swing and abs(tau) >= TREND_STEADY:
|
||
trends.append({"target": name, "axis": axis, "slope": slope, "drift": slope * days, "days": days,
|
||
"swing": swing, "jumps": len(jumps), "t": s[-1][0], "line": trend_line(s, jumps, m, slope, a),
|
||
"levels": [[noon(datetime.fromisoformat(d).toordinal()), statistics.median(vs)]
|
||
for d, vs in sorted(daily(s).items())]})
|
||
at = lambda f: datetime.fromisoformat(f["t"]).timestamp() # noqa: E731
|
||
events = []
|
||
for f in sorted(found, key=lambda f: f["t"]):
|
||
if events and at(f) - at(events[-1]["jumps"][-1]) <= TOGETHER_S:
|
||
events[-1]["jumps"].append(f)
|
||
else:
|
||
events.append({"jumps": [f]})
|
||
for e in events:
|
||
e["start"], e["end"] = e["jumps"][0]["t"], e["jumps"][-1]["t2"]
|
||
e["targets"] = sorted({f["target"] for f in e["jumps"]})
|
||
e["jumps"].sort(key=lambda f: abs(f["jump"]) / f["swing"], reverse=True)
|
||
return events, sorted(trends, key=lambda f: abs(f["drift"]) / f["swing"], reverse=True)
|
||
|
||
|
||
def url(path):
|
||
"""Chemin -> URL relative depuis out/, où la page est écrite."""
|
||
return quote(Path(os.path.relpath(path, OUT)).as_posix())
|
||
|
||
|
||
def build(folder):
|
||
"""Dossier de station -> données de la page ; quitte avec un message s'il n'a pas d'export « advanced »."""
|
||
files = donnees.trouver(str(folder))
|
||
if not files["advanced"]:
|
||
sys.exit(f"Pas d'export « advanced » dans {folder}")
|
||
mesures = donnees.charger(str(folder))
|
||
minute = lambda t: t.replace(second=0, microsecond=0) # noqa: E731 (instants à la minute, comme donnees.iso)
|
||
instants = sorted({minute(m["t"]) for ms in mesures.values() for m in ms})
|
||
col = {t: j for j, t in enumerate(instants)}
|
||
# les cibles d'un autre motif (target02 à target05 à PS des Coudres) sont des cibles comme les autres (point 39)
|
||
kind = lambda s: "target" if mesures[s][0]["pattern_type"].startswith("target") else mesures[s][0]["pattern_type"] # noqa: E731
|
||
order = lambda s: (KINDS.index(kind(s)) if kind(s) in KINDS else len(KINDS), s) # noqa: E731
|
||
sensors = []
|
||
for name in sorted(mesures, key=order):
|
||
ms = mesures[name]
|
||
row = {c: [None] * len(instants) for c in ("x", "y") + COLUMNS}
|
||
for m in ms:
|
||
for c in row:
|
||
row[c][col[minute(m["t"])]] = m[c]
|
||
xs, ys = [v for v in row["x"] if v is not None], [v for v in row["y"] if v is not None]
|
||
sensors.append({"name": name, "kind": kind(name), "threshold": ms[0]["error_threshold"],
|
||
"x": row["x"], "y": row["y"],
|
||
"home": [statistics.median(xs), statistics.median(ys)] if xs and ys else None,
|
||
"values": {c: row[c] for c in COLUMNS}})
|
||
homes = [s["home"] for s in sensors if s["home"]]
|
||
view = {a: [min(h[k] for h in homes) - MARGIN_PX, max(h[k] for h in homes) + MARGIN_PX]
|
||
for k, a in enumerate(("x", "y"))} if homes else None
|
||
images = sorted(({"t": donnees.iso(t), "src": url(p)} for p in files["images"] if (t := donnees.heure_image(p))),
|
||
key=lambda im: im["t"])
|
||
plateforme = Path(folder).resolve().parent / "plateforme"
|
||
captures = {tab: [url(p) for n in prefixes for p in sorted(plateforme.glob(f"{n}_*"))[:1]]
|
||
for tab, prefixes in CAPTURES.items()}
|
||
journal = categories.evenements(mesures)
|
||
for e in journal: # un trou de mesures : des images pendant disent que la caméra tournait (point 15 du plan)
|
||
if e["category"] == "trou":
|
||
n = sum(e["start"] < im["t"] < e["end"] for im in images)
|
||
e["text"] += f" The camera still took {n} images in this period, so it was running." if n \
|
||
else " There is no camera image for this period either."
|
||
hr = hourly(files["horaire"][0]) if files["horaire"] else {"times": [], "sensors": {}}
|
||
regime, trends = regime_changes(hr)
|
||
for tr in trends: # dérive lente : les tendances de l'onglet Displacements (D-055), à vérifier (point 16 du plan)
|
||
journal.append({"start": tr["levels"][0][0], "end": tr["levels"][-1][0], "category": "derive_lente",
|
||
"label": "Slow drift", "text": f"{tr['target']} drifts slowly and steadily: {tr['drift']:+.1f} mm "
|
||
f"in {len(tr['levels'])} days. Keep watching it.", "ignore": False, "sensors": [tr["target"]],
|
||
"process": "aucun", "episodes": []})
|
||
journal.sort(key=lambda e: e["start"])
|
||
return {"platform": Path(files["advanced"][0]).name.split("_advanced_")[0], "times": [donnees.iso(t) for t in instants],
|
||
"sensors": sensors, "images": images, "view": view, "captures": captures,
|
||
"folder": Path(os.path.relpath(Path(folder).resolve(), ROOT)).as_posix(), # pour la demande à l'agent
|
||
"hourly": hr, "regime": regime, "trends": trends, "journal": journal,
|
||
"rules": {"abrupt": ABRUPT, "size": SIZE, "trend_size": TREND_SIZE, "trend_days": TREND_DAYS}}
|
||
|
||
|
||
def page(folder):
|
||
"""Dossier de station -> chemin de la page écrite dans out/."""
|
||
data = build(folder)
|
||
text = (HERE / "explore_template.html").read_text()
|
||
text = text.replace("<!--PLATFORM-->", html.escape(data["platform"]))
|
||
text = text.replace("/*DATA*/null", json.dumps(data).replace("</", "<\\/"))
|
||
text = text.replace("/*AUTOSCALE*/", AUTOSCALE_Y_JS.replace("'{plot_id}'", "plotId")) # ordonnée recalée (D-013)
|
||
OUT.mkdir(exist_ok=True)
|
||
# nom du dossier, ou du cas pour un dossier de vues-deplacements/cas/<cas>/<STATION> : data/NORDEND et le cas
|
||
# 2026-10_NORDEND n'écrivent plus la même page (point 37 du plan)
|
||
d = Path(folder).resolve()
|
||
out = OUT / f"vues_deplacements_{d.parent.name if d.parent.parent.name == 'cas' else d.name}.html"
|
||
out.write_text(text)
|
||
return out
|
||
|
||
|
||
if __name__ == "__main__":
|
||
out = page(sys.argv[1] if len(sys.argv) > 1 else DEFAULT)
|
||
print(out)
|
||
open_html(out)
|