Self-contained sub-project API/: a local support page where Marc pastes a client's mail; a support agent and an analyst agent stay alive for the session and produce a slide PDF that answers the client's question. Tools, detectors, knowledge and Typst brand are copied (API/PROVENANCE.md). First real case: Crissier (LENZSPITZE), workflow validated. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
261 lines
15 KiB
Python
261 lines
15 KiB
Python
"""Journal du matin : le détecteur de la famille Thermal displacement (labeling/familles.md) : 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, E-002) | 2/18, rien | 18/19, 1,8 px, 06-18 h |
|
||
| WILDSTRUBEL (E-003) | 3/7, rien | 6/7, 3,2 px, 04-08 h |
|
||
| CLARIDEN (E-004) | 1/24, rien | 1/24, aucun cycle |
|
||
| NIEDERHORN (E-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 (E-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.
|
||
Glissade commune, sans cycle (boucle /detector-learner MICHIGAN, modification 1) : faute de cycle dans les courbes
|
||
corrigées comme dans les positions brutes, un instant est une glissade de la caméra si les positions brutes (x ou y) d'au
|
||
moins PART des capteurs, références comprises, **et** les courbes corrigées (corr_x ou corr_y) d'au moins PART des cibles
|
||
s'écartent du même côté d'au moins ECART bruits (médiane des pas de la série) de leur médiane du jour d'avant ; les
|
||
glissades à moins d'un jour l'une de l'autre font un épisode, « Camera thermal movement », sur tous les capteurs, hôte
|
||
des sauts revenus (categories.HOTES). La caméra bouge avec la température sans revenir chaque jour à la même heure (une
|
||
mesure toutes les 4 h, refroidissements brefs), et la compensation ne l'enlève pas toute. La condition sur les positions
|
||
brutes laisse aux sauts une bascule de la seule pose calculée (positions brutes immobiles). MICHIGAN : 9 épisodes du 09
|
||
au 30.10, tous dans la dérive thermique étiquetée ; NEBRASKA : 13 instants, tous justes ; BREITHORN, JUNGFRAU, NORDEND,
|
||
WILDSTRUBEL inchangés (cycle trouvé, ou rien) ; ECART = 2 prenait 2 instants Displacement de BREITHORN.
|
||
"""
|
||
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 (E-005) n'a qu'une heure chaude (midi)
|
||
ECART = 3 # provisoire : glissade commune, en bruits (médiane des pas) d'écart à la médiane du jour d'avant
|
||
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) or glissades(mesures))
|
||
|
||
|
||
def _signes(ms, col):
|
||
"""{instant: +1 ou -1} où la mesure s'écarte d'au moins ECART bruits de la médiane du jour d'avant."""
|
||
k = [(m["t"], m[col]) for m in ms if m[col] is not None]
|
||
if len(k) < 3:
|
||
return {}
|
||
bruit = statistics.median(abs(b - a) for (_, a), (_, b) in zip(k, k[1:]))
|
||
out, j = {}, 0
|
||
for i, (t, v) in enumerate(k):
|
||
while k[j][0] < t - timedelta(days=1):
|
||
j += 1
|
||
avant = [w for _, w in k[j:i]]
|
||
if bruit and len(avant) >= 3 and abs(v - statistics.median(avant)) >= ECART * bruit:
|
||
out[t] = 1 if v > statistics.median(avant) else -1
|
||
return out
|
||
|
||
|
||
def _communs(series):
|
||
"""[{instant: signe}] d'un groupe de capteurs -> instants où au moins PART d'entre eux s'écartent du même côté."""
|
||
n, compte = len(series), {}
|
||
for sg in series:
|
||
for t, x in sg.items():
|
||
compte.setdefault((t, x), 0)
|
||
compte[(t, x)] += 1
|
||
return {t for (t, x), c in compte.items() if n and c >= PART * n}
|
||
|
||
|
||
def glissades(mesures):
|
||
"""Glissade commune de la caméra, sans cycle de 24 h : les positions brutes de la plupart des capteurs, références
|
||
comprises, et les courbes corrigées de la plupart des cibles s'écartent ensemble, du même côté, de leur jour d'avant."""
|
||
cibles = [ms for ms in mesures.values() if ms[0]["pattern_type"] != "global_ref"]
|
||
brut = set().union(*(_communs([_signes(ms, c) for ms in mesures.values()]) for c in ("x", "y")))
|
||
corr = set().union(*(_communs([_signes(ms, c) for ms in cibles]) for c in ("corr_x", "corr_y")))
|
||
episodes = []
|
||
for t in sorted(brut & corr):
|
||
if episodes and t - episodes[-1][1] <= timedelta(days=1): # moins d'un jour entre deux : la même glissade
|
||
episodes[-1][1] = t
|
||
else:
|
||
episodes.append([t, t])
|
||
return [{"start": iso(a), "end": iso(b), "kind": "Thermal displacement", "label": "Camera thermal movement",
|
||
"text": "The camera moved with a change of temperature and all the curves moved with it; this is not a "
|
||
"movement of the structure, nothing to do.", "ignore": False, "sensors": sorted(mesures)}
|
||
for a, b in episodes]
|
||
|
||
|
||
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": "Thermal displacement", "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)}")
|