"""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)