"""EV-19: no floor alarm when the batteries first reach the peak reserve early in a Manual car session (EV-15 rig F-B). `python3 -B test_ev19.py` The rig: one PEAK_GUARD_FLOOR_LIMITED ERROR, one `goodwe_peak_soc_floor` and one red sample the moment the batteries reached the reserve, while the excess was smaller than the car. Reproduced (T1): at the reserve inverter-b goes on following the house, so its output RISES in that cycle. The battery reading shows the rise one cycle before the P1 sample does, and EV-18's "house" (meter + what the batteries give now) counted the new battery power as house load. That latched `_car_need_house` for the quarter: the alarm stood until the guard stopped wanting power. Now a rise the reading shows above both earlier readings is not counted as house until a second reading confirms it. The credit stays the lower of the last two readings. T-ids are the test plan's (reports/EV-19-test-plan.md). "base" is 43b0db7. 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 ctl_car, tariff # noqa: E402 from named_absence import first, nth, present # noqa: E402 import ev19_reserve as V # noqa: E402 fails = [] def check(name, cond): print(f" {'ok ' if cond else 'FAIL'} {name}") if not cond: fails.append(name) AIM = V.AIM CAR = V.CAR # =========================================================================== # print("1. UNIT: car_cycle in the reserve cycle (a real `_carq`)") # =========================================================================== # BS = datetime(2026, 11, 20, 20, 30, tzinfo=timezone.utc) # a quarter edge 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.""" floor_limited, saturated = True, False floor_w, able_w, ceiling_w = 0.0, None, AIM + 50.0 engaged, blind, wanted_w, within_aim = True, None, 300.0, False def urun(secs, grid, batt, w=lambda t: CAR): """`car_cycle` once per second of `secs` (seconds from the edge). `grid(t)` is the meter, `batt(t)` the site battery reading. {t: car_explains}.""" c = _Car() 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 c._now = 10000.0 + t c.w, c.site_batt_w = w(t), batt(t) c.car_cycle(p, _G(), AIM, None) out[t] = c.car_explains return out def run_of(d, t0, t1): return [d[t] for t in sorted(d) if t0 <= t <= t1] def rise(at, lo, hi): """A battery reading that steps from `lo` to `hi` at `at`.""" return lambda t: lo if t < at else hi def meter(house, b, lag=1): """The P1 figure: house + car - what the batteries gave `lag` cycles ago (the reading leads the meter by that much).""" return lambda t: house + CAR - b(t - lag) HB = AIM + 520.0 - CAR # F-B: house + car at batteries 0 W = aim + 520 b2 = rise(1, 0.0, 4600.0) u2 = urun(range(-5, 61), meter(HB, b2), b2) print(f" T2 unit E-1..E+3: {run_of(u2, -1, 3)}") check("T2 unit: b starts following the house at the reserve (0 -> 4 600 W) " "and the reading shows it one cycle before the meter: the car explains " "every cycle, the rise cycle E+1 among them (base: not from E+1)", all(run_of(u2, 0, 60)) and len(run_of(u2, 0, 60)) == 61) u2s = urun(range(-5, 61), meter(HB, b2, lag=0), b2) check("T2 unit: the same rise with the meter in step: explained every cycle", all(run_of(u2s, 0, 60)) and len(run_of(u2s, 0, 60)) == 61) # T4: the landing without the car at aim + 9 / + 11 W in the rise cycle. The # rise is at the edge, so with the lower reading credited (0 W) the house # alone lands at exactly `house`. b4 = rise(0, 0.0, 800.0) u409 = urun(range(-3, 10), meter(AIM + 9.0, b4), b4) u411 = urun(range(-3, 10), meter(AIM + 11.0, b4), b4) print(f" T4 unit +9 {run_of(u409, 0, 3)} +11 {run_of(u411, 0, 3)}") check("T4 unit: the house alone at aim + 9 W in the rise cycle: the car " "explains from E+0 (base: no)", all(run_of(u409, 0, 9)) and len(run_of(u409, 0, 9)) == 10) check("T4 unit: at aim + 11 W it does not, from E+0 (as base)", not any(run_of(u411, 0, 9)) and len(run_of(u411, 0, 9)) == 10) # N6 / T7(a): an unknown reading credits nothing; the lower reading is # credited, not the higher or the last known one. b7 = lambda t: None if t == 1 else b2(t) # noqa: E731 u7 = urun(range(-5, 30), meter(HB, b2), b7) check("T7(a) unit: the battery reading unknown in the rise cycle: nothing " "explained in that cycle (no last-known W), explained from the next", u7.get(1) is False and u7.get(0) is True and all(run_of(u7, 2, 29))) u6 = urun(range(-5, 30), meter(AIM + 11.0 + 400.0, lambda t: 400.0, lag=0), lambda t: 800.0 if t == 3 else 400.0) check("N6 unit: b at 400 W, the house alone with it at aim + 11 W, one " "reading of 800 W at E+3: not explained in any cycle", not any(run_of(u6, 0, 29))) # A house step that comes with a battery rise: b steps to 800 W and the # meter, one cycle late, shows a house of aim + 811 W, so with b's 800 W the # house alone misses by 11 W. The meter moved, so nothing is discounted. b8 = rise(5, 0.0, 800.0) u8 = urun(range(0, 30), lambda t: (AIM - 500.0 if t < 5 else AIM + 811.0) + CAR - b8(t - 1), b8) print(f" N6 unit house step with a rise E+4..E+8: {run_of(u8, 4, 8)}") check("N6 unit: a house step that comes with a battery rise is latched in " "the rise cycle (E+5, as base), and stays latched", all(run_of(u8, 0, 4)) and not any(run_of(u8, 5, 29))) # Review round 1 (Major): an honest house step at E+5 answered by ONE reading # of battery power, the meter in step (it shows the burst too) or one cycle # late. Not explained from E+5, the step's own cycle, as base. for H, burst, lag in ((2000.0, 4600.0, 0), (1900.0, 3000.0, 0), (5000.0, 4600.0, 0), (2000.0, 4600.0, 1), (1900.0, 3000.0, 1)): hs = (lambda t, H=H: AIM - 500.0 if t < 5 else AIM + H) bb = (lambda t, burst=burst: burst if t == 5 else 0.0) ub = urun(range(0, 15), lambda t, hs=hs, bb=bb, lag=lag: hs(t) + CAR - bb(t - lag), bb) check(f"RB unit: house -> aim + {H:.0f} W at E+5 with one {burst:.0f} W " f"reading, meter {'in step' if lag == 0 else 'one cycle late'}: " f"explained to E+4, not from E+5 (base: the same)", ub.get(4) is True and not any(run_of(ub, 5, 14)) and len(run_of(ub, 5, 14)) == 10) # The discount needs a still meter: the F-B rise (T2 unit) with the house # side of the meter moving by RISE_STILL_W -/+ 10 W in the rise cycle. STILL = getattr(ctl_car, "RISE_STILL_W", 50.0) # 43b0db7 has none for d, want in ((STILL - 10.0, True), (STILL + 10.0, False)): ud = urun(range(-5, 10), lambda t, d=d: HB + (d if t >= 1 else 0.0) + CAR - b2(t - 1), b2) check(f"RISE_STILL_W: the meter's house side moves {d:.0f} W in the rise " f"cycle: {'still, the rise is not yet house (explained)' if want else 'moved, the rise counts as house (not explained, as base)'}", ud.get(1) is want and ud.get(0) is True) # Review round 2: the blind band in absolute W (the owner's 50 W; change this # check with the owner). An honest step at E+5 (house aim - 500 -> aim + 1 900 # W, more than the car) with one burst that leaves the meter's house side # moving d W: at |d| = 60 the alarm cycle is base's (E+5); inside the band # (d = 0) the car explains at most the step's own cycle, never from E+6. for dd in (60.0, -60.0, 0.0): hb = (lambda t: AIM - 500.0 if t < 5 else AIM + 1900.0) bd = (lambda t, B=2400.0 - dd: B if t == 5 else 0.0) ubd = urun(range(0, 15), lambda t, hb=hb, bd=bd: hb(t) + CAR - bd(t), bd) print(f" band d={dd:+.0f} W E+4..E+8: {run_of(ubd, 4, 8)}") t0 = 5 if dd else 6 check(f"band: an honest step whose burst moves the meter's house side " f"{dd:+.0f} W: not explained from E+{t0}", ubd.get(4) is True and not any(run_of(ubd, t0, 14)) and len(run_of(ubd, t0, 14)) == 15 - t0) # Review round 2: the stillness test uses the house side (held - car). The car # steps 1 380 -> 2 760 W, the house aim - 500 -> aim + 3 000 W (more than the # car) and b gives one reading of 4 880 W, all at E+5, meter in step: the # meter's total stays, its house side drops 1 380 W, so nothing is discounted. hc = (lambda t: AIM - 500.0 if t < 5 else AIM + 3000.0) wc = (lambda t: CAR if t < 5 else 2 * CAR) bc5 = (lambda t: 4880.0 if t == 5 else 0.0) ucw = urun(range(0, 15), lambda t: hc(t) + wc(t) - bc5(t), bc5, w=wc) check("car term: the car steps up with the house and a burst, the meter's " "total still: not explained from E+5 (as base)", ucw.get(4) is True and not any(run_of(ucw, 5, 14)) and len(run_of(ucw, 5, 14)) == 10) # Review round 1 (mC): EV-18's `_car_over_now` keeps the reading as it is. b # gives 2 000 W, the house alone with it lands under the aim and the period # with the car too, so nothing explains; b rises to 4 000 W at E+5 one cycle # before the meter: the period with the car on the reading as it is lands # over, so the car explains from E+5. bc = rise(5, 2000.0, 4000.0) uc = urun(range(0, 15), lambda t: AIM + 500.0 + CAR - bc(t - 1), bc) print(f" over_now unit E+3..E+7: {run_of(uc, 3, 7)}") check("over_now unit: `_car_over_now` grades the undiscounted reading: not " "explained E+0..E+4, explained from the rise cycle E+5", not any(run_of(uc, 0, 4)) and all(run_of(uc, 5, 14)) and len(run_of(uc, 5, 14)) == 10) # =========================================================================== # print("\n2. THE REAL CONTROLLER AT THE RESERVE (N=2, tools/ev19_reserve.py)") # =========================================================================== # JOBS = V.jobs() RES = V.run_many(JOBS) def res(name): return RES[name] def trusted(x): return x["w"] is not None and x["w"] > 0.0 and not x["contra"] def bad(x): return bool(x["alarm"] or x["red"] or x["err"]) def hits(r, t0=-10, t1=60): """T1's reproduction: an alarm, red sample or ERROR in R-10..R+60 in a cycle where the car figure is trusted (every T1 shape lands under the aim without the car, so the car explains there).""" return [int(x["t"] - r.R) for x in r.win(t0, t1) if bad(x) and trusted(x)] def show(name): r = res(name) print(f" {name}: alarms {r.rel_alarms()} edges {r.edges()} errors " f"{r.errors()} red {len(r.red())} s cmd {r.cmd}") # Measured on base 43b0db7 with this file's own runs: the seconds from R of # goodwe_peak_soc_floor in the honest shapes, which must not come later now. BASE_ALARMS = { "T4 +11 manual": [0, 857], "T5 t1 manual": [2], "T5 t4 manual": [11], "T5 tau5 manual": [2], "T6 step R+0 manual": [2], "T6 step R+1 manual": [2], "T6 step R+5 manual": [6], "T7(a) T5": [2], "T7(b) T5": [2], "T8(c) frozen, the car stops": [2], "T9(a) T5 b lost at R": [2], "T9(a) T5 b lost at R-1": [2], "T9(b) T5 P1 5 s late at R": [5], "T10 T5 twin": [2], "T10 T5 restart R-2": [2], "T10 T5 restart R+2": [2], "T10 T5 restart R-1": [2], "T10 T5 restart R+0": [2], "T10 T2 restart R+0": [1], "T11 T5 R=E-1": [2], "T11 T5 R=E+0": [0, 2], "T11 T5 R=E+1": [0, 2], "T11 T5 R=E+43": [2], "T12 T5 1->3 at R-15": [2], "T12 T5 1->3 at R+5": [2], "T13(a) draws 100 W manual": [0, 857], "T14(c) N=1 T5": [2], "T15 honest manual": [13], "T16 x10 T5 manual": [20], "T16 x10 T6 manual": [20], "T16 mono1 T5 manual": [20], "T16 mono1 T6 manual": [20], "T16 x10 T11 T5 R=E-10": [20], "T16 x10 T11 T5 R=E+0": [0, 20], "T16 x10 T11 T5 R=E+10": [0, 20], "T16 x10 T11 T5 R=E+40": [20], "T16 mono1 T11 T5 R=E-10": [20], "T16 mono1 T11 T5 R=E+0": [0, 20], "T16 mono1 T11 T5 R=E+10": [0, 20], "T16 mono1 T11 T5 R=E+40": [20], "T16 mono1 T3 t1 bw=0": [600], "T16 mono1 T3 t1 bw=2000": [700], "T16 mono1 T3 t1 bw=4250": [800], "T16 mono1 T3 t4 bw=0": [600], "T16 mono1 T3 t4 bw=2000": [700], "T16 mono1 T3 t4 bw=4250": [800], } # The T1 cells that reproduce F-B on base (G0): b following the house from R. BASE_REPRO = [f"T1 core bw={bw} t2 rp={rp}" for bw in (0, 400, 800) for rp in (30, 100, 110, 180, 600)] + [ "T1 d: x10 wall+mono t2 bw=1200", "T1 d: x10 wall, mono x1 t2 bw=1200"] def as_base(k): """The same alarm seconds as base.""" return res(k).rel_alarms() == BASE_ALARMS[k] # --- T1: the reproduction grid ------------------------------------------------ # T1 = sorted(k for k in JOBS if k.startswith("T1 ")) C5 = [k for k in T1 if k.startswith("T1 b: energy")] rep = {k: hits(res(k)) for k in T1} print(f" T1 cells {len(T1)}; reproducing on this tree: " f"{sorted(k for k in T1 if rep[k])}") check("T1: no grid cell reproduces F-B: no notice, ERROR or red sample in " "R-10..R+60 while the car figure is trusted (base: the " f"{len(BASE_REPRO)} tau2 cells with b at 0-800 W at R)", not [k for k in T1 if rep[k]]) for k in C5: show(k) check("T1 C5 cells (the energy meter late or never stepping): the figure is " "untrusted (contradicted or unknown) wherever the alarm stands, as EV-18 " "Expected 5 wants", all(not trusted(x) for k in C5 for x in res(k).win(-10, 60) if bad(x))) # --- T2: THE red-before test -------------------------------------------------- # T2 = BASE_REPRO for k in T2: r = res(k) lim = [x for x in r.win(0, 60) if x["floor_lim"]] check(f"T2 {k[3:]}: no notice, no ERROR, no red sample R-60..R+900; the " f"car explains every floor-limited cycle of R..R+60", r.quiet(-60, 900) and bool(lim) and all(x["explains"] for x in lim)) check("T2 PRECONDITION: every reproducing cell is in the grid (b at 0, 400, " "800 W x 5 plug-in times; x10 and mono x1 with b at 1 200 W)", len(T2) == 17 and all(k in RES for k in T2)) r2 = res("T1 core bw=0 t2 rp=180") x1 = r2.at(1) check("T2 PRECONDITION: in the rise cycle the reading shows b's 4 600 W, the " "guard is floor-limited and wants power", present(x1) and x1["batt"] == 4600.0 and x1["floor_lim"] and x1["wants"]) # --- T3: the battery W sweep --------------------------------------------------- # T3 = sorted(k for k in JOBS if k.startswith("T3 ")) loud = [k for k in T3 if not res(k).quiet(-60, 900)] print(f" T3 cells {len(T3)}, with an alarm or red sample: {loud}") check("T3: tau1 and tau2, b at R 0..4 600 W in 200 W steps and 9 600 W " "(tau5): no alarm and no red sample in any cell", loud == []) # --- T4 controller ------------------------------------------------------------- # for k in ("T4 +9 manual", "T4 +11 manual", "T4 +11 off"): show(k) check("T4: the house alone at aim + 9 W, b following the house from R: no " "alarm (base: R+1)", res("T4 +9 manual").quiet(-60, 900)) check("T4: at aim + 11 W the alarm in the same cycle as base and as Off " "(R+0)", as_base("T4 +11 manual") and res("T4 +11 manual").rel_alarms()[:1] == res("T4 +11 off").rel_alarms()[:1] == [0]) # --- T5 / T6: honest alarms ---------------------------------------------------- # def same_as_off(k): on, off = res(f"{k} manual"), res(f"{k} off") show(f"{k} manual") show(f"{k} off") a = on.rel_alarms() return (bool(a) and a == off.rel_alarms() and on.errors() == off.errors()) for k in ("T5 t1", "T5 t4", "T5 tau5"): check(f"{k}: the excess is more than the car: PEAK_GUARD_FLOOR_LIMITED, " f"the ERROR and the notice at the same second as Off and as base", same_as_off(k) and as_base(f"{k} manual")) check(f"{k}: the car explains no cycle", not any(x["explains"] for x in res(f"{k} manual").tr)) for n in (0, 1, 5): k = f"T6 step R+{n}" show(f"{k} manual") check(f"{k}: the house steps to aim + 1 900 W at R+{n}: the alarm and " f"the ERROR at the same second as base, R+{BASE_ALARMS[k + ' manual'][0]}" f" (no grace, no hold; Off alarms from R+0, where the car explains)", as_base(f"{k} manual") and res(f"{k} manual").errors() == BASE_ALARMS[f"{k} manual"]) # --- T7: unknown values -------------------------------------------------------- # def only_while_unknown(r, t0=-60, t1=900): """Every alarm / red cycle has an untrusted car figure in it or in the cycle before (the alarm clears within 1 cycle of the first trusted one).""" prev = None for x in r.win(t0, t1): if bad(x) and trusted(x) and (prev is None or trusted(prev)): return False prev = x return True show("T7(a) T2") check("T7(a) T2: inverter-a's reading unknown at R and R+1: no alarm", res("T7(a) T2").quiet(-60, 900)) check("T7(a) T5: the alarm at the same second as base and as Off (the " "guard grades nothing without the reading)", as_base("T7(a) T5") and res("T7(a) T5").rel_alarms() == res("T7(a) T5 off").rel_alarms()) show("T7(b) T2") check("T7(b) T2: the charger unavailable at R: an alarm only while the " "figure is unknown, cleared within 1 cycle of the first trusted one", only_while_unknown(res("T7(b) T2"))) check("T7(b) T5: the alarm at the same second as base and as Off", as_base("T7(b) T5") and res("T7(b) T5").rel_alarms() == res("T7(b) T5 off").rel_alarms()) # --- T8: a stale car figure ---------------------------------------------------- # r8a = res("T8(a) Off 120 s, Manual R-5") show("T8(a) Off 120 s, Manual R-5") check("T8(a): nothing before Manual is trusted (car_alarm_w None)", all(x["w"] is None for x in r8a.tr if x["t"] < r8a.R - 5)) check("T8(a): after Manual, as T2: no alarm R-60..R+900", r8a.quiet(-60, 900)) r8b = res("T8(b) stale R-5..R+20") show("T8(b) stale R-5..R+20") check("T8(b) PRECONDITION: the figure goes untrusted (older than 15 s)", any(x["w"] is None for x in r8b.win(0, 25))) check("T8(b): the alarm only while the figure is stale, cleared within 1 " "cycle of the first fresh one", only_while_unknown(r8b)) r8c, r8co = res("T8(c) frozen, the car stops"), res("T8(c) off") show("T8(c) frozen, the car stops") a8 = nth(r8c.rel_alarms(), 0) untr = first(int(x["t"] - r8c.R) for x in r8c.tr if x["t"] >= r8c.R - 30 and not trusted(x)) check("T8(c): the alarm at base's second, as Off, within 114 s of the stop", present(a8) and a8 <= -30 + 114 and as_base("T8(c) frozen, the car stops") and r8c.rel_alarms() == r8co.rel_alarms()) check("T8(c): never explained after the figure goes untrusted", present(untr) and not any(x["explains"] for x in r8c.tr if x["t"] >= r8c.R + untr)) # --- T9: comms ------------------------------------------------------------------ # for nm in ("T2", "T5"): for k in (f"T9(a) {nm} b lost at R", f"T9(a) {nm} b lost at R-1", f"T9(b) {nm} P1 5 s late at R"): show(k) r = res(k) if nm == "T2": check(f"{k}: no alarm edge", r.edges() == []) else: check(f"{k}: the alarm at the base second " f"(R+{BASE_ALARMS[k][0]})", as_base(k)) # --- T10: a restart ------------------------------------------------------------ # for nm in ("T2", "T5"): tw = res(f"T10 {nm} twin") for k in (-2, -1, 0, 2): r = res(f"T10 {nm} restart R{k:+d}") show(f"T10 {nm} restart R{k:+d}") if nm == "T2" and k == 0: # the rise cycle R+1 has no reading from two cycles back: nothing # is discounted (the old behaviour), so the alarm is base's check("T10 T2 restart at R+0: no reading two cycles back in the " "rise cycle, so no discount: the alarm as base (R+1)", as_base("T10 T2 restart R+0")) elif nm == "T2": check(f"T10 T2 restart at R{k:+d}: no notice, no red sample, as " f"the unrestarted twin", r.quiet(-60, 900) and tw.quiet(-60, 900)) else: check(f"T10 T5 restart at R{k:+d}: the alarm at the base second " f"and the twin's, red as the twin", as_base(f"T10 T5 restart R{k:+d}") and as_base("T10 T5 twin") and len(r.red()) == len(tw.red())) # --- Review round 1 (Major), controller: the T6 step with a one-cycle burst ---- # for k in (5, 30): for hi in (1900, 2500): for burst in ("3000", "4600"): nm = f"RB step R+{k} aim+{hi} burst {burst} manual" r = res(nm) show(nm) check(f"{nm[:-7]}: P1 and the reading both show the burst: the " f"notice, the ERROR and the first red sample at the step, " f"R+{k}, as base", r.rel_alarms() == [k] and r.errors() == [k] and r.red()[:1] == [k]) # --- T11: the quarter edge ------------------------------------------------------ # for rr in (-1, 0, 1, 43): r = res(f"T11 T2 R=E{rr:+d}") show(f"T11 T2 R=E{rr:+d}") wa = [(int(x["t"] - r.E), x["within_aim"]) for x in r.tr if r.E - 1 <= x["t"] <= r.E] print(f" T11 T2 R=E{rr:+d}: within_aim at E-1/E+0 {wa} (F1, not " f"asserted)") check(f"T11 T2 R=E{rr:+d}: no alarm across the edge", r.quiet(-60, 900)) check(f"T11 T5 R=E{rr:+d}: the alarm at the same seconds as base and " f"as Off", as_base(f"T11 T5 R=E{rr:+d}") and res(f"T11 T5 R=E{rr:+d}").rel_alarms() == res(f"T11 T5 R=E{rr:+d} off").rel_alarms()) pre = res("T11 C4 T2 R=E+1") show("T11 C4 T2 R=E+1") wa = [(int(x["t"] - pre.E), x["within_aim"]) for x in pre.tr if pre.E - 1 <= x["t"] <= pre.E] print(f" T11 C4: within_aim at E-1/E+0 {wa} (F1, not asserted)") check("T11 C4 PRECONDITION: the guard wants power in the last 60 s of the " "old quarter (house 13 350 W all along, car 1 380 W)", all(x["wants"] for x in pre.tr if pre.E - 60 <= x["t"] < pre.E)) sat = [x for x in pre.win(-60, -1) if x["red"]] print(f" T11 C4: red before R {[int(x['t'] - pre.R) for x in sat]} (near " f"the old quarter's end, the guard saturated: SAFETY-81's row)") check("T11 C4: SAFETY-126's latch carried over the edge, the reserve at " "E+1: no floor notice or ERROR R-60..R+900, no red sample from R; " "before R red only where the guard is saturated (not the floor alarm)", pre.quiet(0, 900) and not [t for t in pre.rel_alarms() if t >= -60] and all(x["lim"] and not x["floor_lim"] and not x["alarm"] for x in sat)) # --- T12: our own phase change -------------------------------------------------- # for k in (-15, 5): r = res(f"T12 T2 1->3 at R{k:+d}") show(f"T12 T2 1->3 at R{k:+d}") check(f"T12 T2, 1->3 at R{k:+d}: no alarm during our own pause or after", r.quiet(-60, 900)) on, off = res(f"T12 T5 1->3 at R{k:+d}"), res(f"T12 T5 1->3 at R{k:+d} off") show(f"T12 T5 1->3 at R{k:+d}") a, ao = nth(on.rel_alarms(), 0), nth(off.rel_alarms(), 0) check(f"T12 T5, 1->3 at R{k:+d}: the alarm at base's second, no later " f"than Off's and within OWN_PAUSE_MAX_S " f"({ctl_car.OWN_PAUSE_MAX_S:.0f} s) of the request", present(a, ao) and a <= ao and as_base(f"T12 T5 1->3 at R{k:+d}") and a <= max(k, 0) + ctl_car.OWN_PAUSE_MAX_S) # --- T13: a wrong charger reply ------------------------------------------------- # r13 = res("T13(a) draws 400 W manual") show("T13(a) draws 400 W manual") check("T13(a) 400 W: the energy meter never contradicts a 1 380 W figure " "when 400 W is drawn (CORR_RATIO 0.5 and its slack; EV-18 T9(b)), so " "nothing is uncorroborated and the figure explains; base's R+1 alarm " "was F-B", not any(x["contra"] for x in r13.tr) and all(x["w"] == CAR for x in r13.win(-60, 60))) r13c = res("T13(a) draws 100 W manual") show("T13(a) draws 100 W manual") show("T13(a) draws 100 W off") c0 = first(x["t"] for x in r13c.tr if x["contra"]) a13 = nth(r13c.rel_alarms(), 0) check("T13(a) 100 W PRECONDITION: the energy meter contradicts the figure " "within 104 + 10 s of the plug-in (R-180)", present(c0) and c0 <= r13c.R - 180 + 114) check("T13(a) 100 W: the alarm at base's second and Off's, and never " "explained after the contradiction in that quarter", present(a13) and as_base("T13(a) draws 100 W manual") and r13c.rel_alarms() == res("T13(a) draws 100 W off").rel_alarms() and not any(x["explains"] for x in r13c.tr if present(c0) and x["t"] >= c0 and x["block"] == r13c.at(0)["block"])) for k in ("T13(b) the write ignored, 0 A", "T14(a) 0 W in C", "T14(a) idle B"): show(f"{k} manual") check(f"{k}: the car at 0 W explains nothing: the alarm as Off", same_as_off(k) and not any( x["explains"] for x in res(f"{k} manual").tr)) # --- T14: configuration -------------------------------------------------------- # show("T14(b) ev_charger off") check("T14(b) ev_charger off: no explanation, the alarm as Off", res("T14(b) ev_charger off").rel_alarms() == res("T14(b) off").rel_alarms() != [] and not any(x["explains"] for x in res("T14(b) ev_charger off").tr)) for tj in ("t1", "t4"): show(f"T14(c) N=1 anchor {tj}") check(f"T14(c) N=1 anchor {tj}: no alarm", res(f"T14(c) N=1 anchor {tj}").quiet(-60, 900)) check("T14(c) N=1 T5: the alarm at the same second as base and as Off", as_base("T14(c) N=1 T5") and res("T14(c) N=1 T5").rel_alarms() == res("T14(c) N=1 T5 off").rel_alarms()) # --- T15: one battery first ----------------------------------------------------- # for k in ("T15 anchor manual", "T15 honest manual", "T15 honest off"): show(k) check("T15 anchor: a at the reserve at R, b at R+360: no alarm", res("T15 anchor manual").quiet(-60, 900)) check("T15 honest (house 19 000 W): the alarm after ALARM_HOLD_S at the " "base second (R+13; Off R+11, as base)", as_base("T15 honest manual")) # --- T16: x10 -------------------------------------------------------------------- # for xn in ("x10", "mono1"): r = res(f"T16 {xn} T2") show(f"T16 {xn} T2") check(f"T16 {xn} T2 PRECONDITION: the rise cycle reads b's 4 600 W", present(r.at(10)) and r.at(10)["batt"] == 4600.0) check(f"T16 {xn} T2: no alarm (base: R+10, 10 red cycles)", r.quiet(-60, 900)) t3 = sorted(k for k in JOBS if k.startswith(f"T16 {xn} T3 ")) print(f" T16 {xn} T3 alarms " f"{[(k[10:], res(k).rel_alarms()) for k in t3]}") check(f"T16 {xn} T3 ({len(t3)} cells): no alarm R-60..R+300", all(res(k).quiet(-60, 300) for k in t3)) # mono x1 / wall x10: the car's energy is counted on the monotonic clock, # a tenth of the wall's, so its share of the quarter is short and the # house latch sets late in the quarter (EV-18 F2, out of scope), as base. check(f"T16 {xn} T3: any later alarm at base's second (EV-18 F2)", all(as_base(k) if k in BASE_ALARMS else res(k).quiet(-60, 900) for k in t3)) for k in ("T5", "T6"): show(f"T16 {xn} {k} manual") check(f"T16 {xn} {k}: the alarm at the base second", as_base(f"T16 {xn} {k} manual")) check(f"T16 {xn} T7(b) T2: an alarm only while the figure is unknown", only_while_unknown(res(f"T16 {xn} T7(b) T2"))) for rr in (-10, 0, 10, 40): check(f"T16 {xn} T11 T2 R=E{rr:+d}: no alarm", res(f"T16 {xn} T11 T2 R=E{rr:+d}").quiet(-60, 900)) check(f"T16 {xn} T11 T5 R=E{rr:+d}: the alarm at the base seconds", as_base(f"T16 {xn} T11 T5 R=E{rr:+d}")) # --- T17: no flicker -------------------------------------------------------------- # r17 = res("T17 flicker") print(f" T17 alarm edges per quarter {r17.edges_per_quarter()}") check("T17: the house alone straddles aim + 10 W, the batteries cross the " "reserve 3 times: at most one alarm edge per quarter", all(v <= 1 for v in r17.edges_per_quarter().values())) # --- N2: the car explains only with a trusted, non-zero figure ----------------- # bad2 = sorted(k for k, r in RES.items() if any(x["explains"] and not trusted(x) for x in r.tr)) check(f"N2: car_explains never True with car_alarm_w None, 0 W or " f"contradicted, in any of the {len(RES)} runs: {bad2}", bad2 == []) for k in ("N2 no energy entity", "N2 reports 11 kW at 6 A"): show(f"{k} manual") check(f"{k}: the figure is not trusted for the alarm (no corroboration, " f"or capped by the read-back): nothing explained, the alarm as Off", same_as_off(k) and not any( x["explains"] for x in res(f"{k} manual").tr)) check("N2 PRECONDITION: the charger without an energy entity reports a " "fresh 1 380 W", all(x["car_raw"] == CAR for x in res("N2 no energy entity manual").win(-60, 60))) # --- N4 / T20: no control change --------------------------------------------- # for nm in ("T2", "T5"): a = res("T1 core bw=0 t2 rp=180") if nm == "T2" else res("T10 T5 twin") check(f"N4 {nm}: the claim, the floor, the setpoints and the charger " f"writes are those of the same run with the car never explaining", a.cmd == res(f"N4 {nm} explain off").cmd) # --- N5: at most one floor-alarm edge per quarter ------------------------------ # # Base 43b0db7 has 2 edges in the first quarter of these runs: the guard lets # go for one cycle at R+1 (the battery reads 0 W, the meter does not show it # yet), in Off and in the C5 cells too. Not EV-19's; head must not add one. BASE_TWO = ["T1 b: energy first step late", "T1 b: energy never steps", "T11 T5 R=E+0", "T11 T5 R=E+0 off", "T11 T5 R=E+1", "T11 T5 R=E+1 off", "T16 mono1 T11 T5 R=E+0", "T16 mono1 T11 T5 R=E+10", "T16 mono1 T6 off", "T16 x10 T11 T5 R=E+0", "T16 x10 T11 T5 R=E+10", "T16 x10 T6 off", "T6 step R+0 off", "T6 step R+1 off", "T6 step R+5 off"] + [ f"RB step R+{k} aim+{hi} burst {b} off" for k in (5, 30) for hi in (1900, 2500) for b in (3000, 4600)] many = sorted(k for k, r in RES.items() if any(v > (2 if k in BASE_TWO and q == 0 else 1) for q, v in r.edges_per_quarter().items())) check(f"N5: at most one floor-alarm edge per quarter in every run, and no " f"more than base where base has two ({len(RES)} runs): {many}", many == []) print() print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed") sys.exit(1 if fails else 0)