MAINT-28 fix-forward round 4: the paused pack's cap is its own part of the guard's floor, the largest of the period, per unit
Owner 2026-11-13 ("ok max", relayed by the manager): while the pause holds,
the pack in maintenance CHARGE gives at most the largest floor the guard
claimed in the quarter. The cap is now that pack's own part of the floor
(the floor less what the other units are placed at, split without the cap),
the largest in the 15-minute period, kept per unit (`_m28_hi`). 0 W while
the guard holds it at its reserve. test_maint28b: SoC check stated against
the owner-accepted give (0.70 point, measured 0.64); both-packs-able tests
(B on Cheap hours, B on Solar first); per-unit state and the one-slot
arbitrate. test_maint28 unchanged (5925 W). Pins: test_safety84
n2_charge_banked, test_packshare's one-resolve AST pin (a second call with
the same weights).
Co-Authored-By: Claude <noreply@anthropic.com>
This commit is contained in:
co-authored by
Claude
parent
fb4a449591
commit
07d23d2eed
@@ -16,10 +16,13 @@ peak forecast like the live sensor, house +-50 W every 5 s, 3000 W then
|
||||
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: while the pause holds, A gives only what the peak guard
|
||||
claims, at any SoC (never under its reserve, SoC barely drops); with the
|
||||
other pack under its reserve and a house too big for it, A still gives for
|
||||
the guard.
|
||||
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
|
||||
@@ -33,6 +36,7 @@ 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)
|
||||
@@ -41,7 +45,8 @@ 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, peakguard, tariff # noqa: E402
|
||||
from app import (ctl_cycle, ctl_trade, freshness, maintenance, # noqa: E402
|
||||
packmode, peakguard, tariff)
|
||||
|
||||
fails = []
|
||||
|
||||
@@ -115,10 +120,22 @@ def scen(*, unit="a", soc=49.0, other=30.0, house=None, house_w=3000.0,
|
||||
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)]
|
||||
@@ -190,7 +207,8 @@ check("after the load A's charge is back within 20 cycles (1 s each: a 10 s "
|
||||
back is not None and back <= 20)
|
||||
|
||||
# ============================================================================ #
|
||||
print("\n2. the cap: while the pause holds, A gives only what the guard claims")
|
||||
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)",
|
||||
@@ -200,8 +218,13 @@ check("A never goes under its peak reserve in the peak (rig: to 10 %)",
|
||||
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)
|
||||
check("A at 49 %: its SoC barely drops (under 1 point; f3f9483 6.1)",
|
||||
soc_start - min(r["soc"] for r in rows if r["t"] >= PRE) < 1.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]
|
||||
@@ -213,6 +236,55 @@ 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 "
|
||||
@@ -328,6 +400,26 @@ 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:")
|
||||
|
||||
Reference in New Issue
Block a user