"""Plages datées par capteur et par colonne, au pas natif des mesures, pour l'agent de diagnostic. Usage : python3 tools/plages.py data/PS_DES_COUDRES/ [--colonnes error_value,corr_x,corr_y] [--k 5] [--fusion 1h] [--min-mesures 1] [--hors T1/T2] [--glissant N|DUREE] [--instants N] [--capteurs A,B] [--debut ...] [--fin ...] Pour chaque colonne, chaque capteur est comparé à son propre niveau sur la fenêtre --debut/--fin (médiane des valeurs non vides ; avec --hors T1/T2, celle du reste de la fenêtre, hors du moment lu : utile quand un épisode long fausse la médiane) et à son bruit propre (médiane des écarts entre deux mesures consécutives non vides, hors --hors). 1. Un tableau par colonne : niveau, bruit, et le plus grand saut d'une mesure à la suivante (valeur, en bruits, les deux instants). 2. Les plages où la colonne s'écarte de son niveau de plus de --k bruits : début et fin (première et dernière mesure hors niveau), nombre de mesures hors niveau, valeur extrême (écart signé au niveau, en unités et en bruits) et son instant. Deux plages du même sens séparées de moins de --fusion (défaut 1h) n'en font qu'une (un écart vers le bas puis vers le haut font deux plages) ; les mesures rejetées (colonne vide) ne coupent pas une plage. Colonne « rejetées » : combien des mesures de la plage sont rejetées par la station (error_value au-dessus du seuil), et « extrême rejetée » si l'extrême l'est ; un saut dont un bout est rejeté le dit. corr_x, corr_y d'une mesure rejetée sont vides, références comprises (donnees.charger). Une plage qui touche le bord de la fenêtre est datée au bord (le niveau est celui de la fenêtre : un palier durable peut faire de l'autre moitié la « plage »). Avec --min-mesures N, seules les plages d'au moins N mesures hors niveau sont imprimées (leur nombre total aussi). Avec --glissant N (un entier : N mesures non vides de part et d'autre) ou --glissant DUREE (6h, 1d : les mesures à moins de DUREE avant et après), le niveau de chaque mesure est la médiane de ses voisines, sans elle (niveau local) : une dérive longue ou un palier suivent le niveau, seuls restent les écarts plus brefs que la fenêtre. La colonne « niveau » du tableau 1 reste la médiane de la fenêtre ; le bruit ne change pas. 3. Avec --instants N : les instants où au moins N capteurs sont hors niveau (sur l'une des colonnes), avec, pour chacun, les capteurs et l'écart en bruits (cx corr_x, cy corr_y, ev error_value, sinon le nom de la colonne), les capteurs rejetés à cet instant (parmi --capteurs : en retirer les capteurs toujours rejetés allège la liste), et chaque référence de la station, --capteurs ou non : error_value (« r » si rejetée) / inlier (« - » vide). Chaque colonne est lue aux mesures, jamais moyennée par pas. Rend des valeurs, pas de verdict. """ import argparse import bisect import statistics import sys from donnees import charger, est_reference, filtrer, instant, iso, rejetee from resume import COLONNES, bruit_propre, duree ABREGE = {"corr_x": "cx", "corr_y": "cy", "error_value": "ev"} def locaux(ms, g): """Niveau local de chaque mesure (t, v) : médiane des voisines non vides, sans elle ; g entier (mesures de part et d'autre) ou timedelta (mesures à moins de g) ; None sans voisine.""" ts, vs = [t for t, _ in ms], [v for _, v in ms] out = [] for i, t in enumerate(ts): lo, hi = (max(0, i - g), i + g + 1) if isinstance(g, int) else (bisect.bisect_left(ts, t - g), bisect.bisect_right(ts, t + g)) w = vs[lo:i] + vs[i + 1:hi] out.append(statistics.median(w) if w else None) return out def main(): a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter) a.add_argument("dossier") a.add_argument("--colonnes", default="error_value,corr_x,corr_y") a.add_argument("--k", type=float, default=5, help="écart au niveau compté, en bruits propres du capteur") a.add_argument("--fusion", default="1h", type=duree, help="deux plages séparées de moins que cela n'en font qu'une") a.add_argument("--min-mesures", type=int, default=1, help="n'imprime que les plages d'au moins N mesures hors niveau") a.add_argument("--hors", help="T1/T2 : niveau et bruit se calculent hors de ce moment (les plages se cherchent partout)") a.add_argument("--glissant", type=lambda x: int(x) if x.isdigit() else duree(x), help="N (mesures de part et d'autre) ou durée (6h, 1d) : niveau local, médiane des voisines sans la mesure") a.add_argument("--instants", type=int, help="N : instants où au moins N capteurs sont hors niveau, avec rejets et références") 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) 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(",") 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, 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.") glis = (f"{o.glissant} mesures" if isinstance(o.glissant, int) else f"{int(o.glissant.total_seconds() // 60)} min") if o.glissant is not None else "" par_instant = {} # iso(t) -> ["capteur.col+écart"] (--instants) for col in colonnes: print(f"\n== {col} : niveau, bruit, plus grand saut d'une mesure à la suivante ==") print(f"{'capteur':9}{'n':>5}{'niveau':>10}{'bruit':>10}{'saut':>10}{'(bruits)':>9} entre") plages = [] for s in noms: ms = [(m["t"], m[col]) for m in series[s] if m[col] is not None] rej = {m["t"] for m in series[s] if rejetee(m)} if len(ms) < 2: print(f"{s:9}{len(ms):5} (moins de 2 valeurs)") continue ref = [x for x in ms if not hors or not hors[0] <= x[0] <= hors[1]] if len(ref) < 2: print(f"{s:9}{len(ms):5} (moins de 2 valeurs hors --hors)") continue niv = statistics.median(v for _, v in ref) sauts = [(b[1] - a_[1], a_[0], b[0]) for a_, b in zip(ms, ms[1:])] bruit = bruit_propre([v for _, v in ref]) d, t1, t2 = max(sauts, key=lambda x: abs(x[0])) bru = f"{d / bruit:9.1f}" if bruit else f"{'-':>9}" marque = [iso(x) for x in (t1, t2) if x in rej] print(f"{s:9}{len(ms):5}{niv:10.4g}{bruit:10.3g}{d:+10.4g}{bru} {iso(t1)} et {iso(t2)}" + (f" (rejetée : {', '.join(marque)})" if marque else "")) if not bruit: continue lv = locaux(ms, o.glissant) if o.glissant is not None else [niv] * len(ms) groupe = [] # (t, écart au niveau) for (t, v), n in zip(ms + [(None, 0)], lv + [None]): if t is not None and n is not None and abs(v - n) > o.k * bruit: if groupe and (t - groupe[-1][0] > o.fusion or (v > n) != (groupe[-1][1] > 0)): # même sens seul plages.append((s, groupe, bruit, rej)) groupe = [] groupe.append((t, v - n)) par_instant.setdefault(iso(t), {}).setdefault(s, []).append(f"{ABREGE.get(col, col)}{(v - n) / bruit:+.0f}") elif t is None and groupe: plages.append((s, groupe, bruit, rej)) toutes = len(plages) plages = [p for p in plages if len(p[1]) >= o.min_mesures] print(f"\n{col} : plages à plus de {o.k:g} bruits du niveau{' glissant ±' + glis + ' (médiane des voisines)' if glis else ''}{' (niveau hors ' + o.hors + ')' if hors and not glis else ''}{' (bruit hors ' + o.hors + ')' if hors and glis else ''} (fusion {int(o.fusion.total_seconds() // 60)} min)" + (f" ; {len(plages)} d'au moins {o.min_mesures} mesures sur {toutes}" if o.min_mesures > 1 else "")) print(f"{'capteur':9}{'début':<18}{'fin':<18}{'mesures':>8}{'extrême':>10}{'(bruits)':>9} {'à':<17}{'rejetées':>9}") for s, g, bruit, rej in plages: t, d = max(g, key=lambda x: abs(x[1])) print(f"{s:9}{iso(g[0][0]):<18}{iso(g[-1][0]):<18}{len(g):8}{d:+10.4g}{d / bruit:9.1f} {iso(t):<17}" f"{sum(x[0] in rej for x in g):9}{' extrême rejetée' if t in rej else ''}") if not plages: print("(aucune)") if o.instants is not None: refs = sorted(s for s in par if est_reference(par[s])) rej_t, ref_t = {}, {s: {} for s in refs} for s in set(noms) | set(refs): for m in filtrer(par[s], o.debut, o.fin): if rejetee(m) and s in noms: rej_t.setdefault(iso(m["t"]), []).append(s) if s in ref_t: ref_t[s][iso(m["t"])] = m f = lambda v, fmt: "-" if v is None else format(v, fmt) lignes = [(t, c) for t, c in sorted(par_instant.items()) if len(c) >= o.instants] print(f"\nInstants où au moins {o.instants} capteurs sont à plus de {o.k:g} bruits du niveau{' glissant ±' + glis if glis else ''} " f"({', '.join(colonnes)}) : {len(lignes)} sur {len(par_instant)} instants avec au moins un capteur hors niveau") print("instant n capteurs hors niveau (écart en bruits) | rejetés | références : error_value (r rejetée) / inlier") for t, c in lignes: r = " ".join(f"{s} {f(ref_t[s][t]['error_value'], '.3g')}{'r' if rejetee(ref_t[s][t]) else ''}/{f(ref_t[s][t]['inlier'], 'g')}" for s in refs if t in ref_t[s]) print(f"{t} {len(c):3} {' '.join(s + '.' + ','.join(v) for s, v in c.items())} | {','.join(rej_t.get(t, [])) or '-'} | {r or '-'}") if __name__ == "__main__": main()