Files
goodwe-addon/goodwe_controller/test_ev18.py
T
ems-agentandClaude 12c97b56f4
checks / unit (pull_request) Successful in 23m6s
infra-pin / fresh (pull_request) Successful in 2s
EV-18: no floor alarm at a quarter's start while the car explains the excess
EV-15 rig F-A: with both batteries at the peak reserve and the car charging,
PEAK_GUARD_FLOOR_LIMITED and goodwe_peak_soc_floor fired at a quarter's start
and stayed red for the quarter, the excess smaller than the car. Two causes,
both held by the per-quarter latch `_car_need_excl`:
- C2: "without the car" assumed the batteries give 0 W from now on, so what
  the loop still gives below the reserve counted as house (T2 red on base);
- C1: one cycle with no trusted car figure latched it for the quarter (T1).

Owner 2026-11-19 (Q1-Q3): without the car the batteries keep giving what they
give now (lower of two readings, every cycle); a house need seen with a
trusted car figure stays latched to the quarter's end (`_car_need_house`); an
unknown car figure keeps the alarm only while it is unknown. A car known to
draw nothing (fresh reading, not charging) still grades the house's own need.
After a restart or a gap only the rest of the quarter is graded without the
car. A 0 W figure explains nothing outside our own pause (EV-15). The guard's
claim, floor, setpoints and charger writes are unchanged (N4: 41 runs, same
command digests as base).

test_ev18.py: the test plan's T1-T18, T2b, T2c, N2-N5 (tools/ev18_peak.py:
the real Controller across one quarter edge, N=2 at the reserve).

Co-Authored-By: Claude <noreply@anthropic.com>
2026-11-19 02:59:50 +01:00

682 lines
31 KiB
Python

"""EV-18: no floor alarm at a quarter's start while the car explains the excess
(EV-15 rig F-A). `python3 -B test_ev18.py`
The rig: both batteries at the peak reserve, the car charging, and
PEAK_GUARD_FLOOR_LIMITED + `goodwe_peak_soc_floor` at a quarter's start, red
for most of the quarter, while the grid excess was smaller than the car. Two
causes, both latched for the quarter by `_car_need_excl`:
C1 one cycle with no trusted car figure set the latch (T1);
C2 "without the car" assumed the batteries give 0 W from now on, so what
the loop still gives below the reserve counted as house (T2).
The rule now (owner 2026-11-19, Q1-Q3): without the car the batteries keep
giving what they give now (the lower of the last two readings, re-checked
every cycle); a house need seen with a trusted car figure stays latched to the
quarter's end; an unknown car figure keeps the alarm only while it is unknown.
T-ids are the test plan's (reports/EV-18-test-plan.md). "base" is 9fdce02.
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
"""
import os
import sys
from datetime import datetime, timedelta, timezone
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, os.path.join(HERE, "tools"))
from app import chargers as CH, ctl_car, tariff # noqa: E402
from chargersim import SimCharger # noqa: E402
from named_absence import first, nth, present # noqa: E402
import ev04_peak as P # noqa: E402
import ev18_peak as H # noqa: E402
fails = []
def check(name, cond):
print(f" {'ok ' if cond else 'FAIL'} {name}")
if not cond:
fails.append(name)
AIM = H.AIM
CAR = 1380.0
E = H.E
# Measured on base 9fdce02 with this file's own runs: the seconds of
# goodwe_peak_soc_floor in the honest shapes, which must not come later now. An
# honest shape steps the house at E, and the meter shows it at E+1.
T5_BASE = [E + 1] # also T6 (T5 shape), T8, T9(a), T10(b) T5
T7_BASE = E + 72
T9B_BASE = [] # 400 W real: never uncorroborated (Findings)
T9C_BASE = E + 1 # 100 W real: never trusted at the edge
T10A_T5_BASE = [E + 2] # the guard disengages at E+1 (no battery reading)
T11_BASE = [E + 13] # SAFETY-87: ALARM_HOLD_S after the step
T13_BASE = [E + 301]
T15_T5_BASE = [E + 10] # x10: one cycle
# =========================================================================== #
print("1. UNIT: car_cycle ACROSS A QUARTER EDGE (a real `_carq`, not preset)")
# =========================================================================== #
BS = datetime(2026, 11, 17, 21, 15, tzinfo=timezone.utc) # the edge E
class _Car(ctl_car.CarMixin):
def __init__(self):
self.o = {"ev_batt_cover": True}
self.w = CAR
self._now = 0.0
self.site_batt_w, self.site_rating_w = 0.0, 9600.0
self.store = type("S", (), {"data": {}, "set": lambda s, k, v: 0})()
self.car_init({}, self.store)
def car_now(self):
return self._now
def car_alarm_w(self):
return self.w
class car: # noqa: N801
@staticmethod
def status(*_a):
return "charging"
class _G:
"""Floor-limited, the floor leaves nothing (floor_w 0), wants power."""
def __init__(self, wants=True, within_aim=False):
self.floor_limited, self.saturated = True, False
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, AIM + 50.0
self.engaged, self.blind = True, None
self.wanted_w = 300.0 if wants else 0.0
self.within_aim = within_aim
def urun(secs, grid, batt, w, *, x=1, mono_x=None, c=None, guard=None):
"""`car_cycle` once per entry of `secs` (seconds from the edge E, `x` fake
seconds apart). `grid(t)` is the meter (house + car - batteries),
`batt(t)` the site battery reading, `w(t)` the trusted car figure. Returns
(car, {t: car_explains})."""
c = c or _Car()
mono_x = x if mono_x is None else mono_x
done, out = {}, {}
for t in secs:
q = t // 900
bs, el = BS + timedelta(seconds=900 * q), t - 900 * q
g = float(grid(t))
d = done.get(bs, g * el)
p = tariff.Projection(
projected_w=(d + g * (900 - el)) / 900.0,
elapsed_w=(d / el if el else g), elapsed_s=float(el),
covered_frac=1.0, complete=False, block_start=bs, held_w=g)
done[bs] = d + g * x
c._now = 10000.0 + t * mono_x / x
c.w, c.site_batt_w = w(t), batt(t)
c.car_cycle(p, guard(t) if guard else _G(), AIM, None)
out[t] = c.car_explains
return c, out
def const(v):
return lambda t: v
def run_of(d, t0, t1):
return [d[t] for t in sorted(d) if t0 <= t <= t1]
# --- T1: the car figure untrusted for the edge's first cycles --------------- #
def t1(x=1, mono_x=None):
_c, ex = urun(range(-30, 121, x), const(13000.0 + CAR), const(0.0),
lambda t: None if 0 <= t <= 2 * x else CAR, x=x,
mono_x=mono_x)
return ex
ex = t1()
print(f" T1 explains E-1..E+5: {run_of(ex, -1, 5)}")
check("T1 PRECONDITION: before the edge the car (trusted) explains the "
"excess (house 13 000 W, car 1 380 W, grid 14 380 W)",
all(run_of(ex, -30, -1)) and len(run_of(ex, -30, -1)) == 30)
check("T1 (Expected 5): while the car figure is unknown (E+0..E+2) it "
"explains nothing, so the alarm stands", not any(run_of(ex, 0, 2)))
_c1b, ex1b = urun(range(-30, 121), const(12500.0 + CAR - 800.0), const(800.0),
lambda t: None if 0 <= t <= 2 else CAR)
check("T1b (the EV-10 path: the grid lands under the aim, the batteries at "
"0 W would miss; house 12 500 W, b 800 W): unknown E+0..E+2, released "
"at E+3 and explained to E+120",
not any(run_of(ex1b, 0, 2)) and all(run_of(ex1b, 3, 120))
and len(run_of(ex1b, 3, 120)) == 118)
check("T1 (Expected 3): released at the first trusted cycle (E+3) and "
"explained to E+120 (base: latched False to E+120)",
all(run_of(ex, 3, 120)) and len(run_of(ex, 3, 120)) == 118)
# --- T2c: the battery W boundary, graded on the lower of two readings ------- #
def t2c(b_of):
_c, ex = urun(range(0, 6), lambda t: 14000.0 + CAR - b_of(t), b_of,
const(CAR))
return run_of(ex, 0, 5)
e391, e389 = t2c(const(391.0)), t2c(const(389.0))
e395 = t2c(lambda t: 395.0 if t == 0 else 385.0)
print(f" T2c 391 W {e391}, 389 W {e389}, 395 then 385 W {e395}")
check("T2c: b steady at 391 W (house alone with the real batteries lands "
"13 609 W, aim + 9 W): the car explains from E+0", all(e391)
and len(e391) == 6)
check("T2c: b at 389 W (13 611 W, aim + 11 W): it does not, from E+0",
not any(e389) and len(e389) == 6)
check("T2c: readings 395 then 385 W: graded on 385 W, no explanation from "
"the second cycle on", not any(e395[1:]) and len(e395) == 6)
# --- T4: ALARM_MISS_W, batteries at 0 W -------------------------------------- #
e09 = run_of(urun(range(0, 6), const(13609.0 + CAR), const(0.0),
const(CAR))[1], 0, 5)
e11 = run_of(urun(range(0, 6), const(13611.0 + CAR), const(0.0),
const(CAR))[1], 0, 5)
check("T4 unit: the house alone at aim + 9 W: the car explains from E+0; at "
"aim + 11 W it does not", all(e09) and len(e09) == 6 and not any(e11))
# --- T8 / N2: 0 W and tiny cars ---------------------------------------------- #
e0 = run_of(urun(range(-5, 30), const(14000.0 - 800.0), const(800.0),
const(0.0))[1], -5, 29)
e50 = run_of(urun(range(-5, 30), const(14090.0 + 50.0), const(0.0),
const(50.0))[1], -5, 29)
check("T8 unit: a 0 W car never explains, whatever the batteries give (T2 "
"shape, b 800 W)", not any(e0) and len(e0) == 35)
check("T8 unit: a 50 W car with the house at 14 090 W never explains",
not any(e50) and len(e50) == 35)
# N2: a car that drew 11 kW earlier in the quarter and now reports 0 W
c0, ex0 = urun(range(0, 400), lambda t: 2600.0 + (11040.0 if t < 300 else 0.0),
const(0.0), lambda t: 11040.0 if t < 300 else 0.0)
check("N2: a trusted 0 W figure explains nothing, also after the car drew "
"earlier in the quarter", not any(run_of(ex0, 300, 399)))
# --- T8 unit: a car known to draw nothing is not an unknown car ------------- #
class _Tracker:
"""The two things `_car_idle` reads: the reading, and its fresh power."""
def __init__(self, available):
self.reading = CH.ChargerReading(available=available, state="B",
charging=False, power_w=0.0)
def car_w(self, _now):
return 0.0 if self.reading.available else None
@staticmethod
def status(*_a):
return "charging"
def idle_then_charging(available):
c = _Car()
c.car = _Tracker(available)
_c, ex = urun(range(0, 900),
lambda t: 14090.0 if t < 60 else 13000.0 + CAR, const(0.0),
lambda t: None if t < 60 else CAR, c=c)
return ex
exi, exu = idle_then_charging(True), idle_then_charging(False)
check("T8 unit: a car known idle (mode3 B, 0 W, fresh) while the house alone "
"misses (14 090 W): that house need is latched, so the car charging "
"from E+60 does not explain the quarter (test_ev10's `swapped` case)",
not any(run_of(exi, 0, 899)))
check("T8 unit: the same with the charger unavailable (unknown car): the "
"alarm stands while unknown and is released at E+60 (Expected 5)",
not any(run_of(exu, 0, 59)) and all(run_of(exu, 60, 899)))
# --- T10(a) unit: the battery reading lost for one cycle --------------------- #
cA, eA = urun(range(-3, 10), const(14000.0 + CAR - 800.0),
lambda t: None if t == 1 else 800.0, const(CAR))
check("T10(a) unit, T2 shape: the cycle with no battery reading explains "
"nothing (no last-known W credited); the next ones do",
eA.get(1) is False and eA.get(0) is True and all(run_of(eA, 2, 9))
and len(run_of(eA, 2, 9)) == 8)
# --- T13 unit: a house need seen with a trusted car stays latched ----------- #
c13, e13 = urun(range(-5, 1000),
lambda t: (15500.0 if 300 <= t < 360 else 13000.0) + CAR,
const(0.0), const(CAR))
check("T13 unit: the house steps to 15 500 W at E+300 for 60 s (landing "
"without the car 14 667 W): not explained from E+300 to the quarter's "
"end, though the house is back at 13 000 W from E+360",
all(run_of(e13, 0, 299)) and not any(run_of(e13, 300, 899))
and len(run_of(e13, 300, 899)) == 600)
check("T13 unit: ...and released by the new quarter", all(run_of(e13, 900, 999)))
c13g, e13g = urun(range(0, 400),
lambda t: (15500.0 if 100 <= t < 160 else 13000.0) + CAR,
const(0.0), const(CAR),
guard=lambda t: _G(wants=not (t == 250)))
check("T13 unit: ...or by the guard no longer wanting power (EV-10)",
not any(run_of(e13g, 100, 249)) and all(run_of(e13g, 251, 399)))
# --- T14: no flicker --------------------------------------------------------- #
def floor_edges(ex):
"""Per quarter, False -> True edges of the floor alarm the stub implies
(floor-limited, within_aim False, not explained)."""
out, was = {}, False
for t in sorted(ex):
al = not ex[t]
if al and not was:
out[t // 900] = out.get(t // 900, 0) + 1
was = al
return out
_ca, eta = urun(range(0, 1200),
lambda t: 13610.0 + (40.0 if int(t // 7) % 2 else -40.0) + CAR,
const(0.0), const(CAR))
_cb, etb = urun(range(0, 1200),
lambda t: 14000.0 + CAR - (400.0 if int(t // 7) % 2 else 800.0),
lambda t: 400.0 if int(t // 7) % 2 else 800.0, const(CAR))
fa, fb = floor_edges(eta), floor_edges(etb)
print(f" T14 alarm edges per quarter: (a) {fa} (b) {fb}")
check("T14(a): the house alone straddles aim + 10 W by 40 W every 7 s: at "
"most one alarm edge per quarter", all(v <= 1 for v in fa.values()))
check("T14(b): T2 shape with b alternating 400 / 800 W every 7 s: no alarm "
"edge at all (base: one per quarter)", fb == {})
# --- T15 unit: x10 ------------------------------------------------------------ #
ex10 = t1(x=10)
check("T15 unit x10 (wall and mono 10 s a cycle): T1 the same; released "
"within 1 cycle (E+30, the first trusted cycle)",
not any(run_of(ex10, 0, 20)) and all(run_of(ex10, 30, 120))
and all(run_of(ex10, -30, -10)))
ex10m = t1(x=10, mono_x=1)
check("T15 unit, mono x1 and wall x10: the same verdicts (the edge comes from "
"the projection's block_start, not from mono)",
not any(run_of(ex10m, 0, 20)) and all(run_of(ex10m, 30, 120)))
# =========================================================================== #
print("\n2. THE REAL CONTROLLER ACROSS THE EDGE (N=2, both at the reserve)")
# =========================================================================== #
RUNS = [] # (name, alarm edges) of every run, for N5
def summary(name, r, tr):
RUNS.append((name, H.edges(tr)))
w = H.window(tr, E - 120, E + 900)
lim = [x for x in w if x["lim"]]
print(f" {name}: alarms {[t - E for t in H.alarms(r)]} edges "
f"{[t - E for t in H.edges(tr)]} red {len(H.red_secs(tr))} s "
f"(first {[t - E for t in H.red_secs(tr)[:1]]}) errors "
f"{len(H.errors(tr))} limited {len(lim)} explained "
f"{sum(1 for x in lim if x['explains'])} cmd {H.commands(r, tr)}")
return w, lim
def quiet(r, tr):
"""No floor notification, no ERROR, no red peak_guard row, E-120..E+900."""
return H.alarms(r) == [] and H.red_secs(tr) == [] and H.errors(tr) == []
def all_explained(lim, t0=E - 120):
return bool(lim) and all(x["explains"] for x in lim if x["t"] >= t0)
ZERO = const(0.0)
def honest(w):
"""An honest shape steps at the edge, so Off has no alarm before it."""
return H.shape(w, at=E)
# --- T2: the rig F-A shape ---------------------------------------------------- #
r2, tr2 = H.run(H.shape(14000.0), a=ZERO, b=const(800.0))
w2, lim2 = summary("T2", r2, tr2)
check("T2 PRECONDITION: limited at the reserve from the edge, the car trusted, "
"b 800 W, grid excess 980 W < car",
present(first(x for x in w2 if x["t"] == E and x["lim"]))
and all(x["w"] == CAR and x["batt"] == 800.0 for x in lim2))
check("T2: no goodwe_peak_soc_floor, no PEAK_GUARD_FLOOR_LIMITED ERROR, no "
"red peak_guard row in E-120..E+900 (base: alarm at E+0, red to E+900)",
quiet(r2, tr2))
check("T2: the car explains every floor-limited cycle, E+0..E+10 among them",
all_explained(lim2) and len([x for x in lim2 if x["t"] <= E + 10]) == 11)
# --- T2b: the batteries give less later --------------------------------------- #
r2i, tr2i = H.run(H.shape(14000.0), a=ZERO,
b=lambda t: 800.0 if t < E + 300 else 0.0)
summary("T2b(i)", r2i, tr2i)
a2i = H.alarms(r2i)
check("T2b(i): b drops to 0 W at E+300 (landing without the car 13 733 W): "
"the alarm fires within 1 cycle of E+300",
len(a2i) == 1 and E + 300 <= nth(a2i, 0) <= E + 301)
check("T2b(i): ...and stays to the quarter's end (a house need with a "
"trusted car is latched)", all(x["alarm"] and x["red"] for x in
H.window(tr2i, E + 302, E + 899)))
r2ii, tr2ii = H.run(H.shape(14000.0), a=ZERO,
b=lambda t: 800.0 if t < E + 300 else 400.0)
summary("T2b(ii)", r2ii, tr2ii)
check("T2b(ii): b drops to 400 W (landing 13 467 W): no alarm to E+900",
quiet(r2ii, tr2ii))
# --- T3: batteries at 0 W, and the 11 kW car ---------------------------------- #
r3, tr3 = H.run(H.shape(13000.0), a=ZERO, b=ZERO)
w3, lim3 = summary("T3", r3, tr3)
check("T3: batteries 0 W, house 13 000 W, car 1 380 W: no alarm, no red row, "
"the car explains every limited cycle incl. E+0..E+10, one car notice",
quiet(r3, tr3) and all_explained(lim3)
and len(P.ids(r3, P.OVER)) == 1
and all(x["explains"] for x in lim3 if x["t"] <= E + 10))
def plug_at(t0):
return {t0: lambda p, c: p.ch.plug_in()}
r3k, tr3k = H.run(H.shape(2600.0, before=2600.0), a=ZERO, b=ZERO, car_a=16,
phases=3, aim=6344.0, plug=False, extra=plug_at(E - 120))
w3k, lim3k = summary("T3 11 kW", r3k, tr3k)
check("T3 11 kW: house 2 600 W, car 11 kW, aim 6 344 W (base P 21:30): no "
"alarm, the car explains every limited cycle",
quiet(r3k, tr3k) and all_explained(lim3k)
and len(P.ids(r3k, P.OVER)) == 1)
# --- T4 controller ------------------------------------------------------------ #
r409, tr409 = H.run(H.shape(13609.0), a=ZERO, b=ZERO)
summary("T4 13 609", r409, tr409)
check("T4: the house alone at aim + 9 W: no alarm", quiet(r409, tr409))
r411, tr411 = H.run(H.shape(13611.0), a=ZERO, b=ZERO)
r411o, tr411o = H.run(H.shape(13611.0), a=ZERO, b=ZERO, mode="off")
summary("T4 13 611", r411, tr411)
summary("T4 13 611 Off", r411o, tr411o)
check("T4: at aim + 11 W the alarm at the same cycle as Off (and as base, "
"E+0)", H.alarms(r411) == H.alarms(r411o) == [E])
# --- T5: an honest alarm ------------------------------------------------------ #
r5, tr5 = H.run(honest(14090.0), a=ZERO, b=ZERO)
r5o, tr5o = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off")
summary("T5", r5, tr5)
summary("T5 Off", r5o, tr5o)
check("T5: grid excess 1 870 W > car 1 380 W: the alarm and the ERROR at the "
"same second as Off and as base (E+1, the step's first sample)",
H.alarms(r5) == H.alarms(r5o) == T5_BASE
and nth(H.errors(tr5), 0) == nth(H.errors(tr5o), 0) == E + 1)
check("T5: the car explains no cycle", not any(x["explains"] for x in tr5))
# --- T6: the car figure unknown across the edge ------------------------------- #
def unavailable(t0, t1):
return {t0: lambda p, c: p.ch.go_unavailable(True),
t1: lambda p, c: p.ch.go_unavailable(False)}
r6, tr6 = H.run(H.shape(13000.0), a=ZERO, b=ZERO,
extra=unavailable(E - 20, E + 60))
summary("T6 T3 shape", r6, tr6)
back = first(x["t"] for x in tr6 if x["t"] >= E + 60 and x["w"] is not None)
check("T6 T3 shape: while unknown the car explains nothing and the alarm "
"stands from E+0, as base",
H.alarms(r6) == [E] and not any(
x["explains"] for x in H.window(tr6, E - 5, E + 59))
and all(x["alarm"] for x in H.window(tr6, E, E + 59)))
check("T6 T3 shape: released within 1 cycle of the first trusted cycle after "
"E+60, no new alarm edge to E+900 (base: red to E+900)",
present(back) and all(not x["alarm"] and x["explains"] for x in
H.window(tr6, back + 1, E + 899))
and H.edges(tr6) == [E])
r6h, tr6h = H.run(honest(14090.0), a=ZERO, b=ZERO,
extra=unavailable(E - 20, E + 60))
summary("T6 T5 shape", r6h, tr6h)
check("T6 T5 shape: the alarm at the base second and it stands throughout",
H.alarms(r6h) == T5_BASE and all(x["alarm"] for x in
H.window(tr6h, E + 1, E + 899)))
# --- T7: a frozen car figure, the car really stops ---------------------------- #
def frozen_stop(p, c):
p.ch.freeze()
p.ch.car_full()
r7, tr7 = H.run(honest(14090.0), a=ZERO, b=ZERO, extra={E - 30: frozen_stop})
summary("T7", r7, tr7)
first7 = nth(H.alarms(r7), 0)
untr = first(x["t"] for x in tr7 if x["t"] >= E - 30 and x["w"] is None)
check("T7: the alarm within 114 s of the stop (max(60, 40 Wh / 1.38 kW) "
"+ 10), no later than base",
present(first7) and first7 <= E - 30 + 114 and first7 <= T7_BASE)
check("T7: never explained after the figure goes untrusted",
present(untr) and not any(x["explains"] for x in tr7 if x["t"] >= untr))
# --- T8: a car at 0 W, and a 50 W car ----------------------------------------- #
class Draw(SimCharger):
"""A charger that draws `real_w` while charging and reports `say_w`."""
def __init__(self, real_w, say_w, **kw):
super().__init__(**kw)
self.real_w, self.say_w = real_w, say_w
def target_w(self):
return 0.0 if super().target_w() <= 0.0 else self.real_w
def _build(self):
keep, self._frozen_w = self._frozen_w, self.say_w
try:
return super()._build()
finally:
self._frozen_w = keep
def full(p, c):
p.ch.car_full()
for nm, kw in (("house 14 090 W", dict(house=honest(14090.0), b=ZERO)),
("T2 shape", dict(house=honest(14000.0), b=const(800.0)))):
r8, tr8 = H.run(a=ZERO, extra={1: full}, **kw)
r8o, tr8o = H.run(a=ZERO, extra={1: full}, mode="off", **kw)
summary(f"T8 0 W, {nm}", r8, tr8)
summary(f"T8 0 W, {nm}, Off", r8o, tr8o)
check(f"T8: a car plugged at 0 W, {nm}: the alarm at the same second as "
f"Off, nothing explained", H.alarms(r8) == H.alarms(r8o)
and H.alarms(r8) != [] and not any(x["explains"] for x in tr8))
r8s, tr8s = H.run(honest(14090.0), a=ZERO, b=ZERO,
sim=Draw(50.0, 50.0, setpoint_a=6))
r8so, tr8so = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off",
sim=Draw(50.0, 50.0, setpoint_a=6))
summary("T8 50 W", r8s, tr8s)
check("T8: a 50 W car, house 14 090 W: the alarm at the same second as Off, "
"nothing explained", H.alarms(r8s) == H.alarms(r8so) == T5_BASE
and not any(x["explains"] for x in tr8s))
# --- T9: a wrong charger reply ------------------------------------------------ #
r9a, tr9a = H.run(honest(13900.0), a=ZERO, b=ZERO,
sim=Draw(1380.0, 11000.0, setpoint_a=6))
summary("T9(a)", r9a, tr9a)
check("T9(a): reports 11 kW, read-back 6 A 1-ph (cap 1 518 W): the house "
"alone misses, the alarm at the base second",
H.alarms(r9a) == T5_BASE and all(x["w"] is None or x["w"] <= 1518.0
for x in tr9a))
r9b, tr9b = H.run(honest(13900.0), a=ZERO, b=ZERO,
sim=Draw(400.0, 1380.0, setpoint_a=6))
summary("T9(b)", r9b, tr9b)
check("T9(b): reports 1 380 W, draws 400 W: the same alarms as base (none: "
"400 W corroborates a 1 380 W figure, CORR_RATIO 0.5; see the dev "
"report's Findings)", H.alarms(r9b) == T9B_BASE)
r9c, tr9c = H.run(honest(13900.0), a=ZERO, b=ZERO,
sim=Draw(100.0, 1380.0, setpoint_a=6))
summary("T9(c)", r9c, tr9c)
a9c = nth(H.alarms(r9c), 0)
check("T9(c): reports 1 380 W, draws 100 W: the first alarm once the figure "
"is uncorroborated, at most 104 s + 10 s after the edge, no later than "
"base", present(a9c) and a9c <= E + 114 and a9c <= T9C_BASE)
print(f" T9(c) alarm edges {[t - E for t in H.edges(tr9c)]} (base: one; "
f"the meter's 10 Wh step re-corroborates the figure every 360 s and "
f"Expected 3/5 release the alarm then: see the dev report)")
# --- T10: a lost battery reading, an unavailable charger ---------------------- #
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
("T5", dict(house=honest(14090.0), b=ZERO))):
r10, tr10 = H.run(a=ZERO, lost={"b": {E + 1}}, **kw)
summary(f"T10(a) {nm}", r10, tr10)
gap = first(x for x in tr10 if x["t"] == E + 1)
nxt = first(x for x in tr10 if x["t"] == E + 2)
check(f"T10(a) {nm}: inverter-b's reading lost at E+1: that cycle grades "
f"nothing (P_SAFETY owns a missing input), the next one grades on "
f"what is measured", present(gap, nxt) and gap["batt"] is None
and nxt["batt"] == (800.0 if nm == "T2" else 0.0))
if nm == "T2":
check("T10(a) T2: no alarm edge (base: E+0)", quiet(r10, tr10))
else:
check("T10(a) T5: the same alarm seconds as base",
H.alarms(r10) == T10A_T5_BASE)
r10b, tr10b = H.run(a=ZERO, extra=unavailable(E + 1, E + 2), **kw)
summary(f"T10(b) {nm}", r10b, tr10b)
if nm == "T2":
check("T10(b) T2: the charger unavailable for one cycle (E+1): the "
"alarm stands for that cycle only (Expected 5)",
H.edges(tr10b) == [E + 1]
and all(not x["alarm"] for x in H.window(tr10b, E + 2, E + 899))
and all(x["explains"] for x in H.window(tr10b, E + 2, E + 899)
if x["lim"]))
else:
check("T10(b) T5: the alarm at the base second and it stands",
H.alarms(r10b) == T5_BASE and all(
x["alarm"] for x in H.window(tr10b, E + 1, E + 899)))
# --- T11: one battery first (SAFETY-87) --------------------------------------- #
for nm, house in (("(i) 17 500 W", 17500.0), ("(ii) 19 000 W", 19000.0)):
r11, tr11 = H.run(honest(house), soc={"a": 19.0, "b": 35.0})
summary(f"T11{nm}", r11, tr11)
if house < 18000.0:
check("T11(i): b able, house 17 500 W, car 1 380 W: no alarm across E",
H.alarms(r11) == [] and P.ids(r11, *P.ALARMS) == [])
else:
check("T11(ii): house 19 000 W: the alarm at the base second",
[t for t, _n in P.ids(r11, *P.ALARMS)] == T11_BASE)
# --- T12 (record only): plug-in at E+0, the reserve at E+180 ------------------ #
def reserve_at(p, c):
p.socs.update({"a": 19.0, "b": 19.0})
r12, tr12 = H.run(H.shape(13000.0), soc={"a": 40.0, "b": 40.0}, plug=False,
extra={E: lambda p, c: p.ch.plug_in(), E + 180: reserve_at})
summary("T12 (record, F-B)", r12, tr12)
# --- T13 controller: the latch is kept ---------------------------------------- #
r13, tr13 = H.run(H.shape(lambda t: 15500.0 if E + 300 <= t < E + 360
else 13000.0), a=ZERO, b=ZERO)
summary("T13", r13, tr13)
check("T13: the house steps to 15 500 W at E+300 for 60 s: the alarm at "
"the base second (E+301, the step's first sample), and red to the "
"quarter's end", H.alarms(r13) == T13_BASE and all(
x["alarm"] and x["red"] for x in H.window(tr13, E + 301, E + 899)))
# --- T16: the edge paths ------------------------------------------------------ #
for nm, kw in (("(a)(b)(c) SAFETY-91 roll, modes on", {}),
("(d) the guard not wanting at the edge",
dict(lost={"b": {E}}))):
r16, tr16 = H.run(H.shape(13000.0), a=ZERO, b=ZERO, **kw)
w16, lim16 = summary(f"T16{nm}", r16, tr16)
f16 = first(x for x in tr16 if x["t"] >= E and x["lim"])
pre = first(x for x in tr16 if x["t"] == E - 1)
check(f"T16{nm}: the car explains from the first limited cycle of the "
f"new block, no alarm, no red row, `_carq` key = block_start",
present(f16) and quiet(r16, tr16) and all(
x["explains"] and x["key"] == x["block"]
for x in tr16 if x["t"] >= f16["t"] and x["lim"]))
if not kw:
print(f" T16(c): within_aim at E-1 {pre['within_aim'] if present(pre) else pre}"
" (SAFETY-126's latch carried; not asserted)")
else:
g0 = first(x for x in tr16 if x["t"] == E)
check("T16(d) PRECONDITION: the guard did not want power at E+0",
present(g0) and not g0["wants"])
# --- T17: a restart ----------------------------------------------------------- #
def restart_at(t0):
return {t0: lambda p, c: H.restart(c)}
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
("T3", dict(house=H.shape(13000.0), b=ZERO)),
("T5", dict(house=honest(14090.0), b=ZERO))):
rr0, tr0 = H.run(a=ZERO, **kw)
for at in (E + 2, E + 300):
rr, trr = H.run(a=ZERO, extra=restart_at(at), **kw)
summary(f"T17 {nm} restart at E+{at - E}", rr, trr)
if nm == "T5":
check(f"T17 T5, restart at E+{at - E}: the alarm at the base "
f"second and again on the first cycle after the restart, "
f"as base; red throughout",
H.alarms(rr) == T5_BASE + [at] and len(H.red_secs(trr))
== len(H.red_secs(tr0)))
else:
check(f"T17 {nm}, restart at E+{at - E}: the same as without "
f"(no floor notice, no ERROR, no red row)",
quiet(rr, trr) and quiet(rr0, tr0))
print(f" T17 {nm} car-over notices: twin "
f"{[t - E for t, _n in P.ids(rr0, P.OVER)]}, restarted "
f"{[t - E for t, _n in P.ids(rr, P.OVER)]} (EV-11's "
f"once-per-session state does not survive a restart, as on "
f"base)")
# --- T15 controller: x10 ------------------------------------------------------ #
# F2 (out of scope, filed apart): `_car_quarter` caps a cycle's dt at 5 s, so at
# 10 s a cycle half the car's energy is counted, and late in the quarter the
# house alone seems to miss the aim (T2 from about E+540, T3 E+820, as on base
# for T3). The x10 verdicts are graded to E+500; what comes after is printed.
F2_FROM = E + 500
for nm, kw, want in (
("T2", dict(house=H.shape(14000.0), b=const(800.0)), "quiet"),
("T3", dict(house=H.shape(13000.0), b=ZERO), "quiet"),
("T5", dict(house=honest(14090.0), b=ZERO), "alarm"),
("T6", dict(house=H.shape(13000.0), b=ZERO,
extra=unavailable(E - 20, E + 60)), "release")):
rx, trx = H.run(a=ZERO, x=10, **kw)
summary(f"T15 x10 {nm}", rx, trx)
early = [x for x in trx if x["t"] < F2_FROM]
print(f" T15 x10 {nm}: alarms after E+500 (F2) "
f"{[t - E for t in H.alarms(rx) if t >= F2_FROM]}")
if want == "quiet":
check(f"T15 x10 {nm}: no alarm, no red row, every limited cycle "
f"explained, E-120..E+500",
not [t for t in H.alarms(rx) if t < F2_FROM]
and H.red_secs(trx, t1=F2_FROM - 1) == []
and all_explained([x for x in early if x["lim"]]))
elif want == "alarm":
check("T15 x10 T5: the alarm at the base second (E+10, one cycle)",
H.alarms(rx) == T15_T5_BASE)
else:
bk = first(x["t"] for x in trx if x["t"] >= E + 60
and x["w"] is not None)
check("T15 x10 T6: the alarm while unknown, released within 1 cycle "
"(10 fake s) of the first trusted one, no new edge to E+500",
present(bk) and bk <= E + 70
and all(not x["alarm"] for x in H.window(trx, bk, F2_FROM - 1))
and [t for t in H.edges(trx) if t < F2_FROM] == [E])
# --- N4: the alarm decision changes no command -------------------------------- #
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
("T5", dict(house=honest(14090.0), b=ZERO))):
ra, tra = H.run(a=ZERO, **kw)
rb, trb = H.run(a=ZERO, explain_off=True, **kw)
check(f"N4 {nm}: the claim, the floor, the battery setpoints and the "
f"charger writes are identical whether the car explains or not",
H.commands(ra, tra) == H.commands(rb, trb))
# --- N5: at most one floor-alarm edge per quarter ---------------------------- #
def per_quarter(ts):
out = {}
for t in ts:
out[(t - E) // 900] = out.get((t - E) // 900, 0) + 1
return out
many = [(nm, ts) for nm, ts in RUNS
if not nm.startswith("T9(c)")
and any(v > 1 for v in per_quarter(
[t for t in ts if not nm.startswith("T15 x10") or t < F2_FROM])
.values())]
check(f"N5: at most one floor-alarm edge per quarter in every run "
f"({len(RUNS)} runs; T9(c) apart, x10 to E+500): {many}", many == [])
print()
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
sys.exit(1 if fails else 0)