Organize the project by domain and name analyses by their rule

Energy code moves to src/energy/ and its docs to docs/energy/; shared code
(CSV loading, venv switch, browser, zoom script) goes to src/common/, and the
AIMsight originals to docs/aimsight/. Analyses are no longer numbered: two
Energy scripts remain, daily.py (delivered state and trend) and
all_analyses.py (comparison of the four). Calculations and pages unchanged (D-026).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
maximeandClaude Opus 5.5 committed 2026-10-12 17:12:37 +02:00
1 parent 77c8f24d2f
commit 8a32f4d418
44 files changed
+1757 -771

No files matched your search

View File
Whitespace-only changes.
+95
View File
@@ -0,0 +1,95 @@
"""Les quatre analyses Energy ensemble, pour les comparer (D-016) : un panneau chacune, puis un graphique par série.
Usage : python3 src/energy/all_analyses.py [CSV ou dossiers...] (défaut : data/)
Écrit out/<STATION>_energy.html et l'ouvre. Documentation : docs/energy/analyses/ (une fiche par analyse)
"""
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1])) # src/ : paquets common et energy
from common.page import AUTOSCALE_Y_JS, ROOT, open_html # noqa: E402 (bascule seule sur .venv si plotly manque)
from common.stations import gaps, load_stations # noqa: E402
from plotly.subplots import make_subplots # noqa: E402
from energy import battery_state as bs, battery_trend as bt, moving_average as ma # noqa: E402
from energy.daily import daily_state_panel, daily_trend_panel # noqa: E402
# Zones de BusVoltage selon l'état de la batterie (bandes de fond) : docs/energy/domaine/tensions-selon-l-etat-de-la-batterie.md.
# [V] = VERMONT, 5e-95e centiles horaires ; [M] = manuel ; [E] = experts. Les zones « en charge » et « décharge »
# se recouvrent de 13,1 à 13,2 V : sur le plateau, la tension seule ne sépare pas la charge de la décharge.
ZONES = [
("décharge", 12.0, 13.2, "steelblue", "bottom left"), # 12,0 : coupure de la station [M] ; 13,2 : haut du plateau [V]
("en charge", 13.1, 13.8, "gold", "top left"), # bulk [V]
("pleine charge", 14.0, 14.4, "green", "top left"), # absorption 14,0-14,3 [V] ; secteur 14,2-14,4 [E]
]
def figure(station, series, results):
"""Haut : une analyse par graphique, courbes superposées. Dessous : une série temporelle par graphique."""
metrics = ["BusVoltage"] + sorted(m for m in series if m != "BusVoltage")
n = len(results)
fig = make_subplots(rows=n + len(metrics), cols=1, shared_xaxes=True, vertical_spacing=0.03,
row_heights=[1.5] * n + [1] * len(metrics),
subplot_titles=[f"Analyse {r['analysis']}" for r in results] + metrics)
for row, result in enumerate(results, start=1):
if result["analysis"] == bs.RULE["id"]:
daily_state_panel(fig, result, row)
continue
if result["analysis"] == bt.RULE["id"]:
daily_trend_panel(fig, result, row)
continue
analyse = dict(legendgroup=result["analysis"], legendgrouptitle_text=f"Analyse {result['analysis']}")
thr = result["rule"]["threshold_v"]
pts = result["points"]
x = [p["t"] for p in pts]
ref = [p["facts"].get("ref_v") for p in pts]
hover = [f"écart={p['value'] if p['value'] is None else round(p['value'], 3)}<br>anomalie={p['anomaly']}<br>"
+ "<br>".join(f"{k}={val}" for k, val in p["facts"].items()) for p in pts]
fig.add_scatter(x=x, y=[p["facts"].get("ma_v") for p in pts], name="moyenne 7 j", text=hover,
hovertemplate="%{y:.3f} V<br>%{text}", line=dict(color="royalblue"), row=row, col=1,
**analyse)
fig.add_scatter(x=x, y=[None if r is None else r + thr for r in ref], name=f"seuil (max 30 j {thr:+} V)",
line=dict(color="red", dash="dash"), row=row, col=1, **analyse)
for p in ma.periods(pts):
fig.add_vrect(x0=p["start"], x1=p["end"] or x[-1], fillcolor="red", opacity=0.15,
line_width=0, row=row, col=1)
fig.update_yaxes(title_text="BusVoltage moyennée [V]", row=row, col=1)
mesures = dict(legendgroup="mesures", legendgrouptitle_text="Mesures")
for row, m in enumerate(metrics, start=n + 1):
s = series[m]
fig.add_scatter(x=sorted(s), y=[s[t] for t in sorted(s)], name=m, line=dict(width=1),
row=row, col=1, **mesures)
for a, b in gaps(series["BusVoltage"]):
fig.add_vrect(x0=a, x1=b, fillcolor="gray", opacity=0.3, line_width=0, row=n + 1, col=1)
for name, lo, hi, color, pos in ZONES:
fig.add_hrect(y0=lo, y1=hi, fillcolor=color, opacity=0.15, line_width=0, layer="below",
annotation_text=f"{name} {lo}-{hi} V", annotation_position=pos, row=n + 1, col=1)
fig.update_xaxes(showticklabels=True) # dates sous chaque graphique, pas seulement le dernier
fig.update_yaxes(fixedrange=True) # zoom horizontal seulement : l'ordonnée est recalée par AUTOSCALE_Y_JS
fig.update_layout(title=f"{station} : analyses " + ", ".join(r["analysis"] for r in results),
height=300 * (n + len(metrics)),
barmode="overlay", legend=dict(groupclick="toggleitem"))
return fig
def main(paths):
"""Pour chaque station qui a BusVoltage : out/<STATION>_energy.html. -> chemins écrits."""
(ROOT / "out").mkdir(exist_ok=True)
written = []
for station, series in sorted(load_stations(paths).items()):
if "BusVoltage" not in series:
print(f"{station} : ignorée, pas de BusVoltage")
continue
path = ROOT / "out" / f"{station}_energy.html"
results = [ma.run(series), ma.run_midnight(series), bs.run(series), bt.run(series)]
figure(station, series, results).write_html(path, include_plotlyjs="cdn", post_script=AUTOSCALE_Y_JS,
config={"scrollZoom": True})
print(path)
written.append(path)
return written
if __name__ == "__main__":
for p in main(sys.argv[1:] or [str(ROOT / "data")]):
open_html(p)
+81
View File
@@ -0,0 +1,81 @@
"""DAILY_BATTERY_STATE : état de la batterie jour par jour (phase C : état seul, sans verdict).
Documentation : docs/energy/analyses/daily_battery_state.md
Bibliothèque standard uniquement (cible : système embarqué de la station).
"""
import math
from collections import defaultdict
from datetime import timedelta
HOUR = timedelta(hours=1) # grille des CSV : moyennes horaires (aucun import du projet : DAILY_BATTERY_STATE et DAILY_BATTERY_TREND se livrent seules)
# Constantes (fiche daily_battery_state, « Constantes et sources »).
FULL_CHARGE_V = 14.0 # VERMONT : maxima journaliers < 13,55 V (35 j) ou 14,02-14,33 V (135 j) ; absorption ~14,2 V
PLATEAU_FLOOR_V = 12.8 # coude LiFePO4 : table OCV du collecteur (12,8 V = 30 %) ; pente nocturne doublée sous 12,8 V
MIN_RISE_V = 0.05 # > variations horaires sur le plateau (<= 15 mV/h), < plus faible vraie montée (+0,18 V, VERMONT 04-11)
MIN_COVERAGE = 0.8 # repris de MOVING_AVERAGE_7_DAYS_DROP : 20 h mesurées sur 24
RULE = {
"id": "DAILY_BATTERY_STATE",
"phase": "C : état seul, sans verdict (anomaly = None)",
"full_charge_v": FULL_CHARGE_V,
"plateau_floor_v": PLATEAU_FLOOR_V,
"min_rise_v": MIN_RISE_V,
"min_coverage": MIN_COVERAGE,
"doc": "docs/energy/analyses/daily_battery_state.md",
}
def day_facts(day):
"""{heure UTC: tension mesurée} d'un jour -> faits et état (fiche daily_battery_state, « Principe »)."""
if not day:
return {"state": None, "coverage": 0.0}
max_v, min_v = max(day.values()), min(day.values())
# Montée du jour : la plus grande hausse depuis un minimum antérieur ; la fin de nuit est ce minimum.
# (Le maximum du jour peut être la queue de la soirée précédente, à 00:00 : il ne sert pas de repère.)
low = night_end_h = min(day)
rise_v = 0.0
for h in sorted(day):
if day[h] < day[low]:
low = h
if day[h] - day[low] > rise_v:
rise_v, night_end_h = day[h] - day[low], low
if not rise_v:
night_end_h = min(day, key=day.get) # sans montée : le point le plus bas du jour
night_end_v = day[night_end_h]
hours_full = sum(v >= FULL_CHARGE_V for v in day.values())
coverage = len(day) / 24
# Les états 1 et 2 reposent sur une valeur mesurée : ils passent avant la couverture minimale.
if hours_full:
state = "FULL_CHARGE"
elif min_v < PLATEAU_FLOOR_V:
state = "BELOW_PLATEAU"
elif coverage < MIN_COVERAGE:
state = None # UNKNOWN : trop de trous pour conclure à une absence
elif rise_v < MIN_RISE_V:
state = "NO_CHARGE"
else:
state = "PARTIAL_CHARGE"
return {"state": state, "max_v": round(max_v, 3), "min_v": round(min_v, 3), "night_end_v": round(night_end_v, 3),
"night_end_h": night_end_h,
"rise_v": round(rise_v, 3), "hours_full": hours_full, "coverage": round(coverage, 3)}
def run(series):
"""Analyse DAILY_BATTERY_STATE, causale : le jour d n'utilise que les heures de d. Un point par jour UTC."""
v = series["BusVoltage"]
if v:
t0 = min(v)
if any((t - t0) % HOUR for t in v):
raise ValueError("BusVoltage : horodatages hors de la grille horaire")
days, last = defaultdict(dict), {}
for t in sorted(v):
last[t.date()] = t
x = v[t]
if x is not None and math.isfinite(x): # NaN/inf (ex. export pandas) = pas de mesure
days[t.date()][t.hour] = x
points = []
for d in sorted(last):
facts = day_facts(days.get(d, {}))
points.append({"t": last[d], "value": facts.get("max_v"), "anomaly": None, "facts": facts})
return {"analysis": RULE["id"], "rule": RULE, "points": points}
+49
View File
@@ -0,0 +1,49 @@
"""DAILY_BATTERY_TREND : tendance de la batterie d'un jour à l'autre (modèle markovien : J face à J−1).
Documentation : docs/energy/analyses/daily_battery_trend.md
Bibliothèque standard uniquement (cible : système embarqué de la station).
"""
from datetime import timedelta
from energy import battery_state as bs
# Constantes (fiche daily_battery_trend, « Constantes et sources »).
NIGHT_END_DEADBAND_V = 0.05 # VERMONT : FULL_CHARGE enchaînés, écart de fin de nuit -0,026 à +0,043 V (5e-95e centiles, 125 paires)
STATE_RANK = {"FULL_CHARGE": 3, "PARTIAL_CHARGE": 2, "NO_CHARGE": 1, "BELOW_PLATEAU": 0} # choix de conception (fiche daily_battery_trend)
RULE = {
"id": "DAILY_BATTERY_TREND",
"verdict": "aucun : anomaly = None ; la tendance est dans facts.trend",
"night_end_deadband_v": NIGHT_END_DEADBAND_V,
"state_rank": STATE_RANK,
"doc": "docs/energy/analyses/daily_battery_trend.md",
}
def delta(prev, cur, key):
"""Écart cur − prev d'un fait de DAILY_BATTERY_STATE, None si l'un des deux manque."""
if prev.get(key) is None or cur.get(key) is None:
return None
return round(cur[key] - prev[key], 3) # arrondi au mV avant la comparaison à la zone morte
def run(series):
"""Analyse DAILY_BATTERY_TREND, causale : le jour J n'utilise que J et J−1. Un point par jour UTC."""
points, prev = [], None
for p in bs.run(series)["points"]:
a = prev["facts"] if prev and p["t"].date() - prev["t"].date() == timedelta(days=1) else {} # J−1, sinon rien
b = p["facts"]
facts = {"trend": None, "decided_by": None, "state_prev": a.get("state"), "state": b["state"],
"delta_night_end_v": delta(a, b, "night_end_v"), "delta_max_v": delta(a, b, "max_v"),
"delta_hours_full": delta(a, b, "hours_full")}
if facts["state_prev"] and facts["state"]:
if facts["state_prev"] != facts["state"]: # l'état a changé : il décide
up = STATE_RANK[facts["state"]] > STATE_RANK[facts["state_prev"]]
facts.update(trend="BETTER" if up else "WORSE", decided_by="state")
else: # même état : la fin de nuit décide, avec une zone morte
d = facts["delta_night_end_v"]
trend = "BETTER" if d > NIGHT_END_DEADBAND_V else "WORSE" if d < -NIGHT_END_DEADBAND_V else "STABLE"
facts.update(trend=trend, decided_by="night_end")
points.append({"t": p["t"], "value": facts["delta_night_end_v"], "anomaly": None, "facts": facts})
prev = p
return {"analysis": RULE["id"], "rule": RULE, "points": points}
+121
View File
@@ -0,0 +1,121 @@
"""Analyses livrées (D-020) : DAILY_BATTERY_STATE et DAILY_BATTERY_TREND, en une figure pour le site (D-021).
Usage : python3 src/energy/daily.py [CSV ou dossiers...] (défaut : data/)
Écrit out/<STATION>_daily.html (page de démo) et .json (figure Plotly pour le site, Plotly.newPlot), puis les ouvre.
Documentation : docs/energy/analyses/daily_battery_state.md et daily_battery_trend.md
"""
import sys
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1])) # src/ : paquets common et energy
from datetime import datetime, time, timezone # noqa: E402
from common.page import AUTOSCALE_Y_JS, ROOT, open_html # noqa: E402 (bascule seule sur .venv si plotly manque)
from common.stations import load_stations # noqa: E402
from plotly.subplots import make_subplots # noqa: E402
from energy import battery_state as bs, battery_trend as bt # noqa: E402
# États de DAILY_BATTERY_STATE : couleurs validées par le skill dataviz (toutes paires, fond blanc).
# Le jaune contraste peu avec le fond : chaque état a aussi son symbole, sa légende et son survol.
STATE_STYLE = {
"FULL_CHARGE": ("full charge", "#008300", "circle"),
"PARTIAL_CHARGE": ("partial charge (uncertain)", "#eda100", "diamond"),
"BELOW_PLATEAU": ("below plateau", "#2a78d6", "triangle-down"),
"NO_CHARGE": ("no charge", "#4a3aa7", "x"),
None: ("unknown state", "#8c8c8c", "circle-open"),
}
def noon(day):
"""Abscisse d'un point journalier (DAILY_BATTERY_STATE et DAILY_BATTERY_TREND) : midi UTC de son jour, au milieu de la journée."""
return datetime.combine(day, time(12), timezone.utc)
def daily_state_panel(fig, result, row):
"""Panneau DAILY_BATTERY_STATE : maximum et fin de nuit par jour, seuils, état en marqueurs (fiche daily_battery_state)."""
group = dict(legendgroup=result["analysis"], legendgrouptitle_text=f"Analysis {result['analysis']}")
rule, pts = result["rule"], result["points"]
x = [noon(p["t"].date()) for p in pts]
fig.add_scatter(x=x, y=[p["facts"].get("max_v") for p in pts], name="daily maximum", mode="lines",
line=dict(color="#52514e", width=1.5), hoverinfo="skip", row=row, col=1, **group)
fig.add_scatter(x=x, y=[p["facts"].get("night_end_v") for p in pts], name="night end", mode="lines",
line=dict(color="#9a9893", width=1.5), hovertemplate="night end %{y:.2f} V<extra></extra>",
row=row, col=1, **group)
# Seuils tracés comme des courbes (un point par jour) : AUTOSCALE_Y_JS les garde visibles au zoom (D-013).
for v, name, state in ((rule["full_charge_v"], "full charge", "FULL_CHARGE"),
(rule["plateau_floor_v"], "plateau floor", "BELOW_PLATEAU")):
fig.add_scatter(x=x, y=[v] * len(x), name=f"{name} {v} V", mode="lines", hoverinfo="skip",
line=dict(color=STATE_STYLE[state][1], dash="dash", width=1), row=row, col=1, **group)
for state, (label, color, symbol) in STATE_STYLE.items():
sel = [p for p in pts if p["facts"]["state"] == state and p["facts"].get("max_v") is not None]
if not sel:
continue
hover = [f"{p['t']:%Y-%m-%d}: {label}<br>" + "<br>".join(f"{k}={val}" for k, val in p["facts"].items())
for p in sel]
fig.add_scatter(x=[noon(p["t"].date()) for p in sel], y=[p["facts"]["max_v"] for p in sel], name=label,
mode="markers",
marker=dict(color=color, symbol=symbol, size=8, line=dict(color="white", width=1)),
text=hover, hovertemplate="%{text}<extra></extra>", row=row, col=1, **group)
fig.update_yaxes(title_text="BusVoltage [V]", row=row, col=1)
# Tendances de DAILY_BATTERY_TREND : paire divergente bleu/rouge et gris neutre du skill dataviz
# (vert/rouge refusé par son validateur : deutéranopie, ΔE 5,9). Chaque tendance a aussi sa légende et son survol.
TREND_STYLE = {"BETTER": ("better", "#2a78d6"), "STABLE": ("stable", "#8c8c8c"), "WORSE": ("worse", "#d03b3b")}
def daily_trend_panel(fig, result, row):
"""Panneau DAILY_BATTERY_TREND : écart de fin de nuit J − J−1 en barres, couleur = tendance (fiche daily_battery_trend)."""
group = dict(legendgroup=result["analysis"], legendgrouptitle_text=f"Analysis {result['analysis']}")
pts, db = result["points"], result["rule"]["night_end_deadband_v"]
x = [noon(p["t"].date()) for p in pts]
# Zone morte tracée comme une courbe (un point par jour, None entre +db et −db) : visible au zoom (D-013).
fig.add_scatter(x=x + [None] + x, y=[db] * len(x) + [None] + [-db] * len(x), name=f"dead band ±{db} V",
mode="lines", hoverinfo="skip", line=dict(color="#52514e", dash="dash", width=1),
row=row, col=1, **group)
for trend, (label, color) in TREND_STYLE.items():
sel = [p for p in pts if p["facts"]["trend"] == trend and p["value"] is not None]
if not sel:
continue
hover = [f"{p['t']:%Y-%m-%d}: {label} (decided by {p['facts']['decided_by']})<br>"
f"{p['facts']['state_prev']} → {p['facts']['state']}<br>"
+ "<br>".join(f"{k}={v}" for k, v in p["facts"].items() if k.startswith("delta")) for p in sel]
fig.add_bar(x=[noon(p["t"].date()) for p in sel], y=[p["value"] for p in sel], name=label,
marker_color=color, width=0.8 * 86_400_000, hovertext=hover, hovertemplate="%{hovertext}<extra></extra>",
row=row, col=1, **group)
fig.update_yaxes(title_text="Δ night end [V]", row=row, col=1)
def daily_figure(station, series):
"""Graphique pour le site de monitoring (D-021) : DAILY_BATTERY_STATE en haut, DAILY_BATTERY_TREND dessous, même axe du temps."""
fig = make_subplots(rows=2, cols=1, shared_xaxes=True, vertical_spacing=0.08,
subplot_titles=[f"Analysis {bs.RULE['id']}", f"Analysis {bt.RULE['id']}"])
daily_state_panel(fig, bs.run(series), 1)
daily_trend_panel(fig, bt.run(series), 2)
fig.update_xaxes(showticklabels=True)
fig.update_yaxes(fixedrange=True) # zoom horizontal seulement : l'ordonnée est recalée par AUTOSCALE_Y_JS
fig.update_layout(title=f"{station}: battery state and trend", height=700, barmode="overlay",
legend=dict(groupclick="toggleitem"))
return fig
def main(paths):
"""Pour chaque station qui a BusVoltage : out/<STATION>_daily.html et .json. -> chemins écrits."""
(ROOT / "out").mkdir(exist_ok=True)
written = []
for station, series in sorted(load_stations(paths).items()):
if "BusVoltage" not in series:
print(f"{station} : ignorée, pas de BusVoltage")
continue
path = ROOT / "out" / f"{station}_daily.html"
fig = daily_figure(station, series)
fig.write_html(path, include_plotlyjs="cdn", post_script=AUTOSCALE_Y_JS, config={"scrollZoom": True})
fig.write_json(path.with_suffix(".json"))
print(path)
written.append(path)
return written
if __name__ == "__main__":
for p in main(sys.argv[1:] or [str(ROOT / "data")]):
open_html(p)
+44
View File
@@ -0,0 +1,44 @@
"""Couleur du jour : matrice état (DAILY_BATTERY_STATE) × tendance (DAILY_BATTERY_TREND) -> vert / orange / rouge (D-020).
Documentation : docs/energy/guide/diagnostic-energetique.md (§ 7, la matrice)
Bibliothèque standard uniquement (cible : système embarqué de la station).
"""
from datetime import timedelta
from energy import battery_state as bs, battery_trend as bt
# Matrice tenue par l'utilisateur dans docs/energy/matrice-etat-tendance.drawio : MATRIX[état][tendance].
MATRIX = {
"FULL_CHARGE": {"BETTER": "GREEN", "STABLE": "GREEN", "WORSE": "GREEN"},
"PARTIAL_CHARGE": {"BETTER": "GREEN", "STABLE": "ORANGE", "WORSE": "ORANGE"},
"NO_CHARGE": {"BETTER": "ORANGE", "STABLE": "RED", "WORSE": "RED"},
"BELOW_PLATEAU": {"BETTER": "RED", "STABLE": "RED", "WORSE": "RED"},
}
RULE = {
"id": "DAY_COLOR",
"verdict": "aucun : anomaly = None ; la couleur est dans facts.color (None = inconnu, état ou tendance absent)",
"matrix": MATRIX,
"doc": "docs/energy/guide/diagnostic-energetique.md",
}
def run(series):
"""Couleur du jour, causale comme DAILY_BATTERY_STATE et DAILY_BATTERY_TREND (J et J−1). Un point par jour UTC."""
points = []
for s, t in zip(bs.run(series)["points"], bt.run(series)["points"]): # mêmes jours, même ordre (bt part de bs)
facts = {**s["facts"], **t["facts"]}
facts["color"] = MATRIX.get(facts["state"], {}).get(facts["trend"])
points.append({"t": s["t"], "value": facts["color"], "anomaly": None, "facts": facts})
return {"analysis": RULE["id"], "rule": RULE, "points": points}
def focus(series, day):
"""Ce qu'il faut montrer pour comprendre la couleur du jour J : J et la veille seulement (D-024).
-> {day, color, prev, cur, hours} : faits de J−1 (None s'il manque) et de J, mesures horaires de J−1 et J."""
by_day = {p["t"].date(): p["facts"] for p in run(series)["points"]}
if day not in by_day:
raise ValueError(f"{day} : jour absent de la série BusVoltage")
prev, v = day - timedelta(days=1), series["BusVoltage"]
return {"day": day, "color": by_day[day]["color"], "prev": by_day.get(prev), "cur": by_day[day],
"hours": {t: v[t] for t in sorted(v) if prev <= t.date() <= day}}
+141
View File
@@ -0,0 +1,141 @@
"""Focus sur un jour : sa couleur (matrice état × tendance) et ce qui l'explique, sur le jour J et la veille seulement (D-024).
Usage : python3 src/energy/focus_jour.py JJ.MM[.AAAA] [CSV ou dossiers...] (défaut : data/ ; sans année, celle des données)
Affiche le résumé des faits, écrit out/<STATION>_focus_<AAAA-MM-JJ>.html (+ .json, la figure Plotly pour le site)
et l'ouvre dans le navigateur. Textes du résumé et du graphique en anglais : destinés au site (D-023).
"""
import sys
from datetime import date, timedelta
from pathlib import Path
sys.path.insert(0, str(Path(__file__).resolve().parents[1])) # src/ : paquets common et energy
from common.page import ROOT, open_html # noqa: E402 (bascule seule sur .venv si plotly manque)
from common.stations import gaps, load_stations # noqa: E402
import plotly.graph_objects as go # noqa: E402
from energy import battery_state as bs, battery_trend as bt, day_color as dc # noqa: E402
from energy.daily import STATE_STYLE, TREND_STYLE, noon # noqa: E402
# Statuts : noms et couleurs de la maquette System Summary (maquettes/user/energy_template.html).
COLOR = {"GREEN": ("Green", "#008300"), "ORANGE": ("Orange", "#eda100"), "RED": ("Red", "#d03b3b"),
None: ("Unknown", "#8c8c8c")}
# Condition qui a donné l'état (fiche daily_battery_state, « Principe », dans l'ordre d'évaluation).
STATE_RULE = {
"FULL_CHARGE": f"at least one hour ≥ {bs.FULL_CHARGE_V} V",
"BELOW_PLATEAU": f"one hour < {bs.PLATEAU_FLOOR_V} V",
"NO_CHARGE": f"daily rise < {bs.MIN_RISE_V} V",
"PARTIAL_CHARGE": f"daily rise ≥ {bs.MIN_RISE_V} V, no hour ≥ {bs.FULL_CHARGE_V} V",
None: f"fewer than {bs.MIN_COVERAGE * 24:.0f} h measured, no conclusion",
}
def parse_day(arg, series):
"""« 27.09 » ou « 27.09.2026 » -> date ; sans année, celle de la dernière mesure."""
d, m, *y = (int(x) for x in arg.split("."))
return date(y[0] if y else max(series["BusVoltage"]).year, m, d)
def summary(station, f):
"""Résumé texte traçable : couleur, règle, faits de J−1 et de J, tendance et ce qui l'a décidée."""
d, prev, cur = f["day"], f["prev"], f["cur"]
lines = [f"{station}, {d:%d/%m/%Y}: {COLOR[f['color']][0]}",
f" rule: matrix state × trend (user manual § 7): {cur['state']} × {cur['trend']} → {f['color'] or 'unknown'}"]
for tag, x, facts in (("D-1", d - timedelta(days=1), prev), ("D ", d, cur)):
if not facts or facts.get("max_v") is None:
lines.append(f" {tag} {x:%d/%m}: no measurement")
continue
lines.append(f" {tag} {x:%d/%m}: {facts['state']} ({STATE_RULE[facts['state']]}) · max {facts['max_v']} V"
f" · night end {facts['night_end_v']} V at {facts['night_end_h']:02d}:00"
f" · {facts['coverage'] * 24:.0f} h measured")
if cur["trend"]:
how = (f"state {cur['state_prev']} → {cur['state']}" if cur["decided_by"] == "state" else
f"night end {prev['night_end_v']} → {cur['night_end_v']} V"
f" (dead band ±{bt.NIGHT_END_DEADBAND_V} V)")
lines.append(f" trend: {cur['trend']}, decided by {how} · Δ night end {cur['delta_night_end_v']:+} V")
else:
lines.append(" trend: unknown (no state for D-1 or D)")
if provisional(f):
lines.append(f" provisional: data stop at {max(f['hours']):%H:%M} UTC, "
"the color can still change until midnight UTC")
return "\n".join(lines)
def provisional(f):
"""Le jour J n'est pas fini dans les données (dernier jour d'un export, ou jour en cours) : couleur provisoire."""
last = max(f["hours"])
return last.date() == f["day"] and last.hour < 23
def figure(station, f):
"""BusVoltage horaire sur J−1 et J, seuils de DAILY_BATTERY_STATE, maximum et fin de nuit de chaque jour,
flèche de fin de nuit J−1 -> J (comparaison de DAILY_BATTERY_TREND)."""
d, h = f["day"], f["hours"]
name, color = COLOR[f["color"]]
fig = go.Figure()
fig.add_scatter(x=list(h), y=list(h.values()), mode="lines+markers", line=dict(color="#636efa", width=2),
marker_size=4, hovertemplate="%{x|%d/%m %H:%M} UTC: %{y:.3f} V<extra></extra>")
for a, b in gaps(h):
fig.add_vrect(x0=a, x1=b, fillcolor="gray", opacity=0.3, line_width=0)
for v, label, state in ((bs.FULL_CHARGE_V, "full charge", "FULL_CHARGE"),
(bs.PLATEAU_FLOOR_V, "plateau floor", "BELOW_PLATEAU")):
fig.add_hline(y=v, line_dash="dash", line_width=1, line_color=STATE_STYLE[state][1],
annotation_text=f"{label} {v} V", annotation_position="top right")
midnight = noon(d) - timedelta(hours=12) # début de J (UTC) : l'axe couvre toujours J−1 et J, 48 h
fig.add_vline(x=midnight, line_width=1, line_color="#52514e")
night_ends = []
for tag, x, facts in (("D-1", d - timedelta(days=1), f["prev"]), ("D", d, f["cur"])):
fig.add_annotation(x=noon(x), y=1.07, yref="paper", showarrow=False,
text=f"<b>{tag} {x:%d/%m}</b>: {facts['state'] or 'unknown state' if facts else 'no data'}")
if not facts or facts.get("max_v") is None:
continue
day_h = {t: v for t, v in h.items() if t.date() == x and v is not None}
t_max = max(day_h, key=day_h.get)
t_end = next(t for t in day_h if t.hour == facts["night_end_h"])
night_ends.append((t_end, facts["night_end_v"]))
hover = "<br>".join(f"{k}={v}" for k, v in facts.items())
label, c, symbol = STATE_STYLE[facts["state"]]
fig.add_scatter(x=[t_max], y=[facts["max_v"]], mode="markers+text", text=[f"max {facts['max_v']} V"], cliponaxis=False,
textposition="top center", marker=dict(color=c, symbol=symbol, size=12),
hovertext=[f"{x:%d/%m}: {label}<br>{hover}"], hovertemplate="%{hovertext}<extra></extra>")
fig.add_scatter(x=[t_end], y=[facts["night_end_v"]], mode="markers+text", cliponaxis=False,
text=[f"night end {facts['night_end_v']} V"], textposition="bottom center",
marker=dict(color="#52514e", size=10), hovertext=[f"{x:%d/%m}: night end<br>{hover}"],
hovertemplate="%{hovertext}<extra></extra>")
trend = f["cur"]["trend"]
if len(night_ends) == 2 and trend:
(t0, v0), (t1, v1) = night_ends
label, c = TREND_STYLE[trend]
fig.add_annotation(x=t1, y=v1, ax=t0, ay=v0, axref="x", ayref="y", text="", showarrow=True,
arrowhead=2, arrowwidth=2, arrowcolor=c)
fig.add_annotation(x=t0 + (t1 - t0) / 2, y=(v0 + v1) / 2, showarrow=False, yshift=14, font_color=c,
text=f"{label} (decided by {f['cur']['decided_by'].replace('_', ' ')}) · "
f"Δ night end {f['cur']['delta_night_end_v']:+} V")
fig.update_xaxes(range=[midnight - timedelta(days=1), midnight + timedelta(days=1)], dtick=6 * 3_600_000, tickformat="%d/%m %H:%M")
ys = [v for v in h.values() if v is not None] + [bs.FULL_CHARGE_V, bs.PLATEAU_FLOOR_V] # seuils toujours visibles
fig.update_yaxes(title_text="BusVoltage [V]", range=[min(ys) - 0.15, max(ys) + 0.15])
fig.update_layout(title=f"{station}, {d:%d %b %Y}: <span style='color:{color}'>■ {name}</span>"
f" · {f['cur']['state']} × {trend or 'unknown trend'}"
+ (" · provisional (day not over)" if provisional(f) else "")
+ "<br><sup>gray band: no measurement · dashed: thresholds of the daily state"
" · arrow: night end D-1 → D (trend)</sup>",
height=500, showlegend=False, margin=dict(t=120))
return fig
if __name__ == "__main__":
if len(sys.argv) < 2:
sys.exit(__doc__)
(ROOT / "out").mkdir(exist_ok=True)
for station, series in sorted(load_stations(sys.argv[2:] or [str(ROOT / "data")]).items()):
if "BusVoltage" not in series:
continue
try:
f = dc.focus(series, parse_day(sys.argv[1], series))
except ValueError as e:
sys.exit(f"{station} : {e} (date attendue : JJ.MM ou JJ.MM.AAAA)")
print(summary(station, f))
path = ROOT / "out" / f"{station}_focus_{f['day']}.html"
fig = figure(station, f)
fig.write_html(path, include_plotlyjs="cdn")
fig.write_json(path.with_suffix(".json"))
print(path)
open_html(path)
+126
View File
@@ -0,0 +1,126 @@
"""Tendance de BusVoltage en moyenne glissante sur 7 jours (comparaison seulement, non livrée : D-020).
- MOVING_AVERAGE_7_DAYS_DROP (docs/energy/analyses/moving_average_7_days_drop.md) : sur toutes les heures ;
- MOVING_AVERAGE_7_DAYS_MIDNIGHT_UTC_DROP (docs/energy/analyses/moving_average_7_days_midnight_utc_drop.md) :
le même calcul sur la seule mesure de 00:00 UTC.
Bibliothèque standard uniquement (cible : système embarqué de la station).
"""
import math
from datetime import timedelta
HOUR = timedelta(hours=1)
DAY = timedelta(days=1)
# Constantes de calibration (fiche moving_average_7_days_drop, « Constantes et sources »).
WINDOW_H = 168 # multiple de 24 h : annule le cycle jour/nuit ; 72 h ne lisse pas la météo
REF_H = 720 # 30 jours : contient le dernier régime sain avant un déficit (choix de conception)
MIN_COVERAGE = 0.8 # à 0,5, JUNGFRAU (sain) tombe à -0,19 V en début d'historique ; à 0,8 : -0,13 V
MIN_REF_POINTS = 24 # au moins un jour de référence (choix de conception)
THRESHOLD_V = -0.2 # cas de régression : pire écart sain -0,16 V (VERMONT 05-11)
RULE = {
"id": "MOVING_AVERAGE_7_DAYS_DROP",
"window_h": WINDOW_H,
"ref_h": REF_H,
"min_coverage": MIN_COVERAGE,
"min_ref_points": MIN_REF_POINTS,
"threshold_v": THRESHOLD_V,
"threshold_source": "cas de régression FLORIDA, JUNGFRAU, VERMONT, WILDSTRUBEL, MISSISSIPPI (fiche moving_average_7_days_drop, « Calibration »)",
"doc": "docs/energy/analyses/moving_average_7_days_drop.md",
}
# MOVING_AVERAGE_7_DAYS_MIDNIGHT_UTC_DROP : les mêmes constantes, converties en jours (un point par jour, fiche moving_average_7_days_midnight_utc_drop).
RULE_MIDNIGHT = {
"id": "MOVING_AVERAGE_7_DAYS_MIDNIGHT_UTC_DROP",
"sample": "BusVoltage à 00:00 UTC",
"window_d": WINDOW_H // 24,
"ref_d": REF_H // 24,
"min_coverage": MIN_COVERAGE,
"min_ref_points": MIN_REF_POINTS // 24,
"threshold_v": THRESHOLD_V,
"threshold_source": "repris de MOVING_AVERAGE_7_DAYS_DROP pour comparer les méthodes, non recalibré (fiche moving_average_7_days_midnight_utc_drop)",
"doc": "docs/energy/analyses/moving_average_7_days_midnight_utc_drop.md",
}
def run(series):
"""Analyse MOVING_AVERAGE_7_DAYS_DROP, causale : le point t n'utilise que les données <= t (fiche moving_average_7_days_drop, « Principe »)."""
return _ma_drop(series["BusVoltage"], HOUR, WINDOW_H, REF_H, MIN_REF_POINTS, RULE)
def run_midnight(series):
"""Analyse MOVING_AVERAGE_7_DAYS_MIDNIGHT_UTC_DROP : le même calcul sur la seule mesure de 00:00 UTC (fiche moving_average_7_days_midnight_utc_drop)."""
v = {t: x for t, x in series["BusVoltage"].items() if t.hour == t.minute == 0}
return _ma_drop(v, DAY, WINDOW_H // 24, REF_H // 24, MIN_REF_POINTS // 24, RULE_MIDNIGHT)
def _ma_drop(v, step, window, ref_n, min_ref, rule):
"""Moyenne sur `window` pas de `step`, comparée à son maximum des `ref_n` pas précédents (causal)."""
if not v:
return {"analysis": rule["id"], "rule": rule, "points": []}
t0 = min(v)
if any((t - t0) % step for t in v):
raise ValueError(f"BusVoltage : horodatages hors de la grille (pas de {step})")
grid = [t0 + i * step for i in range((max(v) - t0) // step + 1)]
# NaN/inf (ex. export pandas) = pas de mesure : sinon un NaN pollue la somme courante.
vals = [x if x is not None and math.isfinite(x) else None for x in (v.get(t) for t in grid)]
# Moyenne glissante sur `window` créneaux (somme courante), définie si couverture suffisante.
ma, cov = [None] * len(grid), [0.0] * len(grid)
total = count = 0
for i, x in enumerate(vals):
if x is not None:
total += x
count += 1
if i >= window and vals[i - window] is not None:
total -= vals[i - window]
count -= 1
cov[i] = count / window
if count >= MIN_COVERAGE * window:
ma[i] = total / count
points = []
for i, t in enumerate(grid):
if t not in v:
continue
facts = {"coverage": round(cov[i], 3)}
value = anomaly = None
if ma[i] is not None:
facts["ma_v"] = round(ma[i], 3)
lo = max(0, i - ref_n)
ref_vals = [m for m in ma[lo:i] if m is not None]
if len(ref_vals) >= min_ref:
ref = max(ref_vals)
value = ma[i] - ref
anomaly = value < rule["threshold_v"]
facts["ref_v"] = round(ref, 3)
facts["ref_t"] = grid[ma.index(ref, lo, i)]
points.append({"t": t, "value": value, "anomaly": anomaly, "facts": facts})
return {"analysis": rule["id"], "rule": rule, "points": points}
def periods(points):
"""Séquences maximales True/None commençant et finissant par True."""
spans, cur = [], None
for k, p in enumerate(points):
if p["anomaly"] is True:
if cur is None:
cur = {"first": k, "last": k, "worst": k}
cur["last"] = k
if p["value"] < points[cur["worst"]]["value"]:
cur["worst"] = k
elif p["anomaly"] is False and cur is not None:
spans.append(cur)
cur = None
if cur is not None:
spans.append(cur)
out = []
for s in spans:
ongoing = all(p["anomaly"] is None for p in points[s["last"] + 1:])
out.append({
"start": points[s["first"]]["t"],
"end": None if ongoing else points[s["last"]]["t"],
"worst_value": points[s["worst"]]["value"],
"worst_t": points[s["worst"]]["t"],
})
return out