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>
356 lines
25 KiB
Python
356 lines
25 KiB
Python
"""Journal du matin : le détecteur de la famille Displacement (labeling/familles.md) : les sauts brutaux de corr_x /
|
||
corr_y (px) de chaque cible, à la cadence native de l'export « advanced », et la dérive lente (en fin de fichier). Une
|
||
cible qui bascule (« Target flipping ») est de la famille Target issue : episodes() la rend, detect() la laisse à
|
||
target_issue.py.
|
||
|
||
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 (une heure de mesures de suite à moins de la moitié du saut : BASE à 15 min, une seule à 4 h, boucle
|
||
/detector-learner MICHIGAN, modification 1) 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é ; sa cause n'est pas
|
||
établie ici (categories.py lui donne celle de la catégorie qui le chevauche, sinon : à vérifier sur les images).
|
||
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) :
|
||
- E-001 PS des Coudres : rien (vérité : rien côté sauts).
|
||
- E-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).
|
||
- E-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.
|
||
- E-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.
|
||
- E-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é ; E-002, E-005 : pics absorbés par la toile et les trains ; E-004 : les pics du
|
||
mouvement (19/09 06:30, 06:50) restent dans le « Lasting shift » ; E-001, E-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 ; E-001 à E-003, E-005 à E-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 » (Target issue, 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é) ; E-001 : rien (cibles saines à 6 variations ordinaires au plus) ;
|
||
E-004 : le mouvement du 19/09 couvre deux fois plus de mesures à vérifier ; les autres events 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 E-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits) ; les trains de
|
||
# E-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 ; E-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 (E-002 : paliers jusqu'à 11 h 30)
|
||
BASCULE = timedelta(hours=6) # provisoire : une cible à problème bascule des heures (PR_BG : 2,5 jours) ; en moins,
|
||
# c'est un matin agité (E-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 ; E-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 (E-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:]))
|
||
pas = statistics.median(b - a for a, b in zip(t, t[1:])) # cadence de la série
|
||
retour = max(1, min(BASE, round(timedelta(hours=1) / pas))) # mesures d'une heure (BASE à 15 min, une à 4 h)
|
||
# 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 : une heure de 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 + retour])), 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 episodes(mesures):
|
||
"""{capteur: [mesure]} (donnees.charger) -> épisodes des sauts, triés par début : Displacement, et Target issue pour
|
||
une cible qui bascule."""
|
||
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 à problème
|
||
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 » (Target issue, 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": "Target issue", "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: the cause is not established, look at the images."
|
||
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": "Displacement", "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)
|
||
|
||
|
||
def detect(mesures):
|
||
return sorted([e for e in episodes(mesures) if e["kind"] == "Displacement"] + derive(mesures), key=lambda ep: ep["start"])
|
||
|
||
|
||
# --- Dérive lente ---------------------------------------------------------------------------------------------------
|
||
# Dérive lente : une cible qui bouge peu à peu, jour après jour.
|
||
#
|
||
# 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 sur 24, en part des heures
|
||
# que la station mesure (boucle /detector-learner MICHIGAN, modification 1 : à une mesure toutes les 4 h, 5 des 6
|
||
# heures ; avant, aucun jour ne comptait) ; 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é.
|
||
# 4 bis. Par morceaux (/detector-learner Displacement, modification 1, S1) : une cible sans dérive sur toute la fenêtre
|
||
# peut dériver quelques jours, puis se poser ou repartir en arrière. Sur chaque suite d'au moins JOURS jours retenus,
|
||
# dérive = niveau du dernier jour moins celui du premier, au moins MORCEAU amplitudes du jour (médiane de la série),
|
||
# |tau| ≥ REGULIER du même signe, aucun pas d'un jour retenu au suivant de plus de la moitié de la dérive ; les
|
||
# morceaux pris de la plus grande dérive à la plus petite, sans se chevaucher (ils peuvent partager le jour où le
|
||
# niveau tourne) : chacun va d'un extrême du niveau à l'autre, un épisode par morceau et par axe. À MORCEAU = 1, les
|
||
# cycles thermiques de quelques jours et le bruit des niveaux passent (JUNGFRAU, NORDEND) : 3,5 garde les rangées de
|
||
# CLARIDEN (3,8 à 8,3 amplitudes), écarte JUNGFRAU (3,1 au plus). Les morceaux ne remplacent pas l'étape 3 : à leur
|
||
# place, la fin des dérives de MICHIGAN et ce que couvraient les tendances de WILDSTRUBEL étaient perdus.
|
||
# Un morceau ne franchit pas un trou : deux jours retenus qui se suivent sont à TROU jours au plus l'un de l'autre
|
||
# (modification 2, remarque 1 du contrôle : l'écart d'un niveau à travers trois jours sans mesure est un pas, pas une
|
||
# pente ; il faisait des morceaux de toute la fenêtre, CLARIDEN 09-28 → 11-01). Un jour manquant ne coupe pas.
|
||
# 5. Dérive de la caméra (même modification) : au moins GROS des cibles dérivent du même côté sur corr_x ou corr_y, et au
|
||
# moins GROS des capteurs, références comprises, sur leurs positions brutes x ou y : seuls les morceaux du point 4 bis
|
||
# sont signalés, pas la tendance de toute la fenêtre (/detector-learner Displacement, modification 1, S2 : la caméra
|
||
# mal compensée qui dérive, NEBRASKA, est un Displacement pour les étiquettes ; avant, rien n'était signalé). Les
|
||
# cibles d'un pont qui suivent la saison (JUNGFRAU, étiquetées Thermal displacement jour après jour) passent l'étape 3
|
||
# mais pas MORCEAU ; NEBRASKA les deux. BREITHORN (5 capteurs sur 16 en x comme en y) et MICHIGAN ne sont pas
|
||
# concernées.
|
||
HEURES = 20 # un jour compte s'il a au moins 20 heures mesurées sur 24 (comme D-055), en part des heures mesurées
|
||
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)
|
||
MORCEAU = 3.5 # dérive par morceaux ≥ MORCEAU amplitudes journalières (point 4 bis)
|
||
TROU = 2 # un morceau ne passe pas d'un jour retenu au suivant à plus de TROU jours (point 4 bis)
|
||
|
||
|
||
def _decile(vs, q):
|
||
vs = sorted(vs)
|
||
return vs[min(len(vs) - 1, int(q * len(vs)))]
|
||
|
||
|
||
def _jours(ms, col):
|
||
"""-> {jour UTC: ses mesures}, les jours retenus (point 1)."""
|
||
jours = {}
|
||
for m in ms:
|
||
if m[col] is not None:
|
||
jours.setdefault(m["t"].date(), []).append(m)
|
||
creneaux = len({m["t"].hour for js in jours.values() for m in js}) # heures que la station mesure (6 à 4 h de pas)
|
||
return {d: js for d, js in jours.items() if len({m["t"].hour for m in js}) >= HEURES / 24 * creneaux}
|
||
|
||
|
||
def _derive(ms, col):
|
||
"""-> (dérive en px, jours, premier instant, dernier) ou None."""
|
||
jours = _jours(ms, col)
|
||
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 _morceaux(ms, col):
|
||
"""-> [(dérive en px, jours, premier instant, dernier)] : les morceaux de dérive (point 4 bis)."""
|
||
jours = _jours(ms, col)
|
||
if len(jours) < JOURS:
|
||
return []
|
||
ds = sorted(jours)
|
||
niv = [statistics.median(m[col] for m in jours[d]) for d in ds]
|
||
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())
|
||
morceaux = [] # (dérive, i, j)
|
||
for i in range(len(ds)):
|
||
signes = pas = 0
|
||
for j in range(i + 1, len(ds)):
|
||
if (ds[j] - ds[j - 1]).days > TROU:
|
||
break # un écart à travers un trou est un pas (le détecteur des sauts le prend), pas une pente
|
||
signes += sum((niv[j] > niv[k]) - (niv[j] < niv[k]) for k in range(i, j)) # tau de Kendall, pas à pas
|
||
pas = max(pas, abs(niv[j] - niv[j - 1]))
|
||
n, d = j - i + 1, niv[j] - niv[i]
|
||
if n >= JOURS and d and abs(d) >= MORCEAU * ampl and pas <= abs(d) / 2 \
|
||
and signes * (1 if d > 0 else -1) >= REGULIER * n * (n - 1) / 2:
|
||
morceaux.append((d, i, j))
|
||
pris = []
|
||
for d, i, j in sorted(morceaux, key=lambda x: (-abs(x[0]), x[2] - x[1])):
|
||
if all(j <= a or i >= b for _, a, b in pris):
|
||
pris.append((d, i, j))
|
||
return [(d, j - i + 1, min(m["t"] for m in jours[ds[i]]), max(m["t"] for m in jours[ds[j]])) for d, i, j in pris]
|
||
|
||
|
||
def _commune(mesures, cols):
|
||
"""Au moins GROS des capteurs dérivent du même côté sur un même axe de cols."""
|
||
for col in cols:
|
||
signes = [x[0] > 0 for ms in mesures.values() if (x := _derive(ms, col))]
|
||
if max(signes.count(True), signes.count(False)) >= GROS * len(mesures):
|
||
return True
|
||
return False
|
||
|
||
|
||
def derive(mesures):
|
||
cibles = {s: ms for s, ms in mesures.items() if not donnees.est_reference(ms)}
|
||
camera = _commune(cibles, ("corr_x", "corr_y")) and _commune(mesures, ("x", "y")) # point 5 : morceaux seuls
|
||
out = []
|
||
for s, ms in sorted(mesures.items()):
|
||
if donnees.est_reference(ms):
|
||
continue
|
||
r = [] if camera else [x for col in ("corr_x", "corr_y") if (x := _derive(ms, col))]
|
||
r = [max(r, key=lambda x: abs(x[0]))] if r else [x for col in ("corr_x", "corr_y") for x in _morceaux(ms, col)]
|
||
out += [{"start": donnees.iso(a), "end": donnees.iso(b), "kind": "Displacement", "label": "Slow drift",
|
||
"text": f"{s} drifts slowly and steadily: {derive:+.2f} px in {n} days. Keep watching it.",
|
||
"ignore": False, "sensors": [s]} for derive, n, a, b in r]
|
||
return out
|
||
|
||
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"])
|