102 lines
6.1 KiB
Python
102 lines
6.1 KiB
Python
"""Plages datées par capteur et par colonne, au pas natif des mesures, pour l'agent de diagnostic.
|
|
|
|
Usage : python3 agents/diagnostic/outils/plages.py data/PS_DES_COUDRES/ [--colonnes error_value,corr_x,corr_y]
|
|
[--k 5] [--fusion 1h] [--hors T1/T2] [--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 »).
|
|
Chaque colonne est lue aux mesures, jamais moyennée par pas. Rend des valeurs, pas de verdict.
|
|
"""
|
|
import argparse
|
|
import statistics
|
|
import sys
|
|
|
|
from donnees import charger, est_reference, filtrer, instant, iso, rejetee
|
|
from resume import COLONNES, duree
|
|
|
|
|
|
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("--hors", help="T1/T2 : niveau et bruit se calculent hors de ce moment (les plages se cherchent partout)")
|
|
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.")
|
|
|
|
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 = statistics.median(abs(b[1] - a_[1]) for a_, b in zip(ref, ref[1:]))
|
|
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
|
|
groupe = []
|
|
for t, v in ms + [(None, 0)]:
|
|
if t is not None and abs(v - niv) > o.k * bruit:
|
|
if groupe and (t - groupe[-1][0] > o.fusion or (v > niv) != (groupe[-1][1] > niv)): # même sens seul
|
|
plages.append((s, groupe, niv, bruit, rej))
|
|
groupe = []
|
|
groupe.append((t, v))
|
|
elif t is None and groupe:
|
|
plages.append((s, groupe, niv, bruit, rej))
|
|
print(f"\n{col} : plages à plus de {o.k:g} bruits du niveau{' (niveau hors ' + o.hors + ')' if hors else ''} (fusion {int(o.fusion.total_seconds() // 60)} min)")
|
|
print(f"{'capteur':9}{'début':<18}{'fin':<18}{'mesures':>8}{'extrême':>10}{'(bruits)':>9} {'à':<17}{'rejetées':>9}")
|
|
for s, g, niv, bruit, rej in plages:
|
|
t, v = max(g, key=lambda x: abs(x[1] - niv))
|
|
print(f"{s:9}{iso(g[0][0]):<18}{iso(g[-1][0]):<18}{len(g):8}{v - niv:+10.4g}{(v - niv) / 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 __name__ == "__main__":
|
|
main()
|