Files

255 lines
13 KiB
Python
Raw Permalink Normal View History

"""System metrics of the station (metrics/: temperatures, voltage, battery, link…), as a table and a figure,
against the target median of corr_x, corr_y and the camera pose.
Usage: .venv/bin/python tools/scripts/metrics.py data/PS_DES_COUDRES/
[--names sensor_A0_deg_c,BusVoltage] [--step 1h] [--stat median|min|max] [--against temperature] [--smoothing 24h]
2026-11-18 11:22:02 +01:00
[--metrics-only] [--weather [precipitation_mm,temperature_c,...]] [--sensors A,B] [--start ...] [--end ...]
[--out FOLDER]
Columns: `temperature` (median of the sensor_*_deg_c components at each hour, as the detectors read it,
data.load_temperature), then each metric of --names (default: the *_deg_c and BusVoltage present), then,
unless --metrics-only, tgt_corr_x, tgt_corr_y (at each measurement, median over the targets of corr minus the target's
2026-11-18 11:22:02 +01:00
own level, its median over the window; accepted measurements only), with --sensors A,B the same for each of these
sensors alone (A_corr_x, A_corr_y: one sensor that follows the temperature where the median does not), and the raw camera pose (cam_pan,
2026-11-18 11:20:57 +01:00
cam_tilt, cam_rotation, cam_scale, cam_sigma0); with --weather, the hourly MeteoSwiss weather of weather/
(data.load_weather; the hour starting at time_utc), one w_<column> column each (default WEATHER), and where it was
measured is printed first. An empty cell of a metrics/ CSV is skipped, not read as zero.
A text metric (BatteryState, link, last_sync…) is given as it is (the last one of the step).
Never an identifier: SIM_CCID and ip* are neither read nor listed.
Prints: the available metrics; the table, one line per step of --step (start of the step, UTC; --stat of the values of the
step; "-": no value), steps where no metric has a value are left out; per column, the number of filled
steps, the minimum and the maximum with their time; the correlation r and the slope (least squares, over the steps where
both have a value) of each numeric column on --against (default temperature; with --smoothing D, on its
moving average centred over D, column <against>_smooth); the dated runs of steps without any metric.
One PNG, path printed: temperatures on one panel, each other numeric metric on its own, then tgt_corr_x,
tgt_corr_y and the pose, at native times (line broken over a gap). Gives values, not a verdict.
"""
import argparse
import csv
import glob
import os
import statistics
import sys
from datetime import date, timedelta
import matplotlib
matplotlib.use("Agg")
import matplotlib.dates as mdates # noqa: E402
import matplotlib.pyplot as plt # noqa: E402
from common import STATS, bound, cut, duration, group, targets # noqa: E402
2026-11-18 11:20:57 +01:00
from data import (METRIC_RE, POSE, WHERE, filter_window, iso, load, load_camera, load_temperature, # noqa: E402
load_weather, parse_time)
WEATHER = "precipitation_mm,temperature_c,humidity_pct,wind_speed_kmh,sunshine_min" # default of --weather
def is_identifier(name):
"""Metric that carries an identifier (SIM card, IP addresses): never read."""
return name == "SIM_CCID" or name.startswith("ip")
def parse_value(text):
v = text.strip().strip("[]").strip("'\"")
try:
return float(v)
except ValueError:
return v or None
def read_metrics(folder, start, end):
"""metrics/ -> {name: [{'t', 'v'}]} sorted, over the window; v float or text; empty cell skipped; name without a value: []."""
prefix = os.path.basename(os.path.normpath(folder)) + "_"
by_name = {}
for p in glob.glob(os.path.join(folder, "metrics", "*.csv")):
m = METRIC_RE.match(os.path.basename(p))
if not m:
continue
name = m.group(1)
name = name[len(prefix):] if name.startswith(prefix) else name.split("_", 1)[-1]
if is_identifier(name):
continue
day = date(*map(int, m.group(2, 3, 4)))
series = by_name.setdefault(name, {})
if (start and day < start.date() - timedelta(days=1)) or (end and day > end.date()):
continue
with open(p, newline="") as f:
for r in csv.DictReader(f):
if (v := parse_value(r.get("metric") or "")) is not None:
series[parse_time(r["time_utc"])] = v
return {n: filter_window([{"t": t, "v": s[t]} for t in sorted(s)], start, end) for n, s in by_name.items()}
def smooth(series, width):
"""Moving average centred over width (numeric values)."""
pts = [p for p in series if isinstance(p["v"], float)]
# ponytail: O(n²), enough for hourly metrics over a few weeks
return [{"t": p["t"], "v": statistics.fmean(q["v"] for q in pts if abs(q["t"] - p["t"]) <= width / 2)} for p in pts]
def fmt(v):
return "-" if v is None else f"{v:.6g}" if isinstance(v, float) else str(v)
def main():
a = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
a.add_argument("folder")
a.add_argument("--names", help="metrics, comma-separated (default: the *_deg_c and BusVoltage present)")
a.add_argument("--step", default="1h")
a.add_argument("--stat", default="median", choices=STATS)
a.add_argument("--against", default="temperature", help="column on which r and the slope are computed")
a.add_argument("--smoothing", type=duration, help="centred moving average of --against, e.g. 24h")
a.add_argument("--metrics-only", action="store_true", help="without tgt_corr_x, tgt_corr_y or the pose")
2026-11-18 11:20:57 +01:00
a.add_argument("--weather", nargs="?", const=WEATHER, metavar="COLUMNS",
help=f"add the weather/ columns, comma-separated (without a value: {WEATHER})")
2026-11-18 11:22:02 +01:00
a.add_argument("--sensors", help="sensors, comma-separated: their own corr_x, corr_y minus their level, as columns")
a.add_argument("--start", type=parse_time)
a.add_argument("--end", type=parse_time)
a.add_argument("--out", default=os.path.join("out", "diagnostic"), help="folder of the PNG")
o = a.parse_args()
step = duration(o.step)
met = read_metrics(o.folder, o.start, o.end)
if not met:
print(f"No metrics/ in {o.folder}.")
else:
print("Available metrics (values over the window; identifiers SIM_CCID, ip* excluded): "
+ ", ".join(f"{n} ({len(s)})" if s else f"{n} (empty)" for n, s in sorted(met.items())))
if o.names:
names = o.names.split(",")
if forbidden := [n for n in names if is_identifier(n)]:
sys.exit(f"Identifiers, never read: {', '.join(forbidden)}.")
if missing := [n for n in names if n not in met]:
sys.exit(f"Unknown metrics: {', '.join(missing)}. Known: {', '.join(sorted(met))}.")
else:
names = sorted(n for n in met if n.endswith("_deg_c")) + [n for n in ("BusVoltage",) if n in met]
series = {"temperature": filter_window([{"t": t, "v": v} for t, v in load_temperature(o.folder)], o.start, o.end)}
series.update({n: met[n] for n in names})
if o.smoothing:
if o.against not in series:
sys.exit(f"--against {o.against}: not a column ({', '.join(series)}).")
series[o.against + "_smooth"] = smooth(series[o.against], o.smoothing)
metric_cols = list(series)
2026-11-18 11:22:02 +01:00
sensor_cols = set() # columns of --sensors
2026-11-18 11:20:57 +01:00
if o.weather:
hours = load_weather(o.folder)
if not hours:
print(f"No weather/ in {o.folder}.")
else:
known = [c for c in hours[0] if c not in WHERE and c != "t"]
if missing := [c for c in o.weather.split(",") if c not in known]:
sys.exit(f"Unknown weather columns: {', '.join(missing)}. Known: {', '.join(known)}.")
h = hours[-1]
print(f"Weather: {h.get('station_name')} ({h.get('place')}), {h.get('distance_km')} km, {h.get('height_m')} m; "
"hourly, the hour starting at the time given")
hours = filter_window(hours, o.start, o.end)
for c in o.weather.split(","):
series["w_" + c] = [{"t": p["t"], "v": p[c]} for p in hours if p[c] is not None]
if not o.metrics_only:
by_sensor = load(o.folder)
for c in ("corr_x", "corr_y"):
series["tgt_" + c] = targets(by_sensor, c, o.start, o.end)
2026-11-18 11:22:02 +01:00
for s in o.sensors.split(",") if o.sensors else []:
if s not in by_sensor:
sys.exit(f"Unknown sensor: {s}. Known: {', '.join(by_sensor)}.")
for c in ("corr_x", "corr_y"):
ms = [m for m in filter_window(by_sensor[s], o.start, o.end) if m[c] is not None]
level = statistics.median(m[c] for m in ms) if ms else 0
series[f"{s}_{c}"] = [{"t": m["t"], "v": m[c] - level} for m in ms]
sensor_cols.add(f"{s}_{c}")
poses = filter_window(load_camera(o.folder), o.start, o.end)
for c in POSE:
series["cam_" + c] = [{"t": p["t"], "v": p[c]} for p in poses if p[c] is not None]
reference = o.against + "_smooth" if o.smoothing else o.against
if reference not in series:
sys.exit(f"--against {o.against}: not a column ({', '.join(series)}).")
times = [p["t"] for s in series.values() for p in s]
if not times:
sys.exit("No value in the requested window.")
t0 = (o.start or min(times)).replace(minute=0, second=0, microsecond=0)
t1 = o.end or max(times)
cells = {} # column -> start of the step -> values
for c, s in series.items():
for p in s:
cells.setdefault(c, {}).setdefault(t0 + ((p["t"] - t0) // step) * step, []).append(p["v"])
stat = STATS[o.stat]
table = {c: {k: (stat(v) if all(isinstance(x, float) for x in v) else v[-1]) for k, v in d.items()}
for c, d in cells.items()}
grid = [t0 + i * step for i in range(int((t1 - t0) / step) + 1)]
columns = list(series)
print(f"\n{o.stat} per step of {o.step} (start of the step, UTC); \"-\": no value; tgt_: deviation from the targets' own level")
print("\t".join(["time"] + columns))
for k in grid:
line = [table.get(c, {}).get(k) for c in columns]
if any(v is not None for v in line):
print("\t".join([iso(k)] + [fmt(v) for v in line]))
print(f"\nPer column ({len(grid)} steps):")
for c in columns:
d = table.get(c, {})
nums = [(v, k) for k, v in d.items() if isinstance(v, float)]
if not d:
print(f" {c}: empty")
elif nums:
(vmin, kmin), (vmax, kmax) = min(nums), max(nums)
print(f" {c}: {len(d)} steps; min {fmt(vmin)} ({iso(kmin)}); max {fmt(vmax)} ({iso(kmax)})")
else:
ks = sorted(d)
print(f" {c}: {len(d)} steps, text; {len(set(d.values()))} distinct values; "
f"first {d[ks[0]]} ({iso(ks[0])}); last {d[ks[-1]]} ({iso(ks[-1])})")
ref = table.get(reference, {})
print(f"\nCorrelation r and slope on {reference} (over the steps where both have a value):")
if not any(isinstance(v, float) for v in ref.values()):
print(f" {reference} empty: none")
for c in columns:
if c == reference or not ref or not any(isinstance(v, float) for v in table.get(c, {}).values()):
continue
pairs = [(ref[k], v) for k, v in table.get(c, {}).items()
if isinstance(v, float) and isinstance(ref.get(k), float)]
try:
r = statistics.correlation(*zip(*pairs))
slope = statistics.linear_regression(*zip(*pairs)).slope
print(f" {c}: r = {r:+.2f}; slope = {slope:.4g} per unit of {reference}; n = {len(pairs)}")
except (statistics.StatisticsError, TypeError, ValueError):
print(f" {c}: - (n = {len(pairs)})")
empty = [k for k in grid if all(k not in table.get(c, {}) for c in metric_cols)]
print(f"\nSteps without any metric ({', '.join(metric_cols)}): {len(empty)} of {len(grid)}")
for g in group(empty, lambda a, b: b - a == step):
print(f" {iso(g[0])} → {iso(g[-1])} ({len(g)} steps)")
panels = {} # title -> columns
for c in columns:
if any(isinstance(p["v"], float) for p in series[c]):
2026-11-18 11:22:02 +01:00
key = ("°C" if c.startswith("temperature") or "_deg_c" in c
else "tgt_" + c[-6:] if c in sensor_cols else c) # a sensor's corr on the panel of the targets'
panels.setdefault(key, []).append(c)
if not panels:
print("\nNothing to plot.")
return
fig, axes = plt.subplots(len(panels), 1, sharex=True, figsize=(14, 2.4 * len(panels)), squeeze=False,
layout="constrained")
for ax, (title, cols) in zip(axes[:, 0], panels.items()):
for c in cols:
black = c in ("temperature", reference)
ax.plot(*cut(series[c]), ".-", ms=2, lw=1.4 if black else 0.7, label=c, zorder=3 if black else 2,
color="k" if c == "temperature" else None)
if len(cols) > 1:
ax.legend(loc="upper left", bbox_to_anchor=(1.0, 1.0), fontsize=8)
ax.set_ylabel(title if title == "°C" else title.replace("_", "_\n", 1), fontsize=8)
ax.grid(alpha=0.3)
axes[-1, 0].xaxis.set_major_formatter(mdates.DateFormatter("%d/%m\n%H:%MZ"))
station = os.path.basename(os.path.normpath(o.folder))
fig.suptitle(f"{station}: metrics, targets and pose (UTC times)")
os.makedirs(o.out, exist_ok=True)
out = os.path.join(o.out, f"{station}_metrics_{bound(o.start, 'start')}_{bound(o.end, 'end')}.png")
fig.savefig(out, dpi=100, bbox_inches="tight")
print(f"\n{out}")
if __name__ == "__main__":
main()