[Major] The rise discount applied to any rise, also one the meter
already shows, so an honest house step answered by one cycle of battery
power alarmed one cycle after base (review repro: T6 step + burst, R+6
instead of R+5). Now a reading above both earlier ones is discounted only
while the meter's house side (held - car; held alone when a car figure is
unknown) moved no more than RISE_STILL_W (50 W) since the last cycle.
Tests: the burst shapes (unit, meter in step and one cycle late;
controller, step at R+5 and R+30, 3 000 / 4 600 W) at base's second; the
"N6 unit" check tightened to the rise cycle; the RISE_STILL_W boundary;
a pin on EV-18's `_car_over_now` (mC); T10 restarts at R-1 and R (mE).
test_ev19: 144 of 144 here, 52 red on 43b0db7.
Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
626 lines
30 KiB
Python
626 lines
30 KiB
Python
"""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 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)
|