Detectors, loop and sharpening sessions moved to the repo root (D-084)

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-10-28 17:19:51 +01:00
1 parent be8897e38e
commit 4d99585474
691 files changed
+122 -109

No files matched your search

+92
View File
@@ -0,0 +1,92 @@
"""Essai archivé le 2026-10-24 : version simple de la visibilité (point 11 du plan), moins bonne que la v0 restée en service
(detectors/visibilite.py) ; comparaison sur les six jeux : point 11 du plan.
Journal du matin : visibilité, version simple.
Une cible est rejetée quand son error_value dépasse son error_threshold. Seules comptent les cibles habituellement vues
(sous leur seuil au moins la moitié du temps sur l'export) : une cible que la caméra ne voit presque jamais ne dit rien
de la visibilité du moment (PS des Coudres : PM_G ; NIEDERHORN : sept références « e »).
1. Poor visibility : au moins NIVEAU des cibles rejetées, sur deux mesures d'affilée ou plus (une mesure plus basse entre
deux hautes compte haute : la part rejetée oscille autour du niveau, C-002).
2. Brief obstruction : la même chose sur une seule mesure (un passage).
3. Target obscured : une cible rejetée la plupart du temps (au moins la moitié de ses mesures), au moins CIBLE_MIN fois à
moins de CIBLE_ECART d'écart, quand la station, elle, voit clair.
Tous les épisodes sont grisés (ignore = True) ; les labels sont ceux que lit categories.py.
Usage : python3 detectors/visibilite.py <dossier de station> (affiche les épisodes)
"""
import os
import statistics
import sys
from datetime import timedelta
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "..", "agent-tools"))
from donnees import charger, iso # noqa: E402
NIVEAU = 0.2 # provisoire, réglé sur NORDEND d'octobre (buée du 08/10 : 10 à 20 % rejetées), C-002 (toile : 30 à 40 %)
# et C-005 (pluie : 30 à 60 %) ; balayé de 0,15 à 0,3 le 2026-10-24
CIBLE_MIN = 3 # provisoire : rejets répétés d'une cible (v0)
CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur C-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart ; v0)
def _episode(debut, fin, label, capteurs):
return {"start": iso(debut), "end": iso(fin), "kind": "visibilite", "label": label, "text": "",
"ignore": True, "sensors": sorted(capteurs)}
def detect(mesures):
ratios = {} # capteur -> {t: error_value / error_threshold}
for s, v in mesures.items():
r = {m["t"].replace(second=0, microsecond=0): m["error_value"] / m["error_threshold"]
for m in v if m["error_value"] is not None and m["error_threshold"]}
if r and statistics.median(r.values()) < 1: # habituellement vue
ratios[s] = r
instants = sorted({t for r in ratios.values() for t in r})
rejetes = {t: {s for s, r in ratios.items() if r.get(t, 0) > 1} for t in instants}
vus = {t: sum(t in r for r in ratios.values()) for t in instants}
haut = [len(rejetes[t]) >= NIVEAU * vus[t] > 0 for t in instants]
for k in range(1, len(instants) - 1): # une mesure basse entre deux hautes
haut[k] = haut[k] or (haut[k - 1] and haut[k + 1])
out = []
# 1 et 2 : suites de mesures où la station voit mal ; une seule mesure, c'est un passage.
k = 0
while k < len(instants):
if not haut[k]:
k += 1
continue
j = k
while j + 1 < len(instants) and haut[j + 1]:
j += 1
cs = set().union(*(rejetes[instants[i]] for i in range(k, j + 1)))
out.append(_episode(instants[k], instants[j], "Poor visibility" if j > k else "Brief obstruction", cs))
k = j + 1
# 3 : une cible rejetée la plupart du temps pendant que la station voit clair.
clair = {t for t, h in zip(instants, haut) if not h}
refs = {s for s, v in mesures.items() if v[0]["pattern_type"] == "global_ref"}
cibles = []
for s, r in ratios.items():
if s in refs:
continue
ts = [t for t in sorted(r) if t in clair and r[t] > 1]
groupe = ts[:1]
for t in ts[1:] + [None]:
if t is not None and t - groupe[-1] <= CIBLE_ECART:
groupe.append(t)
continue
mesurees = [u for u in r if groupe and groupe[0] <= u <= groupe[-1]]
if len(groupe) >= CIBLE_MIN and 2 * len(groupe) >= len(mesurees):
cibles.append((groupe[0], groupe[-1], s))
groupe = [t]
for a, b, s in sorted(cibles): # les cibles masquées en même temps forment un seul épisode
if out and out[-1]["label"] == "Target obscured" and iso(a) <= out[-1]["end"]:
out[-1]["end"] = max(out[-1]["end"], iso(b))
out[-1]["sensors"] = sorted(set(out[-1]["sensors"]) | {s})
else:
out.append(_episode(a, b, "Target obscured", {s}))
return sorted(out, key=lambda e: e["start"])
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]))
+212
View File
@@ -0,0 +1,212 @@
"""Journal du matin : des épisodes des détecteurs aux événements catégorisés (point 6 du plan ; catégories validées le
2026-10-24 : events/carte-des-evenements.md, section 4).
Chaque épisode reçoit sa catégorie d'après son détecteur et son label ; catégories du terrain (D-074, 2026-10-27) :
Cible défaillante (`cible_degradee` : degradee, et sauts « Target flipping »), la dérive lente (derive) et le gros saut
(sauts « Large shift ») sous « À vérifier », l'effet thermique de la caméra (thermique « Camera thermal … »). Un saut revenu à la normale qui chevauche une
perte de visibilité, un passage, une turbulence ou, à défaut et s'il touche plusieurs cibles, un effet thermique y est
absorbé ; un saut qui dure ou trop récent pour savoir ne l'est
jamais ; une turbulence qui chevauche un saut à vérifier n'est pas gardée (un vrai mouvement agite aussi les courbes :
le matin du mouvement de CLARIDEN, point 14 du plan). Deux événements de même catégorie à moins d'une heure n'en font
qu'un. Chaque événement reçoit sa phrase
(point 9, validées le 2026-10-24) : ce qui s'est passé et quoi en faire, sans conditionnel ; la cause n'est dite que si la
catégorie l'établit, sinon les images la montrent. Pas de fonction detect : le chargeur ne prend pas ce fichier pour un
détecteur.
Usage : python3 detectors/categories.py <dossier de station> (une ligne par événement)
... <dossier> [--du AAAA-MM-JJ] [--au AAAA-MM-JJ] [--tranche 3] [--historique N] (tri en lot, point 30 :
chaque tranche de 3 jours classée seule, avec les jours d'historique d'avant s'ils existent ; seuls les événements
qui touchent la tranche sont montrés ; « rien » pour une tranche calme)
"""
import importlib.util
import os
import sys
from datetime import datetime, timedelta, timezone
from pathlib import Path
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, iso # noqa: E402
# ignore : zone grisée (None : comme le dit le détecteur, la turbulence n'est grisée que forte) ; process : bouton
# Images, rien, ou Images et lien vers Diagnosis. L'ordre est celui des lignes de la frise.
CATEGORIES = {
"visibilite_reduite": {"label": "Reduced visibility", "ignore": False, "process": "images"}, # en retrait (point 38)
"visibilite_nulle": {"label": "No visibility", "ignore": True, "process": "images"},
"passage": {"label": "Passing obstacle", "ignore": True, "process": "images"},
"cible_masquee": {"label": "Target hidden", "ignore": True, "process": "images"},
"cible_degradee": {"label": "Faulty target", "ignore": True, "process": "images"}, # Cible défaillante (D-074)
"turbulence": {"label": "Heat haze", "ignore": None, "process": "aucun"},
"dilatation_thermique": {"label": "Thermal expansion", "ignore": False, "process": "aucun"}, # effet périodique
"contraction_thermique": {"label": "Thermal contraction", "ignore": False, "process": "aucun"}, # (point 41)
"trou": {"label": "No data", "ignore": False, "process": "aucun"},
"saut_bref": {"label": "Brief jump", "ignore": True, "process": "images"},
"a_verifier": {"label": "Shift to check", "ignore": False, "process": "verifier"},
"derive_lente": {"label": "Slow drift", "ignore": False, "process": "verifier"}, # sous-groupe d'À vérifier (D-074)
}
# (détecteur, label, niveau de l'épisode) -> catégorie ; puis détecteur seul ; un détecteur inconnu garde son nom
LABELS = {("visibilite", "Poor visibility", "reduced"): "visibilite_reduite",
("visibilite", "Poor visibility", "none"): "visibilite_nulle",
("visibilite", "Brief obstruction", None): "passage", ("visibilite", "Target obscured", None): "cible_masquee",
("sauts", "Sudden jump, back to normal", None): "saut_bref", ("sauts", "Lasting shift", None): "a_verifier",
("sauts", "Jump, not back yet", None): "a_verifier", ("sauts", "Large shift", None): "a_verifier",
("sauts", "Target flipping", None): "cible_degradee",
("thermique", "Thermal expansion", None): "dilatation_thermique",
("thermique", "Thermal contraction", None): "contraction_thermique",
("thermique", "Camera thermal expansion", None): "dilatation_thermique",
("thermique", "Camera thermal contraction", None): "contraction_thermique"}
KINDS = {"turbulence": "turbulence", "trous": "trou", "degradee": "cible_degradee", "derive": "derive_lente"}
HOSTS = {"visibilite_reduite", "visibilite_nulle", "passage", "turbulence", "dilatation_thermique",
"contraction_thermique"} # absorbent un saut revenu (point 5 ; la vague thermique : boucle NIEDERHORN, lot 01)
MERGE = timedelta(hours=1) # même catégorie à moins d'une heure : un seul événement (point 5, 2026-10-24)
def detecteurs():
"""Modules de detectors/*.py qui ont detect ; un fichier qui ne se charge pas est sauté avec un
message."""
mods = []
for path in sorted(Path(__file__).resolve().parent.glob("*.py")):
if path == Path(__file__).resolve():
continue
try:
spec = importlib.util.spec_from_file_location(f"journal_{path.stem}", path)
mod = importlib.util.module_from_spec(spec)
spec.loader.exec_module(mod)
except Exception as e: # noqa: BLE001 (prototype : un détecteur cassé ne bloque pas la page)
print(f"Journal : {path.name} sauté ({type(e).__name__}: {e})", file=sys.stderr)
continue
if hasattr(mod, "detect"):
mods.append(mod)
return mods
def categorie(ep):
return LABELS.get((ep["kind"], ep["label"], ep.get("level"))) or KINDS.get(ep["kind"]) or ep["kind"]
def overlap(a, b):
return a["start"] <= b["end"] and a["end"] >= b["start"] # heures donnees.iso : l'ordre du texte est celui du temps
def targets(n):
return "one target" if n == 1 else f"{n} targets"
def phrase(cat, groupe, sensors, references):
"""Phrase du journal d'un événement (validées par l'utilisateur le 2026-10-24) ; un saut absorbé ajoute qu'il n'est
pas un mouvement."""
n, one = len(sensors), len(sensors) == 1
sauts = [e for e in groupe[1:] if categorie(e) == "saut_bref"]
jumped = len({s for e in sauts for s in e["sensors"]})
lasting = len({s for e in groupe if categorie(e) == "a_verifier" for s in e.get("lasting", [])})
refs = ", including the reference targets" if references & set(sensors) else ""
camera = groupe[0]["label"].startswith("Camera")
large = any(e["label"] == "Large shift" for e in groupe)
text = {
"visibilite_nulle": f"The camera could not see {targets(n)} clearly{refs}. "
"The curves in this period are not reliable: ignore them.",
"visibilite_reduite": f"The camera saw {targets(n)} less clearly than usual{refs}. "
"The data in this period are less precise: use them with care.",
"passage": f"Something passed in front of {targets(n)} for a single measurement. Ignore this point on the curves.",
"cible_masquee": f"{', '.join(sensors)} {'was' if one else 'were'} hidden several times while the targets around "
f"{'it' if one else 'them'} stayed clear. Ignore {'its curve' if one else 'their curves'} in this period.",
"turbulence": "Warm air made the readings shake. The small fast wiggles are not movement.",
"dilatation_thermique": ("The camera support expands in the day heat; the curves are corrected for it."
if camera else "The structure expands in the day heat.") + " This daily wave is normal: nothing to do.",
"contraction_thermique": ("The camera support contracts as it cools down; the curves are corrected for it."
if camera else "The structure contracts as it cools down.") + " This daily wave is normal: nothing to do.",
"saut_bref": f"{targets(n).capitalize()} jumped and came back. This is not a movement: ignore it.",
"a_verifier": (f"{targets(n).capitalize()}, most of the targets, shifted together: everything moved." if large
else f"{targets(n).capitalize()} shifted and {'has' if one else 'have'} not come back yet." if not lasting
else f"{targets(n).capitalize()} shifted and stayed shifted." if lasting == n
else f"{targets(n).capitalize()} shifted; {lasting} of them stayed shifted.")
+ " Check whether the structure moved: look at the images.",
}.get(cat, groupe[0]["text"]) # trou, cible défaillante, dérive, détecteur inconnu : le texte du détecteur
if cat == "cible_degradee":
text += f" Ignore {'its curve' if one else 'their curves'} in this period and look at the images of the target."
if not jumped:
return text
return text + (f" The jump of {targets(jumped)} in this period is not a movement." if len(sauts) == 1
else f" The jumps of {targets(jumped)} in this period are not movements.")
def evenement(groupe, references):
"""Épisodes d'un même événement, le principal en tête -> événement."""
cat = categorie(groupe[0])
c = CATEGORIES.get(cat, {"label": groupe[0]["label"], "ignore": None, "process": "aucun"})
sensors = [] if any(not e["sensors"] for e in groupe) else list(dict.fromkeys(s for e in groupe for s in e["sensors"]))
main = [e for e in groupe if categorie(e) == cat] # la durée est celle des épisodes principaux, pas des sauts absorbés
return {"start": min(e["start"] for e in main), "end": max(e["end"] for e in main), "category": cat,
"label": c["label"], "text": phrase(cat, groupe, sensors, references),
"ignore": c["ignore"] if c["ignore"] is not None else any(e["ignore"] for e in groupe if categorie(e) == cat),
"sensors": sensors, "process": c["process"], "episodes": groupe}
def classer(episodes, references=frozenset()):
"""Épisodes de tous les détecteurs -> événements triés par début (règles : docstring du module) ; references : les
capteurs global_ref, pour la phrase."""
eps = sorted(episodes, key=lambda e: e["start"])
checks = [e for e in eps if categorie(e) == "a_verifier"] # un vrai mouvement n'est jamais pris pour de la turbulence
eps = [e for e in eps if categorie(e) != "turbulence" or not any(overlap(e, c) for c in checks)]
# la vague thermique n'absorbe qu'en dernier (un saut d'un passage ou d'une pluie va à eux), et que les sauts de
# plusieurs cibles : la vague les fait bouger ensemble, une cible seule qui saute n'est pas la vague (C2 de C-003)
thermique = lambda e: categorie(e).endswith("_thermique") # noqa: E731
hosts = sorted((e for e in eps if categorie(e) in HOSTS), key=thermique)
host = {id(e): next((h for h in hosts if overlap(e, h) and (len(e["sensors"]) > 1 or not thermique(h))), None)
for e in eps if categorie(e) == "saut_bref"}
groupes = {id(e): [e] for e in eps if not host.get(id(e))}
for e in eps:
if host.get(id(e)):
groupes[id(host[id(e)])].append(e)
merged = []
for g in groupes.values():
prev = next((m for m in reversed(merged) if categorie(m[0]) == categorie(g[0])), None)
end = max((e["end"] for e in prev if categorie(e) == categorie(g[0])), default=None) if prev else None
if end and datetime.fromisoformat(g[0]["start"]) - datetime.fromisoformat(end) < MERGE:
prev += g
else:
merged.append(g)
return sorted((evenement(g, references) for g in merged), key=lambda v: v["start"])
def evenements(mesures, fin=None):
"""Mesures (donnees.charger) -> événements de tous les détecteurs : ce que la page reçoit dans D.journal ; fin : fin
de la fenêtre lue (tri en lot), donnée à trous seul, pour un trou qui la touche."""
episodes = []
for mod in detecteurs():
try:
episodes += mod.detect(mesures, fin) if mod.__name__ == "journal_trous" else mod.detect(mesures)
except Exception as e: # noqa: BLE001
print(f"Journal : {mod.__name__} sauté ({type(e).__name__}: {e})", file=sys.stderr)
return classer(episodes, {s for s, ms in mesures.items() if ms[0]["pattern_type"] == "global_ref"})
if __name__ == "__main__":
import argparse
p = argparse.ArgumentParser(description="Une ligne par événement ; --tranche : chaque tranche classée seule.")
p.add_argument("dossier")
p.add_argument("--du", help="premier jour UTC, AAAA-MM-JJ (défaut : début des données)")
p.add_argument("--au", help="dernier jour UTC exclu, AAAA-MM-JJ (défaut : fin des données)")
p.add_argument("--tranche", type=int, default=0, help="jours par tranche (défaut : un seul passage)")
# sans historique, une tranche qui commence juste avant un vrai saut le prend pour un saut revenu (PR17 à NORDEND,
# le 08/10 à 02:30 : absorbé dans la buée) ; 3 jours le rendent ; règle de l'utilisateur (2026-10-24) : 3 jours
# d'historique par défaut, dans la boucle comme dans la vraie application
p.add_argument("--historique", type=int, default=3, help="jours de mesures d'avant donnés aux détecteurs (défaut 3)")
a = p.parse_args()
mesures = charger(a.dossier)
ts = [m["t"] for ms in mesures.values() for m in ms]
jour = lambda d: datetime.strptime(d, "%Y-%m-%d").replace(tzinfo=timezone.utc) # noqa: E731
debut = jour(a.du) if a.du else min(ts).replace(hour=0, minute=0, second=0, microsecond=0)
fin = jour(a.au) if a.au else max(ts) + timedelta(seconds=1)
t = debut
while t < fin:
b = min(t + timedelta(days=a.tranche), fin) if a.tranche else fin
h = t - timedelta(days=a.historique)
tranche = {s: k for s, ms in mesures.items() if (k := [m for m in ms if h <= m["t"] < b])}
evs = [v for v in evenements(tranche, b) if v["end"] >= iso(t)] if tranche else []
if a.tranche:
print(f"== {iso(t)} → {iso(b)} : {len(evs) or 'rien'}")
for v in evs:
print(v["start"], "→", v["end"], f"{v['category']:<17}", "grisé" if v["ignore"] else "gardé",
f"| {v['episodes'][0]['kind']}", # le détecteur, pour que l'analyste le nomme (boucle, 2026-10-26)
f"| {len(v['sensors']) or 'tous les'} capteurs", "| absorbés :", ", ".join(
f"{e['kind']} {e['start'][5:16]}" for e in v["episodes"][1:]) or "—")
t = b
+120
View File
@@ -0,0 +1,120 @@
"""Journal du matin : cible rejetée la plupart du temps, jour après jour, quand les autres sont vues (cible dégradée).
Le détecteur visibilite compare chaque capteur à son propre niveau habituel : une cible presque toujours rejetée lui
paraît normale (FLORIDA, octobre 2026 : Massif 2 et Sellette 6 rejetées la moitié des mesures ou plus, chaque jour).
Méthode (seuils provisoires, Claude, 2026-10-27) :
1. Instant calme pour un capteur : au plus CALME des autres capteurs rejetés (error_value > error_threshold) ; la météo et
la buée, qui touchent tout le monde, sont ainsi mises de côté.
2. Par jour UTC et par capteur, sur ses instants calmes (au moins MIN_INSTANTS, sinon le jour ne compte pas) : jour dégradé
si au moins PART d'entre eux sont rejetés.
3. Épisode : au moins MIN_JOURS jours dégradés de suite (un jour qui ne compte pas ne coupe pas la suite), de la première
mesure du premier jour à la dernière du dernier ; ignore = True : la courbe de la cible n'est pas fiable.
Sur les jeux de data/ (2026-10-27) : FLORIDA Massif 2 21 → 25.10, Sellette 6 16 → 17.10 et 19 → 20.10 ; NIEDERHORN e03 à
e12 toute la période (jamais vues) ; NORDEND CTR01 plusieurs suites en juin-juillet (déjà « souvent rejetée ») ; rien
sur LENZSPITZE ; CLARIDEN PR-283 du 12 au 16.09. La cause (salissure, végétation, réglage) ne se lit que sur les images.
Cible collée (Cible défaillante, D-074 ; C-011, FLORIDA : une cible définie sur le prisme d'une référence) : par jour UTC,
le bruit de ses corr_x et corr_y (médiane des écarts d'une mesure à la suivante) à moins de COLLE fois le bruit médian
des autres cibles, sur les deux axes, un jour suffit (une journée sans bruit n'arrive pas par accident) ; label « Target stuck ». Sur C-011 : C2 à
7e-5 px et C3 à 2e-4 contre 0,013 pour les autres ; FLORIDA : les mêmes, Pont Ernen et Sellette 3.
Usage : python3 detectors/degradee.py <dossier de station> (affiche les épisodes)
"""
import os
import statistics
import sys
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, est_reference, iso # noqa: E402
CALME = 0.25 # part des autres capteurs rejetés au plus, pour un instant calme
PART = 0.5 # la moitié des instants calmes rejetés : « la plupart du temps »
MIN_INSTANTS = 12 # 3 h à 15 min : en dessous, le jour ne compte pas
MIN_JOURS = 2 # un jour seul est trop souvent un accident (NORDEND : jours isolés sur 16 capteurs)
COLLE = 0.05 # provisoire : bruit d'une cible collée face aux autres (C-011 : 0,006 ; NORDEND, C-001 : 0,7 au plus bas)
def rejete(m):
return m["error_value"] is not None and m["error_threshold"] is not None and m["error_value"] > m["error_threshold"]
def detect(mesures):
par_t = {}
for s, ms in mesures.items():
for m in ms:
par_t.setdefault(m["t"], {})[s] = rejete(m)
jours = {} # capteur -> jour -> [rejetés, calmes, première mesure, dernière]
for t in sorted(par_t):
d = par_t[t]
for s, r in d.items():
autres = [v for k, v in d.items() if k != s]
c = jours.setdefault(s, {}).setdefault(t.date(), [0, 0, t, t])
c[3] = t
if autres and sum(autres) / len(autres) <= CALME:
c[0] += r
c[1] += 1
out = []
for s, js in sorted(jours.items()):
suites, cur = [], []
for j in sorted(js):
rej, calmes = js[j][:2]
if calmes < MIN_INSTANTS:
continue
if rej / calmes >= PART:
cur.append(js[j])
elif cur:
suites.append(cur)
cur = []
suites += [cur] if cur else []
for su in suites:
if len(su) < MIN_JOURS:
continue
part = round(100 * sum(c[0] for c in su) / sum(c[1] for c in su))
out.append({"start": iso(su[0][2]), "end": iso(su[-1][3]), "kind": "degradee", "label": "Degraded target",
"text": f"{s} was rejected in {part} % of the measurements when the other targets were seen, "
f"{len(su)} days in a row.",
"ignore": True, "sensors": [s]})
return sorted(out + colles(mesures), key=lambda e: e["start"])
def _bruit(v):
return statistics.median(abs(y - x) for x, y in zip(v, v[1:])) if len(v) > 2 else None
def colles(mesures):
"""Cibles dont corr_x et corr_y ne bougent presque pas, jour après jour, quand les autres bougent."""
jours = {} # jour -> cible -> (bruit x, bruit y, première mesure, dernière)
for s, ms in mesures.items():
if est_reference(ms):
continue
par_j = {}
for m in ms:
par_j.setdefault(m["t"].date(), []).append(m)
for d, js in par_j.items():
b = [_bruit([m[c] for m in js if m[c] is not None]) for c in ("corr_x", "corr_y")]
if None not in b and len(js) >= MIN_INSTANTS:
jours.setdefault(d, {})[s] = (*b, js[0]["t"], js[-1]["t"])
suites = {} # cible -> [[jours collés de suite]]
for d in sorted(jours):
cs = jours[d]
for s, (bx, by, a, b) in cs.items():
autres = [v for k, (x, y, *_) in cs.items() if k != s for v in (x, y)]
if len(autres) < 4:
continue
ref = statistics.median(autres)
su = suites.setdefault(s, [[]])
if ref and max(bx, by) <= COLLE * ref:
su[-1].append((a, b))
elif su[-1]:
su.append([])
out = []
for s, su in sorted(suites.items()):
for k in su:
if k:
out.append({"start": iso(k[0][0]), "end": iso(k[-1][1]), "kind": "degradee", "label": "Target stuck",
"text": f"{s} barely moved while the other targets did ({len(k)} day{'s' if len(k) > 1 else ''}): it may be "
"set on a reference prism.", "ignore": True, "sensors": [s]})
return out
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e)
+70
View File
@@ -0,0 +1,70 @@
"""Journal du matin : dérive lente, une cible qui bouge peu à peu, jour après jour (sous-groupe de « À vérifier », D-074).
Reprend la tendance de l'onglet Displacements (D-055, explore.find_trend) sur l'export « advanced » (corr_x, corr_y, px),
pour que la boucle puisse l'entraîner comme les autres détecteurs. Méthode, par cible (hors références globales) et par
axe (seuils provisoires, ceux de D-055) :
1. Niveau du jour : médiane des mesures de chaque jour UTC d'au moins HEURES heures mesurées ; au moins JOURS jours.
2. Pente de Theil-Sen et tau de Kendall des niveaux journaliers ; amplitude du jour : écart entre ses déciles 9 et 1.
3. Dérive : |pente| × durée ≥ TAILLE fois l'amplitude médiane du jour, |tau| ≥ REGULIER, et aucun pas d'un jour au
suivant de plus de la moitié de la dérive (un saut qui dure n'est pas une dérive : le détecteur sauts le prend).
4. Un épisode par cible (un axe suffit), de la première mesure du premier jour à la dernière du dernier ; pas grisé.
Usage : python3 detectors/derive.py <dossier de station> (affiche les épisodes)
"""
import os
import statistics
import sys
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, est_reference, iso # noqa: E402
HEURES = 20 # un jour compte s'il a au moins 20 heures mesurées (comme D-055)
JOURS = 5 # jours au minimum pour une tendance (TREND_DAYS de D-055)
TAILLE = 1.0 # dérive ≥ TAILLE amplitudes journalières (TREND_SIZE de D-055)
REGULIER = 0.6 # |tau de Kendall| des niveaux journaliers (TREND_STEADY de D-055)
def _decile(vs, q):
vs = sorted(vs)
return vs[min(len(vs) - 1, int(q * len(vs)))]
def _derive(ms, col):
"""-> (dérive en px, jours, premier instant, dernier) ou None."""
jours = {}
for m in ms:
if m[col] is not None:
jours.setdefault(m["t"].date(), []).append(m)
jours = {d: js for d, js in jours.items() if len({m["t"].hour for m in js}) >= HEURES}
if len(jours) < JOURS:
return None
niv = sorted((d.toordinal(), statistics.median(m[col] for m in js)) for d, js in jours.items())
paires = [(a, b) for k, a in enumerate(niv) for b in niv[k + 1:]]
pente = statistics.median((b[1] - a[1]) / (b[0] - a[0]) for a, b in paires)
tau = sum((b[1] > a[1]) - (b[1] < a[1]) for a, b in paires) / len(paires)
derive = pente * (niv[-1][0] - niv[0][0])
ampl = statistics.median(_decile([m[col] for m in js], 0.9) - _decile([m[col] for m in js], 0.1) for js in jours.values())
pas = max(abs(b[1] - a[1]) for a, b in zip(niv, niv[1:]))
if abs(derive) < TAILLE * ampl or abs(tau) < REGULIER or pas > abs(derive) / 2:
return None
d0, d1 = min(jours), max(jours)
return derive, len(jours), min(m["t"] for m in jours[d0]), max(m["t"] for m in jours[d1])
def detect(mesures):
out = []
for s, ms in sorted(mesures.items()):
if est_reference(ms):
continue
r = [x for col in ("corr_x", "corr_y") if (x := _derive(ms, col))]
if not r:
continue
derive, n, a, b = max(r, key=lambda x: abs(x[0]))
out.append({"start": iso(a), "end": iso(b), "kind": "derive", "label": "Slow drift",
"text": f"{s} drifts slowly and steadily: {derive:+.2f} px in {n} days. Keep watching it.",
"ignore": False, "sensors": [s]})
return out
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e["start"], "→", e["end"], e["sensors"][0], "|", e["text"])
+220
View File
@@ -0,0 +1,220 @@
"""Sauts brutaux du journal du matin : corr_x / corr_y (px) de chaque cible, cadence native de l'export « advanced ».
1. Bruit de la série = médiane des écarts d'une mesure à la suivante ; saut = mesure à K bruits ou plus du niveau
d'avant (médiane des BASE mesures précédentes) ; les BASE premières mesures, faute de niveau d'avant, face au niveau
d'après (médiane des BASE suivantes), un écart y est un saut revenu aussitôt (point 12 du plan, 2026-10-24).
2. Revenu (BASE mesures de suite à moins de la moitié du saut) en moins d'un jour, ou un jour après de retour à sa place
habituelle (premier jour de l'export) ou du jour d'avant : « Sudden jump, back to normal », grisé (artefact).
3. Sinon « Lasting shift », jamais grisé (peut-être un vrai mouvement) ; moins d'un jour de recul :
« Jump, not back yet », pas grisé non plus.
4. Les sauts qui se suivent à moins d'une heure, toutes cibles confondues, font un seul épisode (mode commun) ;
une seule cible durable (ou trop récente) suffit à ne pas griser l'épisode.
5. Références globales exclues ; mesures rejetées (corr vides) sautées.
6. Pic commun (lot 01 de la boucle NORDEND, 2026-10-26) : au même instant, au moins PIC_MIN cibles s'écartent d'au moins
K_PIC bruits de leurs deux mesures voisines, du même côté (toute l'image secouée un pas) : un saut revenu pour chacune,
même sous K. Il entre dans les épisodes du point 4 (près d'un saut durable, il ne grise rien).
7. Boucle CLARIDEN, lot 01 (2026-10-26) : un saut jamais revenu ne clôt plus la lecture de la série, son nouveau niveau
devient le niveau d'avant ; un épisode qui n'est pas grisé finit à son dernier saut, pas aux retours (ils ne sont
plus à griser) ; une cible qui bascule (REPET sauts revenus ou plus, chacun à moins d'un jour du précédent) fait un
épisode « back to normal » à elle seule, de la première à la dernière bascule, hors des épisodes communs.
Résultats (2026-10-23, K = 20) :
- C-001 PS des Coudres : rien (vérité : rien côté sauts).
- C-002 NORDEND juillet : grisés 28/07 21:00 → 29/07 10:45 (18 cibles) et 30/07 13:30 → 31/07 01:15 (18) ; toile revenue
31/07 20:30 : « not back yet » (13 cibles, 1 h avant la fin des données).
- C-003 WILDSTRUBEL : un saut d'un pas grisé, 04/09 06:45 (le C2 de la fiche) ; les autres sont sur des références
ou rejetés.
- C-004 CLARIDEN : « Lasting shift » 19/09 06:10, 18 cibles, non grisé ; faux positif probable : une cible agitée seule,
18/09 15:40, non grisé ; la dérive de nuit de corr_x (lente) n'est pas un saut.
- C-005 NIEDERHORN : train du 01/10 12:00 grisé (1 cible sur 3 : les deux autres à 17 et 19 bruits) ; train du
30/09 22:00 vu depuis le 2026-10-24 (2 cibles, première mesure de l'export) ; feuilles, pluie : rien (error_value, pas
des sauts). Les trains sont de toute façon attrapés par visibilite (« Passing obstacle ») et le classement y absorbe
leurs sauts : ne pas baisser K pour eux (point 12 du plan).
- NORDEND octobre : PR17 seule en « Lasting shift » le 08/10 02:30 ; cinq épisodes communs grisés (07/10 19:45,
08/10 07:15, 09/10 08:45 et 21:15, 14/10 05:15 : 4 à 15 cibles, aller-retour en moins de 5 h) ; PR15 08/10 04:45,
un instant grisé.
Pic commun (K_PIC = 6, PIC_MIN = 3, 2026-10-26) : NORDEND, lot du 01 au 04/09 : secousses du 03/09 13:30 (3 cibles) et
16:45 (4) grisées, aussi 01/09 15:45 → 16:00 et 02/09 09:45, mêmes secousses d'un pas pendant la bascule de la caméra ;
NORDEND octobre : un pic de 3 cibles le 13/10 12:30, et PR17 (08/10 02:30) groupé avec le pic de 02:15, « 3 targets,
1 stayed shifted », toujours non grisé ; C-002, C-005 : pics absorbés par la toile et les trains ; C-004 : les pics du
mouvement (19/09 06:30, 06:50) restent dans le « Lasting shift » ; C-001, C-003 : rien.
Point 7 (REPET = 5, 2026-10-26) : CLARIDEN, lot du 18 au 22/09 : PR_BG grisé 19/09 06:40 → 21/09 23:20 (28 bascules de
12 px ; les autres cibles en font 3 au plus) ; le saut seul de D-303-A le 18/09 15:40 vu ; le « Lasting shift » du
matin garde 05:40 → 10:30 ; C-001 à C-003, C-005 à C-008 : inchangés.
Catégories du terrain (D-074, 2026-10-27) : la cible qui bascule pendant BASCULE au moins, avec SEULES cibles au plus en même temps, devient « Target flipping » (Cible défaillante, plus un
saut bref) ; un saut durable d'au moins GROS des cibles, « Large shift » (gros saut : tout a bougé), toujours à vérifier.
8. Saut sous K qui reste (boucle NIEDERHORN, lot 01, 2026-10-27 ; K_DURABLE = 7, PALIER = 8) : un saut d'au moins
K_DURABLE bruits compte s'il est durable au point 3 et que la médiane du jour d'après s'écarte de celle du jour d'avant,
du côté du saut, d'au moins PALIER fois la variation ordinaire du niveau d'un jour UTC au suivant (médiane des écarts
entre niveaux journaliers) ; sinon il est ignoré (ni revenu ni trop récent : seuls les sauts de K bruits ou plus le
sont). NIEDERHORN : e09, corr_y −0,19 px le 02/10 20:00 (8 bruits, 13 variations ordinaires), « Lasting shift », avec
e10 au même instant (corr_x +0,22 px, resté) ; C-001 : rien (cibles saines à 6 variations ordinaires au plus) ;
C-004 : le mouvement du 19/09 couvre deux fois plus de mesures à vérifier ; les autres cas inchangés.
"""
import statistics
import sys
from datetime import timedelta
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1] / "agent-tools"))
import donnees # noqa: E402
K = 20 # provisoire, réglé sur C-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits) ; les trains de
# C-005 (17 et 19 bruits) sont attrapés par visibilite : ne pas baisser K
K_DURABLE = 7 # provisoire : sous K, un saut qui reste compte dès K_DURABLE bruits (boucle NIEDERHORN, lot 01 : e09,
# corr_y −0,18 px d'un coup, 8 bruits, resté 5 jours)
PALIER = 8 # provisoire : ... s'il reste : médiane du jour d'après, du côté du saut, à PALIER fois la variation
# ordinaire du niveau d'un jour au suivant de celle du jour d'avant (e09 : 13 ; C-001, cibles saines : 6 au plus)
K_PIC = 6 # provisoire : pic d'un pas commun à plusieurs cibles (secousses de NORDEND, 6 à 11 bruits, lot 01 de la boucle)
PIC_MIN = 3 # provisoire : cibles qui piquent au même pas pour un pic commun (une ou deux : bruit ordinaire)
BASE = 4 # mesures qui font le niveau d'avant (1 h à 15 min)
GAP = timedelta(hours=1) # deux sauts à moins d'une heure, toutes cibles confondues : un seul épisode
BACK_H = 24 # provisoire : retour en moins d'un jour = artefact (C-002 : paliers jusqu'à 11 h 30)
BASCULE = timedelta(hours=6) # provisoire : une cible défaillante bascule des heures (PR_BG : 2,5 jours) ; en moins,
# c'est un matin agité (C-009 : C8 et C13, 5 bascules en 1 h 20 pendant le mouvement), un saut bref
SEULES = 2 # provisoire : cibles qui basculent en même temps, au plus (FLORIDA : les deux collées ; C-002, toile sur les
# références : 15 à la fois)
GROS = 0.5 # provisoire : part des cibles d'un saut durable pour un gros saut (C-004 : presque toutes)
REPET = 5 # provisoire : sauts revenus d'une même cible, à moins d'un jour l'un de l'autre, qui en font une cible qui
# bascule (PR_BG de CLARIDEN, boucle lot 01 : une trentaine en 2,5 jours)
def _sauts(t, v):
"""Une série (instants, valeurs) -> [(i début, i fin, état)], état 'back', 'lasting' ou 'recent'."""
day = timedelta(hours=BACK_H)
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
# ponytail: place habituelle = premier jour de l'export, faux s'il commence dans un artefact
ref = statistics.median(x for x, u in zip(v, t) if u < t[0] + day)
lv = {} # niveau de chaque jour UTC ; sa variation ordinaire d'un jour au suivant juge un saut sous K
for x, u in zip(v, t):
lv.setdefault(u.date(), []).append(x)
lv = [statistics.median(x) for _, x in sorted(lv.items())]
ordinaire = statistics.median(abs(b - a) for a, b in zip(lv, lv[1:])) if len(lv) > 2 else 0
# les BASE premières mesures, faute de niveau d'avant, face au niveau d'après : un écart y est revenu aussitôt
out = [(k, k, "back") for k in range(min(BASE, len(v) - BASE))
if noise and abs(v[k] - statistics.median(v[k + 1:k + 1 + BASE])) >= K * noise]
i = BASE
while noise and i < len(v):
base = statistics.median(v[i - BASE:i])
if abs(v[i] - base) < K_DURABLE * noise:
i += 1
continue
tol = abs(v[i] - base) / 2 # revenu : BASE mesures de suite à moins de la moitié du saut du niveau d'avant
j = next((k for k in range(i + 1, len(v)) if all(abs(x - base) < tol for x in v[k:k + BASE])), len(v))
before = statistics.median([x for x, u in zip(v, t) if t[i] - day <= u < t[i]] or [base])
after = statistics.median(x for x, u in zip(v, t) if t[i] <= u < t[i] + day)
if j < len(v) and t[j] - t[i] <= day:
state = "back"
elif abs(after - ref) < tol or abs(after - before) < tol: # le jour d'après, la cible est à sa place
state, j = "back", i + 1 # habituelle, ou là où elle était le jour d'avant : le saut finissait un creux
else:
state = "lasting" if t[-1] - t[i] >= day else "recent" # moins d'un jour de recul : on ne sait pas encore
if abs(v[i] - base) < K * noise and (state != "lasting" or (after - before) * (v[i] - base) < 0
or not ordinaire or abs(after - before) < PALIER * ordinaire):
i += 1 # sous K, seul compte un saut qui reste : le jour d'après loin du jour d'avant, de son côté
continue
out.append((i, j - 1, state))
# niveau d'avant refait après le retour ; jamais revenu : le nouveau niveau devient celui d'avant, la suite
# reste lue (PR_BG de CLARIDEN, lot 01 : ses bascules après le saut de 10:30 étaient invisibles)
i = (j if j < len(v) else i) + BASE
return out
def _pics(t, v):
"""Instants où la mesure s'écarte d'au moins K_PIC bruits de ses deux voisines, du même côté (pic d'un pas)."""
noise = statistics.median(abs(y - x) for x, y in zip(v, v[1:]))
return [t[i] for i in range(1, len(v) - 1) if noise and (v[i] - v[i - 1]) * (v[i] - v[i + 1]) > 0
and min(abs(v[i] - v[i - 1]), abs(v[i] - v[i + 1])) >= K_PIC * noise]
def detect(mesures):
"""{capteur: [mesure]} (donnees.charger) -> épisodes du journal, triés par début."""
found = [] # (début, fin, état, capteur)
pics = {} # instant -> cibles qui y font un pic d'un pas
for name, ms in mesures.items():
if donnees.est_reference(ms):
continue
for axe in ("corr_x", "corr_y"):
kept = [m for m in ms if m[axe] is not None]
if len(kept) <= BASE:
continue
t, v = [m["t"] for m in kept], [m[axe] for m in kept]
# un saut qui n'est pas revenu finit avec lui-même, pas avec les données (sa barre cachait les autres)
found += [(t[a], t[b] if state == "back" else t[a], state, name) for a, b, state in _sauts(t, v)]
for u in _pics(t, v):
pics.setdefault(u, set()).add(name)
found += [(u, u, "back", s) for u, cs in pics.items() if len(cs) >= PIC_MIN for s in cs] # pic commun : revenu
seuls = _bascules(found) # une cible qui saute et revient sans cesse : un épisode à elle seule, hors des communs
found = [f for f in found if f[2] != "back" or not any(f[3] in g["sensors"] and g["start"] <= f[0] <= g["end"]
for g in seuls)]
groups = [] # un saut qui n'est pas revenu ne compte que par son instant : sa fin est souvent celle des données
for s, e, state, name in sorted(found):
if groups and s <= groups[-1]["until"] + GAP:
g = groups[-1]
else:
g = {"start": s, "end": e, "until": s, "last": s, "sensors": {}}
groups.append(g)
g["end"], g["until"], g["last"] = max(g["end"], e), max(g["until"], e if state == "back" else s), s
g["sensors"].setdefault(name, set()).add(state)
longues = [g for g in seuls if g["flip"]] # bascules de nombreuses cibles en même temps : la compensation, pas une
for g in longues: # cible défaillante
if sum(h["start"] <= g["end"] and h["end"] >= g["start"] for h in longues) > SEULES:
g["flip"] = 0
total = sum(not donnees.est_reference(ms) for ms in mesures.values())
return sorted((_episode(g, total) for g in groups + seuls), key=lambda ep: ep["start"])
def _bascules(found):
"""Sauts revenus d'une même cible, chacun à moins de BACK_H du précédent : REPET ou plus -> un groupe, de la
première à la dernière bascule."""
day, seuls = timedelta(hours=BACK_H), []
for name in {f[3] for f in found}:
chain = [] # (début, fin) ; corr_x et corr_y en double : comptés par instant
for s, e in sorted({(s, e) for s, e, state, n in found if n == name and state == "back"}) + [(None, None)]:
if chain and s is not None and s <= max(c[1] for c in chain) + day:
chain.append((s, e))
continue
if len({c[0] for c in chain}) >= REPET:
seuls.append({"start": chain[0][0], "end": max(c[1] for c in chain), "sensors": {name: {"back"}},
"flip": len({c[0] for c in chain}) if max(c[1] for c in chain) - chain[0][0] >= BASCULE else 0})
chain = [(s, e)]
return seuls
def _episode(g, total):
"""Un groupe -> épisode du journal ; un seul saut durable (ou trop récent) suffit à ne pas griser ; une cible qui
bascule : « Target flipping » (Cible défaillante, D-074) ; un saut durable de GROS cibles ou plus : « Large shift »
(le gros saut, sous-groupe de « À vérifier »)."""
n = len(g["sensors"])
lasting = sum("lasting" in st for st in g["sensors"].values())
recent = any("recent" in st for st in g["sensors"].values())
who = "One target" if n == 1 else f"{n} targets together (a single event)"
if g.get("flip"):
name = next(iter(g["sensors"]))
return {"start": donnees.iso(g["start"]), "end": donnees.iso(g["end"]), "kind": "sauts", "label": "Target flipping",
"text": f"{name} jumped and came back {g['flip']} times: its tracking is not reliable, look at the images "
"of the target.", "ignore": True, "sensors": [name], "lasting": []}
if lasting and n >= GROS * total:
label = "Large shift"
text = f"{n} targets jumped together and {lasting} of them stayed shifted: everything moved, please check it."
elif lasting:
label = "Lasting shift"
some = "" if lasting == n else f", {lasting} of them stayed shifted for more than a day"
text = (f"{who} jumped{some}" if some else f"{who} jumped and stayed shifted for more than a day") + \
": this may be a real movement, please check it."
elif recent:
label = "Jump, not back yet"
text = f"{who} jumped less than a day before the last measurement and has not come back yet: check again later."
else:
label = "Sudden jump, back to normal"
text = f"{who} jumped and came back within a day: most likely a measurement artefact, not a movement."
end = g["last"] if lasting or recent else g["end"] # pas grisé : le dernier saut, pas les retours
return {"start": donnees.iso(g["start"]), "end": donnees.iso(end), "kind": "sauts", "label": label,
"text": text, "ignore": not lasting and not recent, "sensors": sorted(g["sensors"]),
"lasting": sorted(s for s, st in g["sensors"].items() if "lasting" in st)} # restées décalées (phrase du journal)
if __name__ == "__main__":
for ep in detect(donnees.charger(sys.argv[1])):
print(ep["start"], ep["end"], "ignore" if ep["ignore"] else "KEEP ", ep["label"], "|", len(ep["sensors"]),
",".join(ep["sensors"][:6]), "|", ep["text"])
+205
View File
@@ -0,0 +1,205 @@
"""Journal du matin : effet périodique, la vague quotidienne des déplacements corrigés (dilatation le jour, contraction
le soir : l'utilisateur, 2026-10-24 ; point 41 du plan).
Méthode, par cible (hors références globales) et par axe (corr_x, corr_y) :
1. Chaque jour UTC d'au moins 20 h : moyenne de chaque heure moins la médiane du jour (enlève sauts et dérive).
2. Profil = médiane, heure par heure, sur les jours ; « répétabilité » = médiane, sur les jours, de la corrélation
entre le jour et le profil des autres jours. Axe concerné si répétabilité ≥ 0,6.
3. Cycle de la station si au moins la moitié des cibles ont un axe concerné, **et** (seconde méthode, demandée par
l'utilisateur) si une sinusoïde de 24 h, a + b·sin(2πt/24 h) + c·cos(2πt/24 h) par moindres carrés, explique au
moins R2_MIN de la courbe d'un axe pour au moins la moitié des cibles.
4. Heures chaudes : niveau de nuit = médiane des 8 heures consécutives les plus plates du profil ; une heure est
chaude si, en médiane sur les axes concernés, le profil s'en écarte d'au moins 0,3 fois son amplitude.
5. Deux épisodes par jour complet qui ressemble aux autres (corrélation médiane ≥ 0,5 sur les axes concernés) :
« Thermal expansion » de la première heure chaude à l'heure du plus grand écart au niveau de nuit, puis « Thermal
contraction » jusqu'à la fin de la dernière heure chaude. Le sens (une courbe qui monte ou qui descend) dépend de la
direction de la cible : on ne le regarde pas, seulement l'écart au niveau de nuit.
Sinusoïde (2026-10-24), axes des courbes corrigées où elle explique ≥ 30 % : PS des Coudres 14/22, NORDEND d'octobre
0/38, juillet 1/38, WILDSTRUBEL 1/14, CLARIDEN 0/48, NIEDERHORN 14/40 (3 jours, deux nuits de pluie aux mêmes heures,
écarté par la première méthode) ; PS des Coudres seule a son effet périodique, 5 jours, dilatation puis contraction.
Résultats (2026-10-23 ; « cibles » = part des cibles concernées, amplitude = médiane max − min du profil, en px) :
| Jeu | corr (ce que voit le client) | x, y bruts |
|---|---|---|
| PS_DES_COUDRES | 11/11 cibles, 0,17 px, 08-17 h, 5 épisodes | 12/12, 0,55 px, 08-16 h |
| NORDEND (juillet, C-002) | 2/18, rien | 18/19, 1,8 px, 06-18 h |
| WILDSTRUBEL (C-003) | 3/7, rien | 6/7, 3,2 px, 04-08 h |
| CLARIDEN (C-004) | 1/24, rien | 1/24, aucun cycle |
| NIEDERHORN (C-005, horaire) | 3/11, rien | 19/30, 4,6 px, ~12 h |
| cas 2026-10_NORDEND (11 j) | 9/19, 0,02 px, 08-17 h, sous le seuil (PART = 0,4 : 8 épisodes, sans 08 ni 09/10) | 17/19, 0,78 px, 09-17 h |
Lecture : le cycle est presque partout dans les positions brutes (mode commun) et la compensation l'enlève,
sauf à PS des Coudres où il reste dans corr, de même forme que dans les positions brutes.
Effet thermique (D-074, 2026-10-27) : sans cycle dans corr, la même méthode sur les positions brutes x, y donne
« Camera thermal expansion » et « Camera thermal contraction » : la caméra bouge avec la chaleur de son support, la
compensation l'enlève ; mêmes catégories du journal, phrase propre.
Caméra sans sinusoïde (boucle WILDSTRUBEL, lot 01) : sur les positions brutes, la seconde méthode n'est plus demandée ;
la caméra y montait d'un bloc de 3 px au lever, tenait 3 h et retombait en un pas vers 09:30, six jours de suite, que
la sinusoïde n'explique pas (une cible sur sept, les pointés faux de 30 px écrasent l'ajustement) ; la répétition
d'un jour à l'autre (méthode 1, 6 cibles sur 7) suffit. En échange, une seule heure chaude n'est pas un cycle
(CHAUDES_MIN) : NIEDERHORN (C-005, horaire) avait sinon son heure de midi (trains, trous) en contraction de la caméra.
L'épisode de la caméra porte sur tous les capteurs, références comprises : toute l'image bouge.
"""
import math
import os
import statistics
import sys
from datetime import datetime, timedelta, timezone
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, iso # noqa: E402
HEURES_MIN = 20 # provisoire : un jour UTC compte s'il a au moins 20 heures mesurées
REPRO = 0.6 # provisoire : un axe a un cycle si chaque jour ressemble aux autres (bruit pur ≈ 0)
PART = 0.5 # provisoire : part des cibles concernées ; 2026-10_NORDEND est juste dessous (9/19)
CHAUD = 0.3 # provisoire : écart au niveau de nuit, en part de l'amplitude du profil
JOUR = 0.5 # provisoire : ressemblance d'un jour aux autres pour lui donner son épisode
NUIT = 8 # heures consécutives du profil les plus plates = niveau de nuit
R2_MIN = 0.3 # provisoire, ébauche du 2026-10-24 : PS des Coudres 14 axes sur 22 au-dessus, CLARIDEN 0 sur 48
CHAUDES_MIN = 2 # provisoire : boucle WILDSTRUBEL, lot 01 ; NIEDERHORN (C-005) n'a qu'une heure chaude (midi)
W = 2 * math.pi / 86400 # pulsation d'un cycle de 24 h, en rad/s
def _corr(a, b):
ma, mb = statistics.mean(a), statistics.mean(b)
num = sum((x - ma) * (y - mb) for x, y in zip(a, b))
den = (sum((x - ma) ** 2 for x in a) * sum((y - mb) ** 2 for y in b)) ** 0.5
return num / den if den else 0.0
def _axe(ms, col):
"""-> (profil sur 24 h, {jour: corrélation au profil des autres jours}) ou None."""
jours = {}
for m in ms:
if m[col] is not None:
jours.setdefault(m["t"].date(), {}).setdefault(m["t"].hour, []).append(m[col])
J = {}
for d, hs in jours.items():
if len(hs) >= HEURES_MIN:
med = statistics.median(v for l in hs.values() for v in l)
J[d] = {h: statistics.mean(l) - med for h, l in hs.items()}
if len(J) < 2:
return None
profil = [statistics.median(q[h] for q in J.values() if h in q) for h in range(24) if any(h in q for q in J.values())]
if len(profil) < 24:
return None
ressemblance = {}
for d, p in J.items():
autres = [q for e, q in J.items() if e != d]
hs = [h for h in p if all(h in q for q in autres)]
ressemblance[d] = _corr([p[h] for h in hs], [statistics.median(q[h] for q in autres) for h in hs])
return profil, ressemblance
def sinus_r2(ms, col):
"""Part de la courbe expliquée par une sinusoïde de 24 h (moindres carrés, 3 inconnues), ou None si trop court."""
pts = [(m["t"].timestamp(), m[col]) for m in ms if m[col] is not None]
if len(pts) <= 48:
return None
rows = [(1.0, math.sin(W * t), math.cos(W * t)) for t, _ in pts]
A = [[sum(r[i] * r[j] for r in rows) for j in range(3)] for i in range(3)]
B = [sum(r[i] * y for r, (_, y) in zip(rows, pts)) for i in range(3)]
for i in range(3): # élimination de Gauss
for k in range(i + 1, 3):
f = A[k][i] / A[i][i]
A[k] = [x - f * y for x, y in zip(A[k], A[i])]
B[k] -= f * B[i]
x = [0.0] * 3
for i in (2, 1, 0):
x[i] = (B[i] - sum(A[i][j] * x[j] for j in range(i + 1, 3))) / A[i][i]
m = statistics.mean(y for _, y in pts)
sst = sum((y - m) ** 2 for _, y in pts)
sse = sum((y - sum(c * v for c, v in zip(x, r))) ** 2 for r, (_, y) in zip(rows, pts))
return 1 - sse / sst if sst else None
def sinus(mesures, cols=("corr_x", "corr_y")):
"""-> (cibles dont un axe suit une sinusoïde de 24 h, cibles évaluées)."""
oui, evaluees = set(), set()
for s, ms in mesures.items():
if ms[0]["pattern_type"] == "global_ref":
continue
for col in cols:
r2 = sinus_r2(ms, col)
if r2 is not None:
evaluees.add(s)
if r2 >= R2_MIN:
oui.add(s)
return oui, evaluees
def cycle(mesures, cols=("corr_x", "corr_y")):
"""-> (axes concernés [(capteur, col, profil, ressemblance)], nombre de cibles évaluées)."""
concernes, cibles = [], set()
for s, ms in mesures.items():
if ms[0]["pattern_type"] == "global_ref":
continue
for col in cols:
r = _axe(ms, col)
if r is None:
continue
cibles.add(s)
if statistics.median(r[1].values()) >= REPRO:
concernes.append((s, col) + r)
return concernes, len(cibles)
def ecarts(concernes):
"""Écart médian (sur les axes concernés) au niveau de nuit, heure par heure, en part de l'amplitude du profil."""
def score(p, h):
debut = min(range(24), key=lambda i: max(p[(i + k) % 24] for k in range(NUIT)) - min(p[(i + k) % 24] for k in range(NUIT)))
nuit = statistics.median(p[(debut + k) % 24] for k in range(NUIT))
return abs(p[h] - nuit) / (max(p) - min(p))
return [statistics.median(score(c[2], h) for c in concernes) for h in range(24)]
def heures_chaudes(concernes):
return [h for h, e in enumerate(ecarts(concernes)) if e >= CHAUD]
def detect(mesures):
"""Cycle des courbes corrigées (l'ouvrage) ; sinon, celui des positions brutes (la caméra qui bouge par dilatation
de son support, compensée : D-074, 2026-10-27)."""
return (_episodes(mesures, ("corr_x", "corr_y"), "Thermal", False) or
_episodes(mesures, ("x", "y"), "Camera thermal", True))
def _episodes(mesures, cols, nom, camera):
concernes, n = cycle(mesures, cols)
capteurs = sorted({c[0] for c in concernes})
if not n or len(capteurs) < PART * n:
return []
if not camera: # seconde méthode, pour l'ouvrage seul : la sinusoïde doit le voir aussi
oui, evaluees = sinus(mesures, cols)
if not evaluees or len(oui) < PART * len(evaluees):
return []
chaudes = heures_chaudes(concernes)
if len(chaudes) < CHAUDES_MIN:
return []
e = ecarts(concernes)
pic = max(chaudes, key=lambda h: e[h]) # le plus grand écart au niveau de nuit : fin de la dilatation
jours = sorted({d for c in concernes for d in c[3]})
if camera: # toute l'image bouge, références comprises
capteurs = sorted(mesures)
episodes = []
for d in jours: # ponytail: jours complets seulement, les bouts d'export (22:00 → minuit) n'ont pas d'épisode
if statistics.median(c[3][d] for c in concernes if d in c[3]) < JOUR:
continue
minuit = datetime(d.year, d.month, d.day, tzinfo=timezone.utc)
for label, a, b in ((f"{nom} expansion", chaudes[0], pic), (f"{nom} contraction", pic, chaudes[-1] + 1)):
if b > a:
episodes.append({"start": iso(minuit + timedelta(hours=a)), "end": iso(minuit + timedelta(hours=b)),
"kind": "thermique", "label": label, "text": "", "ignore": False, "sensors": capteurs})
return episodes
if __name__ == "__main__":
mesures = charger(sys.argv[1])
for e in detect(mesures):
print(e["start"], "→", e["end"], e["label"], len(e["sensors"]), "cibles")
for cols in (("corr_x", "corr_y"), ("x", "y")):
concernes, n = cycle(mesures, cols)
k = len({c[0] for c in concernes})
amp = statistics.median(max(c[2]) - min(c[2]) for c in concernes) if concernes else 0
oui, evaluees = sinus(mesures, cols)
print(f"{cols[0][:-2] or 'brut'} : cibles {k}/{n}, amplitude médiane {amp:.3f} px, heures chaudes (UTC) "
f"{heures_chaudes(concernes) if concernes else '-'} ; sinusoïde : cibles {len(oui)}/{len(evaluees)}")
+43
View File
@@ -0,0 +1,43 @@
"""Journal du matin : moments sans mesure (cadence de l'export « advanced » rompue).
Cadence : écart médian entre deux instants de mesure, tous capteurs confondus. Un trou : plus de 2 pas manquants entre
deux mesures (écart > 3 cadences) ; l'épisode va de la dernière mesure à la suivante. Fin de la fenêtre lue (fin, si
l'appelant la donne : le tri en lot de categories.py) : la même règle entre la dernière mesure et fin, l'épisode allant
jusqu'à fin (boucle CLARIDEN, lot 01 : 44 h sans mesure jusqu'à la fin du lot, non signalées). Pas de mesure dans
l'export ne veut pas dire station arrêtée (CLAUDE.md) : le texte dit seulement que l'export n'a rien.
Usage : python3 detectors/trous.py <dossier de station> (affiche les épisodes)
"""
import os
import statistics
import sys
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, iso # noqa: E402
MISSING = 2 # au-delà de 2 pas manquants, c'est un trou (consigne de l'utilisateur, 2026-10-23)
def duration(s):
h, m = divmod(round(s / 60), 60)
return f"{h} h {m:02d} min" if h else f"{m} min"
def detect(mesures, fin=None):
"""fin : fin de la fenêtre lue (datetime, exclue), facultative ; sans elle, un trou final n'est pas vu."""
ts = sorted({m["t"].replace(second=0, microsecond=0) for ms in mesures.values() for m in ms})
if len(ts) < 3:
return []
gaps = [(b - a).total_seconds() for a, b in zip(ts, ts[1:])]
step = statistics.median(gaps)
out = [(a, b, g, "") for a, b, g in zip(ts, ts[1:], gaps)]
if fin: # fin exclue : la dernière mesure attendue est à fin − 1 pas, l'écart se compte comme entre deux mesures
out.append((ts[-1], fin, (fin - ts[-1]).total_seconds(), ", up to the end of the period"))
return [{"start": iso(a), "end": iso(b), "kind": "trous", "label": "No data",
"text": f"No measurement in the export for {duration(g)}{fin_txt} (usually one every {duration(step)}).",
"ignore": False, "sensors": []}
for a, b, g, fin_txt in out if g > (MISSING + 1) * step]
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e)
+107
View File
@@ -0,0 +1,107 @@
"""Journal du matin : turbulence atmosphérique (bruit rapide sur les déplacements corrigés).
Méthode :
1. Par capteur et par heure H, sur les mesures de [H − 1 h, H + 2 h) : agitation = médiane de |Δcorr_x| + |Δcorr_y|
entre mesures successives (robuste aux sauts d'un seul pas), et médiane de l'error_value.
2. Chacune est rapportée au calme du capteur : le quartile bas de ses valeurs horaires sur l'export (souvent la nuit).
3. Heure turbulente : au moins la moitié des capteurs à ≥ 1,5 fois leur agitation calme, et error_value médiane
des capteurs à ≥ 1,5 fois la calme (l'air chaud brouille les taches : C-003, critère 1).
4. Heures voisines fusionnées (trou d'une heure toléré), épisode d'au moins 3 h, écarté si plus de 15 % des mesures
sont rejetées (c'est alors de la mauvaise visibilité, autre détecteur). Grisé si l'agitation médiane ≥ 2×.
Résultats (2026-10-23, seuils ci-dessous) :
- WILDSTRUBEL (C-003, vérité : chaque jour ~03:30 → 16:00) : 3 épisodes, 02.09 04:00-15:00, 03.09 05:00-15:00,
04.09 04:00-15:00, les 13 capteurs, ×2,3 à ×2,6, tous grisés.
- PS_DES_COUDRES (sain, buée une nuit), NORDEND juillet (toile d'araignée), CLARIDEN (mouvement réel),
NIEDERHORN (trains, pluie), NORDEND octobre (11 jours) : aucun épisode. Écartés en route : midis agités sans
error_value en hausse (PS des Coudres, NORDEND octobre), toile et pluie par les rejets (18 à 43 %), le matin du
mouvement de CLARIDEN (06:00-08:00) par la durée.
"""
import os
import statistics
import sys
from datetime import timedelta
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, iso # noqa: E402
RATIO = 1.5 # provisoire, réglé sur C-003 (WILDSTRUBEL : de jour, corr ×1,7 à ×3 la nuit)
PART = 0.5 # provisoire : part des capteurs agités en même temps
RATIO_ERR = 1.5 # provisoire, réglé sur C-003 (error_value ×1,7 à ×3,2 la nuit ; ≈ ×1 à midi ailleurs)
REJET_MAX = 0.15 # provisoire : C-003 ≤ 7 % ; toile d'araignée (C-002) et pluie (C-005) ≥ 18 %
FORT = 2.0 # provisoire : C-003 (×2,3 à ×2,6) est fort ; un épisode entre ×1,5 et ×2 reste visible
DUREE_MIN = timedelta(hours=3) # provisoire : C-003 dure 10-11 h ; écarte le matin du mouvement réel de C-004 (2 h),
# que le classement écarte aussi, quelle que soit la durée (point 14 du plan)
HEURE = timedelta(hours=1)
def _heure(t):
return t.replace(minute=0, second=0, microsecond=0)
def _rapports(points):
"""[(t, valeur)] -> {heure H: médiane sur [H − 1 h, H + 2 h) / quartile bas de ces médianes}."""
par = {}
for t, v in points:
for k in (-1, 0, 1):
par.setdefault(_heure(t) + k * HEURE, []).append(v)
med = {h: statistics.median(v) for h, v in par.items() if len(v) >= 3}
if len(med) < 8:
return {}
calme = statistics.quantiles(med.values(), n=4)[0]
return {h: v / calme for h, v in med.items()} if calme > 0 else {}
def heures(mesures):
"""-> {heure: {capteur: (agitation / calme, error_value / calme)}}."""
out = {}
for s, ms in mesures.items():
ag = _rapports([(b["t"], abs(b["corr_x"] - a["corr_x"]) + abs(b["corr_y"] - a["corr_y"]))
for a, b in zip(ms, ms[1:]) if a["corr_x"] is not None and b["corr_x"] is not None])
er = _rapports([(m["t"], m["error_value"]) for m in ms if m["error_value"] is not None])
for h, r in ag.items():
if h in er:
out.setdefault(h, {})[s] = (r, er[h])
return out
def _turbulente(r):
return (sum(a >= RATIO for a, _ in r.values()) >= PART * len(r)
and statistics.median(e for _, e in r.values()) >= RATIO_ERR)
def detect(mesures):
H = heures(mesures)
blocs = []
for h in sorted(h for h, r in H.items() if _turbulente(r)):
if blocs and h - blocs[-1][-1] <= 2 * HEURE:
blocs[-1].append(h)
else:
blocs.append([h])
episodes = []
for b in blocs:
debut, fin = b[0], b[-1] + HEURE
dedans = [m for ms in mesures.values() for m in ms if debut <= m["t"] < fin]
if fin - debut < DUREE_MIN or sum(m["corr_x"] is None for m in dedans) > REJET_MAX * len(dedans):
continue
par_capteur = {}
for h in b:
for s, (a, _) in H[h].items():
par_capteur.setdefault(s, []).append(a)
agit = {s: statistics.median(v) for s, v in par_capteur.items()}
fort = statistics.median(agit.values())
episodes.append({
"start": iso(debut), "end": iso(fin), "kind": "turbulence",
"label": "Heat shimmer",
"text": f"Readings were about {fort:.1f}× noisier than in calm hours because of heat shimmer "
"(warm air trembling in the line of sight); the small fast wiggles are not movement.",
"ignore": fort >= FORT,
"sensors": sorted(s for s, v in agit.items() if v >= RATIO),
})
return episodes
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e["start"], "→", e["end"], e["label"], "(grisé)" if e["ignore"] else "",
f"{len(e['sensors'])} capteurs |", e["text"])
+206
View File
@@ -0,0 +1,206 @@
"""Journal du matin : visibilité / taux d'erreur de reconnaissance (error_value), un épisode grisé par moment douteux.
Méthode (seuils provisoires ci-dessous) :
1. Mesure « haute » : error_value > médiane + 10 MAD du capteur sur l'export, et > 2 × médiane, ou rejetée (> error_threshold)
et > 1,2 × médiane : un capteur au niveau habituel de 0,6 ne double jamais, et FLORIDA (boucle, lot 01) montrait ses brouillards
en Target obscured.
2. Brief obstruction : un instant où au moins 3 capteurs sont hauts, 3 fois plus qu'aux instants voisins (train, véhicule),
sans référence (global_ref) parmi eux : un pic d'un pas qui touche les références n'est pas un obstacle devant des
cibles (pic de toute l'image, NORDEND le 01.09 11:15, lot 01 de la boucle) ; il n'est pas montré.
3. Poor visibility : suites d'au moins 3 mesures hautes par capteur, réunies entre capteurs (au moins 2), réduites aux instants
où au moins 15 % du pic de l'épisode est haut ; le texte dit si des références (global_ref) sont touchées.
4. Target obscured : une cible (pas une global_ref) rejetée (> error_threshold) et à plus de 5 MAD, au moins 3 fois à moins de 6 h
d'écart, la plupart hors des épisodes 2 et 3 (feuilles, neige, reflet sur une cible). Tous les épisodes : ignore = True.
5. Niveau d'une Poor visibility (point 38 du plan, validé le 2026-10-24), mesure par mesure : « none » (on ne voit rien) quand
au moins MOITIE des cibles habituellement vues (sous leur seuil la moitié du temps au moins) sont rejetées, « reduced »
(données moyennes) sinon ; un épisode par période de même niveau, avec le champ level. Sur les cas : NORDEND le 09.10
08:45 → 10:30 et 21:30 → 23:15, le 14.10 05:15 → 06:00 en none ; buées de NORDEND et de C-001, toile de C-002, pluie
de C-005 en reduced.
6. Bornes d'une Poor visibility (boucle WILDSTRUBEL, lot 01) : de la première à la dernière mesure où une cible est
rejetée (> error_threshold), et pas d'épisode sans cible rejetée. Sur une chaussée en plein soleil, l'error_value de
jour (×1,5 à ×3, la turbulence) faisait durer la visibilité réduite des heures sans aucun rejet (28.09 10:00 → 12:15,
29.09 jusqu'à 14:15) ; les références ne comptent pas : R3 y passe son seuil presque toute la journée. Benchmark :
le seul épisode perdu est celui, faux, de C-010.
Résultats (2026-10-23 ; vérité : events/INDEX.md) :
- PS_DES_COUDRES (C-001, buée 13.10 23:45 → 14.10 05:15, 2 références sur 3) : Poor visibility 13.10 23:45 → 14.10 04:45, REF_G et
REF_D ; aussi la nuit d'avant, 13.10 01:15 → 03:30, mêmes références (hors vérité, pas d'image : sans doute la même buée).
- NORDEND juillet (C-002, toile 28.07 20:45 → 31.07 03:00, reprise 31.07 20:30) : Poor visibility 28.07 20:45 → 31.07 02:45 (20 capteurs)
et 31.07 20:30 → fin (18), références comprises.
- WILDSTRUBEL (C-003, turbulence de jour) : pas de Poor visibility (error_value ×1,5 à ×3 seulement : laissé au détecteur turbulence) ;
3 Brief obstruction de jour (02.09 12:00, 03.09 08:15, 04.09 14:00 : un véhicule sur la route à 14:00, image ; les deux
premières touchent des références et ne sont plus montrées depuis le lot 01 de la boucle NORDEND) ; PA_9 en
Target obscured chaque matin dès 04:30, jusqu'à 06:45, 08:15 ou 12:00 (soleil sur la cible, probable).
- CLARIDEN (C-004, mouvement réel) : rien sur le groupe à error_value durablement haute (bon) ; Brief obstruction 18.09 13:40
et 20.09 06:20 (tunnel : taches assombries, non établi ; références touchées, plus montrées depuis le lot 01) ;
Target obscured PR-284 19.09 18:30 → 18:50.
- NIEDERHORN (C-005) : trains 30.09 22:00, 01.10 12:00 et 21:00, 02.10 21:00 (celui du 03.10 10:00, 2 cibles, manqué) ;
pluie 01.10 06:00 → 11:00 et 02.10 03:00 → 11:00 (vérité 05:00 et 03:00 → 11:00), références intactes ; feuilles 02.10 10:00 → 22:00.
- NORDEND octobre (cas/2026-10_NORDEND) : Poor visibility 07.10 17:15 → 08.10 12:15 (buée du 08.10 02:30), 09.10 07:45 → 14:00
(parois ruisselantes), 09.10 20:45 → 23:45 (17 rejets à 23:00, retour à 00:00), 13.10 09:45 → 10:30, 14.10 05:15 → 06:30
(taches pâles à l'aube) ; Brief obstruction 12.10 14:15 (09.10 18:45 touche CTR04 : plus montrée depuis le lot 01) ;
Target obscured surtout CTR01, PR04, PR09 (souvent rejetées) : à vérifier.
- FLORIDA (boucle, lot 01 ; cibles au niveau 0,6 pour un seuil de 0,7) : les brouillards du 18.10, du 20-21.10, du 23.10 et
du 24-25.10, avant en Target obscured, en Poor visibility (none et reduced en alternance, cœur seul : à 10 MAD) ; la référence
r1_r au-dessus de son seuil du 22.10 au 24.10 reste manquée (son MAD de 0,15 rend 10 MAD hors d'atteinte).
Version simple essayée le 2026-10-24 (point 11 du plan), à la demande de l'utilisateur : part des cibles rejetées au-dessus
de leur seuil, sans comparer chaque capteur à son propre niveau. Moins bonne sur cinq jeux sur six (buée de C-001 manquée,
toile de C-002 morcelée, turbulence de C-003 prise pour une perte de visibilité) et grisait le vrai mouvement de C-004 :
l'utilisateur a remis cette version en service ; la simple est gardée dans archive/visibilite_simple.py.
"""
import os
import statistics
import sys
from datetime import timedelta
sys.path.insert(0, os.path.join(os.path.dirname(os.path.abspath(__file__)), "..", "agent-tools"))
from donnees import charger, iso # noqa: E402
K_MAD = 10 # provisoire, réglé sur C-001 (buée : 11 à 57 MAD) et C-005 (pluie, trains : 10 à 70 MAD)
FACTEUR = 2 # provisoire : écarte les capteurs à MAD quasi nulle (C-004 : PWD_REF10 ×1,6 à 14 MAD, C-005)
SUITE_MIN = 3 # provisoire : mesures hautes d'affilée pour une mauvaise visibilité (C-001, C-005 pluie)
BREF_MIN = 3 # provisoire, réglé sur C-005 (trains : 5 à 17 capteurs ; celui de 2 cibles est manqué)
K_CIBLE = 5 # provisoire, réglé sur C-005 (feuilles : 6 à 25 MAD, rejetées)
CIBLE_MIN = 3 # provisoire : rejets répétés d'une cible
FRAC = 0.15 # provisoire : coupe les queues de PR09 + CTR01 (NORDEND octobre) sans couper la toile (C-002)
ECART = 2.5 # provisoire : pas tolérés entre deux mesures hautes d'une même suite (un pas manquant, horloge à la seconde près)
COUPURE = timedelta(hours=2) # provisoire : accalmie qui sépare deux épisodes (NORDEND octobre, nuit du 13 au 14.10)
SAILLIE = 3 # provisoire : un train ressort d'au moins 3 fois les instants voisins (C-005 : 5 à 17 contre 0 à 2 ;
# la toile de C-002 varie de 2 à 9 d'un pas à l'autre)
CIBLE_ECART = timedelta(hours=6) # provisoire, réglé sur C-005 (feuilles : 7 rejets en 12 h, jusqu'à 5 h d'écart)
FACTEUR_REJET = 1.2 # provisoire : un rejet à 10 MAD compte aussi (boucle FLORIDA, lot 01 : niveaux de 0,6, ×2 hors d'atteinte) ;
# écarte C24 de C-009 (niveau 0,68 au ras du seuil 0,7, rejeté à ×1,04)
MOITIE = 0.5 # provisoire : « on ne voit rien » ; réglé sur NORDEND (09.10 23:00 : 68 % rejetées) et C-005 (pluie : 24 à 33 %)
def _pas(mesures):
ts = sorted({m["t"] for v in mesures.values() for m in v})
return statistics.median(b - a for a, b in zip(ts, ts[1:]))
def _grouper(points, ecart):
"""[(t, capteur)] triés par t -> groupes [(début, fin, {capteurs}, [t])] dont les points sont à ≤ ecart les uns des autres."""
groupes = []
for t, s in points:
if groupes and t - groupes[-1][1] <= ecart:
g = groupes[-1]
groupes[-1] = (g[0], t, g[2] | {s}, g[3] + [t])
else:
groupes.append((t, t, {s}, [t]))
return groupes
def _episode(debut, fin, label, text, capteurs, level=None):
e = {"start": iso(debut), "end": iso(fin), "kind": "visibilite", "label": label, "text": text,
"ignore": True, "sensors": sorted(capteurs)}
return {**e, "level": level} if level else e
def _niveaux(mesures, instants):
"""t -> "none" si au moins MOITIE des cibles habituellement vues sont rejetées à t, "reduced" sinon."""
ratios = []
for v in mesures.values():
r = {m["t"]: m["error_value"] / m["error_threshold"] for m in v if m["error_value"] is not None and m["error_threshold"]}
if r and statistics.median(r.values()) < 1:
ratios.append(r)
return {t: "none" if sum(r.get(t, 0) > 1 for r in ratios) >= MOITIE * max(1, sum(t in r for r in ratios)) else "reduced"
for t in instants}
def detect(mesures):
ecart = ECART * _pas(mesures)
refs = {s for s, v in mesures.items() if v[0]["pattern_type"] == "global_ref"}
instants = sorted({m["t"] for v in mesures.values() for m in v})
hautes, rejets = {}, {} # capteur -> [t]
refuses = set() # instants où une cible (pas une global_ref) est au-dessus de son seuil
for s, v in mesures.items():
e = [m["error_value"] for m in v if m["error_value"] is not None]
if len(e) < 10:
continue
med = statistics.median(e)
mad = statistics.median(abs(x - med) for x in e) or 1e-9
for m in v:
x = m["error_value"]
if x is None:
continue
rejete = m["error_threshold"] and x > m["error_threshold"]
if rejete and s not in refs:
refuses.add(m["t"])
if x > med + K_MAD * mad and (x > FACTEUR * med or rejete and x > FACTEUR_REJET * med):
hautes.setdefault(s, []).append(m["t"])
if s not in refs and rejete and x > med + K_CIBLE * mad:
rejets.setdefault(s, []).append(m["t"])
par_t = {} # t -> {capteurs hauts}
for s, ts in hautes.items():
for t in ts:
par_t.setdefault(t, set()).add(s)
n = lambda t: len(par_t.get(t, ())) # noqa: E731
out = []
# 2. Brief obstruction : un instant où beaucoup de capteurs sont hauts, au moins SAILLIE fois plus qu'aux instants voisins.
brefs = set()
for i, t in enumerate(instants):
voisins = [n(instants[j]) for j in (i - 1, i + 1) if 0 <= j < len(instants)]
if n(t) >= BREF_MIN and n(t) >= SAILLIE * max(voisins):
brefs.add(t)
if par_t[t] & refs: # références touchées : pas un obstacle devant des cibles (carte : références intactes)
continue
out.append(_episode(t, t, "Brief obstruction", f"{n(t)} points were poorly seen for a single measurement, then came "
"back: probably a train, a vehicle or an animal passing; ignore this point on the curves.", par_t[t]))
# 3. Poor visibility : suites longues par capteur (sans les instants brefs), réunies entre capteurs,
# puis réduites aux instants où au moins FRAC du pic de l'épisode est haut (coupe les queues d'un ou deux capteurs
# et les longues accalmies, plus de COUPURE).
suites = []
for s, ts in hautes.items():
pts = [(t, s) for t in ts if t not in brefs]
suites += [(a, b, s) for a, b, _, l in _grouper(pts, ecart) if len(l) >= SUITE_MIN]
zones = [z for z in _grouper_intervalles(sorted(suites), ecart) if len(z[2]) >= 2]
gardees = []
for a, b, _ in zones:
dans = [t for t in instants if a <= t <= b and t not in brefs]
pic = max(n(t) for t in dans)
pts = [(t, s) for t in dans if n(t) >= max(1, FRAC * pic) for s in par_t[t]]
gardees += [(d, f, cs) for d, f, cs, l in _grouper(pts, max(ecart, COUPURE)) if len(cs) >= 2 and len(set(l)) >= SUITE_MIN]
# Bornes : de la première à la dernière cible rejetée ; sans rejet, pas d'épisode (6).
gardees = [(r[0], r[-1], cs) for a, b, cs in gardees if (r := [t for t in instants if a <= t <= b and t in refuses])]
niveau = _niveaux(mesures, instants)
for a, b, cs in gardees: # un épisode par période de même niveau (5) ; le texte vient de categories.py
seg = []
for t in [t for t in instants if a <= t <= b] + [None]:
if seg and (t is None or niveau[t] != niveau[seg[0]]):
qui = cs & set().union(*(par_t.get(u, set()) for u in seg)) or cs
out.append(_episode(seg[0], seg[-1], "Poor visibility", "", qui, niveau[seg[0]]))
seg = []
if t is not None:
seg.append(t)
dedans = lambda t: t in brefs or any(a <= t <= b for a, b, _ in gardees) # noqa: E731
# 4. Target obscured : une cible rejetée à répétition, surtout hors des épisodes ci-dessus.
cibles = []
for s, ts in rejets.items():
for a, b, _, l in _grouper([(t, s) for t in ts], CIBLE_ECART):
if len(l) >= CIBLE_MIN and sum(map(dedans, l)) * 2 < len(l):
cibles.append((a, b, s))
for a, b, cs in _grouper_intervalles(sorted(cibles), timedelta(0)):
qui, it, its = ("One target was", "it", "its") if len(cs) == 1 else (f"{len(cs)} targets were", "them", "their")
out.append(_episode(a, b, "Target obscured", f"{qui} repeatedly lost while the targets around stayed clear: probably "
f"something in front of {it} (leaves, snow) or glare; {its} displacements in this period are unreliable.", cs))
return sorted(out, key=lambda e: e["start"])
def _grouper_intervalles(intervalles, ecart):
"""[(début, fin, capteur)] triés -> [(début, fin, {capteurs})] des intervalles qui se chevauchent (à ecart près)."""
out = []
for a, b, s in intervalles:
if out and a - out[-1][1] <= ecart:
out[-1] = (out[-1][0], max(out[-1][1], b), out[-1][2] | {s})
else:
out.append((a, b, {s}))
return out
if __name__ == "__main__":
for e in detect(charger(sys.argv[1])):
print(e["start"], "→", e["end"], e["label"], f"| {len(e['sensors'])} :", ",".join(e["sensors"][:8]), "|", e["text"])