Auto labels reviewed per station and cross-reviewed; all labeling knowledge in labeling/ (D-130)
- Every station's auto labels reviewed by an analyst (/review-auto-labels), then a cross-review per family across all stations (new skill /cross-review-labels), a finishing pass, and descriptions rewritten in words (no numeric values). - The three never-labeled ranges (WILDSTRUBEL 07/09-01/10, NORDEND 16/08-01/10) labeled and reviewed: 991 auto labels on 11 stations, labeling/controle.py at 0 errors. - Labeling knowledge gathered in labeling/: regles-d-etiquetage.md (new), familles.md (settled boundaries), connaissances/ (notes moved from docs/, links updated), the label map rebuilt from reviewed labels, events and cases; events tied to their stations (PS_DES_COUDRES is JUNGFRAU). The labeler and reviewers read only labeling/. - labels-map reads auto labels and events; decision D-130; living plan points 73-75. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
8e1cfc52c9
commit
35b5ed4d74
298 files changed
+30413
-960
No files matched your search
@@ -0,0 +1,32 @@
|
||||
"""Le bruit de jour est-il un bruit rapide (turbulence) ou une courbe lente mal compensée ?
|
||||
|
||||
Pour chaque cible, les pas d'une mesure à la suivante (Δcorr, mesures acceptées, cadence régulière) ;
|
||||
corrélation de deux pas qui se suivent : vers -0,5 pour un bruit blanc (le point revient), vers 0 ou plus
|
||||
pour une dérive ou une vague. Médiane sur les cibles, par tranche d'heures UTC données.
|
||||
|
||||
Usage (depuis la racine) : python3 alternance.py STATION DEBUT FIN H1-H2 [H1-H2 ...]
|
||||
"""
|
||||
import sys, statistics as st
|
||||
sys.path.insert(0, "agent-tools")
|
||||
import donnees as d
|
||||
|
||||
nom, t1, t2 = sys.argv[1], d.instant(sys.argv[2]), d.instant(sys.argv[3])
|
||||
tranches = [tuple(map(int, a.split("-"))) for a in sys.argv[4:]]
|
||||
dans = lambda h, a, b: a <= h < b if a < b else (h >= a or h < b)
|
||||
par = d.charger(f"data/{nom}")
|
||||
cib = {s: [m for m in d.filtrer(ms, t1, t2) if m["corr_x"] is not None] for s, ms in par.items() if not d.est_reference(ms)}
|
||||
ts = sorted({m["t"] for ms in cib.values() for m in ms})
|
||||
cad = st.median([(b - a).total_seconds() for a, b in zip(ts, ts[1:])])
|
||||
for a, b in tranches:
|
||||
rs, ampl = [], []
|
||||
for s, ms in cib.items():
|
||||
for q in ("corr_x", "corr_y"):
|
||||
p1, p2 = [], []
|
||||
for m0, m1, m2 in zip(ms, ms[1:], ms[2:]):
|
||||
if (m2["t"] - m0["t"]).total_seconds() > 2.5 * cad or not dans(m1["t"].hour, a, b):
|
||||
continue
|
||||
p1.append(m1[q] - m0[q]); p2.append(m2[q] - m1[q])
|
||||
if len(p1) > 20 and st.pstdev(p1) > 0 and st.pstdev(p2) > 0:
|
||||
rs.append(st.correlation(p1, p2)); ampl.append(st.median(abs(x) for x in p1))
|
||||
print(f"{nom} {a:02d}-{b:02d} UTC : corrélation de deux pas voisins {st.median(rs):+.2f} "
|
||||
f"(médiane de {len(rs)} séries), pas médian {st.median(ampl):.4f}")
|
||||
@@ -0,0 +1,63 @@
|
||||
"""Bords d'étiquettes : les courbes bougent-elles avant le début ou après la fin ?
|
||||
|
||||
Pour une étiquette (STATION#ligne) : niveau (médiane) et bruit (MAD) de chaque cible sur [debut-6h, debut-3h] (avant)
|
||||
et [fin+3h, fin+6h] (après) ; puis, mesure par mesure de debut-3h à debut et de fin à fin+3h,
|
||||
le nombre de cibles dont corr_x ou corr_y sort de K bruits de ce niveau ('r' ajouté s'il y a des rejets
|
||||
de plus qu'au niveau). Une suite qui monte vers le début, ou qui ne retombe pas après la fin,
|
||||
dit une borne posée trop tard ou trop tôt.
|
||||
|
||||
Usage (depuis la racine) : python3 bords.py [--k 5] [--h 3] ID [ID ...]
|
||||
"""
|
||||
import sys, json, statistics as st
|
||||
from datetime import timedelta
|
||||
sys.path.insert(0, "agent-tools")
|
||||
import donnees as d
|
||||
|
||||
args = sys.argv[1:]
|
||||
K = float(args[args.index("--k") + 1]) if "--k" in args else 5
|
||||
H = float(args[args.index("--h") + 1]) if "--h" in args else 3
|
||||
ids = [a for a in args if "#" in a]
|
||||
cache = {}
|
||||
for i in ids:
|
||||
nom, n = i.split("#")
|
||||
e = json.loads(open(f"labeling/auto/{nom}.jsonl").readlines()[int(n) - 1])
|
||||
t1, t2 = d.instant(e["debut"]), d.instant(e["fin"])
|
||||
if nom not in cache:
|
||||
cache[nom] = d.charger(f"data/{nom}")
|
||||
par = cache[nom]
|
||||
cib = {s: ms for s, ms in par.items() if not d.est_reference(ms)}
|
||||
idx = {s: {m["t"]: m for m in ms} for s, ms in cib.items()}
|
||||
h = timedelta(hours=H)
|
||||
|
||||
def niveau(a, b):
|
||||
out = {}
|
||||
for s, ms in cib.items():
|
||||
w = [m for m in d.filtrer(ms, a, b) if m["corr_x"] is not None]
|
||||
if len(w) >= 4:
|
||||
out[s] = {}
|
||||
for q in ("corr_x", "corr_y"):
|
||||
med = st.median(m[q] for m in w) # bruit : MAD de la fenêtre (une dérive thermique lente y tient)
|
||||
out[s][q] = (med, max(st.median(abs(m[q] - med) for m in w), 1e-4))
|
||||
return out
|
||||
|
||||
def suite(a, b, niv):
|
||||
inst = sorted({m["t"] for ms in cib.values() for m in d.filtrer(ms, a, b)})
|
||||
txt = []
|
||||
for t in inst:
|
||||
n = r = 0
|
||||
for s, ms in cib.items():
|
||||
m = idx[s].get(t)
|
||||
if m is None or s not in niv:
|
||||
continue
|
||||
if m["corr_x"] is None:
|
||||
r += 1
|
||||
elif any(abs(m[q] - niv[s][q][0]) > K * niv[s][q][1] for q in ("corr_x", "corr_y")):
|
||||
n += 1
|
||||
txt.append(f"{min(n, 9)}{'r' if r else ''}")
|
||||
return " ".join(txt)
|
||||
|
||||
av = niveau(t1 - 2 * h, t1 - h)
|
||||
ap = niveau(t2 + h, t2 + 2 * h)
|
||||
print(f"{i} {e['debut']} -> {e['fin']} ({len(cib)} cibles, K={K:g})")
|
||||
print(f" avant ({H:g} h) : {suite(t1 - h, t1, av)} | début")
|
||||
print(f" après ({H:g} h) : fin | {suite(t2, t2 + h, ap or av)}")
|
||||
@@ -0,0 +1,67 @@
|
||||
"""Bruit rapide des courbes corrigées, heure par heure et jour par jour, pour une station.
|
||||
|
||||
Bruit d'une cible à une heure : médiane des écarts de chaque mesure acceptée au milieu de ses deux voisines
|
||||
(trois mesures en moins de 3 cadences ; une dérive lente, thermique, s'y annule),
|
||||
corr_x et corr_y ensemble ; bruit de la station : médiane sur les cibles. Profil du lot par heure UTC ;
|
||||
puis, par jour, le bruit des 6 heures les plus bruitées du profil face aux 6 plus calmes (rapport),
|
||||
et si une étiquette Visibility de labeling/auto/ couvre la moitié des heures bruitées ce jour-là.
|
||||
|
||||
Usage (depuis la racine) : python3 bruit.py STATION DEBUT FIN [--propre] [--cibles]
|
||||
"""
|
||||
import sys, json, statistics as st
|
||||
from datetime import timedelta
|
||||
sys.path.insert(0, "agent-tools")
|
||||
import donnees as d
|
||||
|
||||
st_nom, t1, t2 = sys.argv[1], d.instant(sys.argv[2]), d.instant(sys.argv[3])
|
||||
PROPRE = "--propre" in sys.argv # retire à chaque instant la part commune à toutes les cibles (médiane signée) :
|
||||
# reste le bruit propre de chaque cible (turbulence) ; une pose mal compensée, commune, s'en va
|
||||
par = d.charger(f"data/{st_nom}")
|
||||
cib = {s: d.filtrer(ms, t1, t2) for s, ms in par.items() if not d.est_reference(ms)}
|
||||
ts = sorted({m["t"] for ms in cib.values() for m in ms})
|
||||
cad = st.median([(b - a).total_seconds() for a, b in zip(ts, ts[1:])])
|
||||
ecarts = {} # (cible, instant) -> (ex, ey) signés
|
||||
for s, ms in cib.items():
|
||||
ok = [m for m in ms if m["corr_x"] is not None]
|
||||
for a, b, c in zip(ok, ok[1:], ok[2:]):
|
||||
if (c["t"] - a["t"]).total_seconds() > 3 * cad:
|
||||
continue
|
||||
ecarts[(s, b["t"])] = tuple(b[q] - (a[q] + c[q]) / 2 for q in ("corr_x", "corr_y")) # une dérive lente s'annule
|
||||
commun = {}
|
||||
if PROPRE:
|
||||
par_t = {}
|
||||
for (s, t), e in ecarts.items():
|
||||
par_t.setdefault(t, []).append(e)
|
||||
commun = {t: (st.median(e[0] for e in l), st.median(e[1] for e in l)) for t, l in par_t.items() if len(l) >= 3}
|
||||
cell = {} # (jour, heure) -> {cible: [|écart|]}
|
||||
for (s, t), e in ecarts.items():
|
||||
c0 = commun.get(t, (0, 0))
|
||||
cell.setdefault((t.date(), t.hour), {}).setdefault(s, []).extend([abs(e[0] - c0[0]), abs(e[1] - c0[1])])
|
||||
val = {k: st.median([st.median(v) for v in c.values()]) for k, c in cell.items() if len(c) >= 3}
|
||||
prof = {h: st.median([v for (j, hh), v in val.items() if hh == h]) for h in range(24)
|
||||
if any(hh == h for (j, hh) in val)}
|
||||
print(f"{st_nom} cadence {cad/60:.0f} min, {len(cib)} cibles")
|
||||
print("profil (heure UTC: bruit médian, unités de corr) :")
|
||||
print(" " + " ".join(f"{h:02d}:{v:.3f}" for h, v in sorted(prof.items())))
|
||||
ordre = sorted(prof, key=prof.get)
|
||||
calme, agite = sorted(ordre[:6]), sorted(ordre[-6:])
|
||||
print(f"heures calmes {calme}, agitées {agite}, rapport du profil {st.median([prof[h] for h in agite]) / st.median([prof[h] for h in calme]):.2f}")
|
||||
etq = [json.loads(l) for l in open(f"labeling/auto/{st_nom}.jsonl") if l.strip()]
|
||||
vis = [(d.instant(e["debut"]), d.instant(e["fin"])) for e in etq if e["categorie"] == "Visibility"]
|
||||
print("jour agité calme rapport Visibility sur les heures agitées")
|
||||
for j in sorted({j for j, h in val}):
|
||||
a = [val[(j, h)] for h in agite if (j, h) in val]
|
||||
c = [val[(j, h)] for h in calme if (j, h) in val]
|
||||
if len(a) < 3 or len(c) < 3:
|
||||
continue
|
||||
from datetime import datetime, timezone
|
||||
hs = [datetime(j.year, j.month, j.day, h, 30, tzinfo=timezone.utc) for h in agite]
|
||||
couv = sum(any(a0 <= x <= b0 for a0, b0 in vis) for x in hs)
|
||||
print(f"{j} {st.median(a):.3f} {st.median(c):.3f} {st.median(a) / st.median(c):5.2f} {couv}/6")
|
||||
if "--cibles" in sys.argv: # rapport agité / calme de chaque cible, sur tout le lot : une gêne de la scène les touche toutes
|
||||
print("cible : bruit des heures agitées / calmes (rapport)")
|
||||
for s in sorted(cib):
|
||||
a = [x for (j, h), c in cell.items() if h in agite for x in c.get(s, [])]
|
||||
c = [x for (j, h), c in cell.items() if h in calme for x in c.get(s, [])]
|
||||
if len(a) > 20 and len(c) > 20:
|
||||
print(f" {s:24} {st.median(a):.4f} / {st.median(c):.4f} ({st.median(a) / max(st.median(c), 1e-6):.2f})")
|
||||
@@ -0,0 +1,71 @@
|
||||
"""Frontière Visibility / Thermal displacement : sur la plage d'une étiquette (et une marge), mesure par mesure,
|
||||
ce qui bouge avec les courbes : l'error_value des cibles (toute la scène ?), la température du boîtier,
|
||||
l'échelle et la rotation de la caméra.
|
||||
|
||||
Niveaux : médiane des 24 h qui finissent 2 h avant le début. Colonnes : heure ; n_corr = cibles dont corr_x ou
|
||||
corr_y sort de 6 MAD de leur niveau ; ev = médiane sur les cibles de error_value moins niveau ; n_ev = cibles dont
|
||||
l'error_value sort de 6 MAD ; temp = température du boîtier (heure la plus proche) moins niveau ; scale, rot = pose
|
||||
moins niveau, en MAD de la pose.
|
||||
|
||||
Usage (depuis la racine) : python3 frontiere.py ID [--marge 2] [--pas N] (une ligne toutes les N mesures)
|
||||
"""
|
||||
import sys, json, statistics as st
|
||||
from datetime import timedelta
|
||||
sys.path.insert(0, "agent-tools")
|
||||
import donnees as d
|
||||
|
||||
a = sys.argv[1:]
|
||||
i = a[0]
|
||||
marge = timedelta(hours=float(a[a.index("--marge") + 1]) if "--marge" in a else 2)
|
||||
pas = int(a[a.index("--pas") + 1]) if "--pas" in a else 1
|
||||
nom, n = i.split("#")
|
||||
e = json.loads(open(f"labeling/auto/{nom}.jsonl").readlines()[int(n) - 1])
|
||||
t1, t2 = d.instant(e["debut"]), d.instant(e["fin"])
|
||||
dos = f"data/{nom}"
|
||||
par = d.charger(dos)
|
||||
cib = {s: ms for s, ms in par.items() if not d.est_reference(ms)}
|
||||
r0, r1 = t1 - marge - timedelta(hours=24), t1 - marge
|
||||
|
||||
|
||||
def niv(vals):
|
||||
if len(vals) < 4:
|
||||
return None
|
||||
m = st.median(vals)
|
||||
return m, max(st.median(abs(v - m) for v in vals), 1e-6)
|
||||
|
||||
|
||||
nv = {}
|
||||
for s, ms in cib.items():
|
||||
w = d.filtrer(ms, r0, r1)
|
||||
nv[s] = {q: niv([m[q] for m in w if m[q] is not None]) for q in ("corr_x", "corr_y", "error_value")}
|
||||
cam = d.charger_camera(dos)
|
||||
ncam = {q: niv([p[q] for p in cam if r0 <= p["t"] <= r1 and p[q] is not None]) for q in ("scale", "rotation")}
|
||||
pcam = {p["t"].replace(second=0, microsecond=0): p for p in cam}
|
||||
tmp = d.charger_temperature(dos)
|
||||
ntmp = niv([v for t, v in tmp if r0 <= t <= r1])
|
||||
idx = {s: {m["t"]: m for m in ms} for s, ms in cib.items()}
|
||||
inst = sorted({t for s in idx for t in idx[s] if t1 - marge <= t <= t2 + marge})
|
||||
print(f"{i} {e['debut']} -> {e['fin']} {e['categorie']}")
|
||||
print("heure n_corr ev n_ev temp scale rot")
|
||||
for k, t in enumerate(inst):
|
||||
if k % pas:
|
||||
continue
|
||||
nc = ne = 0
|
||||
evs = []
|
||||
for s in idx:
|
||||
m = idx[s].get(t)
|
||||
if m is None:
|
||||
continue
|
||||
L = nv[s]
|
||||
if m["error_value"] is not None and L["error_value"]:
|
||||
evs.append(m["error_value"] - L["error_value"][0])
|
||||
ne += abs(m["error_value"] - L["error_value"][0]) > 6 * L["error_value"][1]
|
||||
if m["corr_x"] is not None and L["corr_x"] and L["corr_y"]:
|
||||
nc += any(abs(m[q] - L[q][0]) > 6 * L[q][1] for q in ("corr_x", "corr_y"))
|
||||
tt = min(tmp, key=lambda x: abs(x[0] - t)) if tmp else None
|
||||
dt = f"{tt[1] - ntmp[0]:+5.1f}" if tt and ntmp and abs(tt[0] - t) < timedelta(hours=1) else " . "
|
||||
p = pcam.get(t.replace(second=0, microsecond=0))
|
||||
cs = " ".join(f"{(p[q] - ncam[q][0]) / ncam[q][1]:+6.1f}" if p and p[q] is not None and ncam[q] else " ."
|
||||
for q in ("scale", "rotation"))
|
||||
mark = "*" if t1 <= t <= t2 else " "
|
||||
print(f"{t:%d %H:%M}{mark} {nc:3d} {st.median(evs) if evs else float('nan'):+.4f} {ne:3d} {dt} {cs}")
|
||||
@@ -0,0 +1,40 @@
|
||||
"""Par heure UTC sur un lot : pas médian de la pose de la caméra d'une mesure à la suivante (pan, tilt, rotation,
|
||||
scale), écart médian de l'error_value des cibles à leur niveau du lot, et température médiane du boîtier.
|
||||
Dit si le bruit de jour vient d'une pose agitée (commune) ou des taches elles-mêmes (error_value).
|
||||
|
||||
Usage (depuis la racine) : python3 pose_ev.py STATION DEBUT FIN
|
||||
"""
|
||||
import sys, statistics as st
|
||||
sys.path.insert(0, "agent-tools")
|
||||
import donnees as d
|
||||
|
||||
nom, t1, t2 = sys.argv[1], d.instant(sys.argv[2]), d.instant(sys.argv[3])
|
||||
dos = f"data/{nom}"
|
||||
cam = [p for p in d.charger_camera(dos) if t1 <= p["t"] <= t2]
|
||||
par = d.charger(dos)
|
||||
cib = {s: d.filtrer(ms, t1, t2) for s, ms in par.items() if not d.est_reference(ms)}
|
||||
tmp = [(t, v) for t, v in d.charger_temperature(dos) if t1 <= t <= t2]
|
||||
pas = {}
|
||||
for a, b in zip(cam, cam[1:]):
|
||||
if (b["t"] - a["t"]).total_seconds() < 7200:
|
||||
for q in ("pan", "tilt", "rotation", "scale"):
|
||||
if a[q] is not None and b[q] is not None:
|
||||
pas.setdefault((b["t"].hour, q), []).append(abs(b[q] - a[q]))
|
||||
ev = {}
|
||||
for s, ms in cib.items():
|
||||
v = [m["error_value"] for m in ms if m["error_value"] is not None]
|
||||
if not v:
|
||||
continue
|
||||
n = st.median(v)
|
||||
for m in ms:
|
||||
if m["error_value"] is not None:
|
||||
ev.setdefault(m["t"].hour, []).append(m["error_value"] - n)
|
||||
th = {}
|
||||
for t, v in tmp:
|
||||
th.setdefault(t.hour, []).append(v)
|
||||
print(f"{nom} heure pan tilt rotation scale ev-niveau temp")
|
||||
for h in range(24):
|
||||
c = [st.median(pas[(h, q)]) if (h, q) in pas else float("nan") for q in ("pan", "tilt", "rotation", "scale")]
|
||||
e = st.median(ev[h]) if h in ev else float("nan")
|
||||
tt = st.median(th[h]) if h in th else float("nan")
|
||||
print(f" {h:02d} {c[0]:.5f} {c[1]:.5f} {c[2]:.5f} {c[3]:.7f} {e:+.4f} {tt:.1f}")
|
||||
@@ -0,0 +1,51 @@
|
||||
"""Écrit visibility/modifications.jsonl à partir des étiquettes actuelles de labeling/auto/ (ids de la table du jour).
|
||||
Usage (depuis la racine) : python3 labeling/auto/revue-croisee/2026-11-04/visibility/outils/proposer.py"""
|
||||
import json, os
|
||||
|
||||
ici = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
|
||||
|
||||
|
||||
def etiq(i):
|
||||
st, n = i.split("#")
|
||||
e = json.loads(open(f"labeling/auto/{st}.jsonl").readlines()[int(n) - 1])
|
||||
return {k: e[k] for k in ("debut", "fin", "categorie", "description")}
|
||||
|
||||
|
||||
mods = []
|
||||
# 1. SNCF01 : l'agitation de jour est la turbulence (bruit rapide de toutes les cibles le jour, calme la nuit), comme à
|
||||
# LENZSPITZE et WILDSTRUBEL ; la cause se dit déduite, sans les hypothèses du soleil et des passages.
|
||||
VIEUX = ("les courbes corrigées de plusieurs cibles s'agitent bien plus que la nuit, surtout",
|
||||
"Cause non établie : sur les images de jour, soleil et ombres changent sur la scène autour des cibles ; "
|
||||
"peut-être aussi la turbulence au-dessus des voies, ou des passages qui cachent les cibles basses.")
|
||||
NEUF = ("les courbes corrigées de toutes les cibles s'agitent bien plus que la nuit, d'une mesure à l'autre, surtout",
|
||||
"Cause déduite : la turbulence de l'air chauffé au-dessus des voies (un bruit rapide sur toute la scène, "
|
||||
"le jour seulement), non visible sur les images ; les rejets de CV.2 et CV.4, cibles basses, peuvent "
|
||||
"venir aussi de passages, non vus.")
|
||||
for n in (9, 12, 15, 21, 28, 29, 33, 37, 39, 45, 49, 55, 59, 68, 73, 75, 82, 87, 91, 95):
|
||||
e = etiq(f"SNCF01#{n}")
|
||||
for a, b in zip(VIEUX, NEUF):
|
||||
assert a in e["description"], n
|
||||
e["description"] = e["description"].replace(a, b)
|
||||
mods.append({"id": f"SNCF01#{n}", "action": "modifier", "etiquette": e})
|
||||
e = etiq("SNCF01#25")
|
||||
a = ("Même gêne de jour que les autres jours, cause non établie (soleil et ombres sur la scène autour des cibles, "
|
||||
"ou turbulence au-dessus des voies).")
|
||||
assert a in e["description"]
|
||||
e["description"] = e["description"].replace(a, "Même turbulence de jour que les autres jours, plus faible : cause "
|
||||
"déduite, l'air chauffé au-dessus des voies, non visible sur les images.")
|
||||
mods.append({"id": "SNCF01#25", "action": "modifier", "etiquette": e})
|
||||
|
||||
# 2. NIEDERHORN#55 : 21:00 -> 04:00 UTC est la soirée et le début de nuit en heure locale (le soleil se lève vers 12:00 UTC),
|
||||
# pas « la nuit et au matin » ; les cibles rejetées sont lues sur l'inventaire de la plage (le train de 04:00 est l'étiquette 56).
|
||||
e = etiq("NIEDERHORN#55")
|
||||
e["description"] = (
|
||||
"En soirée et en début de nuit (heure locale), quelques heures : l'erreur de reconnaissance de nombreuses cibles monte, "
|
||||
"plusieurs sont rejetées par moments (surtout PWD_RMP_B12_019_C09, PWD_RMP_B15_018_C09, e06, e09, PWD_RMP_B12_017_C09, "
|
||||
"PWD_RMP_B12_018_C09 et PWD_IMP_B07_017_C09) et les autres s'agitent ; les références tiennent, plus haut sur la route. "
|
||||
"Retour avant minuit, heure locale. Cause probable : pluie ou brume (taches plus petites et plus faibles sur les "
|
||||
"vignettes de 01:00, sans obstacle). L'ouvrage ne bouge pas : ne pas croire les courbes sur la plage.")
|
||||
mods.append({"id": "NIEDERHORN#55", "action": "modifier", "etiquette": e})
|
||||
|
||||
with open(f"{ici}/modifications.jsonl", "w") as f:
|
||||
f.writelines(json.dumps(m, ensure_ascii=False) + "\n" for m in mods)
|
||||
print(len(mods), "modifications")
|
||||
@@ -0,0 +1,18 @@
|
||||
"""Par jour : part des mesures rejetées de capteurs donnés, sur une tranche d'heures UTC.
|
||||
Dit si une cible est perdue chaque jour, quel que soit le temps (Target issue), ou certains jours seulement (Visibility).
|
||||
|
||||
Usage (depuis la racine) : python3 rejets.py STATION DEBUT FIN H1-H2 CAPTEUR [CAPTEUR ...]
|
||||
"""
|
||||
import sys
|
||||
sys.path.insert(0, "agent-tools")
|
||||
import donnees as d
|
||||
|
||||
nom, t1, t2 = sys.argv[1], d.instant(sys.argv[2]), d.instant(sys.argv[3])
|
||||
a, b = map(int, sys.argv[4].split("-"))
|
||||
par = d.charger(f"data/{nom}")
|
||||
for s in sys.argv[5:]:
|
||||
jours = {}
|
||||
for m in d.filtrer(par[s], t1, t2):
|
||||
if a <= m["t"].hour < b:
|
||||
jours.setdefault(m["t"].date(), []).append(d.rejetee(m))
|
||||
print(s, f"{a:02d}-{b:02d} UTC :", " ".join(f"{j.day:02d}.{j.month:02d}:{100 * sum(v) // len(v)}%" for j, v in sorted(jours.items())))
|
||||
Reference in new issue
Block a user