Files
cantabile-ha-addons/src/edge/cantabile_edge/rcfit.py
T

137 lines
6.2 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
# Copyright © 2026 Setti Solutions S.R.L, www.setti.md. All rights reserved.
"""A room's thermal resistance R and capacity C from its history
(docs/methods.md §6): the planner's first-order model (edge optimizer.py
`room`),
θ_t = (1 − a) θ_{t−1} + a T_out,t + (Δt/C) P_t + γ G_t + c0,
a = Δt / (R C),
written as a regression on 15-minute steps (Δt = 0.25 h):
θ_t − θ_{t−1} = a (T_out,t − θ_{t−1}) + b P_t + γ G_t + c0, b = Δt / C,
with P the heating power (kW; thermal where the site meters the heat
output, else electric: the planner's COP turns that into heat), G the
global irradiance (kW/m², the sun through the windows) and c0 the internal
gains (people, appliances). Least squares on every step where all inputs
are there; then C = Δt / b, R = Δt / (a C).
The other two terms go to the planner with R and C (Finding B6-a: R and C
were fitted with them; without them the planner expects the room to cool
faster than it does), as heat in the same units as P:
gain_w = 1000 c0 / b the internal gain (W, constant),
solar_m2 = γ / b the sun's heat per irradiance (m²: W of heat
per W/m² of global irradiance, an effective
window area).
(electric fits: W and m² of electric equivalent; the box multiplies by
the COP like C.)
Sanity before a fit is used (else the planner keeps its defaults, R 10
K/kW and C 3 kWh/K): a > 0 and b > 0; R within 1..100 K/kW, C within
0.3..50 kWh/K, τ = RC within 3..1000 h; at least a day of steps, the
heating on and off in it, 2 K of spread in T_out − θ; and the fitted
model simulates the room better than the defaults do (4-hour open-loop
runs from every 4th hour: RMSE in K).
The site's heating power is used for every room (the sims: one zone per
home): the rooms of a home with one heat meter each get the whole
home's C. Per-room heating power, where metered per control, is the
next step."""
from __future__ import annotations
import math
import numpy as np
DT_H = 0.25
DEFAULT_R, DEFAULT_C = 10.0, 3.0
R_BOUNDS, C_BOUNDS, TAU_BOUNDS = (1.0, 100.0), (0.3, 50.0), (3.0, 1000.0)
MIN_STEPS = 96
SIM_STEPS = 16
SIM_EVERY = 16
def simulate(theta0: float, tout: np.ndarray, p_kw: np.ndarray, ghi_kw: np.ndarray, r: float, c: float,
gamma: float = 0.0, c0: float = 0.0) -> np.ndarray:
a, b = DT_H / (r * c), DT_H / c
out, th = [], theta0
for k in range(len(tout)):
th = (1 - a) * th + a * tout[k] + b * p_kw[k] + gamma * ghi_kw[k] + c0
out.append(th)
return np.array(out)
def sim_rmse(theta: np.ndarray, tout: np.ndarray, p_kw: np.ndarray, ghi_kw: np.ndarray, r: float, c: float,
gamma: float = 0.0, c0: float = 0.0) -> float | None:
"""4-hour open-loop runs from every 4th hour where all inputs exist."""
errs = []
for s in range(0, len(theta) - SIM_STEPS - 1, SIM_EVERY):
seg = slice(s + 1, s + 1 + SIM_STEPS)
if np.isnan(theta[s]) or np.isnan(theta[seg]).any() or np.isnan(tout[seg]).any() or np.isnan(p_kw[seg]).any():
continue
sim = simulate(theta[s], tout[seg], p_kw[seg], np.nan_to_num(ghi_kw[seg]), r, c, gamma, c0)
errs.append((sim - theta[seg]) ** 2)
if not errs:
return None
return float(math.sqrt(np.concatenate(errs).mean()))
def fit(theta: np.ndarray, tout: np.ndarray, p_w: np.ndarray, ghi: np.ndarray | None = None,
power: str = "thermal") -> dict:
"""theta, tout (°C), p_w (W), ghi (W/m²) per 15-minute slot, aligned.
Returns {"status": "fitted"|"default", r_k_per_kw, c_kwh_per_k, tau_h,
power, n, rmse_k (simulation, fitted), rmse_default_k, r2, note}, and
when fitted gain_w and solar_m2 (the module's docstring)."""
n_all = len(theta)
ghi = np.zeros(n_all) if ghi is None else np.where(np.isnan(ghi), 0.0, ghi)
p_kw = p_w / 1000.0
g_kw = ghi / 1000.0
prev = np.concatenate([[np.nan], theta[:-1]])
dy = theta - prev
x1 = tout - prev
ok = ~(np.isnan(dy) | np.isnan(x1) | np.isnan(p_kw))
out = {"status": "default", "r_k_per_kw": DEFAULT_R, "c_kwh_per_k": DEFAULT_C, "tau_h": DEFAULT_R * DEFAULT_C,
"power": power, "n": int(ok.sum()), "rmse_k": None, "rmse_default_k": None, "r2": None, "note": ""}
if ok.sum() < MIN_STEPS:
out["note"] = f"{int(ok.sum())} usable steps (at least {MIN_STEPS})"
return out
on = p_kw[ok] > 0.05
if on.all() or not on.any():
out["note"] = "the heating was never " + ("off" if on.all() else "on") + " in the data"
return out
if np.ptp(x1[ok]) < 2.0:
out["note"] = "less than 2 K between outside and inside"
return out
X = np.column_stack([x1[ok], p_kw[ok], g_kw[ok], np.ones(int(ok.sum()))])
coef, *_ = np.linalg.lstsq(X, dy[ok], rcond=None)
a, b, gamma, c0 = (float(v) for v in coef)
resid = dy[ok] - X @ coef
var = float(np.var(dy[ok]))
out["r2"] = round(1 - float(np.var(resid)) / var, 3) if var > 0 else None
if a <= 0 or b <= 0:
out["note"] = f"no physical fit (a {a:.4g}, b {b:.4g})"
return out
c = DT_H / b
r = DT_H / (a * c)
tau = r * c
out["fit"] = {"a": a, "b": b, "gamma": gamma, "c0": c0}
if not (R_BOUNDS[0] <= r <= R_BOUNDS[1] and C_BOUNDS[0] <= c <= C_BOUNDS[1] and TAU_BOUNDS[0] <= tau <= TAU_BOUNDS[1]):
out["note"] = f"outside the sanity bounds (R {r:.3g} K/kW, C {c:.3g} kWh/K, τ {tau:.3g} h)"
return out
fitted = sim_rmse(theta, tout, p_kw, g_kw, r, c, gamma, c0)
default = sim_rmse(theta, tout, p_kw, g_kw, DEFAULT_R, DEFAULT_C)
out["rmse_default_k"] = round(default, 3) if default is not None else None
out["rmse_k"] = round(fitted, 3) if fitted is not None else None
if fitted is None or default is None:
out["note"] = "too few complete 4-hour stretches to check the fit"
return out
if fitted >= default:
out["note"] = f"no better than the defaults ({fitted:.2f} K vs {default:.2f} K)"
return out
out.update(status="fitted", r_k_per_kw=round(r, 3), c_kwh_per_k=round(c, 3), tau_h=round(tau, 2),
gain_w=round(1000.0 * c0 / b, 1), solar_m2=round(gamma / b, 3),
note=f"simulates the room to {fitted:.2f} K (defaults {default:.2f} K)")
return out