The reading tools leave agents/diagnostic/outils/ for a root folder of their own; paths updated in skills, agents, detectors, scripts, case fiches, support/, contexts and CLAUDE.md; graphique, vignettes and gif find the repo root one level up; history keeps old paths. Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
206 lines
11 KiB
Python
206 lines
11 KiB
Python
"""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)}")
|