2026-10-26 13:02:03 +01:00
"""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/
2026-10-26 14:47:00 +01:00
[--colonnes x,y,sigma0] [--colonne error_value] [--pas 15min] [--k 5] [--min 5]
2026-10-26 14:55:46 +01:00
[--residus corr_x,corr_y,error_value] [--hors T1/T2] [--autres] [--capteurs A,B] [--debut ...] [--fin ...] [--sortie DOSSIER]
2026-10-26 13:02:03 +01:00
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.
2026-10-26 13:15:46 +01:00
3. « residus-<colonne> » (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.
2026-10-26 14:55:46 +01:00
Avec --autres, chaque capteur est de plus ramené à l'écart à la médiane des AUTRES capteurs au même instant (on
retranche, à chaque mesure, la médiane des autres capteurs de la même colonne moins leur niveau propre) : ce qui est
partagé par tous (le reste de la compensation d'un mouvement commun) s'annule, ce qui est propre au capteur reste.
PNG « residus-<colonne>-autres » ; la table imprime en plus, par capteur, la pente de ce résidu sur chaque
colonne de --colonnes (médiane commune, ex. y) et la corrélation r : un résidu proportionnel au mouvement commun
(même s'il n'est pas partagé par tous) a une pente non nulle et un r élevé.
2026-10-26 13:09:24 +01:00
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
2026-10-26 14:47:00 +01:00
un début ou une fin, la table est au pas de --pas (défaut 15min, la cadence des mesures ; un pas plus large,
1h par ex., aplatit un pic d'un à quatre pas et date à l'heure).
2026-10-26 13:02:03 +01:00
Imprime aussi, pour chaque instant où au moins --min capteurs dépassent leur médiane de plus de --k MAD,
2026-10-26 14:47:00 +01:00
le nombre et les capteurs (--min 1 : aussi les instants où un seul capteur sort de son niveau). Rend des valeurs, pas de verdict.
2026-10-26 13:02:03 +01:00
"""
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 )
2026-10-26 14:47:00 +01:00
a . add_argument ( "--pas" , default = "15min" , type = duree , help = "pas des tables et des courbes en bleu (défaut 15min, la cadence des mesures : un pas plus large aplatit et décale les événements courts)" )
2026-10-26 13:02:03 +01:00
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é" )
2026-10-26 13:15:46 +01:00
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" )
2026-10-26 14:55:46 +01:00
a . add_argument ( "--autres" , action = "store_true" , help = "résidus de plus ramenés à la médiane des autres capteurs au même instant, avec pente et corrélation sur le mouvement commun" )
2026-10-26 13:02:03 +01:00
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 ( "," )
2026-10-26 13:15:46 +01:00
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" )):
2026-10-26 13:02:03 +01:00
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 )
2026-10-26 13:09:24 +01:00
communes = {}
2026-10-26 13:02:03 +01:00
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 ])
2026-10-26 13:09:24 +01:00
communes [ col ] = dict ( zip ( tt , med ))
2026-10-26 13:02:03 +01:00
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 \n de médiane + { o . k : g } MAD \n ( { o . colonne } )" )
axes [ - 1 , 0 ] . grid ( alpha = 0.3 )
2026-10-26 13:09:24 +01:00
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 ])
2026-10-26 13:02:03 +01:00
axes [ - 1 , 0 ] . xaxis . set_major_formatter ( mdates . DateFormatter ( " %d /%m \n %H:%MZ" ))
2026-10-26 13:09:24 +01:00
for ax in axes [:, 0 ]:
ax . grid ( alpha = 0.5 , which = "major" )
2026-10-26 13:02:03 +01:00
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 )
2026-10-26 13:09:24 +01:00
# table de la médiane commune, par pas
2026-10-26 16:48:13 +01:00
minuit = temps [ 0 ] . replace ( hour = 0 , minute = 0 , second = 0 , microsecond = 0 )
t0 = minuit + (( temps [ 0 ] - minuit ) // o . pas ) * o . pas # pas calés sur l'horloge (hh:00, hh:15…), pas sur la 1re mesure
2026-10-26 13:09:24 +01:00
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 " \n Mé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 ]) } " )
2026-10-26 13:02:03 +01:00
# 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 )
2026-10-26 13:15:46 +01:00
# 3. résidus : chaque capteur moins son propre niveau
2026-10-26 14:55:46 +01:00
for col , autres in [( c , False ) for c in residus ] + [( c , True ) for c in residus if o . autres ]:
2026-10-26 13:15:46 +01:00
fig , axes = plt . subplots ( lignes , 5 , sharex = True , figsize = ( 18 , 2.5 * lignes ), squeeze = False )
2026-10-26 14:55:46 +01:00
dev = {}
if autres : # {capteur: {t: valeur - niveau propre}} pour la médiane des autres
for q in noms :
mq = [ m for m in series [ q ] if m [ col ] is not None ]
rq = [ m for m in mq if not hors or not hors [ 0 ] <= m [ "t" ] <= hors [ 1 ]] or mq
nq = niveau ( rq , col )
if nq :
dev [ q ] = { m [ "t" ]: m [ col ] - nq [ 0 ] for m in mq }
print ( f " \n { col } moins le niveau propre { ' et moins la médiane des autres capteurs au même instant' if autres else '' } ( { 'hors ' + o . hors if hors else 'médiane de la fenêtre' } ), médiane par pas de "
2026-10-26 13:15:46 +01:00
f " { int ( o . pas . total_seconds () // 60 ) } min :" )
2026-10-26 14:55:46 +01:00
pentes = []
2026-10-26 13:15:46 +01:00
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
2026-10-26 14:55:46 +01:00
if autres :
res = {}
for m in ms :
v = [ dev [ q ][ m [ "t" ]] for q in dev if q != s and m [ "t" ] in dev [ q ]]
if len ( v ) >= 2 :
res [ m [ "t" ]] = m [ col ] - lv [ 0 ] - statistics . median ( v )
if len ( res ) < 2 :
ax . axis ( "off" )
continue
else :
res = { m [ "t" ]: m [ col ] - lv [ 0 ] for m in ms }
2026-10-26 13:15:46 +01:00
pas = {}
2026-10-26 14:55:46 +01:00
for t , v in res . items ():
pas . setdefault ( t0 + (( t - t0 ) // o . pas ) * o . pas , []) . append ( v )
2026-10-26 13:15:46 +01:00
pm = { t : statistics . median ( v ) for t , v in pas . items ()}
2026-10-26 14:55:46 +01:00
ax . plot ( list ( res ), list ( res . values ()), "-" , lw = 0.4 , color = "0.7" )
2026-10-26 13:15:46 +01:00
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 ]) } " )
2026-10-26 14:55:46 +01:00
if autres :
for c in colonnes :
tt = [ t for t in res if t in communes [ c ]]
if len ( tt ) > 2 and len ({ communes [ c ][ t ] for t in tt }) > 1 :
xs , ys = [ communes [ c ][ t ] for t in tt ], [ res [ t ] for t in tt ]
pente = statistics . linear_regression ( xs , ys ) . slope
pentes . append ( f " { s : 9 } pente sur { c } commun { pente : +.4g } par unité, r = { statistics . correlation ( xs , ys ) : +.2f } " )
2026-10-26 13:15:46 +01:00
for ax in list ( axes . flat )[ n :]:
ax . axis ( "off" )
2026-10-26 14:55:46 +01:00
if pentes :
print ( " \n " . join ( pentes ))
fig . suptitle ( f " { station } : { col } moins le niveau propre { ' et la médiane des autres' if autres else '' } de chaque capteur, médiane par pas de "
2026-10-26 13:15:46 +01:00
f " { int ( o . pas . total_seconds () // 60 ) } min (bleu), mesures (gris) ; une échelle par capteur (heures UTC)" )
fig . tight_layout ()
2026-10-26 14:55:46 +01:00
chemin = base . format ( f "residus- { col } " + ( "-autres" if autres else "" ))
2026-10-26 13:15:46 +01:00
fig . savefig ( chemin , dpi = 100 , bbox_inches = "tight" )
plt . close ( fig )
print ( chemin )
2026-10-26 16:48:13 +01:00
print ( f " \n Instants où au moins { o . min } capteurs ont { o . colonne } > médiane de la fenêtre + { o . k : g } MAD :" )
2026-10-26 13:02:03 +01:00
for t , hauts in qui . items ():
print ( f " { iso ( t ) } { len ( hauts ) : 3 } { ',' . join ( hauts ) } " )
if not qui :
print ( "(aucun)" )
if __name__ == "__main__" :
main ()