180 lines
8.8 KiB
Python
180 lines
8.8 KiB
Python
"""Vue d'ensemble de tous les capteurs d'un export « advanced » : ce que font les capteurs ensemble.
|
|
|
|
Usage : .venv/bin/python agents/diagnostic/outils/ensemble.py data/PS_DES_COUDRES/
|
|
[--colonnes x,y,sigma0] [--colonne error_value] [--pas 1h] [--k 5] [--min 5]
|
|
[--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
|
|
|
|
Chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane et MAD de la fenêtre).
|
|
Deux PNG, dont les chemins sont imprimés :
|
|
1. « commun » : un panneau par colonne de --colonnes (défaut x,y,sigma0 : position brute et sigma0 de la
|
|
caméra) : médiane, sur les capteurs, de l'écart de chaque capteur à sa médiane ; bande grise = 10e à 90e
|
|
centile entre capteurs (la dispersion) ; dernier panneau : nombre de capteurs dont --colonne
|
|
(défaut error_value) dépasse sa médiane de plus de --k MAD à chaque pas.
|
|
2. « multiples » : un petit graphique par capteur (références d'abord) de --colonne, médiane par pas de --pas,
|
|
trait pointillé = médiane de la fenêtre ; chaque graphique a son échelle, un palier se voit.
|
|
Imprime aussi la table de la médiane commune (une ligne par pas de --pas : heure, écart à la médiane de la fenêtre
|
|
pour chaque colonne de --colonnes) puis le minimum et le maximum de chaque colonne avec leur instant ; pour dater
|
|
un début ou une fin à 15 min, relancer sur la fenêtre utile avec --pas 15min.
|
|
Imprime aussi, pour chaque instant où au moins --min capteurs dépassent leur médiane de plus de --k MAD,
|
|
le nombre et les capteurs. Rend des valeurs, pas de verdict.
|
|
"""
|
|
import argparse
|
|
import math
|
|
import os
|
|
import statistics
|
|
import sys
|
|
|
|
import matplotlib
|
|
|
|
matplotlib.use("Agg")
|
|
import matplotlib.dates as mdates # noqa: E402
|
|
import matplotlib.pyplot as plt # noqa: E402
|
|
|
|
from donnees import charger, est_reference, filtrer, instant, iso # noqa: E402
|
|
from graphique import COLONNES, RACINE, borne # noqa: E402
|
|
from resume import duree # noqa: E402
|
|
|
|
|
|
def niveau(ms, col):
|
|
"""(médiane, MAD) des valeurs non vides ; None si aucune."""
|
|
v = [m[col] for m in ms if m[col] is not None]
|
|
if not v:
|
|
return None
|
|
med = statistics.median(v)
|
|
return med, statistics.median(abs(x - med) for x in v)
|
|
|
|
|
|
def main():
|
|
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
a.add_argument("dossier")
|
|
a.add_argument("--colonnes", default="x,y,sigma0")
|
|
a.add_argument("--colonne", default="error_value", choices=COLONNES)
|
|
a.add_argument("--pas", default="1h", type=duree)
|
|
a.add_argument("--k", type=float, default=5, help="écart compté, en MAD de la fenêtre")
|
|
a.add_argument("--min", type=int, default=5, help="nombre de capteurs à partir duquel un instant est imprimé")
|
|
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 + [o.colonne], 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: filtrer(par[s], o.debut, o.fin) for s in noms}
|
|
if not any(series.values()):
|
|
sys.exit("Aucune mesure dans la fenêtre demandée.")
|
|
temps = sorted({m["t"] for s in noms for m in series[s]})
|
|
station = os.path.basename(os.path.normpath(o.dossier))
|
|
os.makedirs(o.sortie, exist_ok=True)
|
|
base = os.path.join(o.sortie, f"{station}_{{}}_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
|
|
|
def ecarts(col):
|
|
"""{capteur: {t: valeur - médiane de la fenêtre}}, et les MAD."""
|
|
e, mad = {}, {}
|
|
for s in noms:
|
|
n = niveau(series[s], col)
|
|
if n:
|
|
e[s] = {m["t"]: m[col] - n[0] for m in series[s] if m[col] is not None}
|
|
mad[s] = n[1]
|
|
return e, mad
|
|
|
|
# 1. commun
|
|
fig, axes = plt.subplots(len(colonnes) + 1, 1, sharex=True, figsize=(14, 3 * (len(colonnes) + 1)), squeeze=False)
|
|
communes = {}
|
|
for ax, col in zip(axes[:, 0], colonnes):
|
|
e, _ = ecarts(col)
|
|
med, bas, haut, tt = [], [], [], []
|
|
for t in temps:
|
|
v = sorted(e[s][t] for s in e if t in e[s])
|
|
if len(v) >= 2:
|
|
q = statistics.quantiles(v, n=10, method="inclusive")
|
|
tt.append(t), med.append(statistics.median(v)), bas.append(q[0]), haut.append(q[-1])
|
|
communes[col] = dict(zip(tt, med))
|
|
ax.fill_between(tt, bas, haut, color="0.85", label="10e-90e centile entre capteurs")
|
|
ax.plot(tt, med, ".-", ms=2, lw=0.8, label="médiane des capteurs")
|
|
ax.set_ylabel(f"{col}\nécart à sa médiane")
|
|
ax.grid(alpha=0.3)
|
|
ax.legend(loc="upper left", fontsize=8)
|
|
e, mad = ecarts(o.colonne)
|
|
compte, qui = [], {}
|
|
for t in temps:
|
|
hauts = [s for s in e if t in e[s] and mad[s] > 0 and e[s][t] > o.k * mad[s]]
|
|
compte.append(len(hauts))
|
|
if len(hauts) >= o.min:
|
|
qui[t] = hauts
|
|
axes[-1, 0].step(temps, compte, where="mid", lw=0.8)
|
|
axes[-1, 0].set_ylabel(f"capteurs au-dessus\nde médiane + {o.k:g} MAD\n({o.colonne})")
|
|
axes[-1, 0].grid(alpha=0.3)
|
|
h = next((h for h in (1, 2, 3, 6, 12) if (temps[-1] - temps[0]).total_seconds() / 3600 / h <= 20), 24)
|
|
axes[-1, 0].xaxis.set_major_locator(mdates.HourLocator(byhour=range(0, 24, h)))
|
|
axes[-1, 0].set_xlim(temps[0], temps[-1])
|
|
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
|
|
for ax in axes[:, 0]:
|
|
ax.grid(alpha=0.5, which="major")
|
|
fig.suptitle(f"{station} : {len(e)} capteurs ensemble, chacun face à son niveau sur la fenêtre (heures UTC)")
|
|
commun = base.format("commun")
|
|
fig.savefig(commun, dpi=100, bbox_inches="tight")
|
|
plt.close(fig)
|
|
print(commun)
|
|
|
|
# table de la médiane commune, par pas
|
|
t0 = temps[0]
|
|
lignes_t = {}
|
|
for col in colonnes:
|
|
for t, v in communes[col].items():
|
|
lignes_t.setdefault(t0 + ((t - t0) // o.pas) * o.pas, {}).setdefault(col, []).append(v)
|
|
print(f"\nMédiane commune (écart à la médiane de la fenêtre), médiane par pas de {int(o.pas.total_seconds() // 60)} min :")
|
|
print(f"{'instant':17}" + "".join(f"{c:>12}" for c in colonnes))
|
|
for t in sorted(lignes_t):
|
|
print(f"{iso(t):17}" + "".join(f"{statistics.median(lignes_t[t][c]):12.4g}" if c in lignes_t[t] else " " * 12 for c in colonnes))
|
|
for col in colonnes:
|
|
if communes[col]:
|
|
lo, hi = min(communes[col].items(), key=lambda x: x[1]), max(communes[col].items(), key=lambda x: x[1])
|
|
print(f"{col} (mesures) : min {lo[1]:.4g} à {iso(lo[0])}, max {hi[1]:.4g} à {iso(hi[0])}")
|
|
|
|
# 2. petits multiples
|
|
col = o.colonne
|
|
n = len(noms)
|
|
lignes = math.ceil(n / 5)
|
|
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 for m in series[s] if m[col] is not None]
|
|
ax.plot([m["t"] for m in ms], [m[col] for m in ms], "-", lw=0.4, color="0.7")
|
|
pas = {}
|
|
for m in ms:
|
|
pas.setdefault(t0 + ((m["t"] - t0) // o.pas) * o.pas, []).append(m[col])
|
|
ax.plot(list(pas), [statistics.median(v) for v in pas.values()], "-", lw=1.1, color="C0")
|
|
lv = niveau(series[s], col)
|
|
if lv:
|
|
ax.axhline(lv[0], color="C3", ls=":", lw=0.8)
|
|
ax.set_title(s + (" (réf.)" if series[s] and est_reference(series[s]) else ""), fontsize=9)
|
|
ax.grid(alpha=0.3)
|
|
ax.tick_params(labelsize=7)
|
|
ax.xaxis.set_major_locator(mdates.AutoDateLocator(minticks=2, maxticks=5))
|
|
ax.xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%Hh"))
|
|
for ax in list(axes.flat)[n:]:
|
|
ax.axis("off")
|
|
fig.suptitle(f"{station} : {col}, médiane par pas de {int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris), "
|
|
f"médiane de la fenêtre (pointillé) ; une échelle par capteur (heures UTC)")
|
|
fig.tight_layout()
|
|
multiples = base.format(f"multiples-{col}")
|
|
fig.savefig(multiples, dpi=100, bbox_inches="tight")
|
|
print(multiples)
|
|
|
|
print(f"\nInstants où au moins {o.min} capteurs ont {col} > médiane de la fenêtre + {o.k:g} MAD :")
|
|
for t, hauts in qui.items():
|
|
print(f"{iso(t)} {len(hauts):3} {','.join(hauts)}")
|
|
if not qui:
|
|
print("(aucun)")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
main()
|