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>
682 lines
31 KiB
Python
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)
|