Copie des agents de Support-Agent/API (sortie mail)
Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
1 parent
cbaab49d3f
commit
5e3faa47b4
49 files changed
+6662
No files matched your search
@@ -0,0 +1,333 @@
|
||||
"""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 agent-tools/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] [--bornes [--lissage N] [--fraction F]]
|
||||
[--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.
|
||||
3. Avec --bornes : chaque jour face à la nuit qui le précède, pour la médiane des cibles de chaque colonne (avec
|
||||
--capteurs : la médiane de ces capteurs, références comprises ; un seul capteur : le sien) et pour la pose de la
|
||||
caméra (pan, tilt, rotation, scale, sigma0) si camera/ existe. Un « jour » : de la fin d'une nuit à la fin de la
|
||||
suivante (24 h), daté du jour où il commence ; son niveau de référence est celui de la nuit qui vient de finir (sans
|
||||
elle, la dernière nuit mesurée avant, ou au début du lot la première : nommée, « pas la précédente »). Écart de chaque mesure à ce niveau (médiane des cibles : à chaque
|
||||
instant, médiane des écarts de chaque cible à son propre niveau de cette nuit) ; bruit : médiane des écarts entre
|
||||
deux valeurs consécutives de cette suite. Par jour : nombre de mesures, première et dernière ; premier et dernier
|
||||
instant où |écart| dépasse --k bruits, avec la mesure juste avant et juste après (au pas natif) ; le maximum et le
|
||||
minimum signés et leur instant ; autour du plus grand des deux en valeur absolue, la suite de mesures consécutives
|
||||
au-delà de --k bruits du même côté qui le contient, avec la mesure juste avant et juste après ; la nuit suivante
|
||||
moins la nuit de référence. Un jour sans mesure le dit. Chaque ligne de jour commence par le nom court de la suite
|
||||
(la colonne, ou pose_tilt…) : `| grep '^pose_tilt '` en garde une, `| grep ' 12/10 '` un jour. Avec --lissage N,
|
||||
l'écart de chaque mesure est la médiane des N mesures du jour centrées sur elle (le bruit reste celui des mesures,
|
||||
la figure trace aussi l'écart brut en gris) : un point isolé ne coupe plus la suite autour de l'extrême et ne fait
|
||||
plus un premier ou un dernier dépassement. Avec --fraction F, le seuil de chaque jour est F fois le plus grand
|
||||
|écart| de ce jour (au lieu de --k bruits ; il est imprimé sur la ligne du jour) : sur une suite très bruitée, ou
|
||||
dont le bruit au pas natif est sans rapport avec l'ampleur du cycle. PNG
|
||||
« bornes » : un panneau par suite, l'écart sur le lot, ±k bruits en pointillé, de chaque jour [premier, dernier]
|
||||
grisé clair et la suite autour de l'extrême grisée foncé, le maximum et le minimum marqués ; cadré du 1er au 99e
|
||||
centile élargi de moitié (le titre dit combien de mesures sortent du cadre).
|
||||
Rend des valeurs, pas de verdict.
|
||||
"""
|
||||
import argparse
|
||||
import math
|
||||
import os
|
||||
import statistics
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
import matplotlib
|
||||
|
||||
matplotlib.use("Agg")
|
||||
import matplotlib.pyplot as plt # noqa: E402
|
||||
|
||||
from donnees import POSE, charger, charger_camera, est_reference, filtrer, instant, iso, rejetee # noqa: E402
|
||||
from graphique import COLONNES, RACINE, borne # noqa: E402
|
||||
from resume import ARRONDI, bruit_propre, 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("--bornes", action="store_true", help="ajoute, jour par jour, les bornes de l'écart au niveau de la nuit précédente")
|
||||
a.add_argument("--lissage", type=int, default=1, metavar="N", help="--bornes : écart lissé par la médiane de N mesures centrées (défaut 1 : aucun)")
|
||||
a.add_argument("--fraction", type=float, metavar="F", help="--bornes : seuil de chaque jour = F fois son plus grand |écart| (au lieu de --k bruits)")
|
||||
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] = bruit_propre([v for _, v in ms])
|
||||
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 o.bornes:
|
||||
bornes(o, noms, series, colonnes, station)
|
||||
|
||||
|
||||
def niveaux_de_nuit(pts, h1, h2):
|
||||
"""[(t, v)] -> {date de la nuit: médiane}."""
|
||||
nuits = {}
|
||||
for t, v in pts:
|
||||
if de_nuit(t, h1, h2):
|
||||
nuits.setdefault((t - timedelta(hours=h1)).date(), []).append(v)
|
||||
return {d: statistics.median(v) for d, v in nuits.items()}
|
||||
|
||||
|
||||
def bornes(o, noms, series, colonnes, station):
|
||||
"""Section 3 : par jour, l'écart au niveau de la nuit qui le précède, pour la médiane des cibles et la pose."""
|
||||
h1, h2 = o.nuit
|
||||
duree_nuit = timedelta(hours=(h2 - h1) % 24)
|
||||
choisis = noms if o.capteurs else [s for s in noms if series[s] and not est_reference(series[s])] or noms
|
||||
suites = [(f"{col} médiane de {len(choisis)} capteur(s)" if len(choisis) > 1 else f"{col} {choisis[0]}", col,
|
||||
{s: [(m["t"], m[col]) for m in series[s] if m[col] is not None] for s in choisis}) for col in colonnes]
|
||||
poses = filtrer(charger_camera(o.dossier), o.debut, o.fin)
|
||||
suites += [(f"pose {c}", f"pose_{c}", {c: [(p["t"], p[c]) for p in poses if p[c] is not None]}) for c in POSE
|
||||
if any(p[c] is not None for p in poses)]
|
||||
tous = [t for _, _, d in suites for p in d.values() for t, _ in p]
|
||||
t0, t1 = min(tous), max(tous)
|
||||
nuit_de = lambda t: (t - duree_nuit - timedelta(hours=h1)).date() # nuit qui finit avant t (le jour de t commence à sa fin)
|
||||
jours = [nuit_de(t0) + timedelta(days=i) for i in range((nuit_de(t1) - nuit_de(t0)).days + 1)]
|
||||
hm = lambda t: f"{t:%d/%m %H:%M}"
|
||||
seuil_txt = f"seuil {o.fraction:g} fois le plus grand |écart| du jour" if o.fraction else f"seuil {o.k:g} bruits"
|
||||
print(f"\n== Bornes de chaque jour : écart au niveau de la nuit qui le précède ({h1} h → {h2} h UTC), {seuil_txt}"
|
||||
+ (f", écart lissé sur {o.lissage} mesures" if o.lissage > 1 else "") + " ==")
|
||||
print("jour : de la fin d'une nuit à la fin de la suivante, daté de son début ; « avant », « après » : mesure juste avant le premier "
|
||||
"dépassement, juste après le dernier ; nuit suivante : son niveau moins celui de la nuit de référence")
|
||||
fig, axes = plt.subplots(len(suites), 1, sharex=True, figsize=(18, 2.2 * len(suites)), squeeze=False)
|
||||
for ax, (nom, court, par_capteur) in zip(axes.flat, suites):
|
||||
niv = {s: niveaux_de_nuit(p, h1, h2) for s, p in par_capteur.items()}
|
||||
nuits = sorted({d for n in niv.values() for d in n})
|
||||
ecarts = [] # (jour, nuit de réf., [(t, écart)], écart de la nuit suivante)
|
||||
for d in jours:
|
||||
debut = datetime.combine(d, datetime.min.time(), tzinfo=timezone.utc) + timedelta(hours=h1) + duree_nuit
|
||||
fin = debut + timedelta(days=1)
|
||||
ref = max((n for n in nuits if n <= d), default=None) or (min(nuits) if nuits else None)
|
||||
par_t = {}
|
||||
for s, p in par_capteur.items():
|
||||
if ref in niv[s]:
|
||||
for t, v in p:
|
||||
if debut <= t < fin:
|
||||
par_t.setdefault(t, []).append(v - niv[s][ref])
|
||||
suivante = [niv[s][d + timedelta(days=1)] - niv[s][ref] for s in niv if ref in niv[s] and d + timedelta(days=1) in niv[s]]
|
||||
ecarts.append((debut.date(), d, ref, [(t, statistics.median(e)) for t, e in sorted(par_t.items())],
|
||||
statistics.median(suivante) if suivante else None))
|
||||
diffs = [abs(b[1] - a_[1]) for *_, p, _ in ecarts for a_, b in zip(p, p[1:])]
|
||||
bruit = statistics.median(diffs) if diffs else 0
|
||||
bruit = bruit if bruit >= ARRONDI else 0
|
||||
print(f"\n{nom} : bruit {bruit:.3g}")
|
||||
enb = lambda e: f"{e:+.4g} ({e / bruit:+.1f})" if bruit else f"{e:+.4g}"
|
||||
h = o.lissage // 2
|
||||
for jour, d, ref, brut, suiv in ecarts:
|
||||
if not brut:
|
||||
print(f"{court} {jour:%d/%m} aucune mesure" + ("" if nuits else " de nuit"))
|
||||
continue
|
||||
p = [(t, statistics.median(e for _, e in brut[max(0, i - h):i + h + 1])) for i, (t, _) in enumerate(brut)] if h else brut
|
||||
seuil = o.fraction * max(abs(e) for _, e in p) if o.fraction else o.k * bruit
|
||||
ligne = (f"{court} {jour:%d/%m} nuit {ref:%d/%m}" + (" (pas la précédente)" if ref != d else "") + f" | {len(p)} mesures {hm(p[0][0])} → {hm(p[-1][0])} | "
|
||||
+ (f"seuil {seuil:.4g} | " if o.fraction else ""))
|
||||
hors = [i for i, (_, e) in enumerate(p) if seuil and abs(e) > seuil]
|
||||
if hors:
|
||||
i, j = hors[0], hors[-1]
|
||||
ligne += (f"> {'seuil' if o.fraction else f'{o.k:g} bruits'} : {len(hors)} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) "
|
||||
f"à {hm(p[j][0])} (après {hm(p[j + 1][0]) if j + 1 < len(p) else '-'})")
|
||||
ax.axvspan(p[i][0], p[j][0], color="0.85", lw=0)
|
||||
else:
|
||||
ligne += f"jamais > {'seuil' if o.fraction else f'{o.k:g} bruits'}"
|
||||
haut, bas = max(p, key=lambda x: x[1]), min(p, key=lambda x: x[1])
|
||||
ligne += f" | max {enb(haut[1])} à {hm(haut[0])}, min {enb(bas[1])} à {hm(bas[0])}"
|
||||
x = max(range(len(p)), key=lambda i: abs(p[i][1]))
|
||||
signe = 1 if p[x][1] > 0 else -1
|
||||
if seuil and signe * p[x][1] > seuil:
|
||||
i = j = x
|
||||
while i > 0 and signe * p[i - 1][1] > seuil:
|
||||
i -= 1
|
||||
while j + 1 < len(p) and signe * p[j + 1][1] > seuil:
|
||||
j += 1
|
||||
ligne += (f" | autour du {'max' if signe > 0 else 'min'} : {j - i + 1} mesures, de {hm(p[i][0])} (avant {hm(p[i - 1][0]) if i else '-'}) "
|
||||
f"à {hm(p[j][0])} (après {hm(p[j + 1][0]) if j + 1 < len(p) else '-'})")
|
||||
ax.axvspan(p[i][0], p[j][0], color="0.7", lw=0)
|
||||
ligne += f" | nuit suivante {enb(suiv)}" if suiv is not None else " | nuit suivante non mesurée"
|
||||
print(ligne)
|
||||
if h:
|
||||
ax.plot([t for t, _ in brut], [e for _, e in brut], "-", lw=0.5, color="0.6")
|
||||
ax.plot([t for t, _ in p], [e for _, e in p], "-", lw=0.8, color="C0")
|
||||
ax.plot([haut[0], bas[0]], [haut[1], bas[1]], "o", ms=3, color="C3")
|
||||
if bruit and not o.fraction:
|
||||
for y in (o.k * bruit, -o.k * bruit):
|
||||
ax.axhline(y, color="0.4", ls=":", lw=0.8)
|
||||
ax.axhline(0, color="0.3", lw=0.5)
|
||||
tous_e = sorted(e for *_, p, _ in ecarts for _, e in p)
|
||||
hors_cadre = 0
|
||||
if tous_e: # cadre du 1er au 99e centile élargi de moitié, comme parheure : un pic isolé n'écrase pas l'échelle
|
||||
q1, q2 = tous_e[len(tous_e) // 100], tous_e[-1 - len(tous_e) // 100]
|
||||
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_e)
|
||||
ax.set_title(f"{nom} bruit {bruit:.2g}" + (f" ({hors_cadre} hors cadre)" if hors_cadre else ""), fontsize=9)
|
||||
ax.grid(alpha=0.3)
|
||||
ax.tick_params(labelsize=7)
|
||||
fig.suptitle(f"{station} : écart au niveau de la nuit qui précède chaque jour ({h1} h → {h2} h) ; "
|
||||
f"grisé clair : du premier au dernier dépassement {'du seuil (' + seuil_txt + ')' if o.fraction else f'de {o.k:g} bruits'}, foncé : la suite autour de l'extrême ; points : max et min du jour"
|
||||
+ (f" ; écart lissé sur {o.lissage} mesures (bleu), brut (gris)" if o.lissage > 1 else ""))
|
||||
fig.tight_layout()
|
||||
chemin = os.path.join(o.sortie, f"{station}_bornes_{borne(o.debut, 'debut')}_{borne(o.fin, 'fin')}.png")
|
||||
fig.savefig(chemin, dpi=100, bbox_inches="tight")
|
||||
plt.close(fig)
|
||||
print(chemin)
|
||||
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
Reference in new issue
Block a user