buzera/heating-mpc-ha
1
0 Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Treat window states unknown at startup as unknown, and continue across restarts

Browse Source 
Reproduced: with a window sensor already unavailable at startup, the
forecast assumed the window closed, exactly as for a window last seen
closed, and the first reading of an already open window was logged as a
confirmed opening.

- An opening or closing is confirmed only when witnessed: the previous
  reading was the other state with no unknown period between. A first
  reading, or a change across an outage or restart, is unconfirmed.
- Last known states, open events and recovery are saved (also whenever a
  window's state changes) and restored as unknown until the sensor
  reports; saved state for another sensor or polarity is ignored. Downtime
  counts as unknown time of an interrupted event.
- Forecast assumption per window: observed; last seen open, assumed open
  only until the configured open time after it was last seen (never
  renewed); last seen closed or never observed, no ventilation but marked
  uncertain. Status shows each window's assumption; zone forecasts list
  their uncertain windows.
- Events report a duration only when both ends are confirmed, otherwise a
  minimum (and a maximum when the opening was seen).

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
This commit is contained in:
buzeraandClaude Opus 5.5 committed 2026-10-27 04:41:28 +02:00
1 parent 49565d610a
commit 13cb972566
5 files changed
+353 -55
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

custom_components/heating_mpc/windows.py
+167 -51
View File
@@ -212,7 +212,15 @@ def _iso(timestamp: float) -> str:
class VentilationTracker:
"""Window states, ventilation inputs per zone, recovery after closing, event log."""
"""Window states, ventilation inputs per zone, recovery after closing, event log.
Each window is OPEN, CLOSED or UNKNOWN (unknown, unavailable or missing).
Unknown never means closed. The last known state is kept apart from the
current one, and an opening or closing counts as confirmed only when it was
seen: the previous reading was the other state, with no unknown period in
between. Last known states, open events and recovery are saved so a restart
or reload continues them; they come back as unknown until the sensor reports.
"""
def __init__(self, windows: list[Window], recovery_minutes: float = DEFAULT_RECOVERY_MINUTES,
saved: Any = None) -> None:
@@ -223,25 +231,24 @@ class VentilationTracker:
self._t_ref: dict[str, float | None] = {} # zone -> temperature before it opened
self._last_temps: dict[str, float | None] = {}
self._open_event: dict[str, dict[str, Any]] = {}
# window -> last known open/closed state, since when, and since when it is unknown.
# window -> last known open/closed state, since when, when it was last seen
# and since when it is unknown (None while known).
self._memory: dict[str, dict[str, Any]] = {}
self._recovery_confirmed: dict[str, bool] = {}
self._last_update: float | None = None
self._restored_at: float | None = None
self.changed = False # something worth saving happened since the last save
saved = saved if isinstance(saved, Mapping) else {}
events = saved.get("events") if isinstance(saved.get("events"), list) else []
self.events: deque[dict[str, Any]] = deque(
(e for e in events if isinstance(e, dict)), maxlen=MAX_EVENTS)
self.window_state: dict[str, dict[str, Any]] = {}
self.zone_state: dict[str, dict[str, Any]] = {}
self._restore(saved.get("state"))
def update(self, now: float, states: Mapping[str, tuple[str | None, float | None]],
temps: Mapping[str, float | None], weather: Mapping[str, float | None]) -> None:
"""One poll. `states`: window key -> (binary sensor state, last_changed timestamp).
Each window is OPEN, CLOSED or UNKNOWN (unknown/unavailable/missing). Unknown
never means closed: the last known state is kept, an open window's event
stays open, and a close that happened while the sensor was unknown is
recorded as unconfirmed.
"""
"""One poll. `states`: window key -> (binary sensor state, last_changed timestamp)."""
self.window_state = {}
zones: dict[str, dict[str, Any]] = {}
for window in self.windows:
@@ -254,7 +261,8 @@ class VentilationTracker:
if previous and changed is not None and 0 < now - previous[0] <= 900:
fraction = open_fraction(previous[1], is_open, changed, previous[0], now)
self._previous[window.key] = (now, is_open)
memory = self._memory.setdefault(window.key, {"last_known": None, "since": None, "unknown_since": None})
memory = self._memory.setdefault(window.key, {"last_known": None, "since": None, "seen": None,
"unknown_since": None})
zone = zones.setdefault(window.zone, {
"opening": 0.0, "facing_unit": 0.0, "known": True, "open_now": False, "possibly_open": False,
"open_windows": [], "last_close": None, "close_confirmed": True, "first_open": None,
@@ -268,19 +276,22 @@ class VentilationTracker:
if weather.get("wind_direction") is not None else 0.0)
if is_open is None:
if memory["unknown_since"] is None:
memory["unknown_since"] = previous[0] if previous and previous[1] is not None else now
memory["unknown_since"] = memory["seen"] if memory["seen"] is not None else now
self.changed = True
zone["unknown_windows"].append(window.name)
if memory["last_known"]:
zone["possibly_open"] = True # last seen open: still treated as open
else:
after_outage = memory["unknown_since"] is not None
if memory["last_known"] is not is_open:
if memory["last_known"] is not is_open: # a change, or the first reading
memory["since"] = changed
if is_open and after_outage:
zone["open_confirmed"] = False # opened at some point during the outage
if is_open is False and memory["last_known"] and after_outage:
zone["close_confirmed"] = False # closed at some point during the outage
memory["last_known"], memory["unknown_since"] = is_open, None
# Seen only if the previous reading was the other state, with no gap.
witnessed = memory["last_known"] is not None and memory["unknown_since"] is None
if not witnessed:
zone["open_confirmed" if is_open else "close_confirmed"] = False
self.changed = True
elif memory["unknown_since"] is not None:
self.changed = True # the same state again after a gap
memory.update(last_known=is_open, seen=now, unknown_since=None)
if is_open:
zone["open_now"] = True
zone["open_windows"].append(window.name)
@@ -290,13 +301,21 @@ class VentilationTracker:
zone["last_close"] = max(zone["last_close"] or 0.0, changed)
self.window_state[window.key] = {
"open": is_open, "since": changed, "last_known_open": memory["last_known"],
"last_known_since": memory["since"], "unknown_since": memory["unknown_since"],
"last_known_since": memory["since"], "seen": memory["seen"],
"unknown_since": memory["unknown_since"],
"relative_wind_direction": (round(angle_difference(weather["wind_direction"], window.azimuth), 1)
if weather.get("wind_direction") is not None else None)}
# Time the integration was not running counts as unknown for events it interrupted.
gap = now - self._restored_at if self._restored_at is not None else 0.0
self._restored_at = None
for key, zone in zones.items():
if gap > 330 and key in self._open_event:
event = self._open_event[key]
event["sensor_unknown_minutes"] = round(event.get("sensor_unknown_minutes", 0.0) + gap / 60, 1)
self._update_zone(now, key, zone, temps.get(key), weather, zones)
self.zone_state = zones
self._last_temps = dict(temps)
self._last_update = now
def _update_zone(self, now: float, key: str, zone: dict[str, Any], temp: float | None,
weather: Mapping[str, float | None], zones: Mapping[str, dict[str, Any]]) -> None:
@@ -314,32 +333,41 @@ class VentilationTracker:
"wind_direction": weather.get("wind_direction"), "wind_gust": weather.get("wind_gust"),
"windows": list(zone["open_windows"]),
"other_open_windows": [n for k, z in zones.items() if k != key for n in z["open_windows"]],
"lowest_temperature": temp, "sensor_unknown_minutes": 0.0,
"lowest_temperature": temp, "sensor_unknown_minutes": 0.0, "last_seen_open": _iso(now),
}
if not zone["open_confirmed"]:
self._t_ref[key] = None # the room may already have cooled before we saw it
self.changed = True
elif ventilating and was_open:
event = self._open_event[key]
if temp is not None:
event["lowest_temperature"] = min(t for t in (event["lowest_temperature"], temp) if t is not None)
if zone["unknown_windows"]:
event["sensor_unknown_minutes"] = round(event["sensor_unknown_minutes"] + 5.0, 1)
if zone["open_now"]:
event["last_seen_open"] = _iso(now)
elif was_open and not ventilating:
event = self._open_event.pop(key)
if zone["close_confirmed"]:
closed = zone["last_close"] or now
event.update(closed=_iso(closed), closed_confirmed=True,
duration_minutes=round((closed - _parse(event["opened"])) / 60, 1))
else:
# Closed while the sensor was unknown: no confirmed time, only a range.
closed = now
event.update(closed=None, closed_confirmed=False, closed_reported=_iso(now),
duration_minutes=None,
duration_max_minutes=round((now - _parse(event["opened"])) / 60, 1))
opened = _parse(event["opened"]) # the confirmed opening, or when it was first seen open
seen_open = _parse(event.get("last_seen_open", event["opened"]))
closed = zone["last_close"] or now if zone["close_confirmed"] else now
confirmed = zone["close_confirmed"] and event.get("opened_confirmed", True)
# Uncertain periods give a range instead of a duration.
event.update(
closed=_iso(closed) if zone["close_confirmed"] else None,
closed_confirmed=zone["close_confirmed"],
duration_minutes=round((closed - opened) / 60, 1) if confirmed else None,
duration_min_minutes=round(((closed if zone["close_confirmed"] else seen_open) - opened) / 60, 1),
duration_max_minutes=(round((now - opened) / 60, 1)
if not zone["close_confirmed"] and event.get("opened_confirmed", True)
else None))
if not zone["close_confirmed"]:
event["closed_reported"] = _iso(now) # closed at some point before this
self._closed_at[key] = closed
self._recovery_confirmed[key] = zone["close_confirmed"] and event.get("opened_confirmed", True)
self._recovery_confirmed[key] = confirmed
event["temperature_at_close"] = temp
self.events.append(event)
self.changed = True
elif not ventilating and key in self._closed_at and temp is not None:
# Fill in the temperature half an hour after closing, for recovery review.
for event in reversed(self.events):
@@ -374,43 +402,131 @@ class VentilationTracker:
"affected": zone["affected"], "known": known,
"unknown_windows": list(zone["unknown_windows"])}
def assumption(self, window: Window, open_minutes: float, now: float) -> dict[str, Any]:
"""What forecasts assume for one window, and on what basis.
Observed open: open for `open_minutes` more. Unknown but last seen open: open
until `open_minutes` after it was last seen, never renewed, so an unavailable
sensor does not keep a window open forever. Unknown otherwise: no ventilation,
marked uncertain (`last_known_closed`, or `unobserved` with no reading at all).
"""
state = self.window_state.get(window.key, {})
if state.get("open"):
return {"basis": "observed", "open_minutes": float(open_minutes), "uncertain": False}
if state.get("open") is False:
return {"basis": "observed", "open_minutes": 0.0, "uncertain": False}
if state.get("last_known_open"):
seen = state.get("seen")
left = open_minutes - (now - seen) / 60 if seen is not None else 0.0
return {"basis": "last_known_open", "open_minutes": round(max(0.0, left), 1), "uncertain": True,
"assumed_closed_at": seen + open_minutes * 60 if seen is not None else now}
basis = "last_known_closed" if state.get("last_known_open") is False else "unobserved"
return {"basis": basis, "open_minutes": 0.0, "uncertain": True}
def forecast(self, key: str, steps: int, open_minutes: float, weather: Mapping[str, float | None],
now: float) -> list[dict[str, Any]]:
"""Assumed ventilation inputs per forecast step.
"""Assumed ventilation inputs per forecast step (see `assumption`).
Windows open now (or unknown but last seen open) are assumed to close after
`open_minutes` (at least one step); after that the zone recovers. Weather
is held at current values.
Each window open now, or assumed open, closes after its assumed time; once
the last one has closed the zone recovers. Weather is held at current values.
"""
zone = self.zone_state.get(key)
if zone is None:
return [{} for _ in range(steps)]
windows = [w for w in self.windows if w.zone == key and w.enabled
and (self.window_state.get(w.key, {}).get("open")
or (self.window_state.get(w.key, {}).get("open") is None
and self.window_state.get(w.key, {}).get("last_known_open")))]
opening = sum(w.opening for w in windows)
facing = sum(w.opening * facing_cos(weather["wind_direction"], w.azimuth) for w in windows) \
if weather.get("wind_direction") is not None else 0.0
open_steps = max(1, round(open_minutes / 5)) if windows else 0
closed_at = self._closed_at.get(key)
windows = [w for w in self.windows if w.zone == key and w.enabled]
assumed = {w.key: self.assumption(w, open_minutes, now) for w in windows}
# Steps each window stays open: at least one for an observed open window.
open_steps = {w.key: (max(1, round(open_minutes / 5)) if self.window_state.get(w.key, {}).get("open")
else round(assumed[w.key]["open_minutes"] / 5)) for w in windows}
direction = weather.get("wind_direction")
last_open = max(open_steps.values(), default=0)
if last_open:
start = now + last_open * 300.0
else:
# Recovery from the last close: observed, or assumed for a window last seen open.
closes = [a["assumed_closed_at"] for a in assumed.values() if "assumed_closed_at" in a]
closed_at = self._closed_at.get(key)
start = max([t for t in (closed_at, *closes) if t is not None], default=None)
result = []
for k in range(steps):
t = now + (k + 1) * 300.0
if k < open_steps:
result.append({"opening": opening, "facing": facing, "recovery": 0.0, "t_ref": zone["t_ref"],
"other_opening": zone["other_opening"], "wind": weather.get("wind") or 0.0,
"gust": weather.get("wind_gust") or weather.get("wind") or 0.0})
open_now = [w for w in windows if k < open_steps[w.key]]
if open_now:
result.append({
"opening": sum(w.opening for w in open_now),
"facing": (sum(w.opening * facing_cos(direction, w.azimuth) for w in open_now)
if direction is not None else 0.0),
"recovery": 0.0, "t_ref": zone["t_ref"], "other_opening": zone["other_opening"],
"wind": weather.get("wind") or 0.0,
"gust": weather.get("wind_gust") or weather.get("wind") or 0.0})
continue
start = now + open_steps * 300.0 if windows else closed_at
recovery = exp(-(t - start) / self.tau) if start is not None else 0.0
recovery = exp(-(t - start) / self.tau) if start is not None and t > start else 0.0
result.append({"opening": 0.0, "facing": 0.0, "other_opening": 0.0, "wind": 0.0, "gust": 0.0,
"recovery": recovery if recovery >= RECOVERY_THRESHOLD else 0.0,
"t_ref": zone["t_ref"]})
return result
def as_dict(self) -> dict[str, Any]:
return {"events": list(self.events)}
"""Events, plus the state a restart or reload needs to continue them."""
windows = {w.key: w for w in self.windows if w.enabled}
state = {
"time": self._last_update,
"windows": {key: {"sensor": windows[key].sensor, "inverted": windows[key].inverted,
"last_known": m["last_known"], "since": m["since"], "seen": m["seen"]}
for key, m in self._memory.items()
if key in windows and m["last_known"] is not None and m["seen"] is not None},
"zones": {zone: {"open_event": self._open_event.get(zone), "closed_at": self._closed_at.get(zone),
"recovery_confirmed": self._recovery_confirmed.get(zone, True),
"t_ref": self._t_ref.get(zone)}
for zone in {w.zone for w in windows.values()}
if zone in self._open_event or zone in self._closed_at},
}
return {"events": list(self.events), "state": state}
def _restore(self, state: Any) -> None:
"""Continue from saved state. Nothing restored is live: every window is unknown
from when it was last seen until its sensor reports again."""
if not isinstance(state, Mapping):
return
windows = {w.key: w for w in self.windows if w.enabled}
saved_windows = state.get("windows") if isinstance(state.get("windows"), Mapping) else {}
for key, item in saved_windows.items():
window = windows.get(key)
if (window is None or not isinstance(item, Mapping) or item.get("sensor") != window.sensor
or item.get("inverted") is not window.inverted or not isinstance(item.get("last_known"), bool)
or not _finite(item.get("seen"))):
continue # another sensor now, or polarity flipped: nothing carries over
seen = float(item["seen"])
self._memory[key] = {"last_known": item["last_known"], "seen": seen, "unknown_since": seen,
"since": float(item["since"]) if _finite(item.get("since")) else None}
remembered_open = {windows[key].zone for key, m in self._memory.items() if m["last_known"]}
saved_zones = state.get("zones") if isinstance(state.get("zones"), Mapping) else {}
for zone, item in saved_zones.items():
if zone not in {w.zone for w in windows.values()} or not isinstance(item, Mapping):
continue
event = item.get("open_event")
# An open event continues only while one of its windows is remembered open.
if isinstance(event, dict) and zone in remembered_open and _valid_iso(event.get("opened")):
self._open_event[zone] = dict(event)
if _finite(item.get("closed_at")):
self._closed_at[zone] = float(item["closed_at"])
self._recovery_confirmed[zone] = item.get("recovery_confirmed") is True
if _finite(item.get("t_ref")):
self._t_ref[zone] = float(item["t_ref"])
if self._open_event and _finite(state.get("time")):
self._restored_at = float(state["time"])
def _finite(value: Any) -> bool:
return isinstance(value, (int, float)) and not isinstance(value, bool) and isfinite(value)
def _valid_iso(value: Any) -> bool:
try:
datetime.fromisoformat(value)
return True
except (TypeError, ValueError):
return False
def _parse(iso: str) -> float: