"""Runnable check for MAINT-28 fix-forward. `python3 test_maint28b.py` The rig failed MAINT-28 (TEST-23, f3f9483): the hold of the maintenance pause ended at almost every guard step (F-1), and while it stuck, the pack in maintenance CHARGE gave its full rating for the house below its peak reserve (F-2). test_maint28.py missed both because its battery reading has no lag. Here the battery register is published every 10 s and held (`Lag.batt_period_s`), the meter reading is 2 s old, as on the rig; the rating is the rig's A (5 kW). All on the real Controller through `cycle()` (tools/opt20_scen.py): cheap window, cap 3500 / margin 50, a month peak of 6000 W banked (aim 5950 W), a peak forecast like the live sensor, house +-50 W every 5 s, 3000 W then 6500 W for 13 min (over a quarter boundary), then 3000 W. 1. A real peak, A in CHARGE above its peak reserve: A flips charge/give a few times (base 1b5f7c9: dozens), no release of the pause on an estimate that mixes a new grid with an old battery reading, quarters at or under the aim, A's charge back after the load. 2. F-2 and the cap (owner 2026-11-13): while the pause holds, A gives at most the largest part of the guard's floor placed on it in the 15-min period, at any SoC (never under its reserve; SoC drop within the owner-accepted give); with both packs able, never over the period's largest floor, and when B is placed part of it A's limit is its own part, not the whole floor; one unit's limit is its own (two packs in CHARGE never share it); with the other pack under its reserve, A still gives for the guard. 3. The mirror: B in CHARGE, under its reserve at the load: it gives nothing for the house. 4. Unchanged: the MAINT-24 live shape (A 1475 W, B no grid trade), with the same lag on. 5. `peakguard.shaping_held()` with `settled`, and `Controller._batts_settled()`. Mutations: DECISIONS/MAINT-28-hold-the-pause-in-a-peak.md. Read MUTATION.md before you report a survivor. """ import logging import os import random import sys from datetime import timedelta HERE = os.path.dirname(os.path.abspath(__file__)) sys.path.insert(0, HERE) sys.path.insert(0, os.path.join(HERE, "tools")) logging.disable(logging.WARNING) import opt11p3_replay as rp # noqa: E402 import opt20_scen as sc # noqa: E402 from app import (ctl_cycle, ctl_trade, freshness, maintenance, # noqa: E402 packmode, peakguard, tariff) fails = [] def check(name, cond): print(f" {'ok ' if cond else 'FAIL'} {name}") if not cond: fails.append(name) rp.RATING, rp.CAP_KWH = 5000.0, 15.36 # the rig's A LAG = rp.Lag(dead_s=1.0, meter_s=2.0, batt_s=1.0, p1_s=0.35, tick=1.0, tau_s=2.0, ramp_w_s=1e9, batt_period_s=10.0) CH = sc.MAINT_CHARGE MONTH_PEAK = 6000.0 AIM = MONTH_PEAK - 50.0 LINE = AIM - getattr(peakguard, "MAINT_RESUME_UNDER_W", 300.0) T0 = sc.at(2.0) # a quarter boundary PRE, LOAD, POST = 120.0, 780.0, 120.0 # s (CI time: short runs) RESERVE = 20.0 # peak_soc_floor default def stepped_house(base_w, hi_w): rnd = random.Random(28) out = [(sc.UTC0.timestamp() - 10, base_w)] for t in range(0, int(PRE + LOAD + POST), 5): w = hi_w if PRE <= t < PRE + LOAD else base_w out.append((T0.timestamp() + t, w + rnd.uniform(-50.0, 50.0))) return out def scen(*, unit="a", soc=49.0, other=30.0, house=None, house_w=3000.0, peak=MONTH_PEAK, dur=PRE + LOAD + POST, fc="quarter", n=2, choice=None): """`unit` is in maintenance CHARGE (forced result), at `soc`, the other at `other`. Rows: the plants' power and SoC, the pause flag, the add-on's house estimate and the real house.""" rows = [] q = dict(q=None, s=0.0, last=None, start=None) idx = 0 if unit == "a" else 1 o = "b" if unit == "a" else "a" def patch(c): c.maints[idx].tick = ( lambda now, soc_, blocked_by=None, gate_open=True: CH) if peak is not None: orig_peak = c.peak.peak def peak_(now): r = orig_peak(now) return tariff.PeakReading(tariff.OBSERVED, getattr(r, "month", ""), peak) c.peak.peak = peak_ orig = c.cycle async def cyc(): c.cheap = True if fc and c.grid is not None: g = float(c.grid) now = ctl_cycle.datetime.now() # the replay's clock qi = int(now.timestamp() // 900) if q["q"] != qi: q.update(q=qi, s=0.0, last=now, start=now) el = (now - q["start"]).total_seconds() q["s"] += g * (now - q["last"]).total_seconds() q["last"] = now c.peak_fc = (q["s"] + g * (900.0 - el)) / 900.0 await orig() c.cycle = cyc def cb(c, h, now, pr): est = (None if c.grid is None or c.site_batt_w is None else float(c.grid) + float(c.site_batt_w)) g = c.peak_guard floor = (float(g.floor_w) if g is not None and g.engaged and g.floor_w is not None else 0.0) sh = (dict(c.allocation.shares) if c.allocation is not None and c.allocation.shares else {}) au = c.actuator_of("maintenance", c.inverters[idx]) ao = c.actuator_of("maintenance", c.inverters[1 - idx]) rows.append(dict( t=(now - T0).total_seconds(), grid=h.grid(), u=h.plants[unit].p, o=h.plants[o].p, soc=h.plants[unit].soc, soc_o=h.plants[o].soc, hold=bool(getattr(c, "_maint_peak_hold", False)), est=est, floor=floor, share_u=float(sh.get(au, 0.0)), hi_u=next((float(pl.hi) for pl in (c.allocation.plans if c.allocation else ()) if pl.unit == au), None), share_o=float(sh.get(ao, 0.0)), house=h.grid() + sum(p.p for p in h.plants.values()))) src = house if house is not None else [(sc.UTC0.timestamp() - 10, house_w)] ch = dict(sc.CH_CH if choice is None else choice) stats, c = rp.run("p3_ch_sell", src, sc.WPTS, T0, dur, check=cb, lag=LAG, n=n, soc0={unit: soc, o: other}, choice=ch, refuse=(), patch=patch, extra={"cycle_cost_threshold_eur": 0.10}) return rows, stats, c def flips(rs, k="u"): n, s = 0, 0 for r in rs: v = 1 if r[k] > 50 else -1 if r[k] < -50 else 0 if v and s and v != s: n += 1 if v: s = v return n def releases(rows): """Cycles in the load where the pause ended: (row, estimate under the release line while the real house was over it).""" out = [] for p, r in zip(rows, rows[1:]): if PRE <= r["t"] < PRE + LOAD and p["hold"] and not r["hold"]: out.append((r, r["est"] is not None and r["est"] < LINE and r["house"] >= LINE)) return out def quarters_ok(st): # SAFETY-126: a landing 0-7 W over the aim is not an overrun. return (max(a[0] / a[1] for a in st["quarters"].values()) <= AIM + peakguard.ALARM_MISS_W) def show(tag, rows, st): load = [r for r in rows if PRE <= r["t"] < PRE + LOAD] rel = releases(rows) print(f" {tag}: flips {flips(load)}, charge s " f"{sum(1 for r in load if r['u'] < -50)}, releases {len(rel)} " f"(stale {sum(1 for _r, s in rel if s)}), lowest SoC " f"{min(r['soc'] for r in rows):.1f} %, give kWh " f"{sum(r['u'] for r in load if r['u'] > 0) / 3.6e6:.2f}, quarters " f"{[round(a[0] / a[1], 1) for a in st['quarters'].values()]}") # ============================================================================ # print("1. a real peak, A in CHARGE at 49 % (above its reserve), the battery " "reading lagging") rows, st, c = scen(house=stepped_house(3000.0, 6500.0)) show("A 49 %", rows, st) load = [r for r in rows if PRE <= r["t"] < PRE + LOAD] rel = releases(rows) after = [r for r in rows if r["t"] >= PRE + LOAD] back = next((i for i, r in enumerate(after) if r["u"] < -50), None) print(f" A's charge back {back} s after the load") check("A flips charge/give 3 times or fewer in the 13 min (1b5f7c9: 60, " "f3f9483: 11)", flips(load) <= 3) check("the pause never ends on an estimate under the release line while the " "real house is over it", not any(s for _r, s in rel)) check("every quarter at or under the month aim", quarters_ok(st)) check("after the load A's charge is back within 20 cycles (1 s each: a 10 s " "register period plus its settle time, 16 s)", back is not None and back <= 20) # ============================================================================ # print("\n2. the cap: while the pause holds, A gives at most the largest part " "of the guard's floor placed on it this period") rows, st, c = scen(soc=RESERVE + 1.0, house=stepped_house(3000.0, 6500.0)) show("A 21 %", rows, st) check("A gives only the guard's claim, under 0.15 kWh (f3f9483 0.94)", sum(r["u"] for r in rows if r["u"] > 0) / 3.6e6 < 0.15) check("A never goes under its peak reserve in the peak (rig: to 10 %)", min(r["soc"] for r in rows) >= RESERVE - 0.5) check("every quarter at or under the month aim", quarters_ok(st)) rows, st, c = scen(house=stepped_house(3000.0, 6500.0)) soc_start = max(r["soc"] for r in rows if r["t"] <= PRE + 5.0) drop = soc_start - min(r["soc"] for r in rows if r["t"] >= PRE) print(f" A at 49 %: SoC drop {drop:.2f} point") # Owner 2026-11-13 accepted about 0.37 kWh per 45-min peak with the cap # (DECISIONS): 0.37 * 13 / 45 = 0.107 kWh in this load, 0.70 point of # 15.36 kWh. Measured 0.64. check("A at 49 %: its SoC drops no more than the owner-accepted give allows " "(0.70 point in the 13 min; f3f9483 6.1)", drop <= 0.70) rows, st, c = scen(soc=49.0, other=18.2, house=stepped_house(3000.0, 12000.0)) show("A 49 %, B 18 % under its reserve, house 12000 W", rows, st) load = [r for r in rows if PRE <= r["t"] < PRE + LOAD] check("the guard's own claim stands: with B under its reserve A gives for " "the peak (over 0.2 kWh; the cap yields to the guard)", sum(r["u"] for r in load if r["u"] > 0) / 3.6e6 > 0.2) g = [("give" if r["u"] > 50 else "idle") for r in load] sw = sum(1 for x, y in zip(g, g[1:]) if x != y) print(f" give/idle switches of A in the load: {sw}") check("...give/idle switches of A at most 10 in the 13 min", sw <= 10) def period_max(rows, f): """Per row: the largest f(row) over the paused rows of its 15-minute period so far (0 W outside the pause), as the owner rule reads.""" out, q, m = [], None, 0.0 for r in rows: qi = int((T0.timestamp() + r["t"]) // 900) if qi != q or not r["hold"]: q, m = qi, 0.0 if r["hold"]: m = max(m, f(r)) out.append(m) return out for tag, ch, hi_w in (("B on Cheap hours", None, 9000.0), ("B on Solar first (it gives for the house too)", {"a": sc.CH_CH["a"], "b": (True, packmode.SOLAR_FIRST, False)}, 12000.0)): rows, st, c = scen(soc=49.0, other=40.0, choice=ch, house=stepped_house(3000.0, hi_w)) show(f"A 49 %, B 40 %, both able, {tag}, house {hi_w:.0f} W", rows, st) mf = period_max(rows, lambda r: r["floor"]) held_rows = [(r, m) for r, m in zip(rows, mf) if r["hold"] and r["floor"] > 0.0 and r["hi_u"] is not None] n = max(1, len(held_rows)) over = sum(1 for r, m in held_rows if r["share_u"] > m + 2.0) # the whole floor, as far as A's rating lets it be A's limit under = sum(1 for r, m in held_rows if r["hi_u"] < min(m, rp.RATING) - 500.0) print(f" {len(held_rows)} paused cycles with a guard floor (mean " f"{sum(r['floor'] for r, _m in held_rows) / n:.0f} W, period's " f"largest {sum(m for _r, m in held_rows) / n:.0f} W): A's limit " f"{sum(r['hi_u'] for r, _m in held_rows) / n:.0f} W, A " f"{sum(r['share_u'] for r, _m in held_rows) / n:.0f} W, B " f"{sum(r['share_o'] for r, _m in held_rows) / n:.0f} W; A over the " f"period's largest floor in {over}; A's limit 500 W or more under it" f" (or A's rating) in {under}") check(f"{tag}: the pause holds with a guard floor for over 5 min", len(held_rows) >= 300) check("...A never gives more than the largest guard floor of the period " "(owner 2026-11-13)", over == 0) if ch is not None: check("...B is placed part of the floor, so A's limit is its own part," " 500 W or more under the period's largest floor (or A's " "rating) in 9 of 10 cycles (not the whole floor)", under >= 0.9 * len(held_rows)) check("...every quarter at or under the month aim", quarters_ok(st)) rows, st, c = scen(soc=18.2, other=30.0, house=stepped_house(3000.0, 12000.0)) show("A 18 % under its reserve, B 30 % able, house 12000 W", rows, st) check("the guard places its claim on the other pack: A under its reserve " "gives under 0.05 kWh and its SoC stays at 18 %", sum(r["u"] for r in rows if r["u"] > 0) / 3.6e6 < 0.05 and min(r["soc"] for r in rows) >= 18.0) # ============================================================================ # print("\n3. mirror: B in CHARGE at 18 % (under its reserve), A on Cheap hours") rows, st, c = scen(unit="b", soc=18.2, other=30.0, house=stepped_house(3000.0, 6500.0)) show("B 18 %", rows, st) check("B gives nothing for the house: its SoC never goes under 18 %", min(r["soc"] for r in rows) >= 18.0) check("every quarter at or under the month aim", quarters_ok(st)) # ============================================================================ # print("\n4. unchanged: the MAINT-24 live shape with the lagging reading") rl, sl, cl = scen(house_w=3000.0, dur=600.0) body = rl[len(rl) // 6:] mean_a = sum(r["u"] for r in body) / len(body) mean_b = sum(r["o"] for r in body) / len(body) print(f" A {mean_a:+.0f} W, B {mean_b:+.0f} W, pause " f"{sum(r['hold'] for r in rl)} cycles") check("A charges about 1475 W (-1500..-1440) and the pause never comes", -1500.0 <= mean_a <= -1440.0 and not any(r["hold"] for r in rl)) check("B does not trade with the grid (Cheap hours, nothing to charge it)", abs(mean_b) < 100.0) # ============================================================================ # print("\n5. peakguard.shaping_held() with `settled`; Controller._batts_settled()") check("the rule exists (MAINT_STEP_W, _batts_settled)", hasattr(ctl_trade, "MAINT_STEP_W") and hasattr(ctl_trade.TradeMixin, "_batts_settled")) if not hasattr(ctl_trade, "MAINT_STEP_W"): print(f"\n{len(fails)} FAILED:") for f in fails: print(f" - {f}") sys.exit(1) U = peakguard.MAINT_RESUME_UNDER_W idle = peakguard.PeakDecision(engaged=False, floor_w=None, ceiling_w=6000.0, ceiling_from="x", target_w=AIM) def held(was, fc, house, settled): return peakguard.shaping_held( peakguard.shaping_suspended(idle, fc, AIM), was, fc, AIM, house, settled) check("held, house under the line but not settled: stays paused", held(True, AIM - 1, AIM - U - 100.0, False)) check("held, house under the line and settled: resumes", not held(True, AIM - 1, AIM - U - 100.0, True)) check("not held: settled makes no difference", not held(False, AIM - 1, 6500.0, False)) check("neither the house nor the forecast read: no pause, settled or not " "(SAFETY-63)", not held(True, None, None, False)) class _Fresh: def __init__(self, changed): self.changed_mono = changed class _Inv: def __init__(self, name, cmd, changed): self.name, self.cmd = name, cmd self.batt_fresh = _Fresh(changed) def standing_w(self): return self.cmd class _Ctl: _batts_settled = getattr(ctl_trade.TradeMixin, "_batts_settled", None) def __init__(self, invs): self.inverters, self._m28_step, self._now_mono = invs, {}, 0.0 S = freshness.PLANT_SETTLE_S a = _Inv("a", -1500.0, 0.0) k = _Ctl([a, _Inv("b", 0.0, 0.0)]) check("no step seen yet: settled", k._batts_settled()) a.cmd = 500.0 k._now_mono = 100.0 check("a step up of the command: not settled", not k._batts_settled()) k._now_mono = 100.0 + S - 0.5 a.batt_fresh.changed_mono = 100.0 + S - 1.0 check("...a reading that arrived before step + settle does not count", not k._batts_settled()) a.batt_fresh.changed_mono = 100.0 + S k._now_mono = 100.0 + S check("...one that arrived at step + settle does", k._batts_settled()) a.cmd = 3000.0 k._now_mono = 200.0 check("a second step up; the old reading is not current", not k._batts_settled()) k._now_mono = 200.0 + freshness.BATT_OBLIGED_S check("...and a reading that never changes is waited for no longer than " "BATT_OBLIGED_S", k._batts_settled()) a.cmd = -1500.0 k._now_mono = 400.0 check("a step down (less give: the estimate errs high) is no step", k._batts_settled()) a2 = _Inv("a", -1500.0, 0.0) k2 = _Ctl([a2]) k2._batts_settled() a2.cmd, k2._now_mono = -1500.0 + ctl_trade.MAINT_STEP_W - 1.0, 1.0 check("a move under ctl_trade.MAINT_STEP_W is no step", k2._batts_settled()) a2.cmd = -1500.0 + ctl_trade.MAINT_STEP_W check("...one of ctl_trade.MAINT_STEP_W is", not k2._batts_settled()) # Per unit: the cap so far lives under each unit's own key, and only one pack # can be in maintenance CHARGE at all (maintenance.arbitrate(): one slot). au, ab = (cl.actuator_of("maintenance", i) for i in cl.inverters) t = T0 + timedelta(seconds=60) cl._m28_hi = {au: (int(t.timestamp() // 900), 3000.0)} check("the period's cap is kept per unit: A's 3000 W is not B's", cl._m28_was(au, t) == 3000.0 and cl._m28_was(ab, t) == 0.0) check("...and it starts again from 0 W in the next 15-minute period", cl._m28_was(au, t + timedelta(seconds=900)) == 0.0) class _M: def __init__(self, name): self.name, self.phase = name, maintenance.CHARGE check("maintenance.arbitrate(): with two packs in CHARGE only the first keeps " "the slot", maintenance.arbitrate([_M("a"), _M("b")], t)[1] != "" and maintenance.arbitrate([_M("a"), _M("b")], t)[0] == "") print() if fails: print(f"{len(fails)} FAILED:") for f in fails: print(f" - {f}") sys.exit(1) print("all checks passed")