Grade visibility, add the periodic effect and the slow drift to the morning journal (D-056)
- Visibility: v0 kept after a measured trial of a simpler version (archived); two levels, Reduced and No visibility - Thermal: a 24-hour sinusoid confirms the daily wave, split into thermal expansion and contraction events - Jumps tested from the first measurement; turbulence never kept over a shift to check (CLARIDEN) - Data gaps say whether camera images exist; Displacements trends become slow drift events - Threshold registry moved to vues-deplacements/contexte/seuils-du-journal.md; plan points 11 to 17, 38 and 41 validated Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
4ac95ae1ca
commit
86547f089b
16 files changed
+475
-143
No files matched your search
@@ -18,7 +18,7 @@ Le code et les maquettes du chantier vivent dans `maquette/` (D-053, D-054) : `e
|
||||
|
||||
Détection mécanique des anomalies (D-055) : faire ressortir les courbes qui comptent, sans toucher aux données : les sauts (décalage soudain qui dure) et les tendances (hausse ou baisse lente), ce que regarde le client ; onglet `Displacements` de la maquette ; idée, méthode, résultats et pistes dans `contexte/detection-d-anomalies.md`, savoir métier dans `docs/displacement/domaine/ce-que-regarde-le-client.md`.
|
||||
|
||||
Journal du matin du client (D-056), le cap actuel : onglet `Journal` de la maquette ; un détecteur élémentaire par fichier dans `journal/` (`detect(mesures)` -> épisodes `start`, `end`, `kind`, `label`, `text`, `ignore`, `sensors`), chargés et classés en événements des huit catégories du journal par `journal/categories.py` (`python3 vues-deplacements/journal/categories.py <dossier>` : une ligne par événement), que `explore.py` affiche ; brainstorming et pistes dans `contexte/journal-du-matin.md`, lissage dans `contexte/lissage.md`, données en masse et boucle Claude dans `contexte/donnees-et-boucle.md`.
|
||||
Journal du matin du client (D-056), le cap actuel : onglet `Journal` de la maquette ; un détecteur élémentaire par fichier dans `journal/` (`detect(mesures)` -> épisodes `start`, `end`, `kind`, `label`, `text`, `ignore`, `sensors`), chargés et classés en événements des huit catégories du journal par `journal/categories.py` (`python3 vues-deplacements/journal/categories.py <dossier>` : une ligne par événement), que `explore.py` affiche ; brainstorming et pistes dans `contexte/journal-du-matin.md`, registre des seuils provisoires dans `contexte/seuils-du-journal.md`, lissage dans `contexte/lissage.md`, données en masse et boucle Claude dans `contexte/donnees-et-boucle.md`.
|
||||
|
||||
## Règles
|
||||
|
||||
|
||||
@@ -88,3 +88,7 @@ Un orchestrateur (la conversation principale) et un agent par piste, qui rapport
|
||||
## Page Journal simplifiée (point 8 du plan, 2026-10-24)
|
||||
|
||||
- Frise d'une seule ligne « What happened » et journal en cartes : validé, mais l'utilisateur n'est « pas entièrement satisfait » ; on pourrait **déplier** au lieu de tout mettre sur une même ligne (point 40 du plan).
|
||||
## Cycle thermique et effet périodique (point 13 du plan, 2026-10-24)
|
||||
|
||||
- Des ouvrages bougent beaucoup le jour par dilatation thermique et redescendent la nuit : de grosses vagues, tout à fait normales (l'utilisateur ne se souvient plus du projet qui le montrait).
|
||||
- Idée de l'utilisateur : un « effet périodique » qui explique ces anomalies ; la vague est un événement de dilatation ou de contraction thermique ; le reconnaître en ajustant une sinusoïde de 24 h (ou un polynôme en vague) : si elle colle, l'événement est cyclique, calqué sur le jour et la nuit. Point 41 du plan ; note `docs/displacement/domaine/cycle-thermique.md`.
|
||||
@@ -0,0 +1,44 @@
|
||||
# Seuils du journal du matin : le registre
|
||||
|
||||
Tous les seuils des détecteurs du journal (`vues-deplacements/journal/`) sont **provisoires** : réglés sur les six jeux des cas C-001 à C-005 et de NORDEND d'octobre. Quand les données en masse arriveront (partie VI du plan `docs/superpowers/plans/2026-10-23-journal-du-matin.md`), c'est la liste à revoir. Une constante ajoutée ou changée met à jour ce fichier dans le même changement. Contrôle : `grep -nE "^[A-Z_0-9]+ = " vues-deplacements/journal/*.py`.
|
||||
|
||||
Registre au 2026-10-24 (point 17 du plan), vérifié contre le code.
|
||||
|
||||
| Détecteur | Constante | Valeur | Réglée sur |
|
||||
|---|---|---|---|
|
||||
| `visibilite` | `K_MAD` | 10 | C-001 (buée 11 à 57 MAD), C-005 (10 à 70 MAD) |
|
||||
| | `FACTEUR` | 2 | écarte les capteurs à MAD quasi nulle (C-004, C-005) |
|
||||
| | `SUITE_MIN` | 3 | C-001, pluie de C-005 |
|
||||
| | `BREF_MIN` | 3 | trains de C-005 (5 à 17 capteurs) |
|
||||
| | `SAILLIE` | 3 | trains (5 à 17) contre toile de C-002 (2 à 9) |
|
||||
| | `FRAC` | 0,15 | queues de PR09 et CTR01 (NORDEND octobre) |
|
||||
| | `COUPURE` | 2 h | NORDEND octobre, nuit du 13 au 14 |
|
||||
| | `K_CIBLE` | 5 | feuilles de C-005 (6 à 25 MAD) |
|
||||
| | `CIBLE_MIN` | 3 | — |
|
||||
| | `CIBLE_ECART` | 6 h | feuilles de C-005 (7 rejets en 12 h) |
|
||||
| | `ECART` | 2,5 pas | gigue des horodatages |
|
||||
| | `MOITIE` | 0,5 | niveau « none » (point 38) : NORDEND 09/10 23:00 (68 % rejetées) contre pluie de C-005 (24 à 33 %) |
|
||||
| `sauts` | `K` | 20 bruits | C-001 (à 15, deux cibles saines grisées) ; ne pas baisser pour les trains, vus par `visibilite` (point 12) |
|
||||
| | `BASE` | 4 mesures | 1 h à 15 min |
|
||||
| | `GAP` | 1 h | — |
|
||||
| | `BACK_H` | 24 h | C-002 (paliers jusqu'à 11 h 30) |
|
||||
| `thermique` | `HEURES_MIN` | 20 h | — |
|
||||
| | `REPRO` | 0,6 | bruit pur ≈ 0 |
|
||||
| | `PART` | 0,5 | NORDEND octobre juste dessous (9/19), laissé dessous (point 13) |
|
||||
| | `CHAUD` | 0,3 | — |
|
||||
| | `JOUR` | 0,5 | — |
|
||||
| | `NUIT` | 8 h | — |
|
||||
| | `R2_MIN` | 0,3 | sinusoïde de 24 h (point 41) : PS des Coudres 14 axes sur 22 au-dessus, CLARIDEN 0 sur 48 |
|
||||
| `turbulence` | `RATIO` | 1,5 | C-003 (×1,7 à ×3 la nuit) |
|
||||
| | `PART` | 0,5 | — |
|
||||
| | `RATIO_ERR` | 1,5 | C-003 (×1,7 à ×3,2) |
|
||||
| | `REJET_MAX` | 15 % | C-003 ≤ 7 % ; toile et pluie ≥ 18 % |
|
||||
| | `FORT` | 2× | C-003 (×2,3 à ×2,6) |
|
||||
| | `DUREE_MIN` | 3 h | C-003 (10-11 h) contre matin de C-004 (2 h) ; le classement écarte aussi ce matin, quelle que soit la durée (point 14) |
|
||||
| `trous` | `MISSING` | 2 pas | consigne de l'utilisateur, 2026-10-23 |
|
||||
| `categories` (classement) | `MERGE` | 1 h | règle validée par l'utilisateur (point 5) : même catégorie à moins d'une heure, un seul événement |
|
||||
| dérive lente (`explore.py`, onglet Displacements, D-055) | `TREND_DAYS` | 5 jours | une tendance demande au moins 5 jours UTC |
|
||||
| | `TREND_SIZE` | 1 | dérive sur la période ≥ une amplitude journalière |
|
||||
| | `TREND_STEADY` | 0,6 | tau de Kendall des niveaux journaliers |
|
||||
|
||||
Essais archivés (`vues-deplacements/journal/archive/`) : la version simple de `visibilite` (`NIVEAU` 0,2, `CIBLE_MIN` 3, `CIBLE_ECART` 6 h), écartée au point 11 ; ses constantes ne sont pas en service.
|
||||
@@ -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
|
||||
(journal/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 vues-deplacements/journal/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__)), "..", "..", "..", "agents", "diagnostic", "outils"))
|
||||
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]))
|
||||
@@ -3,7 +3,9 @@
|
||||
|
||||
Chaque épisode reçoit sa catégorie d'après son détecteur et son label. Un saut revenu à la normale qui chevauche une
|
||||
perte de visibilité, un passage ou une turbulence y est absorbé ; un saut qui dure ou trop récent pour savoir ne l'est
|
||||
jamais. Deux événements de même catégorie à moins d'une heure n'en font qu'un. Chaque événement reçoit sa phrase
|
||||
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.
|
||||
@@ -21,21 +23,27 @@ from donnees import charger # 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_perdue": {"label": "Loss of visibility", "ignore": True, "process": "images"},
|
||||
"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"},
|
||||
"turbulence": {"label": "Heat haze", "ignore": None, "process": "aucun"},
|
||||
"cycle_thermique": {"label": "Daily thermal cycle", "ignore": False, "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"},
|
||||
}
|
||||
# (détecteur, label de l'épisode) -> catégorie ; puis détecteur seul ; un détecteur inconnu garde son nom
|
||||
LABELS = {("visibilite", "Poor visibility"): "visibilite_perdue", ("visibilite", "Brief obstruction"): "passage",
|
||||
("visibilite", "Target obscured"): "cible_masquee", ("sauts", "Sudden jump, back to normal"): "saut_bref",
|
||||
("sauts", "Lasting shift"): "a_verifier", ("sauts", "Jump, not back yet"): "a_verifier"}
|
||||
KINDS = {"turbulence": "turbulence", "thermique": "cycle_thermique", "trous": "trou"}
|
||||
HOSTS = {"visibilite_perdue", "passage", "turbulence"} # ce qui absorbe un saut revenu à la normale (point 5)
|
||||
# (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",
|
||||
("thermique", "Thermal expansion", None): "dilatation_thermique",
|
||||
("thermique", "Thermal contraction", None): "contraction_thermique"}
|
||||
KINDS = {"turbulence": "turbulence", "trous": "trou"}
|
||||
HOSTS = {"visibilite_reduite", "visibilite_nulle", "passage", "turbulence"} # absorbent un saut revenu (point 5)
|
||||
MERGE = timedelta(hours=1) # même catégorie à moins d'une heure : un seul événement (point 5, 2026-10-24)
|
||||
|
||||
|
||||
@@ -59,7 +67,7 @@ def detecteurs():
|
||||
|
||||
|
||||
def categorie(ep):
|
||||
return LABELS.get((ep["kind"], ep["label"])) or KINDS.get(ep["kind"]) or ep["kind"]
|
||||
return LABELS.get((ep["kind"], ep["label"], ep.get("level"))) or KINDS.get(ep["kind"]) or ep["kind"]
|
||||
|
||||
|
||||
def overlap(a, b):
|
||||
@@ -77,16 +85,18 @@ def phrase(cat, groupe, sensors, references):
|
||||
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 ""
|
||||
text = {
|
||||
"visibilite_perdue": f"The camera could not see {targets(n)} clearly"
|
||||
f"{', including the reference targets' if references & set(sensors) else ''}. "
|
||||
"The curves in this period are not reliable: ignore them.",
|
||||
"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.",
|
||||
"cycle_thermique": "The structure and the camera warm up during the day and cool down at night. "
|
||||
"This wave comes back every day: nothing to do.",
|
||||
"dilatation_thermique": "The structure expands in the day heat. This daily wave is normal: nothing to do.",
|
||||
"contraction_thermique": "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()} 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
|
||||
@@ -104,7 +114,8 @@ def evenement(groupe, references):
|
||||
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"]))
|
||||
return {"start": min(e["start"] for e in groupe), "end": max(e["end"] for e in groupe), "category": cat,
|
||||
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}
|
||||
@@ -114,6 +125,8 @@ 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)]
|
||||
hosts = [e for e in eps if categorie(e) in HOSTS]
|
||||
host = {id(e): next((h for h in hosts if overlap(e, 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))}
|
||||
@@ -123,7 +136,8 @@ def classer(episodes, references=frozenset()):
|
||||
merged = []
|
||||
for g in groupes.values():
|
||||
prev = next((m for m in reversed(merged) if categorie(m[0]) == categorie(g[0])), None)
|
||||
if prev and datetime.fromisoformat(g[0]["start"]) - datetime.fromisoformat(max(e["end"] for e in prev)) < MERGE:
|
||||
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)
|
||||
|
||||
@@ -1,7 +1,8 @@
|
||||
"""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).
|
||||
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 :
|
||||
@@ -19,7 +20,9 @@ Résultats (2026-10-23, K = 20) :
|
||||
- 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 manqué (première mesure) ; feuilles, pluie : rien (error_value, pas des sauts).
|
||||
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é.
|
||||
@@ -32,7 +35,8 @@ from pathlib import Path
|
||||
sys.path.insert(0, str(Path(__file__).resolve().parents[2] / "agents" / "diagnostic" / "outils"))
|
||||
import donnees # noqa: E402
|
||||
|
||||
K = 20 # provisoire, réglé sur C-001 : à 15, deux cibles saines y sont grisées (17 et 18 bruits)
|
||||
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
|
||||
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)
|
||||
@@ -44,7 +48,10 @@ def _sauts(t, v):
|
||||
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)
|
||||
out, i = [], BASE # ponytail: les BASE premières mesures ne sont pas testées (train du 30/09 22:00 manqué)
|
||||
# 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 * noise:
|
||||
|
||||
@@ -1,14 +1,22 @@
|
||||
"""Journal du matin : cycle thermique jour / nuit (la vague quotidienne des déplacements corrigés).
|
||||
"""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é.
|
||||
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. Un épisode par jour complet, de la première à la dernière heure chaude, si ce jour ressemble aux autres
|
||||
(corrélation médiane ≥ 0,5 sur les axes concernés).
|
||||
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 |
|
||||
@@ -22,6 +30,7 @@ Résultats (2026-10-23 ; « cibles » = part des cibles concernées, amplitude =
|
||||
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.
|
||||
"""
|
||||
import math
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
@@ -36,6 +45,8 @@ PART = 0.5 # provisoire : part des cibles concernées ; 2026-10_NORDEND
|
||||
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
|
||||
W = 2 * math.pi / 86400 # pulsation d'un cycle de 24 h, en rad/s
|
||||
|
||||
|
||||
def _corr(a, b):
|
||||
@@ -69,6 +80,43 @@ def _axe(ms, col):
|
||||
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()
|
||||
@@ -85,12 +133,17 @@ def cycle(mesures, cols=("corr_x", "corr_y")):
|
||||
return concernes, len(cibles)
|
||||
|
||||
|
||||
def heures_chaudes(concernes):
|
||||
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 [h for h in range(24) if statistics.median(score(c[2], h) for c in concernes) >= CHAUD]
|
||||
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):
|
||||
@@ -98,31 +151,35 @@ def detect(mesures):
|
||||
capteurs = sorted({c[0] for c in concernes})
|
||||
if not n or len(capteurs) < PART * n:
|
||||
return []
|
||||
oui, evaluees = sinus(mesures)
|
||||
if not evaluees or len(oui) < PART * len(evaluees): # seconde méthode : la sinusoïde doit le voir aussi
|
||||
return []
|
||||
chaudes = heures_chaudes(concernes)
|
||||
if not chaudes:
|
||||
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]})
|
||||
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)
|
||||
episodes.append({
|
||||
"start": iso(minuit + timedelta(hours=chaudes[0])), "end": iso(minuit + timedelta(hours=chaudes[-1] + 1)),
|
||||
"kind": "thermique", "label": "Daily thermal cycle",
|
||||
"text": "The structure, the mast and the camera warm up during the day and move very slightly, "
|
||||
"then cool down in the evening: this wave comes back every day and is normal.",
|
||||
"ignore": False, "sensors": capteurs,
|
||||
})
|
||||
for label, a, b in (("Thermal expansion", chaudes[0], pic), ("Thermal 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 |", e["text"])
|
||||
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
|
||||
print(f"{cols[0][:-2] or 'brut'} : cibles {k}/{n}, amplitude médiane {amp:.3f} px, heures chaudes (UTC) {heures_chaudes(concernes) if concernes else '-'}")
|
||||
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)}")
|
||||
@@ -30,7 +30,8 @@ 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)
|
||||
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)
|
||||
|
||||
|
||||
|
||||
@@ -7,6 +7,11 @@ Méthode (seuils provisoires ci-dessous) :
|
||||
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.
|
||||
|
||||
Résultats (2026-10-23 ; vérité : agents/diagnostic/cas/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
|
||||
@@ -24,6 +29,11 @@ Résultats (2026-10-23 ; vérité : agents/diagnostic/cas/INDEX.md) :
|
||||
(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 09.10 18:45 et 12.10 14:15 ; Target obscured surtout CTR01, PR04, PR09
|
||||
(souvent rejetées) : à vérifier.
|
||||
|
||||
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
|
||||
@@ -45,6 +55,7 @@ COUPURE = timedelta(hours=2) # provisoire : accalmie qui sépare deux épisodes
|
||||
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)
|
||||
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):
|
||||
@@ -64,9 +75,21 @@ def _grouper(points, ecart):
|
||||
return groupes
|
||||
|
||||
|
||||
def _episode(debut, fin, label, text, capteurs):
|
||||
return {"start": iso(debut), "end": iso(fin), "kind": "visibilite", "label": label, "text": text,
|
||||
"ignore": True, "sensors": sorted(capteurs)}
|
||||
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):
|
||||
@@ -118,15 +141,16 @@ def detect(mesures):
|
||||
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]
|
||||
for a, b, cs in gardees:
|
||||
r = cs & refs
|
||||
if r:
|
||||
text = (f"{len(cs)} points, including {len(r)} of the {len(refs)} reference points, were poorly seen: probably rain, "
|
||||
"fog, condensation or something in front of the camera; all displacements in this period are unreliable.")
|
||||
else:
|
||||
text = (f"{len(cs)} targets were poorly seen, the reference points stayed clear: probably rain, fog or condensation; "
|
||||
"the displacements of these targets in this period are unreliable.")
|
||||
out.append(_episode(a, b, "Poor visibility", text, cs))
|
||||
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.
|
||||
|
||||
@@ -206,12 +206,24 @@ def build(folder):
|
||||
plateforme = Path(folder).resolve().parent / "plateforme"
|
||||
captures = {tab: [url(p) for n in prefixes for p in sorted(plateforme.glob(f"{n}_*"))[:1]]
|
||||
for tab, prefixes in CAPTURES.items()}
|
||||
journal = categories.evenements(mesures)
|
||||
for e in journal: # un trou de mesures : des images pendant disent que la caméra tournait (point 15 du plan)
|
||||
if e["category"] == "trou":
|
||||
n = sum(e["start"] < im["t"] < e["end"] for im in images)
|
||||
e["text"] += f" The camera still took {n} images in this period, so it was running." if n \
|
||||
else " There is no camera image for this period either."
|
||||
hr = hourly(files["horaire"][0]) if files["horaire"] else {"times": [], "sensors": {}}
|
||||
regime, trends = regime_changes(hr)
|
||||
for tr in trends: # dérive lente : les tendances de l'onglet Displacements (D-055), à vérifier (point 16 du plan)
|
||||
journal.append({"start": tr["levels"][0][0], "end": tr["levels"][-1][0], "category": "derive_lente",
|
||||
"label": "Slow drift", "text": f"{tr['target']} drifts slowly and steadily: {tr['drift']:+.1f} mm "
|
||||
f"in {len(tr['levels'])} days. Keep watching it.", "ignore": False, "sensors": [tr["target"]],
|
||||
"process": "aucun", "episodes": []})
|
||||
journal.sort(key=lambda e: e["start"])
|
||||
return {"platform": Path(files["advanced"][0]).name.split("_advanced_")[0], "times": [donnees.iso(t) for t in instants],
|
||||
"sensors": sensors, "images": images, "view": view, "captures": captures,
|
||||
"folder": Path(os.path.relpath(Path(folder).resolve(), ROOT)).as_posix(), # pour la demande à l'agent
|
||||
"hourly": hr, "regime": regime, "trends": trends, "journal": categories.evenements(mesures),
|
||||
"hourly": hr, "regime": regime, "trends": trends, "journal": journal,
|
||||
"rules": {"abrupt": ABRUPT, "size": SIZE, "trend_size": TREND_SIZE, "trend_days": TREND_DAYS}}
|
||||
|
||||
|
||||
|
||||
@@ -929,12 +929,16 @@ drawRegime();
|
||||
// ignorer grisées, une frise d'une seule ligne « What happened » (une barre par événement, sa catégorie dedans), puis le
|
||||
// journal de la plage visible, une carte par événement.
|
||||
const J = D.journal, J_ROW = "What happened";
|
||||
// une couleur par famille d'événement : gris-bleu ce qu'il faut ignorer (zone grisée), vert ce qui est normal, gris clair
|
||||
// l'absence de données, rouge ce qu'il faut vérifier
|
||||
const J_FAM = { ignore: "#6f8aa3", normal: "#2ca02c", gap: "#c8c8c8", check: "#d62728" };
|
||||
// ordre de dessin de la frise, de dessous à dessus : ce qui touche une cible, puis toute la scène, « Shift to check » en haut
|
||||
const J_ORDER = ["cible_masquee", "cycle_thermique", "turbulence", "trou", "visibilite_perdue", "passage", "saut_bref", "a_verifier"];
|
||||
const jFam = e => e.category === "a_verifier" ? "check" : e.category === "trou" ? "gap" : e.ignore ? "ignore" : "normal";
|
||||
// une couleur par famille d'événement : gris-bleu ce qu'il faut ignorer (zone grisée), orange les données moyennes
|
||||
// (visibilité réduite, zone en léger retrait), vert ce qui est normal (l'effet périodique), gris clair l'absence de données, rouge ce qu'il faut
|
||||
// vérifier
|
||||
const J_FAM = { ignore: "#6f8aa3", reduced: "#f0a030", normal: "#2ca02c", gap: "#c8c8c8", check: "#d62728" };
|
||||
// ordre de dessin de la frise, de dessous à dessus : la dérive lente (longue, des jours), ce qui touche une cible, puis
|
||||
// toute la scène, « Shift to check » en haut
|
||||
const J_ORDER = ["derive_lente", "cible_masquee", "dilatation_thermique", "contraction_thermique", "turbulence", "trou", "visibilite_reduite", "visibilite_nulle", "passage",
|
||||
"saut_bref", "a_verifier"];
|
||||
const jFam = e => ["a_verifier", "derive_lente"].includes(e.category) ? "check" : e.category === "trou" ? "gap"
|
||||
: e.category === "visibilite_reduite" ? "reduced" : e.ignore ? "ignore" : "normal";
|
||||
const MON = ["Jan", "Feb", "Mar", "Apr", "May", "Jun", "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"];
|
||||
const jWhen = t => `${MON[+t.slice(5, 7) - 1]} ${+t.slice(8, 10)}, ${t.slice(11, 16)}`;
|
||||
const plotT = ms => new Date(ms).toISOString().slice(0, 19).replace("T", " "); // instant en ms -> date Plotly (UTC)
|
||||
@@ -954,13 +958,15 @@ function drawJournal() {
|
||||
traces.push({ type: "bar", orientation: "h", yaxis: "y3", name: "events", showlegend: false,
|
||||
y: bars.map(() => J_ROW), base: bars.map(e => e.start), x: bars.map(e => jEnd(e) - Date.parse(e.start)),
|
||||
marker: { color: bars.map(e => J_FAM[jFam(e)]), line: { color: "#fff", width: 1 } },
|
||||
width: bars.map(e => e.category === "derive_lente" ? 0.2 : 0.75), // la dérive, longue, en trait fin sous les autres
|
||||
text: bars.map(e => covered(e) ? "" : e.label), textposition: "inside", insidetextanchor: "middle",
|
||||
insidetextfont: { color: bars.map(e => jFam(e) === "gap" ? "#333" : "#fff") }, customdata: bars.map(e => J.indexOf(e)),
|
||||
hovertext: bars.map(e => `<b>${e.label}</b><br>${e.text}<br>Sensors: ${e.sensors.length ? e.sensors.join(", ") : "all"}`),
|
||||
hovertemplate: "%{hovertext}<extra></extra>" });
|
||||
const C = 220, G = 24, F = 40, A = 2 * C + 2 * G + F; // hauteurs en px, A : zone tracée
|
||||
const grey = J.filter(e => e.ignore).flatMap(e => ["y domain", "y2 domain"].map(yref => ({ type: "rect", xref: "x", yref,
|
||||
x0: e.start, x1: plotT(jEnd(e)), y0: 0, y1: 1, fillcolor: "#888", opacity: 0.25, line: { width: 0 }, layer: "below" })));
|
||||
const grey = J.filter(e => e.ignore || jFam(e) === "reduced").flatMap(e => ["y domain", "y2 domain"].map(yref => ({ type: "rect",
|
||||
xref: "x", yref, x0: e.start, x1: plotT(jEnd(e)), y0: 0, y1: 1, fillcolor: "#888", opacity: e.ignore ? 0.25 : 0.1,
|
||||
line: { width: 0 }, layer: "below" }))); // grisé ; en léger retrait pour une visibilité réduite
|
||||
const end = Date.parse(D.times[D.times.length - 1]);
|
||||
Plotly.newPlot("j-curves", traces, {
|
||||
height: A + 70, margin: { l: 110, r: 10, t: 20, b: 50 }, barmode: "overlay", bargap: 0.25, uniformtext: { mode: "hide", minsize: 10 },
|
||||
|
||||
@@ -116,9 +116,9 @@ Le « journal du matin » du client (utilisateur, 2026-10-23) : il ouvre Explore
|
||||
- **Événements** (2026-10-24, point 6 du plan) : `categories.evenements(mesures)` classe les épisodes en événements des huit catégories du journal (`docs/displacement/domaine/carte-des-evenements.md`, section 4) : un saut revenu à la normale pendant une perte de visibilité, un passage ou une turbulence y est absorbé, un saut qui dure jamais ; même catégorie à moins d'une heure, un seul événement. Événement : `{start, end, category, label, text, ignore, sensors, process, episodes}` (`episodes` : les épisodes d'origine, le principal en tête) ; c'est ce que la page reçoit dans `D.journal`.
|
||||
- **`trous.py`** : les moments sans mesure, cadence de l'export rompue (plus de 2 pas manquants, cadence = écart médian), de la dernière mesure à la suivante ; label `No data`, pas grisé. Les autres (`visibilite`, `sauts`, `turbulence`, `thermique`) sont écrits à part.
|
||||
- **Courbes** : `Horizontal (px)` = `corr_x`, `Vertical (px)` = `corr_y` de l'export « advanced », cibles seules (`target` et `ref`, pas les `global_ref`), lignes fines, axe du temps partagé ; vue de départ : les 3 derniers jours (`#from=AAAA-MM-JJ` dans l'adresse la fait partir d'un autre jour, pour les captures) ; zoom à la molette ou au cadre sur toute la plage, double-clic pour tout voir ; ordonnées recalées sur la plage visible (D-013).
|
||||
- **Zones grisées** : un rectangle gris sur les deux courbes par épisode `ignore`.
|
||||
- **Frise** sous les courbes, même axe du temps (2026-10-24, point 8 du plan ; avant : une ligne par détecteur, puis par catégorie) : **une seule ligne**, « What happened », une barre par événement, sa catégorie dedans si elle tient (`uniformtext` : sinon cachée) ; couleur par famille (`J_FAM`) : gris-bleu ce qui est grisé, vert ce qui est normal (cycle thermique, turbulence faible), gris clair « No data », rouge « Shift to check ». Les barres sont dessinées par portée (`J_ORDER`) : ce qui touche une cible en dessous, ce qui touche toute la scène au-dessus, « Shift to check » tout en haut ; une barre perd son étiquette quand une barre dessinée par-dessus couvre son milieu ; liseré blanc entre les barres. Survol : catégorie, texte et capteurs. Un événement plus court qu'une heure est dessiné sur 1 h, sinon il serait invisible.
|
||||
- **Journal** : une carte par événement de la plage visible, dans l'ordre du temps, mise à jour à chaque zoom : bord gauche à la couleur de sa famille, date et heures UTC en petit, **catégorie en gras**, le texte (provisoire, point 9), le bouton `▶ Images` ; plus de liste de capteurs (elle reste au survol de la barre et viendra dans la couche support, point 23). `Nothing to report on this period.` sinon ; clic sur une carte : les courbes zooment sur l'événement, avec une marge (la moitié de sa durée, 2 h au moins).
|
||||
- **Zones grisées** : un rectangle gris sur les deux courbes par événement `ignore` ; un rectangle très clair (en léger retrait) pour « Reduced visibility », dont les données sont gardées (point 38).
|
||||
- **Frise** sous les courbes, même axe du temps (2026-10-24, point 8 du plan ; avant : une ligne par détecteur, puis par catégorie) : **une seule ligne**, « What happened », une barre par événement, sa catégorie dedans si elle tient (`uniformtext` : sinon cachée) ; couleur par famille (`J_FAM`) : gris-bleu ce qui est grisé, vert ce qui est normal (effet périodique : dilatation puis contraction thermiques ; turbulence faible), gris clair « No data », rouge « Shift to check » et « Slow drift » (la dérive, longue, en trait fin sous les autres barres, point 16), orange « Reduced visibility » (point 38). Les barres sont dessinées par portée (`J_ORDER`) : ce qui touche une cible en dessous, ce qui touche toute la scène au-dessus, « Shift to check » tout en haut ; une barre perd son étiquette quand une barre dessinée par-dessus couvre son milieu ; liseré blanc entre les barres. Survol : catégorie, texte et capteurs. Un événement plus court qu'une heure est dessiné sur 1 h, sinon il serait invisible.
|
||||
- **Journal** : une carte par événement de la plage visible, dans l'ordre du temps, mise à jour à chaque zoom : bord gauche à la couleur de sa famille, date et heures UTC en petit, **catégorie en gras**, le texte (provisoire, point 9), le bouton `▶ Images` ; plus de liste de capteurs (elle reste au survol de la barre et viendra dans la couche support, point 23). Un trou de données dit en plus s'il y a des images pendant (`explore.build`, point 15 : « The camera still took N images in this period, so it was running. » ou « There is no camera image for this period either. »). `Nothing to report on this period.` sinon ; clic sur une carte : les courbes zooment sur l'événement, avec une marge (la moitié de sa durée, 2 h au moins).
|
||||
- **Bouton `▶ Images`** (2026-10-24, point 7 du plan) : sur chaque entrée dont la catégorie a un processus d'images (toutes sauf turbulence, cycle thermique et trou), et au clic sur sa barre de la frise ; il ouvre une fenêtre par-dessus la page qui joue le timelapse des images de l'événement, de son début moins une marge à sa fin plus la marge (la moitié de la durée, 1 h au moins, 6 h au plus : `J_MARGIN`), pour encadrer l'événement de moments où tout va bien. Images recadrées sur les cibles (`D.view`, comme le zoom « Targets » de View), 4 par seconde (`J_FPS`), en boucle, une sur n au-delà de 60 (`J_MAX`) ; sous l'image, l'heure UTC, `Before` / `During` / `After` et le rang ; bord rouge pendant l'événement ; pause, image par image, `Close`, Échap ou clic à côté. Pas d'image dans la plage : bouton grisé et « No camera image for this period. ». Pas de fichier GIF : tout est joué dans la page. `#tab=journal&play=<n>` ouvre le timelapse de l'événement n au chargement, `&frame=<k>` l'arrête sur l'image k (captures). Vérifié par captures : NORDEND d'octobre le 14/10 (nuit à 04:30, aube grise à 05:45, jour à 07:15) ; PS des Coudres, nuit du 13/10 sans image (bouton grisé).
|
||||
- **Vérifié** par captures Chrome headless le 2026-10-23 (`#tab=journal`, `#tab=journal&from=2026-10-07`) : NORDEND (cas d'octobre) et NIEDERHORN (`data/NIEDERHORN/`), avec `trous`, `visibilite` et `sauts` ; courbes, zones grisées, frise, libellés, journal de la plage visible ; le trou de NORDEND (15/10 22:30 → 16/10 01:15) en barre `No data`.
|
||||
- **Pas encore vérifié** : le clic sur une entrée (zoom), le survol des barres, le zoom à la souris ; `turbulence` et `thermique` n'ont rien rendu sur ces deux cas.
|
||||
|
||||
Reference in new issue
Block a user