195 lines
10 KiB
Python
195 lines
10 KiB
Python
"""Ce qui revient d'un jour à l'autre : niveau de chaque nuit, et jours superposés par heure du jour, pour l'agent de diagnostic.
|
|
|
|
Usage : .venv/bin/python agents/diagnostic/outils/jours.py data/PS_DES_COUDRES/ [--colonnes corr_x,corr_y,error_value]
|
|
[--nuit 20-3] [--k 5] [--jours 2] [--pas 15min] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
|
|
|
Mesures acceptées seulement : une mesure rejetée (error_value au-dessus du seuil) n'entre nulle part. Une « nuit » :
|
|
les heures --nuit H1-H2 (UTC, H1 inclus, H2 exclu, à cheval sur minuit si H1 > H2), datée du jour où elle commence ;
|
|
la nuit en cours au début de la fenêtre compte aussi (ses heures après minuit). Bruit propre du capteur : médiane des
|
|
écarts entre deux mesures consécutives sur la fenêtre. Pour chaque colonne de --colonnes :
|
|
1. Niveau de chaque nuit, par capteur : médiane, MAD et nombre de mesures ; puis, d'une nuit à la suivante, la
|
|
marche (différence des médianes, en unités et en bruits) et où elle se place : la suite des mesures de nuit des
|
|
deux nuits est coupée là où la somme des écarts absolus au niveau de la première nuit (avant) et de la seconde
|
|
(après) est la plus petite ; « entre A et B » : dernière mesure de nuit avant la coupure et première après (B en
|
|
début de nuit : la coupure tombe entre deux nuits, de jour).
|
|
2. Jours superposés : chaque mesure moins le niveau de la dernière nuit commencée à son instant (la précédente, ou
|
|
celle en cours ; sans elle, la nuit la plus proche). PNG « parheure-<colonne> » : un petit graphique par capteur,
|
|
en abscisse l'heure du jour (UTC), une courbe par jour, heures de nuit grisées, une échelle par capteur, cadrée du 1er au 99e centile élargi de moitié (le titre dit
|
|
combien de mesures sortent du cadre : un pic isolé n'écrase pas l'échelle ; sa valeur est dans les tables).
|
|
Table : par créneau de --pas de l'heure du jour, les capteurs dont l'écart dépasse --k bruits à ce créneau, du
|
|
même côté, au moins --jours jours différents, avec le nombre de ces jours sur le nombre de jours mesurés et la
|
|
médiane de ces écarts (signée, en unités et en bruits) ; un capteur au-dessus certains jours et au-dessous
|
|
d'autres est cité deux fois.
|
|
Rend des valeurs, pas de verdict.
|
|
"""
|
|
import argparse
|
|
import math
|
|
import os
|
|
import statistics
|
|
import sys
|
|
from datetime import timedelta
|
|
|
|
import matplotlib
|
|
|
|
matplotlib.use("Agg")
|
|
import matplotlib.pyplot as plt # noqa: E402
|
|
|
|
from donnees import charger, est_reference, filtrer, instant, iso, rejetee # noqa: E402
|
|
from graphique import COLONNES, RACINE, borne # noqa: E402
|
|
from resume import duree # noqa: E402
|
|
|
|
|
|
def heures(texte):
|
|
"""'20-3' -> (20, 3)."""
|
|
try:
|
|
h1, h2 = (int(x) for x in texte.split("-"))
|
|
except ValueError:
|
|
raise argparse.ArgumentTypeError(f"heures invalides : {texte!r} (ex. 20-3)")
|
|
return h1, h2
|
|
|
|
|
|
def de_nuit(t, h1, h2):
|
|
return (h1 <= t.hour or t.hour < h2) if h1 > h2 else h1 <= t.hour < h2
|
|
|
|
|
|
def coupure(pts, la, lb):
|
|
"""Indice j (1..n-1) où sum|v-la| avant j + sum|v-lb| à partir de j est le plus petit."""
|
|
avant, apres = 0.0, sum(abs(v - lb) for _, v in pts)
|
|
meilleur = None
|
|
for j in range(1, len(pts)):
|
|
v = pts[j - 1][1]
|
|
avant += abs(v - la)
|
|
apres -= abs(v - lb)
|
|
if meilleur is None or avant + apres < meilleur[0]:
|
|
meilleur = (avant + apres, j)
|
|
return meilleur[1]
|
|
|
|
|
|
def main():
|
|
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
a.add_argument("dossier")
|
|
a.add_argument("--colonnes", default="corr_x,corr_y,error_value")
|
|
a.add_argument("--nuit", default="20-3", type=heures, help="heures de nuit H1-H2, UTC (défaut 20-3)")
|
|
a.add_argument("--k", type=float, default=5, help="écart au niveau de la nuit compté, en bruits propres du capteur")
|
|
a.add_argument("--jours", type=int, default=2, help="nombre de jours à partir duquel un capteur est cité à un créneau")
|
|
a.add_argument("--pas", default="15min", type=duree, help="largeur des créneaux de l'heure du jour (défaut 15min)")
|
|
a.add_argument("--capteurs", help="liste séparée par des virgules (défaut : tous)")
|
|
a.add_argument("--debut", type=instant)
|
|
a.add_argument("--fin", type=instant)
|
|
a.add_argument("--sortie", default=os.path.join(RACINE, "out", "diagnostic"), help="dossier des PNG")
|
|
o = a.parse_args()
|
|
|
|
par = charger(o.dossier)
|
|
if not par:
|
|
sys.exit(f"Aucun export « advanced » dans {o.dossier} (voir inventaire.py).")
|
|
noms = o.capteurs.split(",") if o.capteurs else sorted(par, key=lambda s: (not est_reference(par[s]), s))
|
|
colonnes = o.colonnes.split(",")
|
|
for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes, COLONNES, "Colonnes")):
|
|
absents = [x for x in demandes if x not in connus]
|
|
if absents:
|
|
sys.exit(f"{quoi} inconnus : {', '.join(absents)}. Connus : {', '.join(sorted(connus))}.")
|
|
series = {s: [m for m in filtrer(par[s], o.debut, o.fin) if not rejetee(m)] for s in noms}
|
|
if not any(series.values()):
|
|
sys.exit("Aucune mesure acceptée dans la fenêtre demandée.")
|
|
h1, h2 = o.nuit
|
|
pas = int(o.pas.total_seconds() // 60)
|
|
station = os.path.basename(os.path.normpath(o.dossier))
|
|
os.makedirs(o.sortie, exist_ok=True)
|
|
lignes = math.ceil(len(noms) / 5)
|
|
|
|
for col in colonnes:
|
|
print(f"\n== {col} : niveau de chaque nuit ({h1} h → {h2} h UTC), médiane ±MAD (mesures) ; marches d'une nuit à la suivante ==")
|
|
creneaux = {} # minute du jour -> {(capteur, au-dessus): {jour: écart}}
|
|
bruits = {}
|
|
fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False)
|
|
for ax, s in zip(axes.flat, noms):
|
|
ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None]
|
|
if len(ms) < 2:
|
|
print(f"{s:9}(moins de 2 valeurs acceptées)")
|
|
ax.axis("off")
|
|
continue
|
|
bruit = bruits[s] = statistics.median(abs(b[1] - a_[1]) for a_, b in zip(ms, ms[1:]))
|
|
nuits = {}
|
|
for t, v in ms:
|
|
if de_nuit(t, h1, h2):
|
|
nuits.setdefault((t - timedelta(hours=h1)).date(), []).append((t, v))
|
|
niv = {d: statistics.median(v for _, v in p) for d, p in nuits.items()}
|
|
cases = []
|
|
for d in sorted(nuits):
|
|
vs = [v for _, v in nuits[d]]
|
|
cases.append(f"{d:%d/%m} {niv[d]:+.6g} ±{statistics.median(abs(v - niv[d]) for v in vs):.2g} ({len(vs)})")
|
|
print(f"{s:9}bruit {bruit:.3g} | " + (" | ".join(cases) if cases else "aucune mesure de nuit"))
|
|
jours = sorted(nuits)
|
|
for da, db in zip(jours, jours[1:]):
|
|
pts = nuits[da] + nuits[db]
|
|
j = coupure(pts, niv[da], niv[db])
|
|
d = niv[db] - niv[da]
|
|
enb = f"{d / bruit:+.1f}" if bruit else "-"
|
|
print(f"{'':9}{da:%d/%m} → {db:%d/%m} : {d:+.4g} ({enb} bruits), entre {iso(pts[j - 1][0])} et {iso(pts[j][0])}")
|
|
|
|
def niveau_de(t):
|
|
d = (t - timedelta(hours=h1)).date()
|
|
if d in niv:
|
|
return niv[d]
|
|
return niv[min(niv, key=lambda x: abs((x - d).days))] if niv else statistics.median(v for _, v in ms)
|
|
|
|
par_jour = {}
|
|
for t, v in ms:
|
|
e = v - niveau_de(t)
|
|
par_jour.setdefault(t.date(), []).append((t.hour + t.minute / 60, e))
|
|
if bruit and abs(e) > o.k * bruit:
|
|
c = (t.hour * 60 + t.minute) // pas * pas
|
|
creneaux.setdefault(c, {}).setdefault((s, e > 0), {})[t.date()] = e
|
|
for i, (d, p) in enumerate(sorted(par_jour.items())):
|
|
ax.plot([x for x, _ in p], [e for _, e in p], "-", lw=0.8, color=f"C{i % 10}", label=f"{d:%d/%m}")
|
|
ax.axhline(0, color="0.3", ls=":", lw=0.8)
|
|
tous = sorted(e for p in par_jour.values() for _, e in p)
|
|
q1, q2 = tous[len(tous) // 100], tous[-1 - len(tous) // 100] # cadre du 1er au 99e centile : un pic isolé n'écrase pas l'échelle
|
|
marge = (q2 - q1) * 0.5 or 1
|
|
ax.set_ylim(q1 - marge, q2 + marge)
|
|
hors_cadre = sum(not q1 - marge <= e <= q2 + marge for e in tous)
|
|
for x0, x1 in ((h1, 24), (0, h2)) if h1 > h2 else ((h1, h2),):
|
|
ax.axvspan(x0, x1, color="0.9", lw=0)
|
|
ax.set_title(s + (" (réf.)" if est_reference(series[s]) else "") + f" bruit {bruit:.2g}"
|
|
+ (f" ({hors_cadre} hors cadre)" if hors_cadre else ""), fontsize=9)
|
|
ax.set_xlim(0, 24)
|
|
ax.set_xticks(range(0, 25, 3))
|
|
ax.grid(alpha=0.3)
|
|
ax.tick_params(labelsize=7)
|
|
if ax is axes.flat[0]:
|
|
ax.legend(fontsize=6, ncol=2)
|
|
for ax in list(axes.flat)[len(noms):]:
|
|
ax.axis("off")
|
|
fig.suptitle(f"{station} : {col} moins le niveau de la dernière nuit ({h1} h → {h2} h, grisée), "
|
|
"une courbe par jour, en abscisse l'heure du jour (UTC) ; une échelle par capteur")
|
|
fig.tight_layout()
|
|
chemin = os.path.join(o.sortie, f"{station}_parheure-{col}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
|
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
|
plt.close(fig)
|
|
print(chemin)
|
|
|
|
nb_jours = {s: {} for s in noms} # capteur -> créneau -> jours mesurés
|
|
for s in noms:
|
|
for m in series[s]:
|
|
if m[col] is not None:
|
|
nb_jours[s].setdefault((m["t"].hour * 60 + m["t"].minute) // pas * pas, set()).add(m["t"].date())
|
|
print(f"\n{col} : par créneau de {pas} min de l'heure du jour, capteurs à plus de {o.k:g} bruits du niveau de la nuit "
|
|
f"au moins {o.jours} jours (jours / jours mesurés, médiane de ces écarts, en bruits)")
|
|
vide = True
|
|
for c in sorted(creneaux):
|
|
cites = []
|
|
for s, haut in ((s, h) for s in noms for h in (True, False)):
|
|
ec = creneaux[c].get((s, haut), {})
|
|
if len(ec) >= o.jours:
|
|
med = statistics.median(ec.values())
|
|
cites.append(f"{s} {len(ec)}/{len(nb_jours[s].get(c, ()))} {med:+.3g} ({med / bruits[s]:+.1f})")
|
|
if cites:
|
|
vide = False
|
|
print(f"{c // 60:02d}:{c % 60:02d} {len(cites):2} capteurs : " + ", ".join(cites))
|
|
if vide:
|
|
print("(aucun)")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|