Compare commits
14
Commits
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
77684ecfad | ||
|
|
c2bb32ec93 | ||
|
|
4950a2374f | ||
|
|
43b0db73d2 | ||
|
|
ef8c5dcf62 | ||
|
|
93c6628eca | ||
|
|
5db56b5f28 | ||
|
|
12c97b56f4 | ||
|
|
9fdce023e9 | ||
|
|
7788543e09 | ||
|
|
6d7046fc45 | ||
|
|
07f703d1bc | ||
|
|
2cfbc4aec8 | ||
|
|
f66048b287 |
@@ -1,5 +1,9 @@
|
||||
# Changelog
|
||||
|
||||
### Not in a release yet
|
||||
|
||||
- When the add-on changes the car's phases while the batteries are at the peak reserve, there is no longer a false "Battery stopped limiting the peak" for a moment ([[EV-15]]).
|
||||
|
||||
## 0.24.0
|
||||
|
||||
**A minor bump: the add-on can now charge the car (Manual mode), and a car that alone takes the batteries to the peak reserve no longer raises a false peak alarm. Two new options were added, both with defaults, and none needs setting.**
|
||||
|
||||
@@ -97,10 +97,10 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
that latch twice, with and without the car, from the same readings. Both reset
|
||||
at a new quarter and when the guard stops wanting power, and they run every
|
||||
cycle, so the cover option does not touch them. This holds with the projection
|
||||
still under the aim (rig: 5888 W against 6000 W). A car of 0 W makes the two the
|
||||
same, so it explains nothing; a stale, stuck or uncorroborated figure is `None`,
|
||||
sets the latch without the car, and the normal alarms stand. There is no minimum
|
||||
car power: the comparison itself is what separates car from house.
|
||||
still under the aim (rig: 5888 W against 6000 W). A car of 0 W explains
|
||||
nothing; a stale, stuck or uncorroborated figure is `None` and the normal
|
||||
alarms stand while it is (EV-18 below). There is no minimum car power: the
|
||||
comparison itself is what separates car from house.
|
||||
- **The period without the car is not clipped at 0 W** (EV-10b). The rig showed
|
||||
EV-10 failing: house 3 kW, car 11 kW, batteries 8.1 kW, aim 6 kW. The batteries
|
||||
give more than the house uses, so the house alone is an export; `car_exclude`
|
||||
@@ -120,6 +120,49 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
the gaps seen on the rig, 150 to 250 s at 50 s sampling, and shorter than a
|
||||
quarter) and a gap does not restart the 10 s
|
||||
on-count. `car_explains`, which the alarms read, has no hold.
|
||||
- **Our own phase change is not a reason to alarm** (EV-15). Rig, twice: at the
|
||||
reserve, with the car covering, the add-on's 3 -> 1 switch set the car to 0 A.
|
||||
A car that is not charging has no corroboration (`CarTracker._corr_note` clears
|
||||
the window, `corroborated` is False), so `car_alarm_w()` was None, the car
|
||||
explained nothing and `_car_need_excl` latched for the quarter: one
|
||||
PEAK_GUARD_FLOOR_LIMITED and one `goodwe_peak_soc_floor`. Now, only for grading
|
||||
(`car_cycle`), `ctl_car._car_own_pause` lets the car's fresh, not stuck figure
|
||||
(`CarTracker.car_w_paused`, 0 W while paused) stand in without corroboration:
|
||||
from the moment our 0 A write is SENT (`zero_sent_at`: the cycle runs beside
|
||||
the writer and the car stops before the write returns), until the current is
|
||||
set again, at most
|
||||
`OWN_PAUSE_MAX_S` (85 s, the sequence's own waits), then at most one
|
||||
corroboration window (60 s). It ends at once on Off, Stop, shadow, unplug,
|
||||
another writer, or a refused select or write (`seq["failed"]`). The energy it
|
||||
drew in the pause is kept apart (`ws_p`), so `car_exclude`, the guard's
|
||||
input, the claim, floor and writes are unchanged. A house overload still fails
|
||||
the test without the car, so it alarms as on Off.
|
||||
- **The batteries as they give now, and no latch from an unknown** (EV-18, EV-15
|
||||
rig F-A). At the reserve the loop still gives some battery power; "without the
|
||||
car, batteries at 0 W" counted it as house, `_car_need_excl` latched at the
|
||||
quarter's start and the floor alarm stood for the quarter with the excess
|
||||
smaller than the car. Owner 2026-11-19: without the car the batteries keep
|
||||
giving what they give now (the lower of two readings, every cycle); a miss so
|
||||
(`_car_need_house`) seen with a trusted car figure stays latched to the
|
||||
quarter's end. The car explains where the period with it misses on the same
|
||||
batteries (`_car_over_now`), or by the EV-10 test above. A `None` car figure
|
||||
or battery reading explains nothing in that cycle and latches nothing; a car
|
||||
known to draw nothing (fresh, not charging) still grades the house's need.
|
||||
Owner 2026-11-19: a figure the energy meter contradicted (it answered over a
|
||||
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 the meter has not shown is not house yet** (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. Now, while the meter's house side (held - car)
|
||||
moved no more than `RISE_STILL_W` since the last cycle, a reading above both
|
||||
earlier ones counts only up to the higher of them. A meter that moved shows
|
||||
the rise (an honest step with a battery burst alarms at once, as before). A
|
||||
rise the meter does not move with at all is graded as F-B: the one case the
|
||||
readings cannot tell apart. The credit stays the lower of the last two
|
||||
readings; `_car_over_now` is unchanged.
|
||||
- **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.
|
||||
|
||||
@@ -125,6 +125,8 @@ class ManualWriter:
|
||||
self.phase_fails = 0 # phase selects the charger did not take
|
||||
self.phases_gave_up = False
|
||||
self.undone = 0 # sequences undone before the select
|
||||
self.phase_done_at = None # EV-15: our phase change ended well then
|
||||
self.zero_sent_at = None # EV-15: our 0 A write is out, not yet back
|
||||
|
||||
# ------------------------------------------------------------------ user
|
||||
def user_changed(self) -> None:
|
||||
@@ -292,7 +294,14 @@ class ManualWriter:
|
||||
async def _begin(self, drv, r, cur, n, now, tracker) -> None:
|
||||
"""Step 1 of the safe sequence: 0 A. A charger that does not take it
|
||||
stops the sequence before the phases are touched."""
|
||||
ok = await self._write(drv, 0.0, cur, now, tracker)
|
||||
self.phase_done_at = None
|
||||
# EV-15: the car stops while the write waits for its read-back, and the
|
||||
# cycle runs beside it: the window opens when the write is SENT.
|
||||
self.zero_sent_at = now
|
||||
try:
|
||||
ok = await self._write(drv, 0.0, cur, now, tracker)
|
||||
finally:
|
||||
self.zero_sent_at = None
|
||||
if not ok:
|
||||
self._failed(now)
|
||||
return
|
||||
@@ -336,6 +345,7 @@ class ManualWriter:
|
||||
self.log.append(("phases", q["n"], now, ok))
|
||||
q["stage"], q["t1"] = "settle", self.last_done # from its return
|
||||
if not ok:
|
||||
q["failed"] = True # EV-15: no grace for the alarm
|
||||
# The charger did not take it: the car gets its current back
|
||||
# on the old phases after the same SETTLE_S as a taken select
|
||||
# (HA may have taken it and only the read-back be late), and
|
||||
@@ -356,7 +366,10 @@ class ManualWriter:
|
||||
# still wanted, and one that is in place is adopted.
|
||||
self.seq, self.rev_applied, self.reapply = None, None, False
|
||||
self.fails, self.blocked = 0, False
|
||||
if not q.get("failed"):
|
||||
self.phase_done_at = self.last_done # EV-15
|
||||
return
|
||||
q["failed"] = True # EV-15: a refused write ends it
|
||||
q["tries"] += 1
|
||||
if q["tries"] >= MAX_TRIES:
|
||||
# Left at 0 A is the safe side; the next reading re-applies.
|
||||
|
||||
@@ -790,6 +790,17 @@ class CarTracker:
|
||||
return got_wh >= CORR_RATIO * exp_wh - CORR_SLACK_WH
|
||||
return True
|
||||
|
||||
def contradicted(self, now: float) -> bool:
|
||||
"""EV-18: did the energy meter answer over a whole window and fall
|
||||
short (`corroborated` compared and failed)? Not when the energy
|
||||
reading is unknown, the window is empty or still short, or the car is
|
||||
not charging: those are unknown, not contradicted."""
|
||||
r = self.reading
|
||||
if r is None or not r.available or r.charging is not True \
|
||||
or r.energy_kwh is None or not self._hist:
|
||||
return False
|
||||
return not self.corroborated(now)
|
||||
|
||||
def stuck(self, now: float) -> bool:
|
||||
"""Power and read-back unchanged `STUCK_S` after a write that moved the
|
||||
setpoint. Cleared the moment either moves."""
|
||||
@@ -800,8 +811,20 @@ class CarTracker:
|
||||
EV-03 rules), not stuck after a write, corroborated by the energy meter
|
||||
(`corroborated`), and never above what the read-back allows the car to
|
||||
draw: an old or frozen figure must not hide a house overload."""
|
||||
return self._capped_w(now, True)
|
||||
|
||||
def car_w_paused(self, now: float):
|
||||
"""EV-15: the same figure as `car_w_trusted` without the energy-meter
|
||||
corroboration, which a car held at 0 A by the add-on's own phase change
|
||||
cannot give (the meter's window restarts when it stops charging). Fresh,
|
||||
not stuck, and capped by the read-back. Only for grading the alarm
|
||||
during that sequence (`ctl_car._car_own_pause`)."""
|
||||
return self._capped_w(now, False)
|
||||
|
||||
def _capped_w(self, now: float, corroborate: bool):
|
||||
w = self.car_w(now)
|
||||
if w is None or self.stuck(now) or not self.corroborated(now):
|
||||
if w is None or self.stuck(now) \
|
||||
or (corroborate and not self.corroborated(now)):
|
||||
return None
|
||||
r = self.reading
|
||||
a = r.allowed_a if r.allowed_a is not None else r.setpoint_a
|
||||
|
||||
@@ -24,6 +24,16 @@ OVER_HOLD_S = peakguard.ALARM_HOLD_S
|
||||
# the cause: longer than the gaps seen on the rig (150 to 250 s at 50 s
|
||||
# sampling) and shorter than a quarter, or until the session really ends.
|
||||
OVER_OFF_HOLD_S = 180.0
|
||||
# EV-15: the longest our own phase change can take (0 A wait, settle, three
|
||||
# tries of a write at 5 s apart and up to 10 s each, the select's own wait);
|
||||
# the grace for the alarm never outlasts it, and after the current is set
|
||||
# again it lasts at most one corroboration window.
|
||||
OWN_PAUSE_MAX_S = (carmode.ZERO_WAIT_S + carmode.SETTLE_S
|
||||
+ carmode.MAX_TRIES * 15.0 + 10.0)
|
||||
OWN_PAUSE_TAIL_S = chargers.CORR_WINDOW_S
|
||||
# EV-19: the meter's house side (held - car) moved no more than this since the
|
||||
# last cycle: it has not shown a battery rise the reading already shows.
|
||||
RISE_STILL_W = 50.0
|
||||
|
||||
|
||||
class CarMixin:
|
||||
@@ -51,13 +61,16 @@ 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_hx_prev = None # EV-19: last cycle's (held, car W)
|
||||
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
|
||||
self._car_contra_block = None # EV-18: the quarter it was contradicted
|
||||
self._car_over_notified = None # the session a notice was raised for
|
||||
self._car_session = 0
|
||||
self._car_prev_state = None
|
||||
self._carq = {"key": None, "ws": 0.0, "mono": None}
|
||||
self._carq = {"key": None, "ws": 0.0, "ws_p": 0.0, "mono": None}
|
||||
self._peak_proj_real = None
|
||||
saved = data.get(CAR_PEAK_KEY)
|
||||
self.car_peak_q = dict(saved) if isinstance(saved, dict) else {}
|
||||
@@ -206,17 +219,68 @@ class CarMixin:
|
||||
return None
|
||||
return self.car.car_w_trusted(self.car_now())
|
||||
|
||||
def _car_quarter(self, proj, w, mono) -> None:
|
||||
def _car_own_pause(self, mono) -> bool:
|
||||
"""EV-15: is the car held at 0 A by the add-on's OWN phase change? From
|
||||
the moment its 0 A write is SENT (the cycle runs beside the write)
|
||||
until the current is set again, then at most one corroboration window.
|
||||
No when it was aborted (Off, Stop, shadow, unplug, another writer), a
|
||||
write was refused, or it ran past its own maximum."""
|
||||
wr = getattr(self, "car_writer", None)
|
||||
if wr is None or (wr.seq is None and wr.phase_done_at is None
|
||||
and wr.zero_sent_at is None) or wr.hold:
|
||||
return False
|
||||
r = self.car.reading
|
||||
if not (self.car_manual() and self.car_writing()
|
||||
and r is not None and r.available and r.state != "A"):
|
||||
return False
|
||||
q = wr.seq
|
||||
if q is None and wr.zero_sent_at is not None: # sent, not yet back
|
||||
return 0.0 <= mono - wr.zero_sent_at <= OWN_PAUSE_MAX_S
|
||||
if q is not None:
|
||||
return not q.get("failed") and 0.0 <= mono - q["t0"] \
|
||||
<= OWN_PAUSE_MAX_S
|
||||
return 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S
|
||||
|
||||
def _car_contradicted(self, mono) -> bool:
|
||||
"""EV-18 (owner 2026-11-19): did the charger's energy meter answer
|
||||
and fall short of a fresh, not stuck figure of a charging car
|
||||
(`CarTracker.contradicted`)? Then that figure stays untrusted for the
|
||||
alarm to the quarter's end (`car_cycle`). An unknown energy reading
|
||||
contradicts nothing."""
|
||||
r = getattr(self.car, "reading", None)
|
||||
if r is None or not r.available or r.charging is not True \
|
||||
or not self.car_manual():
|
||||
return False
|
||||
return (self.car.car_w(mono) is not None and not self.car.stuck(mono)
|
||||
and self.car.contradicted(mono))
|
||||
|
||||
def _car_idle(self, mono) -> bool:
|
||||
"""EV-18: is the car known to draw nothing? A fresh reading that says
|
||||
it is not charging (mode3 A or B) at under `CAR_PEAK_MIN_W`. Not an
|
||||
unknown figure: the house's own need is graded in such a cycle."""
|
||||
r = getattr(self.car, "reading", None)
|
||||
if r is None or not r.available or r.charging is not False:
|
||||
return False
|
||||
p = self.car.car_w(mono)
|
||||
return p is not None and p < CAR_PEAK_MIN_W
|
||||
|
||||
def _car_quarter(self, proj, w, mono, wg=None) -> None:
|
||||
"""The car's energy in the open quarter, for the average the guard's
|
||||
house leaves out and for the peak line."""
|
||||
house leaves out and for the peak line. `wg` (EV-15) is the figure for
|
||||
grading during our own pause; its energy is kept apart (`ws_p`) so the
|
||||
guard's input is unchanged."""
|
||||
q = self._carq
|
||||
key = None if proj is None else proj.block_start
|
||||
last = q["mono"]
|
||||
if key != q["key"]:
|
||||
self._car_bank(q)
|
||||
q["key"], q["ws"] = key, 0.0
|
||||
if key is not None and w is not None and last is not None:
|
||||
q["ws"] += float(w) * min(max(mono - last, 0.0), 5.0)
|
||||
q["key"], q["ws"], q["ws_p"] = key, 0.0, 0.0
|
||||
if key is not None and last is not None:
|
||||
dt = min(max(mono - last, 0.0), 5.0)
|
||||
if w is not None:
|
||||
q["ws"] += float(w) * dt
|
||||
elif wg is not None:
|
||||
q["ws_p"] = q.get("ws_p", 0.0) + float(wg) * dt
|
||||
q["mono"] = mono
|
||||
|
||||
def _car_bank(self, q) -> None:
|
||||
@@ -233,14 +297,17 @@ class CarMixin:
|
||||
del self.car_peak_q[k]
|
||||
self.store.set(CAR_PEAK_KEY, dict(self.car_peak_q))
|
||||
|
||||
def car_avg_w(self, proj, w) -> float:
|
||||
def car_avg_w(self, proj, w, graded=False) -> float:
|
||||
"""The car's average over the whole open quarter: what it drew so far
|
||||
and `w` for the rest."""
|
||||
and `w` for the rest. `graded` (EV-15) adds what it drew during our
|
||||
own pause."""
|
||||
if proj is None or w is None:
|
||||
return 0.0
|
||||
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
|
||||
so_far = self._carq["ws"] if self._carq["key"] == proj.block_start \
|
||||
else 0.0
|
||||
if graded and self._carq["key"] == proj.block_start:
|
||||
so_far += self._carq.get("ws_p", 0.0)
|
||||
return (so_far + float(w) * left) / QUARTER_S
|
||||
|
||||
def car_exclude(self, proj, w):
|
||||
@@ -264,7 +331,7 @@ class CarMixin:
|
||||
the car asked for. Unchanged without a fresh car reading."""
|
||||
if proj is None or w is None or proj.block_start is None:
|
||||
return proj
|
||||
avg = self.car_avg_w(proj, w)
|
||||
avg = self.car_avg_w(proj, w, graded=True)
|
||||
left = max(0.0, QUARTER_S - float(proj.elapsed_s))
|
||||
held = float(proj.held_w)
|
||||
done_ws = QUARTER_S * float(proj.projected_w) - max(held, 0.0) * left
|
||||
@@ -280,13 +347,37 @@ class CarMixin:
|
||||
`real_proj` is the projection WITH the car, whatever the guard saw."""
|
||||
mono = self.car_now()
|
||||
w = self.car_alarm_w()
|
||||
self._car_quarter(real_proj, w, mono)
|
||||
# EV-15: the figure for grading only. Our own phase change holds the
|
||||
# car at 0 A and the energy meter cannot corroborate it then, so for
|
||||
# that bounded time its fresh, not stuck figure stands in.
|
||||
own = (w is None or float(w) <= 0.0) and self._car_own_pause(mono)
|
||||
wg = w
|
||||
if w is None and own:
|
||||
wg = self.car.car_w_paused(mono)
|
||||
self._car_quarter(real_proj, w, mono, wg)
|
||||
self._car_session_tick(mono)
|
||||
# EV-18 (owner 2026-11-19): a figure the meter contradicted grades no
|
||||
# alarm again in that quarter, not even as our own pause's stand-in.
|
||||
# The alarm decision only: the car's energy count, the guard's input
|
||||
# (`car_exclude`) and, with the cover off, the car-over row keep it.
|
||||
key = None if real_proj is None else real_proj.block_start
|
||||
if key is not None and not own and self._car_contradicted(mono):
|
||||
self._car_contra_block = key
|
||||
contra = key is not None and key == self._car_contra_block
|
||||
explains = over = False
|
||||
if real_proj is not None and target_w is not None \
|
||||
and real_proj.block_start is not None:
|
||||
# EV-10: every cycle, so the latches do not depend on the option.
|
||||
graded = self._car_explains_alarm(real_proj, guard, target_w, w)
|
||||
# EV-18: a car known to draw nothing counts as 0 W for the latches
|
||||
# (the house's own need); it and a 0 W figure explain nothing,
|
||||
# but in our own pause (EV-15).
|
||||
idle = wg is None and self._car_idle(mono)
|
||||
graded = self._car_explains_alarm(
|
||||
real_proj, guard, target_w,
|
||||
None if contra else 0.0 if idle else wg)
|
||||
if contra or idle or (w is not None and float(w) <= 0.0
|
||||
and not own):
|
||||
graded = False
|
||||
if self.car_cover:
|
||||
explains = over = graded
|
||||
elif w is not None:
|
||||
@@ -316,35 +407,58 @@ class CarMixin:
|
||||
batteries left are graded by `load_too_high` on where the period lands
|
||||
(SAFETY-81 / 87); a floor that leaves nothing is graded by SAFETY-126's
|
||||
`misses_aim` (the batteries at 0 W from now on), latched for the
|
||||
quarter. That latch is kept here twice, on the period as it is
|
||||
(`_car_need_real`) and without the car (`_car_need_excl`), from the
|
||||
same `misses_aim` and the same batteries reading. Both reset at a new
|
||||
quarter and when the guard no longer wants power, whatever the cover
|
||||
option says (this runs every cycle). A car that is 0 W, or untrusted
|
||||
(`w` None sets the second latch), makes the two equal and explains
|
||||
nothing."""
|
||||
batt, prev = self.site_batt_w, self._car_batt_prev
|
||||
self._car_batt_prev = batt
|
||||
quarter (`_car_need_real`, and `_car_need_excl` without the car).
|
||||
EV-18 (owner 2026-11-19): without the car, the batteries keep giving
|
||||
what they give now (the lower of two readings), re-checked every cycle;
|
||||
a miss seen so (`_car_need_house`) never lets the car explain for the
|
||||
rest of the quarter. The car also explains where the period with it,
|
||||
on the same batteries, misses (`_car_over_now`). Only a trusted figure
|
||||
latches: an untrusted car (`w` None) or an unknown battery reading
|
||||
explains nothing in that cycle only. All reset at a new quarter and
|
||||
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
|
||||
wants = bool(guard is not None and guard.engaged
|
||||
and guard.blind is None
|
||||
and (guard.wanted_w or 0.0) > 0.0)
|
||||
if real_proj.block_start != self._car_latch_block:
|
||||
if real_proj.block_start != self._car_latch_block or not wants:
|
||||
self._car_latch_block = real_proj.block_start
|
||||
self._car_need_real = self._car_need_excl = False
|
||||
if not wants:
|
||||
self._car_need_real = self._car_need_excl = False
|
||||
self._car_need_house = self._car_over_now = False
|
||||
batt = now
|
||||
if batt is not None and prev is not None:
|
||||
batt = min(float(batt), float(prev))
|
||||
excl = self.car_exclude_alarm(real_proj, w)
|
||||
if wants:
|
||||
if batt is None:
|
||||
self._car_need_real = self._car_need_excl = True
|
||||
else:
|
||||
self._car_need_real = self._car_need_real or \
|
||||
peakguard.misses_aim(real_proj, batt_w=batt,
|
||||
target_w=target_w)
|
||||
self._car_need_excl = self._car_need_excl or w is None or \
|
||||
# EV-19: the reading can show a rise one cycle before the meter does
|
||||
# (the batteries pick up the house at the reserve). While the meter's
|
||||
# house side (held - car; held alone when a car figure is unknown) has
|
||||
# not moved, a reading above both earlier ones is not yet counted as
|
||||
# house; a meter that moved shows it (no discount).
|
||||
held = float(real_proj.held_w)
|
||||
hp, self._car_hx_prev = self._car_hx_prev, (held, w)
|
||||
still = False
|
||||
if hp is not None:
|
||||
moved = held - hp[0]
|
||||
if w is not None and hp[1] is not None:
|
||||
moved -= float(w) - float(hp[1])
|
||||
still = abs(moved) <= RISE_STILL_W
|
||||
seen = now
|
||||
if still and now is not None and prev is not None \
|
||||
and prev2 is not None:
|
||||
seen = min(float(now), max(float(prev), float(prev2)))
|
||||
if wants and batt is not None:
|
||||
self._car_need_real = self._car_need_real or \
|
||||
peakguard.misses_aim(real_proj, batt_w=batt,
|
||||
target_w=target_w)
|
||||
self._car_over_now = self._car_over_now or \
|
||||
self._car_lands_over(real_proj, now, batt, target_w)
|
||||
if w is not None:
|
||||
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, 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
|
||||
@@ -354,7 +468,8 @@ class CarMixin:
|
||||
rating = guard.able_w
|
||||
else:
|
||||
return bool(not guard.within_aim and self._car_need_real
|
||||
and not self._car_need_excl)
|
||||
and not self._car_need_house
|
||||
and (self._car_over_now or not self._car_need_excl))
|
||||
|
||||
def high(p):
|
||||
return peakguard.load_too_high(
|
||||
@@ -362,6 +477,16 @@ class CarMixin:
|
||||
achievable_w=rating)
|
||||
return bool(high(real_proj) and not high(excl))
|
||||
|
||||
@staticmethod
|
||||
def _car_lands_over(p, now, gives, target_w) -> bool:
|
||||
"""EV-18: does the period end more than `ALARM_MISS_W` over the aim
|
||||
with the batteries giving `gives` W from now on (`now`: what they gave
|
||||
in the meter's figure)? Of what is done, only the car's energy counted
|
||||
since the add-on started is the car's (a restart or a gap leaves the
|
||||
rest with the house)."""
|
||||
return peakguard.load_too_high(p, batt_w=now, ceiling_w=target_w,
|
||||
achievable_w=gives)
|
||||
|
||||
def _car_session_tick(self, mono) -> None:
|
||||
"""A charging session is a plug-in: the state goes from no car to a
|
||||
car. The notice is raised once per session."""
|
||||
|
||||
@@ -0,0 +1,344 @@
|
||||
"""EV-15: the add-on's own phase change at the peak reserve raises no alarm.
|
||||
`python3 -B test_ev15.py`
|
||||
|
||||
The rig (EV-10 and EV-10b, F-2): cover on, the batteries at the reserve, the car
|
||||
charging and explaining the excess. The add-on's own 3 -> 1 phase switch sets
|
||||
the car to 0 A; with the car not charging its figure is no longer corroborated
|
||||
(`CarTracker.corroborated`), so `car_alarm_w()` is None, nothing is explained,
|
||||
and PEAK_GUARD_FLOOR_LIMITED plus `goodwe_peak_soc_floor` fire. The rule: for
|
||||
the add-on's own sequence only (`ctl_car._car_own_pause`, bounded) the car's
|
||||
fresh, not stuck figure stands in for grading.
|
||||
|
||||
1. The rig shapes end to end through the car cycle: 3 -> 1 and 1 -> 3.
|
||||
2. A house overload that starts during the sequence still alarms, as on Off.
|
||||
3. Aborted (Off, Stop, unplug), refused, an outside writer: no grace.
|
||||
4. The bounds, and the figure that stands in (stale, stuck: nothing).
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import asyncio
|
||||
import logging
|
||||
import os
|
||||
import sys
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import ctl_car, carmode, chargers as CH # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
|
||||
logging.disable(logging.CRITICAL)
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
def at(t, fn):
|
||||
return {"t": t, "fn": fn}
|
||||
|
||||
|
||||
def beside(plant, c):
|
||||
"""The writer runs BESIDE the cycle, as in production (`car_kick`): its 1 s
|
||||
poll for the read-back lands after the cycle's own read, and the cycle does
|
||||
not wait for the writer (`ev04_peak.drive` does)."""
|
||||
gate = asyncio.Event()
|
||||
|
||||
async def sleep(_s):
|
||||
gate.clear()
|
||||
await gate.wait()
|
||||
|
||||
async def settle():
|
||||
gate.set()
|
||||
for _ in range(5):
|
||||
await asyncio.sleep(0)
|
||||
c.charger._sleep = sleep
|
||||
c.car_settle = settle
|
||||
|
||||
|
||||
def run(house, cap, t_res, t_sw, new, *, extra=None, mode="manual",
|
||||
sim_fn=None, dur=895, plug=True, side=False):
|
||||
"""Reserve at `t_res`, our phase change to `new` at `t_sw`. Returns the
|
||||
run, a per-second trace (second, own-pause, explains, red rows) and the
|
||||
alarms."""
|
||||
tr = []
|
||||
|
||||
def note(plant, c):
|
||||
red = [x["id"] for x in c.checks()
|
||||
if x["ok"] is False and not x["warn"]] \
|
||||
if t_sw - 5 <= plant.t <= t_sw + 90 else []
|
||||
g = c.peak_guard
|
||||
lim = bool(g is not None and (g.floor_limited or g.saturated))
|
||||
tr.append((plant.t, getattr(c, "_car_own_pause", lambda _t: False)(c.car_now()), c.car_explains,
|
||||
red, plant.ch.power_w, plant.ch.state, lim))
|
||||
|
||||
def reserve(plant, c):
|
||||
plant.soc = 19.0
|
||||
plant.load = lambda t: house + plant.ch.power_w
|
||||
|
||||
def switch(plant, c):
|
||||
asyncio.get_event_loop().create_task(
|
||||
c.handle_action("car_phases", value=new))
|
||||
|
||||
ev = {t: note for t in range(0, dur)}
|
||||
ev[t_res] = lambda p, c: (reserve(p, c), note(p, c))
|
||||
ev[t_sw] = lambda p, c: (switch(p, c), note(p, c))
|
||||
if side:
|
||||
ev[t_sw - 2] = lambda p, c: (beside(p, c), note(p, c))
|
||||
for t, fn in (extra or {}).items():
|
||||
prev = ev.get(t, note)
|
||||
ev[t] = (lambda p, c, prev=prev, fn=fn: (fn(p, c), prev(p, c)))
|
||||
sim = None
|
||||
if sim_fn is not None or side:
|
||||
from chargersim import SimCharger
|
||||
sim = SimCharger(setpoint_a=16)
|
||||
sim_fn = sim_fn or (lambda s: None)
|
||||
sim_fn(sim)
|
||||
r = P.drive(s81.constant(house), dur=dur, rating=12000.0, soc=60.0,
|
||||
cap=cap, phases=(3 if new == 1 else 1), user_a=16, setpoint=16,
|
||||
mode=mode, events=ev, sim=sim, plug=plug)
|
||||
return r, tr, P.ids(r, *P.ALARMS)
|
||||
|
||||
|
||||
def reds(tr):
|
||||
return [x for x in tr if x[3]]
|
||||
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. THE RIG SHAPES THROUGH THE CAR CYCLE")
|
||||
# =========================================================================== #
|
||||
SHAPES = (
|
||||
("EV-10 shape: house 3 kW, car 11 kW, aim 6 kW, 3 -> 1",
|
||||
3000.0, 6050.0, 300, 600, 1),
|
||||
("EV-10b shape: a 9411 W limit, 3 -> 1", 2000.0, 9461.0, 300, 600, 1),
|
||||
("1 -> 3 (the car 3.7 kW, then 11 kW), aim 5 kW", 2500.0, 5050.0,
|
||||
100, 600, 3),
|
||||
)
|
||||
for name, house, cap, t_res, t_sw, new in SHAPES:
|
||||
r, tr, al = run(house, cap, t_res, t_sw, new)
|
||||
c, sim = r["c"], r["sim"]
|
||||
sw = [x for x in sim.writes() if x[1] == "phases"]
|
||||
check(f"{name}: the car at the reserve covers, and the add-on's own "
|
||||
f"sequence ran (0 A, select, the current back)",
|
||||
len(sw) == 1 and [x[2] for x in sim.writes("current")][-2:]
|
||||
== [0.0, 16.0] and sim.phases_allowed == new)
|
||||
pause = [x for x in tr if x[1]]
|
||||
check(f"{name}: the own-pause grace was on during it, and ended",
|
||||
len(pause) >= 10 and not any(x[1] for x in tr[-1:])
|
||||
and (pause[-1][0] - pause[0][0])
|
||||
<= getattr(ctl_car, "OWN_PAUSE_MAX_S", 0)
|
||||
+ getattr(ctl_car, "OWN_PAUSE_TAIL_S", 0))
|
||||
check(f"{name}: no PEAK_GUARD_FLOOR_LIMITED / saturated, no "
|
||||
f"goodwe_peak_soc_floor notification", al == [])
|
||||
check(f"{name}: no red row in any sample around the switch",
|
||||
reds(tr) == [])
|
||||
limited = [x for x in tr if x[1] and x[6]]
|
||||
check(f"{name}: in every cycle of the sequence in which the guard is "
|
||||
f"limited (the cycle of the rig's alarm among them) the car "
|
||||
f"explains it", len(limited) >= 1 and all(x[2] for x in limited)
|
||||
and any(x[2] for x in tr if x[0] == t_sw + 1))
|
||||
check(f"{name}: and in every limited cycle after it, to the quarter's end",
|
||||
all(x[2] for x in tr if x[0] >= t_sw and x[6]))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. A HOUSE OVERLOAD DURING THE SEQUENCE STILL ALARMS")
|
||||
# =========================================================================== #
|
||||
def overload(plant, c):
|
||||
plant.load = lambda t: 25000.0 + plant.ch.power_w
|
||||
|
||||
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, extra={606: overload})
|
||||
ro, tro, alo = run(3000.0, 6050.0, 300, 600, 1, extra={606: overload},
|
||||
mode="off", plug=False)
|
||||
rn, trn, aln = run(3000.0, 6050.0, 300, 900, 1, extra={606: overload})
|
||||
check("PRECONDITION: on Off (no car) the same load alarms, and in Manual "
|
||||
"with no phase change", alo != [] and aln != [])
|
||||
check("a 25 kW house overload that starts 6 s into the sequence (the car "
|
||||
"paused): the alarm fires", al != [])
|
||||
print(f" alarm seconds: in the sequence {[t for t, _ in al]}, Off without "
|
||||
f"the car {[t for t, _ in alo]}, Manual with no phase change "
|
||||
f"{[t for t, _ in aln]}")
|
||||
check("...at the same second as on Off and as in Manual with no phase change",
|
||||
bool(al) and bool(alo) and bool(aln)
|
||||
and al[0][0] == alo[0][0] == aln[0][0])
|
||||
check("...and the car does not explain it (during the sequence too)",
|
||||
not any(x[2] for x in tr if 640 <= x[0] <= 660))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n3. ABORTED, REFUSED, OUTSIDE: NO GRACE AFTER IT")
|
||||
# =========================================================================== #
|
||||
def hit(res, t0, secs):
|
||||
return [x for x in res if t0 <= x[0] <= t0 + secs and x[1]]
|
||||
|
||||
|
||||
def off_now(plant, c):
|
||||
asyncio.get_event_loop().create_task(c.handle_action("car_mode",
|
||||
value="off"))
|
||||
|
||||
|
||||
def stop_now(plant, c):
|
||||
c.auto = False
|
||||
|
||||
|
||||
def unplug(plant, c):
|
||||
plant.ch.unplug()
|
||||
|
||||
|
||||
slow = lambda s: setattr(s, "stop_delay_s", 8.0) # noqa: E731
|
||||
for what, fn in (("Off", off_now), ("Stop", stop_now), ("unplug", unplug)):
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, extra={602: fn},
|
||||
sim_fn=slow)
|
||||
check(f"{what} 2 s into the sequence: the grace is off from the next "
|
||||
f"cycle on", not hit(tr, 604, 200)
|
||||
and any(x[1] for x in tr if 600 <= x[0] <= 602))
|
||||
|
||||
def refuse_phases(sim):
|
||||
sim.request_phases = lambda n: False
|
||||
|
||||
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, sim_fn=refuse_phases)
|
||||
check("the select is refused: the grace ends at once (no cycle of it after "
|
||||
"the refusal), the current comes back",
|
||||
len([x for x in r["sim"].writes("current")]) >= 2
|
||||
and not hit(tr, 606, 200))
|
||||
|
||||
def outside_zero(plant, c):
|
||||
plant.ch.set_current(0.0)
|
||||
|
||||
|
||||
r2, tr2, al2 = run(3000.0, 6050.0, 300, 900, 1, extra={602: outside_zero})
|
||||
check("an outside writer's 0 A: no grace, and the normal grading (no car "
|
||||
"power: nothing explained) raises the alarm as before",
|
||||
not any(x[1] for x in tr2) and not any(x[2] for x in tr2
|
||||
if 610 <= x[0] <= 700)
|
||||
and al2 != [])
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n4. THE BOUNDS AND THE FIGURE THAT STANDS IN")
|
||||
# =========================================================================== #
|
||||
class _C(ctl_car.CarMixin):
|
||||
"""The mixin with just what `_car_own_pause` reads."""
|
||||
def __init__(self):
|
||||
self.o = {}
|
||||
self.car_init({}, type("S", (), {"data": {}, "set": lambda s, k, v: 0})())
|
||||
self.car_mode = carmode.MANUAL
|
||||
self.auto, self.shadow = True, False
|
||||
self.inverters, self.site_sign_wd = [], type("W", (), {"tripped": False})()
|
||||
self.circ_wd = type("W", (), {"tripped": False})()
|
||||
self.charger = type("H", (), {"configured": lambda s: True})()
|
||||
self.car = CH.CarTracker()
|
||||
self.car.reading = CH.ChargerReading(available=True, state="B")
|
||||
|
||||
|
||||
c = _C()
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0, "n": 1, "tries": 0,
|
||||
"prev": 16.0}
|
||||
M = ctl_car.OWN_PAUSE_MAX_S
|
||||
check("bound: the sequence's own maximum is its waits (0 A wait, settle, "
|
||||
"three tries at 15 s, the select) and no more",
|
||||
M == carmode.ZERO_WAIT_S + carmode.SETTLE_S + carmode.MAX_TRIES * 15.0
|
||||
+ 10.0 and ctl_car.OWN_PAUSE_TAIL_S == CH.CORR_WINDOW_S)
|
||||
check("bound: on at the 0 A write and up to the maximum",
|
||||
c._car_own_pause(100.0) and c._car_own_pause(100.0 + M))
|
||||
check("bound: off one second past it", not c._car_own_pause(101.0 + M))
|
||||
c.car_writer.seq = None
|
||||
c.car_writer.phase_done_at = 200.0
|
||||
T = ctl_car.OWN_PAUSE_TAIL_S
|
||||
check("bound: after the current is set again it lasts one corroboration "
|
||||
"window", c._car_own_pause(200.0 + T) and not c._car_own_pause(201.0 + T))
|
||||
c.car_writer.phase_done_at = None
|
||||
check("no sequence and none just done: no grace", not c._car_own_pause(100.0))
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0, "failed": True}
|
||||
check("a refused write marks the sequence: no grace", not c._car_own_pause(110.0))
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0}
|
||||
c.car_mode = carmode.OFF
|
||||
check("Off: no grace", not c._car_own_pause(110.0))
|
||||
c.car_mode, c.shadow = carmode.MANUAL, True
|
||||
check("shadow mode: no grace", not c._car_own_pause(110.0))
|
||||
c.shadow, c.auto = False, False
|
||||
check("control stopped: no grace", not c._car_own_pause(110.0))
|
||||
c.auto = True
|
||||
c.car_writer.hold = True
|
||||
check("another writer (hold): no grace", not c._car_own_pause(110.0))
|
||||
c.car_writer.hold = False
|
||||
c.car_writer.seq, c.car_writer.zero_sent_at = None, 100.0
|
||||
check("0 A sent, not yet back: grace from the send, to the maximum, no more",
|
||||
c._car_own_pause(100.0) and c._car_own_pause(100.0 + M)
|
||||
and not c._car_own_pause(101.0 + M))
|
||||
c.car_writer.zero_sent_at = None
|
||||
c.car_writer.phase_done_at = 200.0
|
||||
c.car_writer.hold = True
|
||||
check("another writer in the 60 s after the current is set: no grace",
|
||||
not c._car_own_pause(210.0))
|
||||
c.car_writer.hold, c.car_writer.phase_done_at = False, None
|
||||
c.car_writer.seq = {"stage": "settle", "t0": 100.0}
|
||||
c.car.reading = CH.ChargerReading(available=True, state="A")
|
||||
check("unplugged: no grace", not c._car_own_pause(110.0))
|
||||
c.car.reading = CH.ChargerReading(available=True, state="B")
|
||||
check("PRECONDITION: the same state is on", c._car_own_pause(110.0))
|
||||
|
||||
tk = CH.CarTracker()
|
||||
tk.reading = CH.ChargerReading(available=True, state="B", power_w=500.0,
|
||||
allowed_a=16.0, phases_allowed=1)
|
||||
tk.last_ok = 0.0
|
||||
check("the stand-in figure is the fresh reading, capped by the read-back",
|
||||
tk.car_w_paused(5.0) == 500.0 and tk.car_w_trusted(5.0) is None)
|
||||
check("a stale reading stands in for nothing", tk.car_w_paused(100.0) is None)
|
||||
tk.stuck_now = True
|
||||
check("a stuck reading stands in for nothing", tk.car_w_paused(5.0) is None)
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n5. THE WRITER RUNS BESIDE THE CYCLE (review F-1)")
|
||||
# =========================================================================== #
|
||||
# The car stops (state B) in the same Home Assistant update as the 0 A
|
||||
# read-back; the write has not returned yet, so no sequence exists. The window
|
||||
# opens when the write is SENT (`ManualWriter.zero_sent_at`).
|
||||
def lagged(lag, delay):
|
||||
def f(s):
|
||||
s.lag_s, s.stop_delay_s = lag, delay
|
||||
return f
|
||||
|
||||
|
||||
for lag, delay in ((2, 0), (0, 0), (2, 3), (5, 2)):
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, side=True,
|
||||
sim_fn=lagged(lag, delay))
|
||||
nm = f"beside the cycle, lag {lag} s, stop delay {delay} s"
|
||||
limited = [x for x in tr if x[0] >= 600 and x[6]]
|
||||
check(f"{nm}: our sequence ran (select once, then 16 A again)",
|
||||
len([x for x in r["sim"].writes("phases")]) == 1
|
||||
and r["sim"].phases_allowed == 1
|
||||
and [x[2] for x in r["sim"].writes("current")][-2:] == [0.0, 16.0])
|
||||
check(f"{nm}: no PEAK_GUARD_FLOOR_LIMITED, no goodwe_peak_soc_floor",
|
||||
al == [])
|
||||
check(f"{nm}: no red row, and the car explains every limited cycle",
|
||||
reds(tr) == [] and all(x[2] for x in limited))
|
||||
|
||||
|
||||
def not_taken(plant, c):
|
||||
plant.ch.refuse = "ignore" # HA accepts, the charger does nothing
|
||||
|
||||
|
||||
r, tr, al = run(3000.0, 6050.0, 300, 600, 1, side=True,
|
||||
sim_fn=lagged(0, 0), extra={600: not_taken})
|
||||
check("the 0 A write is not taken (read-back never follows): the window was "
|
||||
"open while it waited", any(x[1] for x in tr if 600 <= x[0] <= 606))
|
||||
own = [x[0] for x in tr if x[1]]
|
||||
runs = 1 + len([1 for a, b in zip(own, own[1:]) if b - a > 1])
|
||||
check("...and no grace after the refusal (the retry, RETRY_S later, opens it "
|
||||
"again only while that write waits: at most 3 runs of 11 s), no "
|
||||
"sequence made", not hit(tr, 613, 40) and r["c"].car_writer.seq is None
|
||||
and 1 <= runs <= 3 and len(own) <= 3 * 11)
|
||||
check("...the car went on charging and nothing was written but the 0 A",
|
||||
r["sim"].power_w > 5000.0 and not r["sim"].writes("phases"))
|
||||
|
||||
print()
|
||||
if fails:
|
||||
print(f"FAIL: {len(fails)} check(s)")
|
||||
for f in fails:
|
||||
print(" -", f)
|
||||
sys.exit(1)
|
||||
print("ok: EV-15")
|
||||
@@ -0,0 +1,832 @@
|
||||
"""EV-18: no floor alarm at a quarter's start while the car explains the excess
|
||||
(EV-15 rig F-A). `python3 -B test_ev18.py`
|
||||
|
||||
The rig: both batteries at the peak reserve, the car charging, and
|
||||
PEAK_GUARD_FLOOR_LIMITED + `goodwe_peak_soc_floor` at a quarter's start, red
|
||||
for most of the quarter, while the grid excess was smaller than the car. Two
|
||||
causes, both latched for the quarter by `_car_need_excl`:
|
||||
C1 one cycle with no trusted car figure set the latch (T1);
|
||||
C2 "without the car" assumed the batteries give 0 W from now on, so what
|
||||
the loop still gives below the reserve counted as house (T2).
|
||||
The rule now (owner 2026-11-19, Q1-Q3): without the car the batteries keep
|
||||
giving what they give now (the lower of the last two readings, re-checked
|
||||
every cycle); a house need seen with a trusted car figure stays latched to the
|
||||
quarter's end; an unknown car figure keeps the alarm only while it is unknown.
|
||||
|
||||
T-ids are the test plan's (reports/EV-18-test-plan.md). "base" is 9fdce02.
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import chargers as CH, ctl_car, tariff # noqa: E402
|
||||
from chargersim import SimCharger # noqa: E402
|
||||
from named_absence import first, nth, present # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import ev18_peak as H # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
AIM = H.AIM
|
||||
CAR = 1380.0
|
||||
E = H.E
|
||||
# Measured on base 9fdce02 with this file's own runs: the seconds of
|
||||
# goodwe_peak_soc_floor in the honest shapes, which must not come later now. An
|
||||
# honest shape steps the house at E, and the meter shows it at E+1.
|
||||
T5_BASE = [E + 1] # also T6 (T5 shape), T8, T9(a), T10(b) T5
|
||||
T7_BASE = E + 72
|
||||
T9B_BASE = [] # 400 W real: never uncorroborated (Findings)
|
||||
T9C_BASE = E + 1 # 100 W real: never trusted at the edge
|
||||
T10A_T5_BASE = [E + 2] # the guard disengages at E+1 (no battery reading)
|
||||
T11_BASE = [E + 13] # SAFETY-87: ALARM_HOLD_S after the step
|
||||
T13_BASE = [E + 301]
|
||||
T15_T5_BASE = [E + 10] # x10: one cycle
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. UNIT: car_cycle ACROSS A QUARTER EDGE (a real `_carq`, not preset)")
|
||||
# =========================================================================== #
|
||||
BS = datetime(2026, 11, 17, 21, 15, tzinfo=timezone.utc) # the edge E
|
||||
|
||||
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self):
|
||||
self.o = {"ev_batt_cover": True}
|
||||
self.w = CAR
|
||||
self._now = 0.0
|
||||
self.site_batt_w, self.site_rating_w = 0.0, 9600.0
|
||||
self.store = type("S", (), {"data": {}, "set": lambda s, k, v: 0})()
|
||||
self.car_init({}, self.store)
|
||||
|
||||
def car_now(self):
|
||||
return self._now
|
||||
|
||||
def car_alarm_w(self):
|
||||
return self.w
|
||||
|
||||
class car: # noqa: N801
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
class _G:
|
||||
"""Floor-limited, the floor leaves nothing (floor_w 0), wants power."""
|
||||
def __init__(self, wants=True, within_aim=False):
|
||||
self.floor_limited, self.saturated = True, False
|
||||
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, AIM + 50.0
|
||||
self.engaged, self.blind = True, None
|
||||
self.wanted_w = 300.0 if wants else 0.0
|
||||
self.within_aim = within_aim
|
||||
|
||||
|
||||
def urun(secs, grid, batt, w, *, x=1, mono_x=None, c=None, guard=None):
|
||||
"""`car_cycle` once per entry of `secs` (seconds from the edge E, `x` fake
|
||||
seconds apart). `grid(t)` is the meter (house + car - batteries),
|
||||
`batt(t)` the site battery reading, `w(t)` the trusted car figure. Returns
|
||||
(car, {t: car_explains})."""
|
||||
c = c or _Car()
|
||||
mono_x = x if mono_x is None else mono_x
|
||||
done, out = {}, {}
|
||||
t0 = nth(list(secs), 0)
|
||||
if c._carq["key"] is None and present(t0) and t0 % 900:
|
||||
# started mid-quarter: the car was counted since its start (no restart)
|
||||
c._carq.update(key=BS + timedelta(seconds=900 * (t0 // 900)),
|
||||
ws=float(w(t0) or 0.0) * (t0 % 900), ws_p=0.0)
|
||||
for t in secs:
|
||||
q = t // 900
|
||||
bs, el = BS + timedelta(seconds=900 * q), t - 900 * q
|
||||
g = float(grid(t))
|
||||
d = done.get(bs, g * el)
|
||||
p = tariff.Projection(
|
||||
projected_w=(d + g * (900 - el)) / 900.0,
|
||||
elapsed_w=(d / el if el else g), elapsed_s=float(el),
|
||||
covered_frac=1.0, complete=False, block_start=bs, held_w=g)
|
||||
done[bs] = d + g * x
|
||||
c._now = 10000.0 + t * mono_x / x
|
||||
c.w, c.site_batt_w = w(t), batt(t)
|
||||
c.car_cycle(p, guard(t) if guard else _G(), AIM, None)
|
||||
out[t] = c.car_explains
|
||||
return c, out
|
||||
|
||||
|
||||
def const(v):
|
||||
return lambda t: v
|
||||
|
||||
|
||||
def run_of(d, t0, t1):
|
||||
return [d[t] for t in sorted(d) if t0 <= t <= t1]
|
||||
|
||||
|
||||
# --- T1: the car figure untrusted for the edge's first cycles --------------- #
|
||||
def t1(x=1, mono_x=None):
|
||||
_c, ex = urun(range(-30, 121, x), const(13000.0 + CAR), const(0.0),
|
||||
lambda t: None if 0 <= t <= 2 * x else CAR, x=x,
|
||||
mono_x=mono_x)
|
||||
return ex
|
||||
|
||||
|
||||
ex = t1()
|
||||
print(f" T1 explains E-1..E+5: {run_of(ex, -1, 5)}")
|
||||
check("T1 PRECONDITION: before the edge the car (trusted) explains the "
|
||||
"excess (house 13 000 W, car 1 380 W, grid 14 380 W)",
|
||||
all(run_of(ex, -30, -1)) and len(run_of(ex, -30, -1)) == 30)
|
||||
check("T1 (Expected 5): while the car figure is unknown (E+0..E+2) it "
|
||||
"explains nothing, so the alarm stands", not any(run_of(ex, 0, 2)))
|
||||
_c1b, ex1b = urun(range(-30, 121), const(12500.0 + CAR - 800.0), const(800.0),
|
||||
lambda t: None if 0 <= t <= 2 else CAR)
|
||||
check("T1b (the EV-10 path: the grid lands under the aim, the batteries at "
|
||||
"0 W would miss; house 12 500 W, b 800 W): unknown E+0..E+2, released "
|
||||
"at E+3 and explained to E+120",
|
||||
not any(run_of(ex1b, 0, 2)) and all(run_of(ex1b, 3, 120))
|
||||
and len(run_of(ex1b, 3, 120)) == 118)
|
||||
check("T1 (Expected 3): released at the first trusted cycle (E+3) and "
|
||||
"explained to E+120 (base: latched False to E+120)",
|
||||
all(run_of(ex, 3, 120)) and len(run_of(ex, 3, 120)) == 118)
|
||||
|
||||
# --- T2c: the battery W boundary, graded on the lower of two readings ------- #
|
||||
def t2c(b_of):
|
||||
_c, ex = urun(range(0, 6), lambda t: 14000.0 + CAR - b_of(t), b_of,
|
||||
const(CAR))
|
||||
return run_of(ex, 0, 5)
|
||||
|
||||
|
||||
e391, e389 = t2c(const(391.0)), t2c(const(389.0))
|
||||
e395 = t2c(lambda t: 395.0 if t == 0 else 385.0)
|
||||
print(f" T2c 391 W {e391}, 389 W {e389}, 395 then 385 W {e395}")
|
||||
check("T2c: b steady at 391 W (house alone with the real batteries lands "
|
||||
"13 609 W, aim + 9 W): the car explains from E+0", all(e391)
|
||||
and len(e391) == 6)
|
||||
check("T2c: b at 389 W (13 611 W, aim + 11 W): it does not, from E+0",
|
||||
not any(e389) and len(e389) == 6)
|
||||
check("T2c: readings 395 then 385 W: graded on 385 W, no explanation from "
|
||||
"the second cycle on", not any(e395[1:]) and len(e395) == 6)
|
||||
# review round 1 (MD): the meter shows the higher output while the readings
|
||||
# are 389 W then 800 W. b gives 800 W; one reading of 389 W at E+3, the meter
|
||||
# still at 800 W. House 14 005 W: at E+4 the house latch grades on the lower
|
||||
# reading (389 W), rest 13 616 W, landing 13 614 W > aim + 10 W; on the
|
||||
# current one (800 W) it would be 13 205 W.
|
||||
_cl, elag = urun(range(0, 12), const(14005.0 + CAR - 800.0),
|
||||
lambda t: 389.0 if t == 3 else 800.0, const(CAR))
|
||||
print(f" T2c lagging meter E+0..E+11: {run_of(elag, 0, 11)}")
|
||||
check("T2c (meter lags, readings 389 then 800 W): explained before, the "
|
||||
"house latch sets on the lower reading at E+4 and holds to E+11",
|
||||
all(run_of(elag, 0, 3)) and not any(run_of(elag, 4, 11))
|
||||
and len(run_of(elag, 4, 11)) == 8)
|
||||
|
||||
# --- T4: ALARM_MISS_W, batteries at 0 W -------------------------------------- #
|
||||
e09 = run_of(urun(range(0, 6), const(13609.0 + CAR), const(0.0),
|
||||
const(CAR))[1], 0, 5)
|
||||
e11 = run_of(urun(range(0, 6), const(13611.0 + CAR), const(0.0),
|
||||
const(CAR))[1], 0, 5)
|
||||
check("T4 unit: the house alone at aim + 9 W: the car explains from E+0; at "
|
||||
"aim + 11 W it does not", all(e09) and len(e09) == 6 and not any(e11))
|
||||
|
||||
# --- T8 / N2: 0 W and tiny cars ---------------------------------------------- #
|
||||
e0 = run_of(urun(range(-5, 30), const(14000.0 - 800.0), const(800.0),
|
||||
const(0.0))[1], -5, 29)
|
||||
e50 = run_of(urun(range(-5, 30), const(14090.0 + 50.0), const(0.0),
|
||||
const(50.0))[1], -5, 29)
|
||||
check("T8 unit: a 0 W car never explains, whatever the batteries give (T2 "
|
||||
"shape, b 800 W)", not any(e0) and len(e0) == 35)
|
||||
check("T8 unit: a 50 W car with the house at 14 090 W never explains",
|
||||
not any(e50) and len(e50) == 35)
|
||||
# N2: a car that drew 11 kW earlier in the quarter and now reports 0 W
|
||||
c0, ex0 = urun(range(0, 400), lambda t: 2600.0 + (11040.0 if t < 300 else 0.0),
|
||||
const(0.0), lambda t: 11040.0 if t < 300 else 0.0)
|
||||
check("N2: a trusted 0 W figure explains nothing, also after the car drew "
|
||||
"earlier in the quarter", not any(run_of(ex0, 300, 399)))
|
||||
|
||||
# --- T8 unit: a car known to draw nothing is not an unknown car ------------- #
|
||||
class _Tracker:
|
||||
"""The two things `_car_idle` reads: the reading, and its fresh power."""
|
||||
def __init__(self, available):
|
||||
self.reading = CH.ChargerReading(available=available, state="B",
|
||||
charging=False, power_w=0.0)
|
||||
|
||||
def car_w(self, _now):
|
||||
return 0.0 if self.reading.available else None
|
||||
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
def idle_then_charging(available):
|
||||
c = _Car()
|
||||
c.car = _Tracker(available)
|
||||
_c, ex = urun(range(0, 900),
|
||||
lambda t: 14090.0 if t < 60 else 13000.0 + CAR, const(0.0),
|
||||
lambda t: None if t < 60 else CAR, c=c)
|
||||
return ex
|
||||
|
||||
|
||||
exi, exu = idle_then_charging(True), idle_then_charging(False)
|
||||
check("T8 unit: a car known idle (mode3 B, 0 W, fresh) while the house alone "
|
||||
"misses (14 090 W): that house need is latched, so the car charging "
|
||||
"from E+60 does not explain the quarter (test_ev10's `swapped` case)",
|
||||
not any(run_of(exi, 0, 899)))
|
||||
check("T8 unit: the same with the charger unavailable (unknown car): the "
|
||||
"alarm stands while unknown and is released at E+60 (Expected 5)",
|
||||
not any(run_of(exu, 0, 59)) and all(run_of(exu, 60, 899)))
|
||||
|
||||
# --- the contradiction latch (owner 2026-11-19), unit ----------------------- #
|
||||
class _TrackerC:
|
||||
"""A charging car whose energy meter contradicts it when `contra(t)`."""
|
||||
def __init__(self, contra):
|
||||
self.contra = contra
|
||||
self.reading = CH.ChargerReading(available=True, state="C",
|
||||
charging=True, power_w=CAR)
|
||||
|
||||
def car_w(self, _now):
|
||||
return CAR
|
||||
|
||||
def stuck(self, _now):
|
||||
return False
|
||||
|
||||
def contradicted(self, now):
|
||||
return self.contra(now - 10000.0)
|
||||
|
||||
def car_w_paused(self, _now):
|
||||
return CAR
|
||||
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
class _CarC(_Car):
|
||||
def __init__(self, contra, own):
|
||||
super().__init__()
|
||||
self.car, self.own = _TrackerC(contra), own
|
||||
|
||||
def car_manual(self):
|
||||
return True
|
||||
|
||||
def _car_own_pause(self, mono):
|
||||
return self.own(mono - 10000.0)
|
||||
|
||||
|
||||
def contra_run(contra, own, secs):
|
||||
c = _CarC(contra, own)
|
||||
_c, ex = urun(secs, const(13000.0 + CAR), const(0.0),
|
||||
lambda t: None if contra(t) or own(t) else CAR, c=c)
|
||||
return ex
|
||||
|
||||
|
||||
never = lambda t: False # noqa: E731
|
||||
exg = contra_run(lambda t: 300 <= t < 306, never, range(0, 1100))
|
||||
check("contradiction (T3 shape): the meter contradicts the figure at E+300: "
|
||||
"not explained from E+300 to the quarter's end, though trusted again "
|
||||
"from E+306", all(run_of(exg, 0, 299)) and not any(run_of(exg, 300, 899))
|
||||
and len(run_of(exg, 300, 899)) == 600)
|
||||
check("contradiction: released by the next quarter (review MG): explained "
|
||||
"again from E+900", all(run_of(exg, 900, 1099))
|
||||
and len(run_of(exg, 900, 1099)) == 200)
|
||||
exf = contra_run(lambda t: 100 <= t < 130, lambda t: 100 <= t < 130,
|
||||
range(0, 400))
|
||||
check("contradiction during our own pause (EV-15) latches nothing (review "
|
||||
"MF): the stand-in explains in it, the trusted figure after it",
|
||||
all(run_of(exf, 0, 399)) and len(run_of(exf, 0, 399)) == 400)
|
||||
|
||||
# --- T10(a) unit: the battery reading lost for one cycle --------------------- #
|
||||
cA, eA = urun(range(-3, 10), const(14000.0 + CAR - 800.0),
|
||||
lambda t: None if t == 1 else 800.0, const(CAR))
|
||||
check("T10(a) unit, T2 shape: the cycle with no battery reading explains "
|
||||
"nothing (no last-known W credited); the next ones do",
|
||||
eA.get(1) is False and eA.get(0) is True and all(run_of(eA, 2, 9))
|
||||
and len(run_of(eA, 2, 9)) == 8)
|
||||
|
||||
# --- T13 unit: a house need seen with a trusted car stays latched ----------- #
|
||||
c13, e13 = urun(range(-5, 1000),
|
||||
lambda t: (15500.0 if 300 <= t < 360 else 13000.0) + CAR,
|
||||
const(0.0), const(CAR))
|
||||
check("T13 unit: the house steps to 15 500 W at E+300 for 60 s (landing "
|
||||
"without the car 14 667 W): not explained from E+300 to the quarter's "
|
||||
"end, though the house is back at 13 000 W from E+360",
|
||||
all(run_of(e13, 0, 299)) and not any(run_of(e13, 300, 899))
|
||||
and len(run_of(e13, 300, 899)) == 600)
|
||||
check("T13 unit: ...and released by the new quarter", all(run_of(e13, 900, 999)))
|
||||
c13g, e13g = urun(range(0, 400),
|
||||
lambda t: (15500.0 if 100 <= t < 160 else 13000.0) + CAR,
|
||||
const(0.0), const(CAR),
|
||||
guard=lambda t: _G(wants=not (t == 250)))
|
||||
check("T13 unit: ...or by the guard no longer wanting power (EV-10)",
|
||||
not any(run_of(e13g, 100, 249)) and all(run_of(e13g, 251, 399)))
|
||||
|
||||
# --- T14: no flicker --------------------------------------------------------- #
|
||||
def floor_edges(ex):
|
||||
"""Per quarter, False -> True edges of the floor alarm the stub implies
|
||||
(floor-limited, within_aim False, not explained)."""
|
||||
out, was = {}, False
|
||||
for t in sorted(ex):
|
||||
al = not ex[t]
|
||||
if al and not was:
|
||||
out[t // 900] = out.get(t // 900, 0) + 1
|
||||
was = al
|
||||
return out
|
||||
|
||||
|
||||
_ca, eta = urun(range(0, 1200),
|
||||
lambda t: 13610.0 + (40.0 if int(t // 7) % 2 else -40.0) + CAR,
|
||||
const(0.0), const(CAR))
|
||||
_cb, etb = urun(range(0, 1200),
|
||||
lambda t: 14000.0 + CAR - (400.0 if int(t // 7) % 2 else 800.0),
|
||||
lambda t: 400.0 if int(t // 7) % 2 else 800.0, const(CAR))
|
||||
fa, fb = floor_edges(eta), floor_edges(etb)
|
||||
print(f" T14 alarm edges per quarter: (a) {fa} (b) {fb}")
|
||||
check("T14(a): the house alone straddles aim + 10 W by 40 W every 7 s: at "
|
||||
"most one alarm edge per quarter", all(v <= 1 for v in fa.values()))
|
||||
check("T14(b): T2 shape with b alternating 400 / 800 W every 7 s: no alarm "
|
||||
"edge at all (base: one per quarter)", fb == {})
|
||||
|
||||
# --- T15 unit: x10 ------------------------------------------------------------ #
|
||||
ex10 = t1(x=10)
|
||||
check("T15 unit x10 (wall and mono 10 s a cycle): T1 the same; released "
|
||||
"within 1 cycle (E+30, the first trusted cycle)",
|
||||
not any(run_of(ex10, 0, 20)) and all(run_of(ex10, 30, 120))
|
||||
and all(run_of(ex10, -30, -10)))
|
||||
ex10m = t1(x=10, mono_x=1)
|
||||
check("T15 unit, mono x1 and wall x10: the same verdicts (the edge comes from "
|
||||
"the projection's block_start, not from mono)",
|
||||
not any(run_of(ex10m, 0, 20)) and all(run_of(ex10m, 30, 120)))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. THE REAL CONTROLLER ACROSS THE EDGE (N=2, both at the reserve)")
|
||||
# =========================================================================== #
|
||||
|
||||
|
||||
RUNS = [] # (name, alarm edges) of every run, for N5
|
||||
|
||||
|
||||
def summary(name, r, tr):
|
||||
RUNS.append((name, H.edges(tr)))
|
||||
w = H.window(tr, E - 120, E + 900)
|
||||
lim = [x for x in w if x["lim"]]
|
||||
print(f" {name}: alarms {[t - E for t in H.alarms(r)]} edges "
|
||||
f"{[t - E for t in H.edges(tr)]} red {len(H.red_secs(tr))} s "
|
||||
f"(first {[t - E for t in H.red_secs(tr)[:1]]}) errors "
|
||||
f"{len(H.errors(tr))} limited {len(lim)} explained "
|
||||
f"{sum(1 for x in lim if x['explains'])} cmd {H.commands(r, tr)}")
|
||||
return w, lim
|
||||
|
||||
|
||||
def quiet(r, tr):
|
||||
"""No floor notification, no ERROR, no red peak_guard row, E-120..E+900."""
|
||||
return H.alarms(r) == [] and H.red_secs(tr) == [] and H.errors(tr) == []
|
||||
|
||||
|
||||
def all_explained(lim, t0=E - 120):
|
||||
return bool(lim) and all(x["explains"] for x in lim if x["t"] >= t0)
|
||||
|
||||
|
||||
ZERO = const(0.0)
|
||||
|
||||
|
||||
def honest(w):
|
||||
"""An honest shape steps at the edge, so Off has no alarm before it."""
|
||||
return H.shape(w, at=E)
|
||||
|
||||
# --- T2: the rig F-A shape ---------------------------------------------------- #
|
||||
r2, tr2 = H.run(H.shape(14000.0), a=ZERO, b=const(800.0))
|
||||
w2, lim2 = summary("T2", r2, tr2)
|
||||
check("T2 PRECONDITION: limited at the reserve from the edge, the car trusted, "
|
||||
"b 800 W, grid excess 980 W < car",
|
||||
present(first(x for x in w2 if x["t"] == E and x["lim"]))
|
||||
and all(x["w"] == CAR and x["batt"] == 800.0 for x in lim2))
|
||||
check("T2: no goodwe_peak_soc_floor, no PEAK_GUARD_FLOOR_LIMITED ERROR, no "
|
||||
"red peak_guard row in E-120..E+900 (base: alarm at E+0, red to E+900)",
|
||||
quiet(r2, tr2))
|
||||
check("T2: the car explains every floor-limited cycle, E+0..E+10 among them",
|
||||
all_explained(lim2) and len([x for x in lim2 if x["t"] <= E + 10]) == 11)
|
||||
|
||||
# --- T2b: the batteries give less later --------------------------------------- #
|
||||
r2i, tr2i = H.run(H.shape(14000.0), a=ZERO,
|
||||
b=lambda t: 800.0 if t < E + 300 else 0.0)
|
||||
summary("T2b(i)", r2i, tr2i)
|
||||
a2i = H.alarms(r2i)
|
||||
check("T2b(i): b drops to 0 W at E+300 (landing without the car 13 733 W): "
|
||||
"the alarm fires within 1 cycle of E+300",
|
||||
len(a2i) == 1 and E + 300 <= nth(a2i, 0) <= E + 301)
|
||||
check("T2b(i): ...and stays to the quarter's end (a house need with a "
|
||||
"trusted car is latched)", all(x["alarm"] and x["red"] for x in
|
||||
H.window(tr2i, E + 302, E + 899)))
|
||||
r2ii, tr2ii = H.run(H.shape(14000.0), a=ZERO,
|
||||
b=lambda t: 800.0 if t < E + 300 else 400.0)
|
||||
summary("T2b(ii)", r2ii, tr2ii)
|
||||
check("T2b(ii): b drops to 400 W (landing 13 467 W): no alarm to E+900",
|
||||
quiet(r2ii, tr2ii))
|
||||
|
||||
# --- T3: batteries at 0 W, and the 11 kW car ---------------------------------- #
|
||||
r3, tr3 = H.run(H.shape(13000.0), a=ZERO, b=ZERO)
|
||||
w3, lim3 = summary("T3", r3, tr3)
|
||||
check("T3: batteries 0 W, house 13 000 W, car 1 380 W: no alarm, no red row, "
|
||||
"the car explains every limited cycle incl. E+0..E+10, one car notice",
|
||||
quiet(r3, tr3) and all_explained(lim3)
|
||||
and len(P.ids(r3, P.OVER)) == 1
|
||||
and all(x["explains"] for x in lim3 if x["t"] <= E + 10))
|
||||
|
||||
|
||||
def plug_at(t0):
|
||||
return {t0: lambda p, c: p.ch.plug_in()}
|
||||
|
||||
|
||||
r3k, tr3k = H.run(H.shape(2600.0, before=2600.0), a=ZERO, b=ZERO, car_a=16,
|
||||
phases=3, aim=6344.0, plug=False, extra=plug_at(E - 120))
|
||||
w3k, lim3k = summary("T3 11 kW", r3k, tr3k)
|
||||
check("T3 11 kW: house 2 600 W, car 11 kW, aim 6 344 W (base P 21:30): no "
|
||||
"alarm, the car explains every limited cycle",
|
||||
quiet(r3k, tr3k) and all_explained(lim3k)
|
||||
and len(P.ids(r3k, P.OVER)) == 1)
|
||||
|
||||
# --- T4 controller ------------------------------------------------------------ #
|
||||
r409, tr409 = H.run(H.shape(13609.0), a=ZERO, b=ZERO)
|
||||
summary("T4 13 609", r409, tr409)
|
||||
check("T4: the house alone at aim + 9 W: no alarm", quiet(r409, tr409))
|
||||
r411, tr411 = H.run(H.shape(13611.0), a=ZERO, b=ZERO)
|
||||
r411o, tr411o = H.run(H.shape(13611.0), a=ZERO, b=ZERO, mode="off")
|
||||
summary("T4 13 611", r411, tr411)
|
||||
summary("T4 13 611 Off", r411o, tr411o)
|
||||
check("T4: at aim + 11 W the alarm at the same cycle as Off (and as base, "
|
||||
"E+0)", H.alarms(r411) == H.alarms(r411o) == [E])
|
||||
|
||||
# --- T5: an honest alarm ------------------------------------------------------ #
|
||||
r5, tr5 = H.run(honest(14090.0), a=ZERO, b=ZERO)
|
||||
r5o, tr5o = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off")
|
||||
summary("T5", r5, tr5)
|
||||
summary("T5 Off", r5o, tr5o)
|
||||
check("T5: grid excess 1 870 W > car 1 380 W: the alarm and the ERROR at the "
|
||||
"same second as Off and as base (E+1, the step's first sample)",
|
||||
H.alarms(r5) == H.alarms(r5o) == T5_BASE
|
||||
and nth(H.errors(tr5), 0) == nth(H.errors(tr5o), 0) == E + 1)
|
||||
check("T5: the car explains no cycle", not any(x["explains"] for x in tr5))
|
||||
|
||||
|
||||
# --- T6: the car figure unknown across the edge ------------------------------- #
|
||||
def unavailable(t0, t1):
|
||||
return {t0: lambda p, c: p.ch.go_unavailable(True),
|
||||
t1: lambda p, c: p.ch.go_unavailable(False)}
|
||||
|
||||
|
||||
r6, tr6 = H.run(H.shape(13000.0), a=ZERO, b=ZERO,
|
||||
extra=unavailable(E - 20, E + 60))
|
||||
summary("T6 T3 shape", r6, tr6)
|
||||
back = first(x["t"] for x in tr6 if x["t"] >= E + 60 and x["w"] is not None)
|
||||
check("T6 T3 shape: while unknown the car explains nothing and the alarm "
|
||||
"stands from E+0, as base",
|
||||
H.alarms(r6) == [E] and not any(
|
||||
x["explains"] for x in H.window(tr6, E - 5, E + 59))
|
||||
and all(x["alarm"] for x in H.window(tr6, E, E + 59)))
|
||||
check("T6 T3 shape: released within 1 cycle of the first trusted cycle after "
|
||||
"E+60, no new alarm edge to E+900 (base: red to E+900)",
|
||||
present(back) and all(not x["alarm"] and x["explains"] for x in
|
||||
H.window(tr6, back + 1, E + 899))
|
||||
and H.edges(tr6) == [E])
|
||||
r6h, tr6h = H.run(honest(14090.0), a=ZERO, b=ZERO,
|
||||
extra=unavailable(E - 20, E + 60))
|
||||
summary("T6 T5 shape", r6h, tr6h)
|
||||
check("T6 T5 shape: the alarm at the base second and it stands throughout",
|
||||
H.alarms(r6h) == T5_BASE and all(x["alarm"] for x in
|
||||
H.window(tr6h, E + 1, E + 899)))
|
||||
|
||||
|
||||
# --- T7: a frozen car figure, the car really stops ---------------------------- #
|
||||
def frozen_stop(p, c):
|
||||
p.ch.freeze()
|
||||
p.ch.car_full()
|
||||
|
||||
|
||||
r7, tr7 = H.run(honest(14090.0), a=ZERO, b=ZERO, extra={E - 30: frozen_stop})
|
||||
summary("T7", r7, tr7)
|
||||
first7 = nth(H.alarms(r7), 0)
|
||||
untr = first(x["t"] for x in tr7 if x["t"] >= E - 30 and x["w"] is None)
|
||||
check("T7: the alarm within 114 s of the stop (max(60, 40 Wh / 1.38 kW) "
|
||||
"+ 10), no later than base",
|
||||
present(first7) and first7 <= E - 30 + 114 and first7 <= T7_BASE)
|
||||
check("T7: never explained after the figure goes untrusted",
|
||||
present(untr) and not any(x["explains"] for x in tr7 if x["t"] >= untr))
|
||||
|
||||
|
||||
# --- T8: a car at 0 W, and a 50 W car ----------------------------------------- #
|
||||
class Draw(SimCharger):
|
||||
"""A charger that draws `real_w` while charging and reports `say_w`."""
|
||||
def __init__(self, real_w, say_w, **kw):
|
||||
super().__init__(**kw)
|
||||
self.real_w, self.say_w = real_w, say_w
|
||||
|
||||
def target_w(self):
|
||||
return 0.0 if super().target_w() <= 0.0 else self.real_w
|
||||
|
||||
def _build(self):
|
||||
keep, self._frozen_w = self._frozen_w, self.say_w
|
||||
try:
|
||||
return super()._build()
|
||||
finally:
|
||||
self._frozen_w = keep
|
||||
|
||||
|
||||
def full(p, c):
|
||||
p.ch.car_full()
|
||||
|
||||
|
||||
for nm, kw in (("house 14 090 W", dict(house=honest(14090.0), b=ZERO)),
|
||||
("T2 shape", dict(house=honest(14000.0), b=const(800.0)))):
|
||||
r8, tr8 = H.run(a=ZERO, extra={1: full}, **kw)
|
||||
r8o, tr8o = H.run(a=ZERO, extra={1: full}, mode="off", **kw)
|
||||
summary(f"T8 0 W, {nm}", r8, tr8)
|
||||
summary(f"T8 0 W, {nm}, Off", r8o, tr8o)
|
||||
check(f"T8: a car plugged at 0 W, {nm}: the alarm at the same second as "
|
||||
f"Off, nothing explained", H.alarms(r8) == H.alarms(r8o)
|
||||
and H.alarms(r8) != [] and not any(x["explains"] for x in tr8))
|
||||
r8s, tr8s = H.run(honest(14090.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(50.0, 50.0, setpoint_a=6))
|
||||
r8so, tr8so = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off",
|
||||
sim=Draw(50.0, 50.0, setpoint_a=6))
|
||||
summary("T8 50 W", r8s, tr8s)
|
||||
check("T8: a 50 W car, house 14 090 W: the alarm at the same second as Off, "
|
||||
"nothing explained", H.alarms(r8s) == H.alarms(r8so) == T5_BASE
|
||||
and not any(x["explains"] for x in tr8s))
|
||||
|
||||
# --- T9: a wrong charger reply ------------------------------------------------ #
|
||||
r9a, tr9a = H.run(honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(1380.0, 11000.0, setpoint_a=6))
|
||||
summary("T9(a)", r9a, tr9a)
|
||||
check("T9(a): reports 11 kW, read-back 6 A 1-ph (cap 1 518 W): the house "
|
||||
"alone misses, the alarm at the base second",
|
||||
H.alarms(r9a) == T5_BASE and all(x["w"] is None or x["w"] <= 1518.0
|
||||
for x in tr9a))
|
||||
r9b, tr9b = H.run(honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(400.0, 1380.0, setpoint_a=6))
|
||||
summary("T9(b)", r9b, tr9b)
|
||||
check("T9(b): reports 1 380 W, draws 400 W: the same alarms as base (none: "
|
||||
"400 W corroborates a 1 380 W figure, CORR_RATIO 0.5; see the dev "
|
||||
"report's Findings)", H.alarms(r9b) == T9B_BASE)
|
||||
r9c, tr9c = H.run(honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(100.0, 1380.0, setpoint_a=6))
|
||||
summary("T9(c)", r9c, tr9c)
|
||||
a9c = nth(H.alarms(r9c), 0)
|
||||
check("T9(c): reports 1 380 W, draws 100 W: the first alarm once the figure "
|
||||
"is uncorroborated, at most 104 s + 10 s after the edge, no later than "
|
||||
"base", present(a9c) and a9c <= E + 114 and a9c <= T9C_BASE)
|
||||
check("T9(c) (owner 2026-11-19): the meter contradicted the figure, so it "
|
||||
"stays untrusted to the quarter's end: one alarm edge, red and never "
|
||||
"explained to E+899 (the meter's 10 Wh step re-corroborates it every "
|
||||
"360 s)", H.edges(tr9c) == [a9c] and all(
|
||||
x["alarm"] and x["red"] and not x["explains"]
|
||||
for x in H.window(tr9c, a9c, E + 899)))
|
||||
|
||||
# --- T10: a lost battery reading, an unavailable charger ---------------------- #
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO))):
|
||||
r10, tr10 = H.run(a=ZERO, lost={"b": {E + 1}}, **kw)
|
||||
summary(f"T10(a) {nm}", r10, tr10)
|
||||
gap = first(x for x in tr10 if x["t"] == E + 1)
|
||||
nxt = first(x for x in tr10 if x["t"] == E + 2)
|
||||
check(f"T10(a) {nm}: inverter-b's reading lost at E+1: that cycle grades "
|
||||
f"nothing (P_SAFETY owns a missing input), the next one grades on "
|
||||
f"what is measured", present(gap, nxt) and gap["batt"] is None
|
||||
and nxt["batt"] == (800.0 if nm == "T2" else 0.0))
|
||||
if nm == "T2":
|
||||
check("T10(a) T2: no alarm edge (base: E+0)", quiet(r10, tr10))
|
||||
else:
|
||||
check("T10(a) T5: the same alarm seconds as base",
|
||||
H.alarms(r10) == T10A_T5_BASE)
|
||||
r10b, tr10b = H.run(a=ZERO, extra=unavailable(E + 1, E + 2), **kw)
|
||||
summary(f"T10(b) {nm}", r10b, tr10b)
|
||||
if nm == "T2":
|
||||
check("T10(b) T2: the charger unavailable for one cycle (E+1): the "
|
||||
"alarm stands for that cycle only (Expected 5)",
|
||||
H.edges(tr10b) == [E + 1]
|
||||
and all(not x["alarm"] for x in H.window(tr10b, E + 2, E + 899))
|
||||
and all(x["explains"] for x in H.window(tr10b, E + 2, E + 899)
|
||||
if x["lim"]))
|
||||
else:
|
||||
check("T10(b) T5: the alarm at the base second and it stands",
|
||||
H.alarms(r10b) == T5_BASE and all(
|
||||
x["alarm"] for x in H.window(tr10b, E + 1, E + 899)))
|
||||
|
||||
# --- R1 (review round 2): the energy reading unknown for one cycle ----------- #
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T3", dict(house=H.shape(13000.0), b=ZERO))):
|
||||
rg, trg = H.run(a=ZERO, extra=H.energy_gap(E + 200), **kw)
|
||||
summary(f"R1 {nm} energy gap at E+200", rg, trg)
|
||||
check(f"R1 {nm}: the charger's energy entity unknown for one cycle "
|
||||
f"(E+200) on a correct car: unknown, not contradicted, so red for "
|
||||
f"that cycle only and explained from the next (Expected 5)",
|
||||
H.red_secs(trg) == [E + 200] and H.edges(trg) == [E + 200]
|
||||
and all(x["explains"] for x in H.window(trg, E + 201, E + 899)
|
||||
if x["lim"]))
|
||||
|
||||
# --- T11: one battery first (SAFETY-87) --------------------------------------- #
|
||||
for nm, house in (("(i) 17 500 W", 17500.0), ("(ii) 19 000 W", 19000.0)):
|
||||
r11, tr11 = H.run(honest(house), soc={"a": 19.0, "b": 35.0})
|
||||
summary(f"T11{nm}", r11, tr11)
|
||||
if house < 18000.0:
|
||||
check("T11(i): b able, house 17 500 W, car 1 380 W: no alarm across E",
|
||||
H.alarms(r11) == [] and P.ids(r11, *P.ALARMS) == [])
|
||||
else:
|
||||
check("T11(ii): house 19 000 W: the alarm at the base second",
|
||||
[t for t, _n in P.ids(r11, *P.ALARMS)] == T11_BASE)
|
||||
|
||||
# --- T12 (record only): plug-in at E+0, the reserve at E+180 ------------------ #
|
||||
def reserve_at(p, c):
|
||||
p.socs.update({"a": 19.0, "b": 19.0})
|
||||
|
||||
|
||||
r12, tr12 = H.run(H.shape(13000.0), soc={"a": 40.0, "b": 40.0}, plug=False,
|
||||
extra={E: lambda p, c: p.ch.plug_in(), E + 180: reserve_at})
|
||||
summary("T12 (record, F-B)", r12, tr12)
|
||||
|
||||
# --- T13 controller: the latch is kept ---------------------------------------- #
|
||||
r13, tr13 = H.run(H.shape(lambda t: 15500.0 if E + 300 <= t < E + 360
|
||||
else 13000.0), a=ZERO, b=ZERO)
|
||||
summary("T13", r13, tr13)
|
||||
check("T13: the house steps to 15 500 W at E+300 for 60 s: the alarm at "
|
||||
"the base second (E+301, the step's first sample), and red to the "
|
||||
"quarter's end", H.alarms(r13) == T13_BASE and all(
|
||||
x["alarm"] and x["red"] for x in H.window(tr13, E + 301, E + 899)))
|
||||
|
||||
# --- T16: the edge paths ------------------------------------------------------ #
|
||||
for nm, kw in (("(a)(b)(c) SAFETY-91 roll, modes on", {}),
|
||||
("(d) the guard not wanting at the edge",
|
||||
dict(lost={"b": {E}}))):
|
||||
r16, tr16 = H.run(H.shape(13000.0), a=ZERO, b=ZERO, **kw)
|
||||
w16, lim16 = summary(f"T16{nm}", r16, tr16)
|
||||
f16 = first(x for x in tr16 if x["t"] >= E and x["lim"])
|
||||
pre = first(x for x in tr16 if x["t"] == E - 1)
|
||||
check(f"T16{nm}: the car explains from the first limited cycle of the "
|
||||
f"new block, no alarm, no red row, `_carq` key = block_start",
|
||||
present(f16) and quiet(r16, tr16) and all(
|
||||
x["explains"] and x["key"] == x["block"]
|
||||
for x in tr16 if x["t"] >= f16["t"] and x["lim"]))
|
||||
if not kw:
|
||||
print(f" T16(c): within_aim at E-1 {pre['within_aim'] if present(pre) else pre}"
|
||||
" (SAFETY-126's latch carried; not asserted)")
|
||||
else:
|
||||
g0 = first(x for x in tr16 if x["t"] == E)
|
||||
check("T16(d) PRECONDITION: the guard did not want power at E+0",
|
||||
present(g0) and not g0["wants"])
|
||||
|
||||
|
||||
# --- T17: a restart ----------------------------------------------------------- #
|
||||
def restart_at(t0):
|
||||
return {t0: lambda p, c: H.restart(c)}
|
||||
|
||||
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T3", dict(house=H.shape(13000.0), b=ZERO)),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO))):
|
||||
rr0, tr0 = H.run(a=ZERO, **kw)
|
||||
for at in (E + 2, E + 300):
|
||||
rr, trr = H.run(a=ZERO, extra=restart_at(at), **kw)
|
||||
summary(f"T17 {nm} restart at E+{at - E}", rr, trr)
|
||||
if nm == "T5":
|
||||
check(f"T17 T5, restart at E+{at - E}: the alarm at the base "
|
||||
f"second and again on the first cycle after the restart, "
|
||||
f"as base; red throughout",
|
||||
H.alarms(rr) == T5_BASE + [at] and len(H.red_secs(trr))
|
||||
== len(H.red_secs(tr0)))
|
||||
elif nm == "T2" and at == E + 300:
|
||||
# review round 1: the car's energy before a restart is not known,
|
||||
# so it counts as house (never credited to the car). Here that
|
||||
# tips the house alone over the aim: the alarm stands from the
|
||||
# restart, the conservative side (base: red from E+0).
|
||||
check("T17 T2, restart at E+300: quiet before the restart; after "
|
||||
"it the car's unknown earlier share counts as house, so at "
|
||||
"most one alarm edge, at the restart",
|
||||
quiet(rr0, tr0) and H.red_secs(trr, t1=at - 1) == []
|
||||
and H.edges(trr) in ([], [at]))
|
||||
else:
|
||||
check(f"T17 {nm}, restart at E+{at - E}: the same as without "
|
||||
f"(no floor notice, no ERROR, no red row)",
|
||||
quiet(rr, trr) and quiet(rr0, tr0))
|
||||
print(f" T17 {nm} car-over notices: twin "
|
||||
f"{[t - E for t, _n in P.ids(rr0, P.OVER)]}, restarted "
|
||||
f"{[t - E for t, _n in P.ids(rr, P.OVER)]} (EV-11's "
|
||||
f"once-per-session state does not survive a restart, as on "
|
||||
f"base)")
|
||||
|
||||
# --- T17b (review round 1): a house need only the done part shows ----------- #
|
||||
def heavy_then_light(t):
|
||||
"""House 18 000 W for E..E+300, then 12 000 W: alone it lands 14 000 W."""
|
||||
if t < E:
|
||||
return H.PRE_W if t < E - 120 else 12000.0
|
||||
return 18000.0 if t < E + 300 else 12000.0
|
||||
|
||||
|
||||
r17b0, tr17b0 = H.run(heavy_then_light, a=ZERO, b=ZERO)
|
||||
r17b, tr17b = H.run(heavy_then_light, a=ZERO, b=ZERO,
|
||||
extra=restart_at(E + 310))
|
||||
summary("T17b no restart", r17b0, tr17b0)
|
||||
summary("T17b restart at E+310", r17b, tr17b)
|
||||
check("T17b: the house heavy before a restart at E+310 (alone it lands "
|
||||
"14 000 W, excess 1 780 W > car): red to the quarter's end and never "
|
||||
"explained, as without the restart (and as base and Off)",
|
||||
len(H.red_secs(tr17b, E, E + 899)) == len(H.red_secs(tr17b0, E, E + 899))
|
||||
== 899 and not any(x["explains"] for x in H.window(tr17b, E, E + 899)))
|
||||
|
||||
# --- T15 controller: x10 ------------------------------------------------------ #
|
||||
# F2 (out of scope, filed apart): `_car_quarter` caps a cycle's dt at 5 s, so at
|
||||
# 10 s a cycle half the car's energy is counted, and late in the quarter the
|
||||
# house alone seems to miss the aim (T2 from about E+540, T3 E+820, as on base
|
||||
# for T3). The x10 verdicts are graded to E+500; what comes after is printed.
|
||||
F2_FROM = E + 500
|
||||
for nm, kw, want in (
|
||||
("T2", dict(house=H.shape(14000.0), b=const(800.0)), "quiet"),
|
||||
("T3", dict(house=H.shape(13000.0), b=ZERO), "quiet"),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO), "alarm"),
|
||||
("T6", dict(house=H.shape(13000.0), b=ZERO,
|
||||
extra=unavailable(E - 20, E + 60)), "release")):
|
||||
rx, trx = H.run(a=ZERO, x=10, **kw)
|
||||
summary(f"T15 x10 {nm}", rx, trx)
|
||||
early = [x for x in trx if x["t"] < F2_FROM]
|
||||
print(f" T15 x10 {nm}: alarms after E+500 (F2) "
|
||||
f"{[t - E for t in H.alarms(rx) if t >= F2_FROM]}")
|
||||
if want == "quiet":
|
||||
check(f"T15 x10 {nm}: no alarm, no red row, every limited cycle "
|
||||
f"explained, E-120..E+500",
|
||||
not [t for t in H.alarms(rx) if t < F2_FROM]
|
||||
and H.red_secs(trx, t1=F2_FROM - 1) == []
|
||||
and all_explained([x for x in early if x["lim"]]))
|
||||
elif want == "alarm":
|
||||
check("T15 x10 T5: the alarm at the base second (E+10, one cycle)",
|
||||
H.alarms(rx) == T15_T5_BASE)
|
||||
else:
|
||||
bk = first(x["t"] for x in trx if x["t"] >= E + 60
|
||||
and x["w"] is not None)
|
||||
check("T15 x10 T6: the alarm while unknown, released within 1 cycle "
|
||||
"(10 fake s) of the first trusted one, no new edge to E+500",
|
||||
present(bk) and bk <= E + 70
|
||||
and all(not x["alarm"] for x in H.window(trx, bk, F2_FROM - 1))
|
||||
and [t for t in H.edges(trx) if t < F2_FROM] == [E])
|
||||
|
||||
# --- N4: the alarm decision changes no command -------------------------------- #
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO))):
|
||||
ra, tra = H.run(a=ZERO, **kw)
|
||||
rb, trb = H.run(a=ZERO, explain_off=True, **kw)
|
||||
check(f"N4 {nm}: the claim, the floor, the battery setpoints and the "
|
||||
f"charger writes are identical whether the car explains or not",
|
||||
H.commands(ra, tra) == H.commands(rb, trb))
|
||||
|
||||
# N4 with "Batteries help with the peak" off (review round 2): the guard's
|
||||
# input is `car_exclude`, which reads the car's energy count. The
|
||||
# contradiction latch must not touch it: the same commands with the latch off.
|
||||
for nm, kw in (
|
||||
("SoC 60 %, energy gap at E+200",
|
||||
dict(house=H.shape(13000.0), soc={"a": 60.0, "b": 60.0},
|
||||
extra=H.energy_gap(E + 200))),
|
||||
("at the reserve, energy gap at E+200",
|
||||
dict(house=H.shape(13000.0), a=ZERO, b=ZERO,
|
||||
extra=H.energy_gap(E + 200))),
|
||||
("SoC 60 %, the T9(c) liar",
|
||||
dict(house=honest(13900.0), soc={"a": 60.0, "b": 60.0},
|
||||
sim=Draw(100.0, 1380.0, setpoint_a=6))),
|
||||
("at the reserve, the T9(c) liar",
|
||||
dict(house=honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(100.0, 1380.0, setpoint_a=6)))):
|
||||
ra, tra = H.run(cover=False, **kw)
|
||||
if "sim" in kw:
|
||||
kw = dict(kw, sim=Draw(100.0, 1380.0, setpoint_a=6))
|
||||
rb, trb = H.run(cover=False, latch_off=True, **kw)
|
||||
summary(f"N4 cover off, {nm}", ra, tra)
|
||||
check(f"N4 cover off, {nm}: the claim, the floor, the setpoints and the "
|
||||
f"charger writes are those of the same run without the "
|
||||
f"contradiction latch", H.commands(ra, tra) == H.commands(rb, trb))
|
||||
|
||||
# --- N5: at most one floor-alarm edge per quarter ---------------------------- #
|
||||
def per_quarter(ts):
|
||||
out = {}
|
||||
for t in ts:
|
||||
out[(t - E) // 900] = out.get((t - E) // 900, 0) + 1
|
||||
return out
|
||||
|
||||
|
||||
# Cover off, the T9(c) liar at the reserve: the guard's own engagement flips
|
||||
# as the liar's figure is corroborated now and then (its input is
|
||||
# `car_exclude`), pre-existing (base: 4 edges). Printed, not graded here.
|
||||
LIAR_OFF = "N4 cover off, at the reserve, the T9(c) liar"
|
||||
print(f" {LIAR_OFF}: alarm edges "
|
||||
f"{[[t - E for t in ts] for nm, ts in RUNS if nm == LIAR_OFF]}")
|
||||
many = [(nm, ts) for nm, ts in RUNS
|
||||
if nm != LIAR_OFF and any(v > 1 for v in per_quarter(
|
||||
[t for t in ts if not nm.startswith("T15 x10") or t < F2_FROM])
|
||||
.values())]
|
||||
check(f"N5: at most one floor-alarm edge per quarter in every run "
|
||||
f"({len(RUNS)} runs; x10 to E+500; the cover-off liar apart): "
|
||||
f"{many}", many == [])
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -0,0 +1,654 @@
|
||||
"""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)
|
||||
@@ -0,0 +1,223 @@
|
||||
"""EV-18: the real Controller across one quarter edge `E`, N=2, both units at
|
||||
the peak reserve and the car charging (`ev04_peak.drive`). Used by test_ev18.py.
|
||||
|
||||
The run starts `E` s before an edge (rig.BASE is moved back for the run), with
|
||||
a light house so the first quarter does not raise the month's peak (the aim
|
||||
stays `AIM`). At `E - 120` the house steps to the shape, so the guard first
|
||||
wants power at the edge, as on the rig (EV-15 F-A). `force` makes a unit give
|
||||
what the loop gives below the reserve whatever it is told; `lost` drops its
|
||||
reading for some seconds (the grid still sees it). The trace is one dict per
|
||||
cycle, taken after it.
|
||||
"""
|
||||
|
||||
import hashlib
|
||||
import logging
|
||||
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 opt11_identity as rig # noqa: E402
|
||||
import safety81_sim as s81 # noqa: E402
|
||||
from app import peakguard # noqa: E402
|
||||
|
||||
E = 150 # the edge, in run seconds
|
||||
AIM = 13600.0
|
||||
MARGIN = 50.0
|
||||
PRE_W = 5000.0 # the first quarter's house: under the cap
|
||||
FLOOR = "goodwe_peak_soc_floor"
|
||||
OPTS = {"peak_soc_floor": 20, "inverters": [
|
||||
{"name": "inverter-a", "setpoint_entity": "number.sp_a",
|
||||
"soc_entity": "sensor.soc_a", "batt_entity": "sensor.batt_a",
|
||||
"max_w": 5000, "bms_soc_floor": 10},
|
||||
{"name": "inverter-b", "setpoint_entity": "number.sp_b",
|
||||
"soc_entity": "sensor.soc_b", "batt_entity": "sensor.batt_b",
|
||||
"max_w": 4600, "bms_soc_floor": 10}]}
|
||||
|
||||
|
||||
class _Errors(logging.Handler):
|
||||
def __init__(self):
|
||||
super().__init__(logging.ERROR)
|
||||
self.rec = []
|
||||
|
||||
def emit(self, r):
|
||||
self.rec.append(r.getMessage())
|
||||
|
||||
|
||||
ERR = _Errors()
|
||||
_lg = logging.getLogger("goodwe")
|
||||
_lg.addHandler(ERR)
|
||||
_lg.setLevel(logging.ERROR)
|
||||
_lg.propagate = False
|
||||
|
||||
|
||||
class Plant(P.CarPlantN):
|
||||
force = {}
|
||||
lost = {}
|
||||
|
||||
def batt_of(self, u, at):
|
||||
f = self.force.get(u)
|
||||
if f is not None:
|
||||
return float(f(at))
|
||||
return super().batt_of(u, 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
|
||||
return await super().number(e, invert)
|
||||
|
||||
|
||||
def shape(after, before=PRE_W, at=None):
|
||||
"""The house: `before` until `at` (E - 120), then `after` (W or fn(t))."""
|
||||
at = E - 120 if at is None else at
|
||||
return lambda t: before if t < at else (after(t) if callable(after)
|
||||
else after)
|
||||
|
||||
|
||||
def run(house, *, a=None, b=None, lost=None, car_a=6, phases=1, aim=AIM,
|
||||
mode="manual", dur=None, extra=None, sim=None, soc=None, plug=True,
|
||||
x=1, mono_x=None, explain_off=False, latch_off=False,
|
||||
cover=True):
|
||||
"""One run; returns (run, trace). `x`: fake seconds per cycle (wall and
|
||||
monotonic both; `mono_x` sets the monotonic rate apart). `explain_off`:
|
||||
the car never explains, `latch_off`: no contradiction latch (both for the
|
||||
control-identity check). `cover`: the option `ev_batt_cover`."""
|
||||
force = {}
|
||||
if a is not None:
|
||||
force["a"] = a
|
||||
if b is not None:
|
||||
force["b"] = b
|
||||
cls = type("Plant", (Plant,), {"force": force, "lost": lost or {}})
|
||||
tr = []
|
||||
n_err = [len(ERR.rec)]
|
||||
dur = E + 900 if dur is None else dur
|
||||
|
||||
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 not cover:
|
||||
c.o["ev_batt_cover"] = 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 = []
|
||||
if plant.t >= E - 130:
|
||||
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 ERR.rec[n_err[0]:]
|
||||
if "may not draw the battery lower" in m]
|
||||
n_err[0] = len(ERR.rec)
|
||||
cl = peakguard.claim(g) if g is not None else None
|
||||
tr.append({
|
||||
"t": plant.t, "explains": c.car_explains,
|
||||
"lim": bool(g is not None and (g.floor_limited
|
||||
or g.saturated)),
|
||||
"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),
|
||||
"alarm": c._peak_floor_limited, "red": red, "err": errs,
|
||||
"w": c.car_alarm_w(), "batt": c.site_batt_w,
|
||||
"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
|
||||
|
||||
ev = {0: hook}
|
||||
for t, fn in (extra or {}).items():
|
||||
if t == 0:
|
||||
ev[0] = (lambda p, c, fn=fn: (hook(p, c), fn(p, c)))
|
||||
else:
|
||||
ev[t] = fn
|
||||
socs = soc or {"a": 19.0, "b": 19.0}
|
||||
s = sim
|
||||
if s is None:
|
||||
from chargersim import SimCharger
|
||||
s = SimCharger(setpoint_a=car_a)
|
||||
if x != 1:
|
||||
tick = s.tick
|
||||
s.tick = lambda secs=1.0: tick(secs * x)
|
||||
base, step = rig.BASE, s81.TICK
|
||||
rig.BASE, s81.TICK = base - timedelta(seconds=E), float(x)
|
||||
try:
|
||||
r = P.drive(house, dur=dur, rating=5000.0, soc=socs,
|
||||
cap=aim + MARGIN, phases=phases, n=2, plant_cls=cls,
|
||||
opts=OPTS, dev_w=5000.0, setpoint=car_a, user_a=car_a,
|
||||
mode=mode, events=ev, sim=s, plug=plug)
|
||||
finally:
|
||||
rig.BASE, s81.TICK = base, step
|
||||
return r, tr
|
||||
|
||||
|
||||
def alarms(r):
|
||||
"""Seconds of each goodwe_peak_soc_floor notification."""
|
||||
return [t for t, n in r["raised"] if n == FLOOR]
|
||||
|
||||
|
||||
def window(tr, t0, t1):
|
||||
return [x for x in tr if t0 <= x["t"] <= t1]
|
||||
|
||||
|
||||
def edges(tr):
|
||||
"""Seconds at which the floor alarm goes False -> True."""
|
||||
out, was = [], False
|
||||
for x in tr:
|
||||
if x["alarm"] and not was:
|
||||
out.append(x["t"])
|
||||
was = x["alarm"]
|
||||
return out
|
||||
|
||||
|
||||
def red_secs(tr, t0=None, t1=None):
|
||||
t0 = E - 120 if t0 is None else t0
|
||||
t1 = E + 900 if t1 is None else t1
|
||||
return [x["t"] for x in window(tr, t0, t1) if x["red"]]
|
||||
|
||||
|
||||
def errors(tr):
|
||||
return [x["t"] for x in tr if x["err"]]
|
||||
|
||||
|
||||
def commands(r, tr):
|
||||
"""A digest of every command: the units' setpoints, the charger's writes,
|
||||
and the guard's floor and claim per cycle (N4)."""
|
||||
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 energy_gap(at, secs=1):
|
||||
"""The charger's energy entity is missing (unknown) for `secs` from `at`."""
|
||||
def on(p, c):
|
||||
p.ch.no_energy = True
|
||||
|
||||
def off(p, c):
|
||||
p.ch.no_energy = False
|
||||
return {at: on, at + secs: off}
|
||||
|
||||
|
||||
def restart(c):
|
||||
"""A restart as the car side sees it: a fresh `car_init` and an empty
|
||||
corroboration history, and no floor alarm standing."""
|
||||
mode, n, a = c.car_mode, c.car_n, c.car_a
|
||||
c.car_init(c.o, c.store)
|
||||
c.car_mode, c.car_n, c.car_a = mode, n, a
|
||||
c.car._hist.clear()
|
||||
c._peak_floor_limited = False
|
||||
@@ -0,0 +1,779 @@
|
||||
"""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, "R": R,
|
||||
"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 _burst(k, w):
|
||||
"""Inverter-b: 2 125 W until R+1, then `w` for 0.5 s before the cycle at
|
||||
R+k (P1, sampled 0.3 s before it, and the reading both show it), else
|
||||
0 W."""
|
||||
def f(at, plant):
|
||||
if at < plant.R + 1:
|
||||
return 4250.0 / 2.0
|
||||
return w if plant.R + k - 0.5 <= at <= plant.R + k else 0.0
|
||||
return f
|
||||
|
||||
|
||||
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)
|
||||
# Review round 1: an honest house step answered by ONE cycle of inverter-b
|
||||
# power that P1 and the reading both show (the meter in step), after the
|
||||
# T6 shape (4 250 W until R, then 0 W).
|
||||
for k in (5, 30):
|
||||
for hi in (1900, 2500):
|
||||
for burst in (3000.0, 4600.0):
|
||||
for md in ("manual", "off"):
|
||||
j[f"RB step R+{k} aim+{hi} burst {burst:.0f} {md}"] = dict(
|
||||
bw=4250.0, traj="t1", mode=md,
|
||||
house_fn=_step_house(k - 0.5, hi=AIM + hi),
|
||||
force={"b": _burst(k, burst)})
|
||||
# T10 (mE): restarts at R-1 and R, so the rise cycle has no reading from
|
||||
# two cycles back
|
||||
for nm, sh in (("T2", t2_shape), ("T5", t5_shape)):
|
||||
for k in (-1, 0):
|
||||
j[f"T10 {nm} restart R{k:+d}"] = sh(rel=restart(k))
|
||||
# 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)
|
||||
Reference in New Issue
Block a user