Compare commits

...
1 Commits
Author SHA1 Message Date
ems-agentandClaude 4950a2374f EV-19: no floor alarm when the batteries first reach the reserve early in a Manual car session
checks / unit (pull_request) Successful in 25m47s
infra-pin / fresh (pull_request) Failing after 2s
EV-15 rig F-B, reproduced on 43b0db7 (tools/ev19_reserve.py, T1 grid). 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 figure (held - car + now - min(now, prev))
counted the new battery power as house load. `_car_need_house` latched:
one PEAK_GUARD_FLOOR_LIMITED ERROR and goodwe_peak_soc_floor at R+1, red
until the guard stopped wanting power.

ctl_car._car_explains_alarm: for the house latch only, a reading above
both earlier readings counts as house only up to the higher of them. The
credit stays the lower of the last two readings. The claim, floor,
setpoints and charger writes are unchanged (342 runs, same digests).

test_ev19.py: T1-T17, T20, N1-N6 of reports/EV-19-test-plan.md; 49
checks red on 43b0db7, 124 of 124 green here.

Co-Authored-By: Claude <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01VSY9UpTaUYnjJF5oVtbM1w
2026-11-20 20:16:25 +01:00
4 changed files with 1332 additions and 2 deletions
@@ -152,6 +152,13 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
whole window and fell short; an unknown reading is no contradiction) grades
no alarm to the quarter's end; the guard's input keeps it. After a restart
or a gap the car's earlier energy is not known, so it counts as house.
- **A battery rise is house only once a second reading shows it** (EV-19, EV-15
rig F-B). At the reserve inverter-b goes on following the house, so its
output rises; the reading shows it one cycle before P1 does, and the house
figure (meter + battery) counted that power as house. `_car_need_house`
latched and the alarm stood. For the house figure, a reading above both
earlier ones counts only up to the higher of them; the credit stays the lower
of the last two readings.
- **Our own write is ours until its mute ends** (EV-12). The mute of the tracker's
own detector opens before the write and runs 15 s from when it returns, because
the read-back reaches the cycle while the write still waits for it.
+9 -2
View File
@@ -58,7 +58,7 @@ class CarMixin:
self.car_over = False # ... held: the card and row say so
self._car_over_since = None
self._car_over_gone = None
self._car_batt_prev = None
self._car_batt_prev = self._car_batt_prev2 = None
self._car_need_real = self._car_need_excl = False # EV-10 latches
self._car_need_house = self._car_over_now = False # EV-18 latches
self._car_latch_block = None
@@ -414,7 +414,14 @@ class CarMixin:
when the guard no longer wants power, whatever the cover option says
(this runs every cycle). DECISIONS/EV-04-manual-mode.md (EV-18)."""
now, prev = self.site_batt_w, self._car_batt_prev
prev2, self._car_batt_prev2 = self._car_batt_prev2, prev
self._car_batt_prev = now
# EV-19: the reading can show a rise one cycle before the meter does
# (the batteries pick up the house at the reserve), so a reading above
# both earlier ones is not yet counted as house.
seen = now
if now is not None and prev is not None and prev2 is not None:
seen = min(float(now), max(float(prev), float(prev2)))
wants = bool(guard is not None and guard.engaged
and guard.blind is None
and (guard.wanted_w or 0.0) > 0.0)
@@ -436,7 +443,7 @@ class CarMixin:
self._car_need_excl = self._car_need_excl or \
peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
self._car_need_house = self._car_need_house or \
self._car_lands_over(excl, now, batt, target_w)
self._car_lands_over(excl, seen, batt, target_w)
if w is None or batt is None or not wants \
or not (guard.saturated or guard.floor_limited):
return False
+564
View File
@@ -0,0 +1,564 @@
"""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)))
# The rise counts as house once a second reading confirms it: b steps to
# 800 W and the meter, one cycle late, shows a house of aim + 811 W (the
# house steps with it), so with b's 800 W the house alone misses by 11 W.
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 at "
"most one cycle after the rise (E+6), and stays latched",
all(run_of(u8, 0, 4)) and not any(run_of(u8, 6, 29)))
# =========================================================================== #
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],
"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, 2):
r = res(f"T10 {nm} restart R{k:+d}")
show(f"T10 {nm} restart R{k:+d}")
if 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()))
# --- 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"]
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)
+752
View File
@@ -0,0 +1,752 @@
"""EV-19: the real Controller, N=2, when the batteries first reach the peak
reserve `R` early in a Manual car session (EV-15 F-B). Used by test_ev19.py.
python3 tools/ev19_reserve.py # the T1 grid, one row per cell
The units stand at 21 % and give `bw` W (`force`) until `R`, where both read
19 %; after `R` they follow the trajectory `traj`. The house is set so that
house + car with the batteries at 0 W lands at aim + `over` W (F-B: +520 W,
less than the 1 380 W car). Manual is set, then the car plugs in, `rp` s
before `R`. The run starts `E` s before a quarter edge (rig.BASE moved back),
so `R = E + r_rel`. One dict per cycle, taken after it.
Trajectories after R: t1 both 0 W; t2 a 0 W, b follows the house (the loop
below the reserve covers house + car, up to b's rating); t3 both ramp to 0 W
over 3 cycles; t4 as t1, but every battery reading is 10 s old (the rig reads
battery W every 10 fake s, P1 every 5) while P1 is fresh; t4r as t1, but P1
is 5 s late while the battery reading is fresh.
"""
import hashlib
import os
import sys
from datetime import timedelta
HERE = os.path.dirname(os.path.abspath(__file__))
sys.path.insert(0, HERE)
import ev04_peak as P # noqa: E402
import ev18_peak as H # noqa: E402
import opt11_identity as rig # noqa: E402
import safety81_sim as s81 # noqa: E402
from app import peakguard # noqa: E402
from chargersim import SimCharger # noqa: E402
AIM = H.AIM
CAR = 1380.0
FLOOR = H.FLOOR
RATE = {"a": 5000.0, "b": 4600.0}
OPTS = H.OPTS
OPTS1 = {"peak_soc_floor": 20, "inverters": [OPTS["inverters"][0]]}
class Meter(SimCharger):
"""A charger whose energy meter shows no 10 Wh step until `hold_until`
(sim seconds; None: always live, float('inf'): never)."""
hold_until = None
_held = None
def _build(self):
if self.hold_until is None or self.t >= self.hold_until:
self._held = None
return super()._build()
if self._held is None:
self._held = self.kwh
keep, self.kwh = self.kwh, self._held
try:
return super()._build()
finally:
self.kwh = keep
class Draw(Meter):
"""A charger that draws `real_w` while charging and reports `say_w`
(as test_ev18's). `c_at_0`: it stays in mode3 C while drawing 0 W."""
def __init__(self, real_w, say_w, c_at_0=False, **kw):
super().__init__(**kw)
self.real_w, self.say_w, self.c_at_0 = real_w, say_w, c_at_0
def target_w(self):
if super().target_w() <= 0.0:
return 0.0
return self.real_w
def tick(self, seconds=1.0):
super().tick(seconds)
if self.c_at_0 and self.state == "B" and not self.full:
self.state = "C"
def _build(self):
keep, self._frozen_w = self._frozen_w, self.say_w
try:
return super()._build()
finally:
self._frozen_w = keep
class Plant(H.Plant):
"""`batt_lag`: every battery reading is that many s old. `p1_lag` with
`p1_from`: P1 that many s late from that second on."""
batt_lag = 0.0
p1_lag = 0.0
p1_from = 0.0
house = None
def batt_of(self, u, at):
f = self.force.get(u)
if f is not None:
return float(f(at, self))
return P.CarPlantN.batt_of(self, u, at)
def grid(self, at):
if self.p1_lag and at >= self.p1_from:
at = at - self.p1_lag
return super().grid(at)
async def number(self, e, invert=False):
for u, secs in self.lost.items():
if e == "sensor.batt_" + u and int(self.t) in secs:
return None
if self.batt_lag and e.startswith("sensor.batt_") \
and e[-1] in self.socs:
return self.batt_of(e[-1], self.t - self.batt_lag)
return await P.CarPlantN.number(self, e, invert)
def split(bw, units="ab"):
"""`bw` over the units, each capped at its rating."""
if len(units) == 1:
return {units: min(bw, RATE[units])}
a = min(RATE["a"], bw / 2.0)
b = min(RATE["b"], bw - a)
a = min(RATE["a"], bw - b)
return {"a": a, "b": b}
def traj_fn(u, traj, before, R, house, step=1):
"""Unit `u`'s W at time `at`: `before` until the first cycle after R
(R + `step`), then the trajectory. P1 is sampled 0.3 s before each cycle,
so the battery reading shows a change one cycle before the meter does."""
def f(at, plant):
if at < R + step:
return before
if traj in ("t1", "t4", "t4r"):
return 0.0
if traj == "t2":
if u == "a":
return 0.0
return min(RATE["b"], house(at) + plant.ch.power_w)
if traj == "t3":
k = int((at - R) // step)
return before * max(0.0, (3 - k) / 3.0)
if traj == "keep":
return before
raise ValueError(traj)
return f
def run(*, bw=4250.0, traj="t1", rp=180, r_rel=43, order="manual",
energy="ok", x=1, mono_x=None, aim=AIM, over=520.0, house_w=None,
house_fn=None, car_a=6, n=2, extra=None, rel=None, lost=None,
after=900,
soc_after=None, soc0=21.0, mode="manual", sim=None,
explain_off=False, latch_off=False, force=None, plug_at=None,
man_at=None, opts=None, pre_w=H.PRE_W):
"""One run; returns (run, trace, meta). `over`: house + car at batteries
0 W lands at aim + `over` W (ignored with `house_w`). `order`: 'manual'
(Manual at plug-in - 3 s), 'plug' (plug-in at R-185, Manual at R-180),
'off120' (plug-in and charging in Off from R-180, Manual at R-60).
`energy`: 'ok', 'late' (first 10 Wh step at plug-in + 150 s), 'never'.
`mode`: 'manual' or 'off' (Off throughout: the base for honest alarms).
`house_fn`: fn(t, R) for the house after the step. `extra`: events at
run seconds, `rel`: at seconds from R. `lost`: {unit: seconds from R}.
`plug_at` / `man_at`: plug-in / Manual at these seconds from R (override
`order`). `force`: {unit: fn(at, plant) or None (the unit obeys)}.
`opts`: added to the options. `pre_w`: the house before its step."""
units = "ab" if n == 2 else "a"
step = int(x)
if order == "plug":
lead = 185
elif order == "off120":
lead = 180
else:
lead = rp + 3
if plug_at is not None or man_at is not None:
lead = -min(v for v in (plug_at, man_at) if v is not None)
E = 150
while E + r_rel - lead - 2 * step < 10:
E += 150
E = int(-(-E // step) * step)
R = E + r_rel
if x != 1:
R = int(-(-R // step) * step)
hw = (aim + over - CAR) if house_w is None else house_w
t_house = min(E - 120, R - lead - step)
if x != 1:
t_house = int(t_house // step * step)
def house(t):
if t < t_house:
return pre_w
if house_fn is not None:
return house_fn(t, R)
return hw
sp = split(bw, units)
frc = {u: traj_fn(u, traj, sp[u], R, house, step) for u in units}
frc.update(force or {})
soc_after = soc_after or {u: 19.0 for u in units}
lagb = 10.0 if traj == "t4" else 0.0
cls = type("Plant", (Plant,), {
"force": frc, "batt_lag": lagb,
"lost": {u: {R + k for k in v} for u, v in (lost or {}).items()},
"p1_lag": 5.0 if traj == "t4r" else 0.0, "p1_from": float(R)})
s = sim or Meter(setpoint_a=car_a)
if energy == "never":
s.hold_until = float("inf")
if x != 1:
tick = s.tick
s.tick = lambda secs=1.0: tick(secs * x)
if order == "plug":
t_plug, t_man = R - 185, R - 180
elif order == "off120":
t_plug, t_man = R - 180, R - 60
else:
t_plug, t_man = R - rp, R - rp - 3
if plug_at is not None:
t_plug = R + plug_at
if man_at is not None:
t_man = R + man_at
if x != 1:
t_plug = int(t_plug // step * step)
t_man = int(t_man // step * step)
if t_man == t_plug and order != "plug":
t_man -= step
tr = []
n_err = [len(H.ERR.rec)]
def hook(plant, c):
orig = c.car_settle
if explain_off:
c._car_explains_alarm = lambda *a_, **k_: False
if latch_off:
c._car_contradicted = lambda *a_, **k_: False
if mono_x is not None and mono_x != x:
c.car_now = (lambda f=c.car_now: f() * mono_x / x)
async def settle():
await orig()
g = c.peak_guard
red = [r_["id"] for r_ in c.checks()
if r_["ok"] is False and not r_["warn"]
and r_["id"] == "peak_guard"]
errs = [m for m in H.ERR.rec[n_err[0]:]
if "may not draw the battery lower" in m]
n_err[0] = len(H.ERR.rec)
cl = peakguard.claim(g) if g is not None else None
mono = c.car_now()
tr.append({
"t": plant.t, "explains": c.car_explains,
"lim": bool(g is not None and (g.floor_limited
or g.saturated)),
"floor_lim": bool(g is not None and g.floor_limited),
"within_aim": bool(g is not None and g.within_aim),
"wants": bool(g is not None and g.engaged
and (g.wanted_w or 0.0) > 0.0),
"wanted": None if g is None else g.wanted_w,
"target": None if g is None else g.target_w,
"alarm": c._peak_floor_limited, "red": red, "err": errs,
"w": c.car_alarm_w(), "car_raw": c.car.car_w(mono),
"batt": c.site_batt_w,
"true_batt": plant.batt(plant.t),
"need_real": c._car_need_real, "need_excl": c._car_need_excl,
"need_house": c._car_need_house, "over_now": c._car_over_now,
"contra": c._car_contra_block is not None and (
c._peak_proj_real is not None
and c._car_contra_block
== c._peak_proj_real.block_start),
"idle": c._car_idle(mono), "peak_needed": c._peak_needed,
"key": c._carq["key"],
"block": (c._peak_proj_real.block_start
if c._peak_proj_real is not None else None),
"floor_w": g.floor_w if g is not None else None,
"lo": getattr(cl, "lo", None),
"sp": tuple(i.last_write for i in c.inverters)})
c.car_settle = settle
def set_manual(p, c):
c._car_action("car_mode", "manual", c.car_now())
def plug(p, c):
p.ch.plug_in()
if energy == "late":
p.ch.hold_until = p.ch.t + 150.0
def reserve(p, c):
p.socs.update(soc_after)
ev = {}
def add(t, fn):
t = int(t)
old = ev.get(t)
ev[t] = fn if old is None else (
lambda p, c, a_=old, b_=fn: (a_(p, c), b_(p, c)))
add(0, hook)
add(t_plug, plug)
if mode == "manual":
add(t_man, set_manual)
add(R, reserve)
for t, fn in (extra or {}).items():
add(t, fn)
for t, fn in (rel or {}).items():
add(R + t, fn)
base, tick0 = rig.BASE, s81.TICK
rig.BASE, s81.TICK = base - timedelta(seconds=E), float(x)
o = dict(OPTS if n == 2 else OPTS1, **(opts or {}))
try:
r = P.drive(house, dur=R + after + step, rating=5000.0,
soc={u: soc0 for u in units}, cap=aim + H.MARGIN,
phases=1, n=n, plant_cls=cls, opts=o, dev_w=5000.0,
setpoint=car_a, user_a=car_a, mode="off", events=ev,
sim=s, plug=False)
finally:
rig.BASE, s81.TICK = base, tick0
meta = {"E": E, "R": R, "t_plug": t_plug, "t_man": t_man,
"t_house": t_house, "house_w": hw, "step": step}
return r, tr, meta
# ---------------------------------------------------------- event helpers
# For `rel` (seconds from R) or `extra` (run seconds).
def p1_gap(t0, secs):
"""No P1 sample reaches the add-on for `secs` from `t0` (it is late)."""
def off(p, c):
c.p1._ev19_submit = c.p1.submit
c.p1.submit = lambda *a, **k: None
def on(p, c):
c.p1.submit = c.p1._ev19_submit
return {t0: off, t0 + secs: on}
def stale(t0, t1):
"""The charger's readings stop reaching the car tracker from t0 to t1:
its figure ages past `stale_s`."""
def off(p, c):
c.car._ev19_observe = c.car.observe
c.car.observe = lambda *a, **k: None
def on(p, c):
c.car.observe = c.car._ev19_observe
return {t0: off, t1: on}
def unavailable(t0, t1):
return {t0: lambda p, c: p.ch.go_unavailable(True),
t1: lambda p, c: p.ch.go_unavailable(False)}
def restart(t0):
return {t0: lambda p, c: H.restart(c)}
def phases(t0, n=3):
"""The user asks for `n` phases (the add-on's own 0 A pause follows)."""
return {t0: lambda p, c: c._car_action("car_phases", n, c.car_now())}
def socs(t0, **s):
return {t0: lambda p, c: p.socs.update(s)}
def merge(*evs):
out = {}
for e in evs:
for t, fn in e.items():
old = out.get(t)
out[t] = fn if old is None else (
lambda p, c, a_=old, b_=fn: (a_(p, c), b_(p, c)))
return out
# --------------------------------------------------------------- grading
def window(tr, t0, t1):
return [x for x in tr if t0 <= x["t"] <= t1]
def alarms(r):
return H.alarms(r)
def edges(tr):
return H.edges(tr)
def bad(x):
"""An alarm, red sample or ERROR in this cycle."""
return bool(x["alarm"] or x["red"] or x["err"])
def repro(r, tr, meta, t0=-10, t1=60):
"""T1's definition: a floor notice, ERROR or red sample in R-10..R+60 in
a cycle where the car figure is trusted (the shape lands under the aim
without the car, so the car explains). Returns (cycles, C5-only cycles)."""
R = meta["R"]
w = window(tr, R + t0, R + t1)
notes = [t for t in alarms(r) if R + t0 <= t <= R + t1]
hit = [x["t"] for x in w if bad(x) and x["w"] is not None
and x["w"] > 0.0]
c5 = [x["t"] for x in w if bad(x) and not (x["w"] is not None
and x["w"] > 0.0)]
return hit, c5, notes
def quiet(r, tr, t0, t1):
return (not [t for t in alarms(r) if t0 <= t <= t1]
and not any(bad(x) for x in window(tr, t0, t1)))
def commands(r, tr):
h = hashlib.sha256()
for u in sorted(r["plant"].hists):
h.update(repr((u, r["plant"].hists[u])).encode())
h.update(repr(r["sim"].writes()).encode())
h.update(repr([(x["t"], x["floor_w"], x["lo"], x["sp"])
for x in tr]).encode())
return h.hexdigest()[:16]
def row(name, r, tr, meta):
hit, c5, notes = repro(r, tr, meta)
R = meta["R"]
first = hit[:1]
cause = ""
if first:
x = next(y for y in tr if y["t"] == first[0])
cause = (f"w={x['w']:.0f} batt={x['batt']} true={x['true_batt']:.0f}"
f" real={x['need_real']:d} excl={x['need_excl']:d} "
f"house={x['need_house']:d} over={x['over_now']:d} "
f"contra={x['contra']:d} pn={x['peak_needed']:d} "
f"wa={x['within_aim']:d} wanted={x['wanted']:.0f}")
return (f"{name:42s} R={R:5d} notes {[t - R for t in notes]} "
f"hit {[t - R for t in hit][:6]}{'...' if len(hit) > 6 else ''}"
f" n={len(hit)} c5 {len(c5)} err "
f"{len([x for x in window(tr, R - 10, R + 60) if x['err']])} "
f"red900 {len([x for x in window(tr, R - 60, R + 900) if x['red']])}"
f" {cause}")
def t2_shape(**kw):
"""The reproducing shape (T2): b follows the house from R, 0 W before."""
return dict(dict(bw=0.0, traj="t2"), **kw)
def t5_shape(**kw):
"""The honest shape (T5): the house alone misses the aim by 1 680 W, more
than the 1 380 W car; the batteries give 4 250 W until R."""
return dict(dict(bw=4250.0, traj="t1", house_w=AIM + 1680.0), **kw)
def flicker_force(bw=2000.0):
"""T17: each unit gives bw/2 above its reserve and ramps to 0 W over 3
cycles once at it (tau3); back above it, it gives bw/2 again at once."""
def mk(u):
st = {"since": None}
def f(at, plant):
if plant.socs[u] >= 20.0:
st["since"] = None
return bw / 2.0
if st["since"] is None:
st["since"] = at
k = int(at - st["since"])
return bw / 2.0 * max(0.0, (3 - k) / 3.0)
return f
return {"a": mk("a"), "b": mk("b")}
def _step_house(k, lo=AIM + 520.0 - CAR, hi=AIM + 1900.0):
return lambda t, R: lo if t < R + k else hi
def _ignoring():
"""The charger accepts the 6 A write and ignores it: the car stays at
0 A."""
s = Meter(setpoint_a=0)
s.refuse = "ignore"
return s
def _full_at_plug(p, c):
"""The car is full (after the plug-in at R-180): mode3 B, 0 W."""
p.ch.car_full()
def _no_energy(p, c):
"""The charger has no energy entity."""
p.ch.no_energy = True
def _freeze_stop(p, c):
p.ch.freeze()
p.ch.car_full()
def jobs():
"""Every controller run test_ev19.py grades: {name: kwargs}."""
j = {}
for name, kw in grid():
j["T1 " + name] = kw
# T3: the battery W sweep
for tj in ("t1", "t2"):
for bw in range(0, 4601, 200):
j[f"T3 {tj} bw={bw}"] = dict(bw=float(bw), traj=tj)
j[f"T3 {tj} tau5"] = dict(bw=9600.0, traj=tj, aim=6000.0,
house_w=5200.0)
# T4: the landing without the car at aim + 9 / + 11 W
for d in (9, 11):
for md in ("manual", "off"):
j[f"T4 +{d} {md}"] = t2_shape(house_w=AIM + d, mode=md)
# T5: honest at the reserve
for tj in ("t1", "t4"):
for md in ("manual", "off"):
j[f"T5 {tj} {md}"] = t5_shape(traj=tj, mode=md)
for md in ("manual", "off"):
j[f"T5 tau5 {md}"] = dict(bw=9600.0, traj="t1", aim=6000.0,
house_w=7700.0, mode=md)
# T6: the honest step in the reserve cycle
for k in (0, 1, 5):
for md in ("manual", "off"):
j[f"T6 step R+{k} {md}"] = dict(bw=4250.0, traj="t1", mode=md,
house_fn=_step_house(k))
# T7: unknown values
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
j[f"T7(a) {nm}"] = sh(lost={"a": {0, 1}})
j[f"T7(b) {nm}"] = sh(rel=unavailable(0, 1))
j["T7(a) T5 off"] = t5_shape(lost={"a": {0, 1}}, mode="off")
j["T7(b) T5 off"] = t5_shape(rel=unavailable(0, 1), mode="off")
# T8: a stale car figure
j["T8(a) Off 120 s, Manual R-5"] = t2_shape(plug_at=-125, man_at=-5)
j["T8(b) stale R-5..R+20"] = t2_shape(rel=stale(-5, 20))
j["T8(c) frozen, the car stops"] = t5_shape(rel={-30: _freeze_stop})
j["T8(c) off"] = t5_shape(rel={-30: _freeze_stop}, mode="off")
# T9: comms
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
j[f"T9(a) {nm} b lost at R"] = sh(lost={"b": {0}})
j[f"T9(a) {nm} b lost at R-1"] = sh(lost={"b": {-1}})
j[f"T9(b) {nm} P1 5 s late at R"] = sh(rel=p1_gap(0, 5))
# T10: a restart
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
j[f"T10 {nm} twin"] = sh()
for k in (-2, 2):
j[f"T10 {nm} restart R{k:+d}"] = sh(rel=restart(k))
# T11: the quarter edge
for rr in (-1, 0, 1, 43):
j[f"T11 T2 R=E{rr:+d}"] = t2_shape(r_rel=rr)
j[f"T11 T5 R=E{rr:+d}"] = t5_shape(r_rel=rr)
j[f"T11 T5 R=E{rr:+d} off"] = t5_shape(r_rel=rr, mode="off")
# C4: the old quarter heads over the aim (the house high all along), so the
# guard wants power in its last 60 s and SAFETY-126's latch is carried
j["T11 C4 T2 R=E+1"] = t2_shape(r_rel=1, house_w=13350.0, pre_w=13350.0)
# T12: our own phase change
for k in (-15, 5):
j[f"T12 T2 1->3 at R{k:+d}"] = t2_shape(rel=phases(k))
j[f"T12 T5 1->3 at R{k:+d}"] = t5_shape(rel=phases(k))
j[f"T12 T5 1->3 at R{k:+d} off"] = t5_shape(rel=phases(k),
mode="off")
# T13: a wrong charger reply
# (a): the house + the 400 W it really draws lands at aim + 520 W, so the
# house alone misses by 120 W; (b) and T14(a): the car draws 0 W and the
# house alone lands at aim + 520 W. An alarm is due in each.
for md in ("manual", "off"):
j[f"T13(a) draws 400 W {md}"] = t2_shape(
sim=Draw(400.0, CAR, setpoint_a=6), house_w=AIM + 120.0, mode=md)
j[f"T13(a) draws 100 W {md}"] = t2_shape(
sim=Draw(100.0, CAR, setpoint_a=6), house_w=AIM + 420.0, mode=md)
j[f"T13(b) the write ignored, 0 A {md}"] = t2_shape(
sim=_ignoring(), house_w=AIM + 520.0, mode=md)
# T14: configuration
j[f"T14(a) 0 W in C {md}"] = t2_shape(
sim=Draw(0.0, 0.0, c_at_0=True, setpoint_a=6),
house_w=AIM + 520.0, mode=md)
j[f"T14(a) idle B {md}"] = t2_shape(
house_w=AIM + 520.0, mode=md, rel={-179: _full_at_plug})
j["T14(b) ev_charger off"] = t2_shape(opts={"ev_charger": "off"})
j["T14(b) off"] = t2_shape(mode="off")
for tj in ("t1", "t4"):
j[f"T14(c) N=1 anchor {tj}"] = dict(n=1, bw=4250.0, traj=tj)
j["T14(c) N=1 T5"] = t5_shape(n=1)
j["T14(c) N=1 T5 off"] = t5_shape(n=1, mode="off")
# T15: one battery first (SAFETY-87)
for nm, hw in (("anchor", AIM + 520.0 - CAR), ("honest", 19000.0)):
for md in ("manual", "off"):
j[f"T15 {nm} {md}"] = dict(
bw=4250.0, traj="t1", house_w=hw, mode=md,
force={"b": None}, soc_after={"a": 19.0, "b": 35.0},
rel=socs(360, b=19.0))
# T16: x10 (wall and mono), and mono x1 / wall x10
for xn, xk in (("x10", dict(x=10)), ("mono1", dict(x=10, mono_x=1))):
xk = dict(xk, r_rel=40)
# x10: b at 1 200 W before R (at 0 W, which the forced unit holds
# against the guard's floor, SAFETY-37's gate reads it as frozen)
xk2 = dict(xk, bw=1200.0)
j[f"T16 {xn} T2"] = t2_shape(**xk2)
for tj in ("t1", "t4"):
for bw in (0.0, 2000.0, 4250.0):
j[f"T16 {xn} T3 {tj} bw={bw:.0f}"] = dict(bw=bw, traj=tj,
**xk)
for md in ("manual", "off"):
j[f"T16 {xn} T5 {md}"] = t5_shape(mode=md, **xk)
j[f"T16 {xn} T6 {md}"] = dict(bw=4250.0, traj="t1", mode=md,
house_fn=_step_house(0), **xk)
j[f"T16 {xn} T7(b) T2"] = t2_shape(rel=unavailable(0, 10), **xk2)
for rr in (-10, 0, 10, 40):
j[f"T16 {xn} T11 T2 R=E{rr:+d}"] = t2_shape(
**dict(xk2, r_rel=rr))
j[f"T16 {xn} T11 T5 R=E{rr:+d}"] = t5_shape(**dict(xk, r_rel=rr))
# T17: no flicker
j["T17 flicker"] = dict(
force=flicker_force(), after=1200,
rel=merge(socs(300, a=21.0, b=21.0), socs(600, a=19.0, b=19.0)),
house_fn=lambda t, R: AIM + 10.0 + (40.0 if int(t // 7) % 2
else -40.0))
# N2: figures only `car_w_trusted` keeps out of the alarm path: no energy
# entity (never corroborated, never contradicted) and 11 kW reported at
# a 6 A read-back (capped at 1 518 W; the house alone misses by 1 680 W)
for md in ("manual", "off"):
j[f"N2 no energy entity {md}"] = t2_shape(extra={0: _no_energy},
mode=md)
j[f"N2 reports 11 kW at 6 A {md}"] = t5_shape(
sim=Draw(CAR, 11000.0, setpoint_a=6), mode=md)
# T20 / N4: the same runs with the car never explaining
j["N4 T2 explain off"] = t2_shape(explain_off=True)
j["N4 T5 explain off"] = t5_shape(explain_off=True)
return j
def grid():
"""The T1 cells: (name, kwargs)."""
cells = []
for bw in (0.0, 400.0, 800.0, 2000.0, 4250.0, 9600.0):
for tj in ("t1", "t2", "t3", "t4", "t4r"):
for rp in (30, 100, 110, 180, 600):
kw = dict(bw=bw, traj=tj, rp=rp)
if bw == 9600.0:
kw.update(aim=6000.0, house_w=5200.0)
cells.append((f"core bw={bw:.0f} {tj} rp={rp}", kw))
cells.append(("a: plug R-185, Manual R-180", dict(order="plug")))
cells.append(("a: Off 120 s, Manual R-60", dict(order="off120")))
cells.append(("b: energy first step late", dict(energy="late")))
cells.append(("b: energy never steps", dict(energy="never")))
for rr in (-60, 0, 1, 43, 450, 890):
cells.append((f"c: R=E{rr:+d}", dict(r_rel=rr)))
cells.append(("d: x10 wall+mono", dict(x=10, r_rel=40)))
cells.append(("d: x10 wall, mono x1", dict(x=10, mono_x=1, r_rel=40)))
for tj, bw in (("t4", 4250.0), ("t2", 4250.0), ("t2", 1200.0)):
cells.append((f"d: x10 wall+mono {tj} bw={bw:.0f}",
dict(x=10, r_rel=40, traj=tj, bw=bw)))
cells.append((f"d: x10 wall, mono x1 {tj} bw={bw:.0f}",
dict(x=10, mono_x=1, r_rel=40, traj=tj, bw=bw)))
return cells
class Res:
"""What a check needs from one run, picklable: the notices (`raised`,
seconds and ids), the trace, the command digest and the run's times."""
def __init__(self, r, tr, meta):
self.raised = list(r["raised"])
self.tr, self.meta = tr, meta
self.cmd = commands(r, tr)
self.R, self.E = meta["R"], meta["E"]
def alarms(self):
return [t for t, n in self.raised if n == FLOOR]
def rel_alarms(self):
return [int(t - self.R) for t in self.alarms()]
def edges(self):
return [int(t - self.R) for t in edges(self.tr)]
def errors(self):
return [int(x["t"] - self.R) for x in self.tr if x["err"]]
def red(self, t0=-60, t1=900):
return [int(x["t"] - self.R) for x in
window(self.tr, self.R + t0, self.R + t1) if x["red"]]
def at(self, k):
return next((x for x in self.tr if x["t"] == self.R + k), None)
def win(self, t0, t1):
return window(self.tr, self.R + t0, self.R + t1)
def quiet(self, t0=-60, t1=900):
return quiet({"raised": self.raised}, self.tr,
self.R + t0, self.R + t1)
def edges_per_quarter(self):
"""False -> True edges of the floor alarm per quarter (N5)."""
out = {}
for t in edges(self.tr):
q = int((t - self.E) // 900)
out[q] = out.get(q, 0) + 1
return out
def summary(self):
return {"alarms": self.rel_alarms(), "edges": self.edges(),
"errors": self.errors(), "red": len(self.red()),
"cmd": self.cmd}
_JOBS = {}
def _job(name):
import logging
logging.disable(logging.WARNING)
return name, Res(*run(**_JOBS[name]))
def run_many(jobs, procs=None):
"""{name: kwargs} -> {name: Res}, `procs` runs at a time (fork: the
kwargs may hold functions)."""
import multiprocessing
_JOBS.clear()
_JOBS.update(jobs)
procs = procs or int(os.environ.get("EV19_JOBS", "0")) \
or min(8, os.cpu_count() or 1)
ctx = multiprocessing.get_context("fork")
with ctx.Pool(procs) as pool:
return dict(pool.imap_unordered(_job, list(jobs), chunksize=1))
def _one(cell):
import logging
logging.disable(logging.WARNING)
name, kw = cell
try:
r, tr, meta = run(**kw)
except Exception as e: # noqa: BLE001
import traceback
return name, f"{name:42s} Traceback {e!r}\n{traceback.format_exc()}"
return name, row(name, r, tr, meta)
if __name__ == "__main__":
import multiprocessing
cells = grid()
if len(sys.argv) > 1:
cells = [c for c in cells if any(a in c[0] for a in sys.argv[1:])]
with multiprocessing.Pool(int(os.environ.get("EV19_JOBS", "8"))) as pool:
for _name, line in pool.imap(_one, cells):
print(line, flush=True)