314 lines
19 KiB
Python
314 lines
19 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. Un jour incomplet (au moins
|
||
PARTIEL heures, moins de 20) n'entre pas dans le profil, mais sa ressemblance se mesure sur les heures qu'il a : un
|
||
trou d'une demi-journée ne lui ôte plus son épisode (/detector-learner Thermal displacement, modification 1, S4 ;
|
||
à HEURES_MIN = 12 ou 16, les jours incomplets faussaient le profil, NIEDERHORN reculait).
|
||
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 » du départ à l'heure du plus grand écart au niveau de nuit (le pic), puis « Thermal
|
||
contraction » jusqu'au retour. Les heures chaudes disent qu'il y a un cycle ; ses bornes se lisent plus bas, à BORD
|
||
fois l'amplitude : le départ, en remontant du pic tant que l'écart reste ≥ BORD (au plus jusqu'à l'heure la plus
|
||
calme du profil) ; le retour, en descendant du pic jusqu'à ce qu'il repasse sous BORD, après minuit s'il le faut, au
|
||
plus jusqu'au départ du lendemain : un retour lent la nuit enchaîne les cycles (/detector-learner Thermal
|
||
displacement, modification 1, S1 : avant, la vague s'arrêtait à la dernière heure chaude, le soir et la nuit
|
||
manquaient). 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.
|
||
La caméra bouge avec le froid (/detector-learner Thermal displacement, modification 1, S3) : faute de cycle, aussi un
|
||
« Camera thermal movement » là où la pose de la caméra (tilt, rotation ou échelle) s'écarte de sa médiane du jour d'avant
|
||
d'au moins FROID bruits, pendant que la température de la station (detect la déclare, D-124) tombe sous la sienne d'au
|
||
moins FROID bruits la même heure ; bruit : la médiane des variations sur une heure (sur un pas, à une mesure toutes les
|
||
4 h), pour que le seuil ne dépende pas de la cadence. Les cibles peuvent s'écarter en sens opposés ou rester presque
|
||
immobiles (la compensation absorbe le mouvement) : la règle des glissades ne le voit pas. Les instants qui se suivent dans
|
||
la pose font un épisode. Sans pose ou sans température, rien. FROID = 3 prenait plus d'instants Displacement de NEBRASKA
|
||
et de MICHIGAN ; la chaleur n'est pas prise : par beau temps, c'est le cycle du jour.
|
||
"""
|
||
import math
|
||
import os
|
||
import statistics
|
||
import sys
|
||
from datetime import datetime, timedelta, timezone
|
||
|
||
sys.path.insert(0, os.path.dirname(os.path.abspath(__file__))) # donnees.py, à côté
|
||
from donnees import charger, iso # noqa: E402
|
||
|
||
HEURES_MIN = 20 # provisoire : un jour UTC compte dans le profil s'il a au moins 20 heures mesurées
|
||
PARTIEL = 12 # provisoire : un jour incomplet d'au moins 12 heures reçoit son épisode s'il ressemble au profil
|
||
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)
|
||
BORD = 0.1 # provisoire : bornes de la vague (départ, retour), en part de l'amplitude ; CHAUD dit s'il y a un cycle
|
||
ECART = 3 # provisoire : glissade commune, en bruits (médiane des pas) d'écart à la médiane du jour d'avant
|
||
FROID = 4 # provisoire : la caméra bouge avec le froid, en bruits d'une heure d'écart au jour d'avant (pose, température)
|
||
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, tous = {}, {}
|
||
for d, hs in jours.items():
|
||
if len(hs) >= PARTIEL:
|
||
med = statistics.median(v for l in hs.values() for v in l)
|
||
tous[d] = {h: statistics.mean(l) - med for h, l in hs.items()}
|
||
if len(hs) >= HEURES_MIN:
|
||
J[d] = tous[d]
|
||
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 tous.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)]
|
||
if len(hs) >= 3:
|
||
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, temperature=(), camera=()):
|
||
"""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) ; sinon, les glissades de la caméra (avec le froid)."""
|
||
return (_episodes(mesures, ("corr_x", "corr_y"), "Thermal", False) or
|
||
_episodes(mesures, ("x", "y"), "Camera thermal", True) or glissades(mesures, temperature, camera))
|
||
|
||
|
||
def _signes(ms, col, heure=False, seuil=None):
|
||
"""{instant: +1 ou -1} où la mesure s'écarte d'au moins ECART bruits de la médiane du jour d'avant ; bruit : la
|
||
médiane des pas d'une mesure à la suivante, ou, heure, des variations sur une heure (un pas si la cadence est lente)."""
|
||
k = [(m["t"], m[col]) for m in ms if m[col] is not None]
|
||
if len(k) < 3:
|
||
return {}
|
||
pas = statistics.median((b - a).total_seconds() for (a, _), (b, _) in zip(k, k[1:])) if heure else 0
|
||
n = max(1, round(3600 / pas)) if pas else 1
|
||
bruit = statistics.median(abs(k[i + n][1] - k[i][1]) for i in range(len(k) - n)) if len(k) > n else 0
|
||
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)) >= (seuil or 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 _froid(mesures, temperature, camera):
|
||
"""[(début, fin)] des suites d'instants où la pose de la caméra (tilt, rotation ou échelle) s'écarte de son jour
|
||
d'avant pendant que la température tombe sous le sien, d'au moins FROID bruits d'une heure ; vide sans l'une d'elles."""
|
||
ts = [m["t"] for ms in mesures.values() for m in ms]
|
||
heure = lambda t: t.replace(minute=0, second=0, microsecond=0) # noqa: E731
|
||
froid = {heure(t) for t, x in _signes([{"t": t, "T": v} for t, v in temperature], "T", True, FROID).items() if x < 0}
|
||
pose = [p for p in camera if min(ts) <= p["t"] <= max(ts)] if ts else []
|
||
vus = {t for c in ("tilt", "rotation", "scale") for t in _signes(pose, c, True, FROID) if heure(t) in froid}
|
||
episodes = [] # les instants qui se suivent dans la pose font un épisode
|
||
for i, p in enumerate(pose):
|
||
if p["t"] in vus:
|
||
if episodes and episodes[-1][2] == i - 1:
|
||
episodes[-1][1:] = [p["t"], i]
|
||
else:
|
||
episodes.append([p["t"], p["t"], i])
|
||
return [(a, b) for a, b, _ in episodes]
|
||
|
||
|
||
def glissades(mesures, temperature=(), camera=()):
|
||
"""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 ;
|
||
ou la pose de la caméra s'en écarte avec le froid (_froid)."""
|
||
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 + _froid(mesures, temperature, camera)]
|
||
|
||
|
||
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
|
||
repos = min(range(24), key=lambda h: e[h])
|
||
a = pic # départ : on remonte du pic tant que le profil reste au-dessus de BORD, jusqu'à l'heure la plus calme
|
||
while (a - 1) % 24 != repos and e[(a - 1) % 24] >= BORD:
|
||
a -= 1
|
||
b = pic + 1 # retour : jusqu'à ce que le profil repasse sous BORD, au plus jusqu'au départ suivant
|
||
while b < a + 24 and e[b % 24] >= BORD:
|
||
b += 1
|
||
derniere = max(m["t"] for ms in mesures.values() for m in ms)
|
||
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 d'au moins PARTIEL heures, 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, u, v in ((f"{nom} expansion", a, pic), (f"{nom} contraction", pic, b)):
|
||
debut, fin = minuit + timedelta(hours=u), min(minuit + timedelta(hours=v), derniere)
|
||
if fin > debut:
|
||
episodes.append({"start": iso(debut), "end": iso(fin),
|
||
"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)}")
|