Compare commits
1
Commits
release/1.0
...
EV-18
| Author | SHA1 | Date | |
|---|---|---|---|
|
|
12c97b56f4 |
@@ -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`
|
||||
@@ -137,6 +137,18 @@ up to 1.8 kW; the 40 Wh floor fixes that.)
|
||||
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. After
|
||||
a restart or a gap the car's share of what is done is unknown (`_carq`
|
||||
`whole`), so only the rest of the period is graded without the car.
|
||||
- **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.
|
||||
|
||||
@@ -60,6 +60,7 @@ class CarMixin:
|
||||
self._car_over_gone = None
|
||||
self._car_batt_prev = None
|
||||
self._car_need_real = self._car_need_excl = False # EV-10 latches
|
||||
self._car_need_house = self._car_over_now = False # EV-18 latches
|
||||
self._car_latch_block = None
|
||||
self._car_over_notified = None # the session a notice was raised for
|
||||
self._car_session = 0
|
||||
@@ -235,6 +236,16 @@ class CarMixin:
|
||||
<= OWN_PAUSE_MAX_S
|
||||
return 0.0 <= mono - wr.phase_done_at <= OWN_PAUSE_TAIL_S
|
||||
|
||||
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. `wg` (EV-15) is the figure for
|
||||
@@ -244,8 +255,16 @@ class CarMixin:
|
||||
key = None if proj is None else proj.block_start
|
||||
last = q["mono"]
|
||||
if key != q["key"]:
|
||||
# EV-18: `whole` when the count covers the block: it follows on
|
||||
# from the block before, or starts in its first seconds (not
|
||||
# after a restart or a gap).
|
||||
whole = key is not None and (
|
||||
float(proj.elapsed_s) <= 5.0 or (
|
||||
last is not None and q["key"] is not None
|
||||
and (key - q["key"]).total_seconds() == QUARTER_S))
|
||||
self._car_bank(q)
|
||||
q["key"], q["ws"], q["ws_p"] = key, 0.0, 0.0
|
||||
q["whole"] = whole
|
||||
if key is not None and last is not None:
|
||||
dt = min(max(mono - last, 0.0), 5.0)
|
||||
if w is not None:
|
||||
@@ -322,7 +341,8 @@ class CarMixin:
|
||||
# car at 0 A and the energy meter cannot corroborate it then, so for
|
||||
# that bounded time its fresh, not stuck figure stands in.
|
||||
wg = w
|
||||
if w is None and self._car_own_pause(mono):
|
||||
own = (w is None or float(w) <= 0.0) and self._car_own_pause(mono)
|
||||
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)
|
||||
@@ -330,7 +350,14 @@ class CarMixin:
|
||||
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, wg)
|
||||
# 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,
|
||||
0.0 if idle else wg)
|
||||
if 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:
|
||||
@@ -360,35 +387,41 @@ 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
|
||||
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 \
|
||||
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:
|
||||
whole = self._carq.get("whole", True)
|
||||
self._car_need_excl = self._car_need_excl or \
|
||||
peakguard.misses_aim(excl, batt_w=batt, target_w=target_w)
|
||||
self._car_need_house = self._car_need_house or \
|
||||
self._car_lands_over(excl, now, batt, target_w, whole)
|
||||
if w is None or batt is None or not wants \
|
||||
or not (guard.saturated or guard.floor_limited):
|
||||
return False
|
||||
@@ -398,7 +431,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(
|
||||
@@ -406,6 +440,20 @@ class CarMixin:
|
||||
achievable_w=rating)
|
||||
return bool(high(real_proj) and not high(excl))
|
||||
|
||||
@staticmethod
|
||||
def _car_lands_over(p, now, gives, target_w, whole=True) -> 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)? Not `whole`: the car's share of what is done
|
||||
is not known (a restart, a gap), so only the rest is graded."""
|
||||
if whole:
|
||||
return peakguard.load_too_high(p, batt_w=now, ceiling_w=target_w,
|
||||
achievable_w=gives)
|
||||
if QUARTER_S - float(p.elapsed_s) <= 0.0:
|
||||
return False
|
||||
rest = float(p.held_w) + float(now) - float(gives)
|
||||
return rest - float(target_w) > peakguard.ALARM_MISS_W
|
||||
|
||||
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,681 @@
|
||||
"""EV-18: no floor alarm at a quarter's start while the car explains the excess
|
||||
(EV-15 rig F-A). `python3 -B test_ev18.py`
|
||||
|
||||
The rig: both batteries at the peak reserve, the car charging, and
|
||||
PEAK_GUARD_FLOOR_LIMITED + `goodwe_peak_soc_floor` at a quarter's start, red
|
||||
for most of the quarter, while the grid excess was smaller than the car. Two
|
||||
causes, both latched for the quarter by `_car_need_excl`:
|
||||
C1 one cycle with no trusted car figure set the latch (T1);
|
||||
C2 "without the car" assumed the batteries give 0 W from now on, so what
|
||||
the loop still gives below the reserve counted as house (T2).
|
||||
The rule now (owner 2026-11-19, Q1-Q3): without the car the batteries keep
|
||||
giving what they give now (the lower of the last two readings, re-checked
|
||||
every cycle); a house need seen with a trusted car figure stays latched to the
|
||||
quarter's end; an unknown car figure keeps the alarm only while it is unknown.
|
||||
|
||||
T-ids are the test plan's (reports/EV-18-test-plan.md). "base" is 9fdce02.
|
||||
Mutating a module this file grades? Read MUTATION.md first (purge __pycache__).
|
||||
"""
|
||||
|
||||
import os
|
||||
import sys
|
||||
from datetime import datetime, timedelta, timezone
|
||||
|
||||
HERE = os.path.dirname(os.path.abspath(__file__))
|
||||
sys.path.insert(0, os.path.join(HERE, "tools"))
|
||||
|
||||
from app import chargers as CH, ctl_car, tariff # noqa: E402
|
||||
from chargersim import SimCharger # noqa: E402
|
||||
from named_absence import first, nth, present # noqa: E402
|
||||
import ev04_peak as P # noqa: E402
|
||||
import ev18_peak as H # noqa: E402
|
||||
|
||||
fails = []
|
||||
|
||||
|
||||
def check(name, cond):
|
||||
print(f" {'ok ' if cond else 'FAIL'} {name}")
|
||||
if not cond:
|
||||
fails.append(name)
|
||||
|
||||
|
||||
AIM = H.AIM
|
||||
CAR = 1380.0
|
||||
E = H.E
|
||||
# Measured on base 9fdce02 with this file's own runs: the seconds of
|
||||
# goodwe_peak_soc_floor in the honest shapes, which must not come later now. An
|
||||
# honest shape steps the house at E, and the meter shows it at E+1.
|
||||
T5_BASE = [E + 1] # also T6 (T5 shape), T8, T9(a), T10(b) T5
|
||||
T7_BASE = E + 72
|
||||
T9B_BASE = [] # 400 W real: never uncorroborated (Findings)
|
||||
T9C_BASE = E + 1 # 100 W real: never trusted at the edge
|
||||
T10A_T5_BASE = [E + 2] # the guard disengages at E+1 (no battery reading)
|
||||
T11_BASE = [E + 13] # SAFETY-87: ALARM_HOLD_S after the step
|
||||
T13_BASE = [E + 301]
|
||||
T15_T5_BASE = [E + 10] # x10: one cycle
|
||||
|
||||
# =========================================================================== #
|
||||
print("1. UNIT: car_cycle ACROSS A QUARTER EDGE (a real `_carq`, not preset)")
|
||||
# =========================================================================== #
|
||||
BS = datetime(2026, 11, 17, 21, 15, tzinfo=timezone.utc) # the edge E
|
||||
|
||||
|
||||
class _Car(ctl_car.CarMixin):
|
||||
def __init__(self):
|
||||
self.o = {"ev_batt_cover": True}
|
||||
self.w = CAR
|
||||
self._now = 0.0
|
||||
self.site_batt_w, self.site_rating_w = 0.0, 9600.0
|
||||
self.store = type("S", (), {"data": {}, "set": lambda s, k, v: 0})()
|
||||
self.car_init({}, self.store)
|
||||
|
||||
def car_now(self):
|
||||
return self._now
|
||||
|
||||
def car_alarm_w(self):
|
||||
return self.w
|
||||
|
||||
class car: # noqa: N801
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
class _G:
|
||||
"""Floor-limited, the floor leaves nothing (floor_w 0), wants power."""
|
||||
def __init__(self, wants=True, within_aim=False):
|
||||
self.floor_limited, self.saturated = True, False
|
||||
self.floor_w, self.able_w, self.ceiling_w = 0.0, None, AIM + 50.0
|
||||
self.engaged, self.blind = True, None
|
||||
self.wanted_w = 300.0 if wants else 0.0
|
||||
self.within_aim = within_aim
|
||||
|
||||
|
||||
def urun(secs, grid, batt, w, *, x=1, mono_x=None, c=None, guard=None):
|
||||
"""`car_cycle` once per entry of `secs` (seconds from the edge E, `x` fake
|
||||
seconds apart). `grid(t)` is the meter (house + car - batteries),
|
||||
`batt(t)` the site battery reading, `w(t)` the trusted car figure. Returns
|
||||
(car, {t: car_explains})."""
|
||||
c = c or _Car()
|
||||
mono_x = x if mono_x is None else mono_x
|
||||
done, out = {}, {}
|
||||
for t in secs:
|
||||
q = t // 900
|
||||
bs, el = BS + timedelta(seconds=900 * q), t - 900 * q
|
||||
g = float(grid(t))
|
||||
d = done.get(bs, g * el)
|
||||
p = tariff.Projection(
|
||||
projected_w=(d + g * (900 - el)) / 900.0,
|
||||
elapsed_w=(d / el if el else g), elapsed_s=float(el),
|
||||
covered_frac=1.0, complete=False, block_start=bs, held_w=g)
|
||||
done[bs] = d + g * x
|
||||
c._now = 10000.0 + t * mono_x / x
|
||||
c.w, c.site_batt_w = w(t), batt(t)
|
||||
c.car_cycle(p, guard(t) if guard else _G(), AIM, None)
|
||||
out[t] = c.car_explains
|
||||
return c, out
|
||||
|
||||
|
||||
def const(v):
|
||||
return lambda t: v
|
||||
|
||||
|
||||
def run_of(d, t0, t1):
|
||||
return [d[t] for t in sorted(d) if t0 <= t <= t1]
|
||||
|
||||
|
||||
# --- T1: the car figure untrusted for the edge's first cycles --------------- #
|
||||
def t1(x=1, mono_x=None):
|
||||
_c, ex = urun(range(-30, 121, x), const(13000.0 + CAR), const(0.0),
|
||||
lambda t: None if 0 <= t <= 2 * x else CAR, x=x,
|
||||
mono_x=mono_x)
|
||||
return ex
|
||||
|
||||
|
||||
ex = t1()
|
||||
print(f" T1 explains E-1..E+5: {run_of(ex, -1, 5)}")
|
||||
check("T1 PRECONDITION: before the edge the car (trusted) explains the "
|
||||
"excess (house 13 000 W, car 1 380 W, grid 14 380 W)",
|
||||
all(run_of(ex, -30, -1)) and len(run_of(ex, -30, -1)) == 30)
|
||||
check("T1 (Expected 5): while the car figure is unknown (E+0..E+2) it "
|
||||
"explains nothing, so the alarm stands", not any(run_of(ex, 0, 2)))
|
||||
_c1b, ex1b = urun(range(-30, 121), const(12500.0 + CAR - 800.0), const(800.0),
|
||||
lambda t: None if 0 <= t <= 2 else CAR)
|
||||
check("T1b (the EV-10 path: the grid lands under the aim, the batteries at "
|
||||
"0 W would miss; house 12 500 W, b 800 W): unknown E+0..E+2, released "
|
||||
"at E+3 and explained to E+120",
|
||||
not any(run_of(ex1b, 0, 2)) and all(run_of(ex1b, 3, 120))
|
||||
and len(run_of(ex1b, 3, 120)) == 118)
|
||||
check("T1 (Expected 3): released at the first trusted cycle (E+3) and "
|
||||
"explained to E+120 (base: latched False to E+120)",
|
||||
all(run_of(ex, 3, 120)) and len(run_of(ex, 3, 120)) == 118)
|
||||
|
||||
# --- T2c: the battery W boundary, graded on the lower of two readings ------- #
|
||||
def t2c(b_of):
|
||||
_c, ex = urun(range(0, 6), lambda t: 14000.0 + CAR - b_of(t), b_of,
|
||||
const(CAR))
|
||||
return run_of(ex, 0, 5)
|
||||
|
||||
|
||||
e391, e389 = t2c(const(391.0)), t2c(const(389.0))
|
||||
e395 = t2c(lambda t: 395.0 if t == 0 else 385.0)
|
||||
print(f" T2c 391 W {e391}, 389 W {e389}, 395 then 385 W {e395}")
|
||||
check("T2c: b steady at 391 W (house alone with the real batteries lands "
|
||||
"13 609 W, aim + 9 W): the car explains from E+0", all(e391)
|
||||
and len(e391) == 6)
|
||||
check("T2c: b at 389 W (13 611 W, aim + 11 W): it does not, from E+0",
|
||||
not any(e389) and len(e389) == 6)
|
||||
check("T2c: readings 395 then 385 W: graded on 385 W, no explanation from "
|
||||
"the second cycle on", not any(e395[1:]) and len(e395) == 6)
|
||||
|
||||
# --- T4: ALARM_MISS_W, batteries at 0 W -------------------------------------- #
|
||||
e09 = run_of(urun(range(0, 6), const(13609.0 + CAR), const(0.0),
|
||||
const(CAR))[1], 0, 5)
|
||||
e11 = run_of(urun(range(0, 6), const(13611.0 + CAR), const(0.0),
|
||||
const(CAR))[1], 0, 5)
|
||||
check("T4 unit: the house alone at aim + 9 W: the car explains from E+0; at "
|
||||
"aim + 11 W it does not", all(e09) and len(e09) == 6 and not any(e11))
|
||||
|
||||
# --- T8 / N2: 0 W and tiny cars ---------------------------------------------- #
|
||||
e0 = run_of(urun(range(-5, 30), const(14000.0 - 800.0), const(800.0),
|
||||
const(0.0))[1], -5, 29)
|
||||
e50 = run_of(urun(range(-5, 30), const(14090.0 + 50.0), const(0.0),
|
||||
const(50.0))[1], -5, 29)
|
||||
check("T8 unit: a 0 W car never explains, whatever the batteries give (T2 "
|
||||
"shape, b 800 W)", not any(e0) and len(e0) == 35)
|
||||
check("T8 unit: a 50 W car with the house at 14 090 W never explains",
|
||||
not any(e50) and len(e50) == 35)
|
||||
# N2: a car that drew 11 kW earlier in the quarter and now reports 0 W
|
||||
c0, ex0 = urun(range(0, 400), lambda t: 2600.0 + (11040.0 if t < 300 else 0.0),
|
||||
const(0.0), lambda t: 11040.0 if t < 300 else 0.0)
|
||||
check("N2: a trusted 0 W figure explains nothing, also after the car drew "
|
||||
"earlier in the quarter", not any(run_of(ex0, 300, 399)))
|
||||
|
||||
# --- T8 unit: a car known to draw nothing is not an unknown car ------------- #
|
||||
class _Tracker:
|
||||
"""The two things `_car_idle` reads: the reading, and its fresh power."""
|
||||
def __init__(self, available):
|
||||
self.reading = CH.ChargerReading(available=available, state="B",
|
||||
charging=False, power_w=0.0)
|
||||
|
||||
def car_w(self, _now):
|
||||
return 0.0 if self.reading.available else None
|
||||
|
||||
@staticmethod
|
||||
def status(*_a):
|
||||
return "charging"
|
||||
|
||||
|
||||
def idle_then_charging(available):
|
||||
c = _Car()
|
||||
c.car = _Tracker(available)
|
||||
_c, ex = urun(range(0, 900),
|
||||
lambda t: 14090.0 if t < 60 else 13000.0 + CAR, const(0.0),
|
||||
lambda t: None if t < 60 else CAR, c=c)
|
||||
return ex
|
||||
|
||||
|
||||
exi, exu = idle_then_charging(True), idle_then_charging(False)
|
||||
check("T8 unit: a car known idle (mode3 B, 0 W, fresh) while the house alone "
|
||||
"misses (14 090 W): that house need is latched, so the car charging "
|
||||
"from E+60 does not explain the quarter (test_ev10's `swapped` case)",
|
||||
not any(run_of(exi, 0, 899)))
|
||||
check("T8 unit: the same with the charger unavailable (unknown car): the "
|
||||
"alarm stands while unknown and is released at E+60 (Expected 5)",
|
||||
not any(run_of(exu, 0, 59)) and all(run_of(exu, 60, 899)))
|
||||
|
||||
# --- T10(a) unit: the battery reading lost for one cycle --------------------- #
|
||||
cA, eA = urun(range(-3, 10), const(14000.0 + CAR - 800.0),
|
||||
lambda t: None if t == 1 else 800.0, const(CAR))
|
||||
check("T10(a) unit, T2 shape: the cycle with no battery reading explains "
|
||||
"nothing (no last-known W credited); the next ones do",
|
||||
eA.get(1) is False and eA.get(0) is True and all(run_of(eA, 2, 9))
|
||||
and len(run_of(eA, 2, 9)) == 8)
|
||||
|
||||
# --- T13 unit: a house need seen with a trusted car stays latched ----------- #
|
||||
c13, e13 = urun(range(-5, 1000),
|
||||
lambda t: (15500.0 if 300 <= t < 360 else 13000.0) + CAR,
|
||||
const(0.0), const(CAR))
|
||||
check("T13 unit: the house steps to 15 500 W at E+300 for 60 s (landing "
|
||||
"without the car 14 667 W): not explained from E+300 to the quarter's "
|
||||
"end, though the house is back at 13 000 W from E+360",
|
||||
all(run_of(e13, 0, 299)) and not any(run_of(e13, 300, 899))
|
||||
and len(run_of(e13, 300, 899)) == 600)
|
||||
check("T13 unit: ...and released by the new quarter", all(run_of(e13, 900, 999)))
|
||||
c13g, e13g = urun(range(0, 400),
|
||||
lambda t: (15500.0 if 100 <= t < 160 else 13000.0) + CAR,
|
||||
const(0.0), const(CAR),
|
||||
guard=lambda t: _G(wants=not (t == 250)))
|
||||
check("T13 unit: ...or by the guard no longer wanting power (EV-10)",
|
||||
not any(run_of(e13g, 100, 249)) and all(run_of(e13g, 251, 399)))
|
||||
|
||||
# --- T14: no flicker --------------------------------------------------------- #
|
||||
def floor_edges(ex):
|
||||
"""Per quarter, False -> True edges of the floor alarm the stub implies
|
||||
(floor-limited, within_aim False, not explained)."""
|
||||
out, was = {}, False
|
||||
for t in sorted(ex):
|
||||
al = not ex[t]
|
||||
if al and not was:
|
||||
out[t // 900] = out.get(t // 900, 0) + 1
|
||||
was = al
|
||||
return out
|
||||
|
||||
|
||||
_ca, eta = urun(range(0, 1200),
|
||||
lambda t: 13610.0 + (40.0 if int(t // 7) % 2 else -40.0) + CAR,
|
||||
const(0.0), const(CAR))
|
||||
_cb, etb = urun(range(0, 1200),
|
||||
lambda t: 14000.0 + CAR - (400.0 if int(t // 7) % 2 else 800.0),
|
||||
lambda t: 400.0 if int(t // 7) % 2 else 800.0, const(CAR))
|
||||
fa, fb = floor_edges(eta), floor_edges(etb)
|
||||
print(f" T14 alarm edges per quarter: (a) {fa} (b) {fb}")
|
||||
check("T14(a): the house alone straddles aim + 10 W by 40 W every 7 s: at "
|
||||
"most one alarm edge per quarter", all(v <= 1 for v in fa.values()))
|
||||
check("T14(b): T2 shape with b alternating 400 / 800 W every 7 s: no alarm "
|
||||
"edge at all (base: one per quarter)", fb == {})
|
||||
|
||||
# --- T15 unit: x10 ------------------------------------------------------------ #
|
||||
ex10 = t1(x=10)
|
||||
check("T15 unit x10 (wall and mono 10 s a cycle): T1 the same; released "
|
||||
"within 1 cycle (E+30, the first trusted cycle)",
|
||||
not any(run_of(ex10, 0, 20)) and all(run_of(ex10, 30, 120))
|
||||
and all(run_of(ex10, -30, -10)))
|
||||
ex10m = t1(x=10, mono_x=1)
|
||||
check("T15 unit, mono x1 and wall x10: the same verdicts (the edge comes from "
|
||||
"the projection's block_start, not from mono)",
|
||||
not any(run_of(ex10m, 0, 20)) and all(run_of(ex10m, 30, 120)))
|
||||
|
||||
# =========================================================================== #
|
||||
print("\n2. THE REAL CONTROLLER ACROSS THE EDGE (N=2, both at the reserve)")
|
||||
# =========================================================================== #
|
||||
|
||||
|
||||
RUNS = [] # (name, alarm edges) of every run, for N5
|
||||
|
||||
|
||||
def summary(name, r, tr):
|
||||
RUNS.append((name, H.edges(tr)))
|
||||
w = H.window(tr, E - 120, E + 900)
|
||||
lim = [x for x in w if x["lim"]]
|
||||
print(f" {name}: alarms {[t - E for t in H.alarms(r)]} edges "
|
||||
f"{[t - E for t in H.edges(tr)]} red {len(H.red_secs(tr))} s "
|
||||
f"(first {[t - E for t in H.red_secs(tr)[:1]]}) errors "
|
||||
f"{len(H.errors(tr))} limited {len(lim)} explained "
|
||||
f"{sum(1 for x in lim if x['explains'])} cmd {H.commands(r, tr)}")
|
||||
return w, lim
|
||||
|
||||
|
||||
def quiet(r, tr):
|
||||
"""No floor notification, no ERROR, no red peak_guard row, E-120..E+900."""
|
||||
return H.alarms(r) == [] and H.red_secs(tr) == [] and H.errors(tr) == []
|
||||
|
||||
|
||||
def all_explained(lim, t0=E - 120):
|
||||
return bool(lim) and all(x["explains"] for x in lim if x["t"] >= t0)
|
||||
|
||||
|
||||
ZERO = const(0.0)
|
||||
|
||||
|
||||
def honest(w):
|
||||
"""An honest shape steps at the edge, so Off has no alarm before it."""
|
||||
return H.shape(w, at=E)
|
||||
|
||||
# --- T2: the rig F-A shape ---------------------------------------------------- #
|
||||
r2, tr2 = H.run(H.shape(14000.0), a=ZERO, b=const(800.0))
|
||||
w2, lim2 = summary("T2", r2, tr2)
|
||||
check("T2 PRECONDITION: limited at the reserve from the edge, the car trusted, "
|
||||
"b 800 W, grid excess 980 W < car",
|
||||
present(first(x for x in w2 if x["t"] == E and x["lim"]))
|
||||
and all(x["w"] == CAR and x["batt"] == 800.0 for x in lim2))
|
||||
check("T2: no goodwe_peak_soc_floor, no PEAK_GUARD_FLOOR_LIMITED ERROR, no "
|
||||
"red peak_guard row in E-120..E+900 (base: alarm at E+0, red to E+900)",
|
||||
quiet(r2, tr2))
|
||||
check("T2: the car explains every floor-limited cycle, E+0..E+10 among them",
|
||||
all_explained(lim2) and len([x for x in lim2 if x["t"] <= E + 10]) == 11)
|
||||
|
||||
# --- T2b: the batteries give less later --------------------------------------- #
|
||||
r2i, tr2i = H.run(H.shape(14000.0), a=ZERO,
|
||||
b=lambda t: 800.0 if t < E + 300 else 0.0)
|
||||
summary("T2b(i)", r2i, tr2i)
|
||||
a2i = H.alarms(r2i)
|
||||
check("T2b(i): b drops to 0 W at E+300 (landing without the car 13 733 W): "
|
||||
"the alarm fires within 1 cycle of E+300",
|
||||
len(a2i) == 1 and E + 300 <= nth(a2i, 0) <= E + 301)
|
||||
check("T2b(i): ...and stays to the quarter's end (a house need with a "
|
||||
"trusted car is latched)", all(x["alarm"] and x["red"] for x in
|
||||
H.window(tr2i, E + 302, E + 899)))
|
||||
r2ii, tr2ii = H.run(H.shape(14000.0), a=ZERO,
|
||||
b=lambda t: 800.0 if t < E + 300 else 400.0)
|
||||
summary("T2b(ii)", r2ii, tr2ii)
|
||||
check("T2b(ii): b drops to 400 W (landing 13 467 W): no alarm to E+900",
|
||||
quiet(r2ii, tr2ii))
|
||||
|
||||
# --- T3: batteries at 0 W, and the 11 kW car ---------------------------------- #
|
||||
r3, tr3 = H.run(H.shape(13000.0), a=ZERO, b=ZERO)
|
||||
w3, lim3 = summary("T3", r3, tr3)
|
||||
check("T3: batteries 0 W, house 13 000 W, car 1 380 W: no alarm, no red row, "
|
||||
"the car explains every limited cycle incl. E+0..E+10, one car notice",
|
||||
quiet(r3, tr3) and all_explained(lim3)
|
||||
and len(P.ids(r3, P.OVER)) == 1
|
||||
and all(x["explains"] for x in lim3 if x["t"] <= E + 10))
|
||||
|
||||
|
||||
def plug_at(t0):
|
||||
return {t0: lambda p, c: p.ch.plug_in()}
|
||||
|
||||
|
||||
r3k, tr3k = H.run(H.shape(2600.0, before=2600.0), a=ZERO, b=ZERO, car_a=16,
|
||||
phases=3, aim=6344.0, plug=False, extra=plug_at(E - 120))
|
||||
w3k, lim3k = summary("T3 11 kW", r3k, tr3k)
|
||||
check("T3 11 kW: house 2 600 W, car 11 kW, aim 6 344 W (base P 21:30): no "
|
||||
"alarm, the car explains every limited cycle",
|
||||
quiet(r3k, tr3k) and all_explained(lim3k)
|
||||
and len(P.ids(r3k, P.OVER)) == 1)
|
||||
|
||||
# --- T4 controller ------------------------------------------------------------ #
|
||||
r409, tr409 = H.run(H.shape(13609.0), a=ZERO, b=ZERO)
|
||||
summary("T4 13 609", r409, tr409)
|
||||
check("T4: the house alone at aim + 9 W: no alarm", quiet(r409, tr409))
|
||||
r411, tr411 = H.run(H.shape(13611.0), a=ZERO, b=ZERO)
|
||||
r411o, tr411o = H.run(H.shape(13611.0), a=ZERO, b=ZERO, mode="off")
|
||||
summary("T4 13 611", r411, tr411)
|
||||
summary("T4 13 611 Off", r411o, tr411o)
|
||||
check("T4: at aim + 11 W the alarm at the same cycle as Off (and as base, "
|
||||
"E+0)", H.alarms(r411) == H.alarms(r411o) == [E])
|
||||
|
||||
# --- T5: an honest alarm ------------------------------------------------------ #
|
||||
r5, tr5 = H.run(honest(14090.0), a=ZERO, b=ZERO)
|
||||
r5o, tr5o = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off")
|
||||
summary("T5", r5, tr5)
|
||||
summary("T5 Off", r5o, tr5o)
|
||||
check("T5: grid excess 1 870 W > car 1 380 W: the alarm and the ERROR at the "
|
||||
"same second as Off and as base (E+1, the step's first sample)",
|
||||
H.alarms(r5) == H.alarms(r5o) == T5_BASE
|
||||
and nth(H.errors(tr5), 0) == nth(H.errors(tr5o), 0) == E + 1)
|
||||
check("T5: the car explains no cycle", not any(x["explains"] for x in tr5))
|
||||
|
||||
|
||||
# --- T6: the car figure unknown across the edge ------------------------------- #
|
||||
def unavailable(t0, t1):
|
||||
return {t0: lambda p, c: p.ch.go_unavailable(True),
|
||||
t1: lambda p, c: p.ch.go_unavailable(False)}
|
||||
|
||||
|
||||
r6, tr6 = H.run(H.shape(13000.0), a=ZERO, b=ZERO,
|
||||
extra=unavailable(E - 20, E + 60))
|
||||
summary("T6 T3 shape", r6, tr6)
|
||||
back = first(x["t"] for x in tr6 if x["t"] >= E + 60 and x["w"] is not None)
|
||||
check("T6 T3 shape: while unknown the car explains nothing and the alarm "
|
||||
"stands from E+0, as base",
|
||||
H.alarms(r6) == [E] and not any(
|
||||
x["explains"] for x in H.window(tr6, E - 5, E + 59))
|
||||
and all(x["alarm"] for x in H.window(tr6, E, E + 59)))
|
||||
check("T6 T3 shape: released within 1 cycle of the first trusted cycle after "
|
||||
"E+60, no new alarm edge to E+900 (base: red to E+900)",
|
||||
present(back) and all(not x["alarm"] and x["explains"] for x in
|
||||
H.window(tr6, back + 1, E + 899))
|
||||
and H.edges(tr6) == [E])
|
||||
r6h, tr6h = H.run(honest(14090.0), a=ZERO, b=ZERO,
|
||||
extra=unavailable(E - 20, E + 60))
|
||||
summary("T6 T5 shape", r6h, tr6h)
|
||||
check("T6 T5 shape: the alarm at the base second and it stands throughout",
|
||||
H.alarms(r6h) == T5_BASE and all(x["alarm"] for x in
|
||||
H.window(tr6h, E + 1, E + 899)))
|
||||
|
||||
|
||||
# --- T7: a frozen car figure, the car really stops ---------------------------- #
|
||||
def frozen_stop(p, c):
|
||||
p.ch.freeze()
|
||||
p.ch.car_full()
|
||||
|
||||
|
||||
r7, tr7 = H.run(honest(14090.0), a=ZERO, b=ZERO, extra={E - 30: frozen_stop})
|
||||
summary("T7", r7, tr7)
|
||||
first7 = nth(H.alarms(r7), 0)
|
||||
untr = first(x["t"] for x in tr7 if x["t"] >= E - 30 and x["w"] is None)
|
||||
check("T7: the alarm within 114 s of the stop (max(60, 40 Wh / 1.38 kW) "
|
||||
"+ 10), no later than base",
|
||||
present(first7) and first7 <= E - 30 + 114 and first7 <= T7_BASE)
|
||||
check("T7: never explained after the figure goes untrusted",
|
||||
present(untr) and not any(x["explains"] for x in tr7 if x["t"] >= untr))
|
||||
|
||||
|
||||
# --- T8: a car at 0 W, and a 50 W car ----------------------------------------- #
|
||||
class Draw(SimCharger):
|
||||
"""A charger that draws `real_w` while charging and reports `say_w`."""
|
||||
def __init__(self, real_w, say_w, **kw):
|
||||
super().__init__(**kw)
|
||||
self.real_w, self.say_w = real_w, say_w
|
||||
|
||||
def target_w(self):
|
||||
return 0.0 if super().target_w() <= 0.0 else self.real_w
|
||||
|
||||
def _build(self):
|
||||
keep, self._frozen_w = self._frozen_w, self.say_w
|
||||
try:
|
||||
return super()._build()
|
||||
finally:
|
||||
self._frozen_w = keep
|
||||
|
||||
|
||||
def full(p, c):
|
||||
p.ch.car_full()
|
||||
|
||||
|
||||
for nm, kw in (("house 14 090 W", dict(house=honest(14090.0), b=ZERO)),
|
||||
("T2 shape", dict(house=honest(14000.0), b=const(800.0)))):
|
||||
r8, tr8 = H.run(a=ZERO, extra={1: full}, **kw)
|
||||
r8o, tr8o = H.run(a=ZERO, extra={1: full}, mode="off", **kw)
|
||||
summary(f"T8 0 W, {nm}", r8, tr8)
|
||||
summary(f"T8 0 W, {nm}, Off", r8o, tr8o)
|
||||
check(f"T8: a car plugged at 0 W, {nm}: the alarm at the same second as "
|
||||
f"Off, nothing explained", H.alarms(r8) == H.alarms(r8o)
|
||||
and H.alarms(r8) != [] and not any(x["explains"] for x in tr8))
|
||||
r8s, tr8s = H.run(honest(14090.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(50.0, 50.0, setpoint_a=6))
|
||||
r8so, tr8so = H.run(honest(14090.0), a=ZERO, b=ZERO, mode="off",
|
||||
sim=Draw(50.0, 50.0, setpoint_a=6))
|
||||
summary("T8 50 W", r8s, tr8s)
|
||||
check("T8: a 50 W car, house 14 090 W: the alarm at the same second as Off, "
|
||||
"nothing explained", H.alarms(r8s) == H.alarms(r8so) == T5_BASE
|
||||
and not any(x["explains"] for x in tr8s))
|
||||
|
||||
# --- T9: a wrong charger reply ------------------------------------------------ #
|
||||
r9a, tr9a = H.run(honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(1380.0, 11000.0, setpoint_a=6))
|
||||
summary("T9(a)", r9a, tr9a)
|
||||
check("T9(a): reports 11 kW, read-back 6 A 1-ph (cap 1 518 W): the house "
|
||||
"alone misses, the alarm at the base second",
|
||||
H.alarms(r9a) == T5_BASE and all(x["w"] is None or x["w"] <= 1518.0
|
||||
for x in tr9a))
|
||||
r9b, tr9b = H.run(honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(400.0, 1380.0, setpoint_a=6))
|
||||
summary("T9(b)", r9b, tr9b)
|
||||
check("T9(b): reports 1 380 W, draws 400 W: the same alarms as base (none: "
|
||||
"400 W corroborates a 1 380 W figure, CORR_RATIO 0.5; see the dev "
|
||||
"report's Findings)", H.alarms(r9b) == T9B_BASE)
|
||||
r9c, tr9c = H.run(honest(13900.0), a=ZERO, b=ZERO,
|
||||
sim=Draw(100.0, 1380.0, setpoint_a=6))
|
||||
summary("T9(c)", r9c, tr9c)
|
||||
a9c = nth(H.alarms(r9c), 0)
|
||||
check("T9(c): reports 1 380 W, draws 100 W: the first alarm once the figure "
|
||||
"is uncorroborated, at most 104 s + 10 s after the edge, no later than "
|
||||
"base", present(a9c) and a9c <= E + 114 and a9c <= T9C_BASE)
|
||||
print(f" T9(c) alarm edges {[t - E for t in H.edges(tr9c)]} (base: one; "
|
||||
f"the meter's 10 Wh step re-corroborates the figure every 360 s and "
|
||||
f"Expected 3/5 release the alarm then: see the dev report)")
|
||||
|
||||
# --- T10: a lost battery reading, an unavailable charger ---------------------- #
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO))):
|
||||
r10, tr10 = H.run(a=ZERO, lost={"b": {E + 1}}, **kw)
|
||||
summary(f"T10(a) {nm}", r10, tr10)
|
||||
gap = first(x for x in tr10 if x["t"] == E + 1)
|
||||
nxt = first(x for x in tr10 if x["t"] == E + 2)
|
||||
check(f"T10(a) {nm}: inverter-b's reading lost at E+1: that cycle grades "
|
||||
f"nothing (P_SAFETY owns a missing input), the next one grades on "
|
||||
f"what is measured", present(gap, nxt) and gap["batt"] is None
|
||||
and nxt["batt"] == (800.0 if nm == "T2" else 0.0))
|
||||
if nm == "T2":
|
||||
check("T10(a) T2: no alarm edge (base: E+0)", quiet(r10, tr10))
|
||||
else:
|
||||
check("T10(a) T5: the same alarm seconds as base",
|
||||
H.alarms(r10) == T10A_T5_BASE)
|
||||
r10b, tr10b = H.run(a=ZERO, extra=unavailable(E + 1, E + 2), **kw)
|
||||
summary(f"T10(b) {nm}", r10b, tr10b)
|
||||
if nm == "T2":
|
||||
check("T10(b) T2: the charger unavailable for one cycle (E+1): the "
|
||||
"alarm stands for that cycle only (Expected 5)",
|
||||
H.edges(tr10b) == [E + 1]
|
||||
and all(not x["alarm"] for x in H.window(tr10b, E + 2, E + 899))
|
||||
and all(x["explains"] for x in H.window(tr10b, E + 2, E + 899)
|
||||
if x["lim"]))
|
||||
else:
|
||||
check("T10(b) T5: the alarm at the base second and it stands",
|
||||
H.alarms(r10b) == T5_BASE and all(
|
||||
x["alarm"] for x in H.window(tr10b, E + 1, E + 899)))
|
||||
|
||||
# --- T11: one battery first (SAFETY-87) --------------------------------------- #
|
||||
for nm, house in (("(i) 17 500 W", 17500.0), ("(ii) 19 000 W", 19000.0)):
|
||||
r11, tr11 = H.run(honest(house), soc={"a": 19.0, "b": 35.0})
|
||||
summary(f"T11{nm}", r11, tr11)
|
||||
if house < 18000.0:
|
||||
check("T11(i): b able, house 17 500 W, car 1 380 W: no alarm across E",
|
||||
H.alarms(r11) == [] and P.ids(r11, *P.ALARMS) == [])
|
||||
else:
|
||||
check("T11(ii): house 19 000 W: the alarm at the base second",
|
||||
[t for t, _n in P.ids(r11, *P.ALARMS)] == T11_BASE)
|
||||
|
||||
# --- T12 (record only): plug-in at E+0, the reserve at E+180 ------------------ #
|
||||
def reserve_at(p, c):
|
||||
p.socs.update({"a": 19.0, "b": 19.0})
|
||||
|
||||
|
||||
r12, tr12 = H.run(H.shape(13000.0), soc={"a": 40.0, "b": 40.0}, plug=False,
|
||||
extra={E: lambda p, c: p.ch.plug_in(), E + 180: reserve_at})
|
||||
summary("T12 (record, F-B)", r12, tr12)
|
||||
|
||||
# --- T13 controller: the latch is kept ---------------------------------------- #
|
||||
r13, tr13 = H.run(H.shape(lambda t: 15500.0 if E + 300 <= t < E + 360
|
||||
else 13000.0), a=ZERO, b=ZERO)
|
||||
summary("T13", r13, tr13)
|
||||
check("T13: the house steps to 15 500 W at E+300 for 60 s: the alarm at "
|
||||
"the base second (E+301, the step's first sample), and red to the "
|
||||
"quarter's end", H.alarms(r13) == T13_BASE and all(
|
||||
x["alarm"] and x["red"] for x in H.window(tr13, E + 301, E + 899)))
|
||||
|
||||
# --- T16: the edge paths ------------------------------------------------------ #
|
||||
for nm, kw in (("(a)(b)(c) SAFETY-91 roll, modes on", {}),
|
||||
("(d) the guard not wanting at the edge",
|
||||
dict(lost={"b": {E}}))):
|
||||
r16, tr16 = H.run(H.shape(13000.0), a=ZERO, b=ZERO, **kw)
|
||||
w16, lim16 = summary(f"T16{nm}", r16, tr16)
|
||||
f16 = first(x for x in tr16 if x["t"] >= E and x["lim"])
|
||||
pre = first(x for x in tr16 if x["t"] == E - 1)
|
||||
check(f"T16{nm}: the car explains from the first limited cycle of the "
|
||||
f"new block, no alarm, no red row, `_carq` key = block_start",
|
||||
present(f16) and quiet(r16, tr16) and all(
|
||||
x["explains"] and x["key"] == x["block"]
|
||||
for x in tr16 if x["t"] >= f16["t"] and x["lim"]))
|
||||
if not kw:
|
||||
print(f" T16(c): within_aim at E-1 {pre['within_aim'] if present(pre) else pre}"
|
||||
" (SAFETY-126's latch carried; not asserted)")
|
||||
else:
|
||||
g0 = first(x for x in tr16 if x["t"] == E)
|
||||
check("T16(d) PRECONDITION: the guard did not want power at E+0",
|
||||
present(g0) and not g0["wants"])
|
||||
|
||||
|
||||
# --- T17: a restart ----------------------------------------------------------- #
|
||||
def restart_at(t0):
|
||||
return {t0: lambda p, c: H.restart(c)}
|
||||
|
||||
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T3", dict(house=H.shape(13000.0), b=ZERO)),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO))):
|
||||
rr0, tr0 = H.run(a=ZERO, **kw)
|
||||
for at in (E + 2, E + 300):
|
||||
rr, trr = H.run(a=ZERO, extra=restart_at(at), **kw)
|
||||
summary(f"T17 {nm} restart at E+{at - E}", rr, trr)
|
||||
if nm == "T5":
|
||||
check(f"T17 T5, restart at E+{at - E}: the alarm at the base "
|
||||
f"second and again on the first cycle after the restart, "
|
||||
f"as base; red throughout",
|
||||
H.alarms(rr) == T5_BASE + [at] and len(H.red_secs(trr))
|
||||
== len(H.red_secs(tr0)))
|
||||
else:
|
||||
check(f"T17 {nm}, restart at E+{at - E}: the same as without "
|
||||
f"(no floor notice, no ERROR, no red row)",
|
||||
quiet(rr, trr) and quiet(rr0, tr0))
|
||||
print(f" T17 {nm} car-over notices: twin "
|
||||
f"{[t - E for t, _n in P.ids(rr0, P.OVER)]}, restarted "
|
||||
f"{[t - E for t, _n in P.ids(rr, P.OVER)]} (EV-11's "
|
||||
f"once-per-session state does not survive a restart, as on "
|
||||
f"base)")
|
||||
|
||||
# --- T15 controller: x10 ------------------------------------------------------ #
|
||||
# F2 (out of scope, filed apart): `_car_quarter` caps a cycle's dt at 5 s, so at
|
||||
# 10 s a cycle half the car's energy is counted, and late in the quarter the
|
||||
# house alone seems to miss the aim (T2 from about E+540, T3 E+820, as on base
|
||||
# for T3). The x10 verdicts are graded to E+500; what comes after is printed.
|
||||
F2_FROM = E + 500
|
||||
for nm, kw, want in (
|
||||
("T2", dict(house=H.shape(14000.0), b=const(800.0)), "quiet"),
|
||||
("T3", dict(house=H.shape(13000.0), b=ZERO), "quiet"),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO), "alarm"),
|
||||
("T6", dict(house=H.shape(13000.0), b=ZERO,
|
||||
extra=unavailable(E - 20, E + 60)), "release")):
|
||||
rx, trx = H.run(a=ZERO, x=10, **kw)
|
||||
summary(f"T15 x10 {nm}", rx, trx)
|
||||
early = [x for x in trx if x["t"] < F2_FROM]
|
||||
print(f" T15 x10 {nm}: alarms after E+500 (F2) "
|
||||
f"{[t - E for t in H.alarms(rx) if t >= F2_FROM]}")
|
||||
if want == "quiet":
|
||||
check(f"T15 x10 {nm}: no alarm, no red row, every limited cycle "
|
||||
f"explained, E-120..E+500",
|
||||
not [t for t in H.alarms(rx) if t < F2_FROM]
|
||||
and H.red_secs(trx, t1=F2_FROM - 1) == []
|
||||
and all_explained([x for x in early if x["lim"]]))
|
||||
elif want == "alarm":
|
||||
check("T15 x10 T5: the alarm at the base second (E+10, one cycle)",
|
||||
H.alarms(rx) == T15_T5_BASE)
|
||||
else:
|
||||
bk = first(x["t"] for x in trx if x["t"] >= E + 60
|
||||
and x["w"] is not None)
|
||||
check("T15 x10 T6: the alarm while unknown, released within 1 cycle "
|
||||
"(10 fake s) of the first trusted one, no new edge to E+500",
|
||||
present(bk) and bk <= E + 70
|
||||
and all(not x["alarm"] for x in H.window(trx, bk, F2_FROM - 1))
|
||||
and [t for t in H.edges(trx) if t < F2_FROM] == [E])
|
||||
|
||||
# --- N4: the alarm decision changes no command -------------------------------- #
|
||||
for nm, kw in (("T2", dict(house=H.shape(14000.0), b=const(800.0))),
|
||||
("T5", dict(house=honest(14090.0), b=ZERO))):
|
||||
ra, tra = H.run(a=ZERO, **kw)
|
||||
rb, trb = H.run(a=ZERO, explain_off=True, **kw)
|
||||
check(f"N4 {nm}: the claim, the floor, the battery setpoints and the "
|
||||
f"charger writes are identical whether the car explains or not",
|
||||
H.commands(ra, tra) == H.commands(rb, trb))
|
||||
|
||||
# --- N5: at most one floor-alarm edge per quarter ---------------------------- #
|
||||
def per_quarter(ts):
|
||||
out = {}
|
||||
for t in ts:
|
||||
out[(t - E) // 900] = out.get((t - E) // 900, 0) + 1
|
||||
return out
|
||||
|
||||
|
||||
many = [(nm, ts) for nm, ts in RUNS
|
||||
if not nm.startswith("T9(c)")
|
||||
and any(v > 1 for v in per_quarter(
|
||||
[t for t in ts if not nm.startswith("T15 x10") or t < F2_FROM])
|
||||
.values())]
|
||||
check(f"N5: at most one floor-alarm edge per quarter in every run "
|
||||
f"({len(RUNS)} runs; T9(c) apart, x10 to E+500): {many}", many == [])
|
||||
|
||||
print()
|
||||
print("FAIL: " + ", ".join(fails) if fails else "PASS: every check passed")
|
||||
sys.exit(1 if fails else 0)
|
||||
@@ -0,0 +1,207 @@
|
||||
"""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):
|
||||
"""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 (for the control-identity check)."""
|
||||
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 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 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
|
||||
Reference in New Issue
Block a user