"""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] [--residus corr_x,corr_y,error_value] [--hors T1/T2] [--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. 3. « residus- » (un PNG par colonne de --residus, défaut corr_x,corr_y,error_value) : un petit graphique par capteur de la colonne moins le niveau propre du capteur (sa médiane sur la fenêtre, ou hors de --hors T1/T2 si donné : le niveau est alors celui du reste de la fenêtre, pas celui du moment lu), une échelle par capteur, zéro en pointillé ; un écart de quelques centièmes sur une colonne `corr` que les bandes parallèles de `graphique.py` cachent s'y voit. Imprime, par capteur, le niveau, le bruit propre (médiane des écarts entre deux mesures consécutives) et l'écart minimum et maximum de la médiane par pas de --pas, avec leur instant, en unités de la colonne et en bruits. 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("--residus", default="corr_x,corr_y,error_value", help="colonnes tracées moins le niveau propre de chaque capteur ('' : aucune)") a.add_argument("--hors", help="T1/T2 : le niveau propre des résidus se calcule hors de ce moment") 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(",") residus = [c for c in o.residus.split(",") if c] hors = tuple(instant(x) for x in o.hors.split("/")) if o.hors else None if hors and len(hors) != 2: sys.exit("--hors attend T1/T2.") for demandes, connus, quoi in ((noms, par, "Capteurs"), (colonnes + residus + [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) # 3. résidus : chaque capteur moins son propre niveau for col in residus: fig, axes = plt.subplots(lignes, 5, sharex=True, figsize=(18, 2.5 * lignes), squeeze=False) print(f"\n{col} moins le niveau propre ({'hors ' + o.hors if hors else 'médiane de la fenêtre'}), médiane par pas de " f"{int(o.pas.total_seconds() // 60)} min :") print(f"{'capteur':9}{'niveau':>10}{'bruit':>10}{'écart min':>11} {'à':<17}{'(bruits)':>9}{'écart max':>11} {'à':<17}{'(bruits)':>9}") for ax, s in zip(axes.flat, noms): ms = [m for m in series[s] if m[col] is not None] ref = [m for m in ms if not hors or not hors[0] <= m["t"] <= hors[1]] or ms lv = niveau(ref, col) if not lv: ax.axis("off") continue d = [abs(b[col] - a_[col]) for a_, b in zip(ms, ms[1:])] bruit = statistics.median(d) if d else 0 pas = {} for m in ms: pas.setdefault(t0 + ((m["t"] - t0) // o.pas) * o.pas, []).append(m[col] - lv[0]) pm = {t: statistics.median(v) for t, v in pas.items()} ax.plot([m["t"] for m in ms], [m[col] - lv[0] for m in ms], "-", lw=0.4, color="0.7") ax.plot(list(pm), list(pm.values()), "-", lw=1.1, color="C0") ax.axhline(0, color="C3", ls=":", lw=0.8) ax.set_title(s + (" (réf.)" if est_reference(ms) else "") + f" bruit {bruit:.2g}", 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")) lo, hi = min(pm.items(), key=lambda x: x[1]), max(pm.items(), key=lambda x: x[1]) f = lambda v: f"{v / bruit:9.1f}" if bruit else f"{'-':>9}" print(f"{s:9}{lv[0]:10.4g}{bruit:10.3g}{lo[1]:11.3g} {iso(lo[0]):<17}{f(lo[1])}{hi[1]:11.3g} {iso(hi[0]):<17}{f(hi[1])}") for ax in list(axes.flat)[n:]: ax.axis("off") fig.suptitle(f"{station} : {col} moins le niveau propre de chaque capteur, médiane par pas de " f"{int(o.pas.total_seconds() // 60)} min (bleu), mesures (gris) ; une échelle par capteur (heures UTC)") fig.tight_layout() chemin = base.format(f"residus-{col}") fig.savefig(chemin, dpi=100, bbox_inches="tight") plt.close(fig) print(chemin) 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()