nwp500-python 9.8.0__tar.gz → 9.9.0__tar.gz

{nwp500_python-9.8.0 → nwp500_python-9.9.0}/CHANGELOG.rst

@@ -2,6 +2,52 @@
 Changelog
 =========
 
+Version 9.9.0 (2026-10-22)
+==========================
+
+Added
+-----
+- **A bottom loss in the standby model** (#187). Over one installation's 407
+  quiet windows across ten months, a window that opens stratified loses
+  heat at the bottom: its gap widens, its lower probe falls about 40 %
+  faster than a mixed tank's, and its upper probe hardly moves. One UA
+  on the whole tank could not represent it, and the fitted UA was a
+  blend that cooled a mixed tank too fast, as after a cold season's full
+  recoveries. ``LossParams`` gains ``bottom_loss_btu_hr`` and
+  ``bottom_gate_f``: heat leaving the lower zone, of which the lower
+  probe sees ``1 - exp(-gap / gate)`` (``sim.physics.tank.
+  bottom_loss_reach``). The standby walk (``decay.project_decay``) and
+  the recovery integrator charge it to the lower zone. A bottom loss of
+  0.0, the default and what stored parameter sets carry, reproduces the
+  model before it.
+- ``sim.calibration.fit_loss`` fits the UA law and the bottom loss
+  together, through the standby walk, on the quiet windows opening with
+  a gap of 10 °F or less (``loss_windows``); ``fit_standby`` uses it.
+  On the installation above, the lower probe's median error over ten
+  hours fell from 1.25 to 0.77 °F from March to October and from 1.67
+  to 1.05 °F over the winter (1.15 °F trained without the winter).
+  ``StandbyWindow`` carries each window's probes and air, and
+  ``standby_ends`` and ``standby_error`` walk a loss over windows.
+- The report has the bottom loss and its gate, and ``keep_better``
+  judges them with the standby loss, on the probes' error in each
+  held-out window's fall, °F/h.
+
+Changed
+-------
+- The standby loss is fitted only on quiet windows opening with a gap of
+  10 °F or less: a wider gap is a draw's front closing, which the gap's
+  time constant describes.
+- ``keep_better`` scores the standby group on the probes' error in each
+  held-out window's fall, walked as the simulation walks it, in place of
+  the error in log UA, so a loss with a bottom term and one without are
+  scored alike.
+- The zone gap time constant is fitted with the bottom loss opening the
+  gaps it relaxes (``fit_gap_tau``'s ``loss``, ``gap_paths``), in turn
+  with the loss until it settles: a gap the bottom loss widens read as a
+  pure relaxation pushed the constant long. ``keep_better`` judges the
+  constant before the standby loss and fits and scores the loss on the
+  constant kept.
+
 Version 9.8.0 (2026-10-21)
 ==========================
 

{nwp500_python-9.8.0/src/nwp500_python.egg-info → nwp500_python-9.9.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nwp500-python
-Version: 9.8.0
+Version: 9.9.0
 Summary: A library for controlling Navien NWP500 Water Heaters via NaviLink
 Home-page: https://github.com/eman/nwp500-python
 Author: Emmanuel Levijarvi

{nwp500_python-9.8.0 → nwp500_python-9.9.0}/docs/explanation/simulator.rst

@@ -78,7 +78,11 @@ zone (about half the tank's mass). Once the gap between the zones
 closes, the tank heats as one body. In standby the gap relaxes on a
 fitted time constant. Standby loss follows a jacket law,
 ``UA(dT) = ua_ref * (max(dT, 5) / 50) ^ n``, with the ambient as the
-other side.
+other side, on the whole tank. A bottom loss ``Q_b`` leaves the lower
+zone alone: the lower probe sees the share ``1 - exp(-gap / gate)`` of
+it, so a stratified tank's lower zone falls faster and its gap opens,
+while a mixed tank hides it below the probe. With ``Q_b = 0`` the loss
+is the jacket law alone.
 
 **The elements.** They follow the device's own rules
 (:doc:`heating-elements`): per-mode entry thresholds, a dead time,

{nwp500_python-9.8.0 → nwp500_python-9.9.0}/docs/how-to/calibrate-simulator.rst

@@ -139,16 +139,23 @@ fitted or kept the base's value, and why:
 
    * - Term
      - Fitted from
-   * - Standby loss and its exponent
+   * - Standby loss, its exponent, the bottom loss and its gate
      - Quiet windows of 3 h or more, starting 45 minutes after any
-       heating or hot water in use. A window counts only if its fit
-       tracks the probes within 2 °F. The exponent is fitted only when
-       the windows span two 20 °F bands of tank-to-air difference; it
-       is held at 0 (a constant loss) otherwise.
+       heating or hot water in use, that open with a gap of 10 °F or
+       less between the probes. A window counts only if its fit tracks
+       the probes within 2 °F. Each window's upper and lower probe are
+       walked from its start as the simulation walks them, and the
+       terms are fitted to where the probes ended. The exponent is
+       fitted only when the windows span two 20 °F bands of tank-to-air
+       difference; it is held at 0 (a constant loss) otherwise. The
+       bottom loss needs 10 windows that open with a gap of 1 °F or
+       more; with fewer it is 0, and the loss is the jacket law
+       alone.
    * - Zone gap time constant
      - How fast the upper and lower probes' gap closes over quiet
        windows; it needs 20 windows that open with a gap of 2 °F or
-       more.
+       more. The bottom loss opens the gaps it relaxes, so the two are
+       fitted in turn until the constant settles.
    * - Compressor constant, evaporator approach
      - Heat-pump recoveries that reached their target, against the loss
        just fitted. The error is the mean absolute error of the
@@ -240,8 +247,12 @@ fit as ``params`` with ``keep_better=True``:
 
 Each group of terms holds out its latest evidence from its refit:
 
-- the standby loss and its exponent: its quiet windows;
-- the zone gap time constant: its windows that open a gap;
+- the standby loss, its exponent, the bottom loss and its gate: its
+  quiet windows, scored on the probes' error in each window's fall,
+  °F/h;
+- the zone gap time constant: its windows that open a gap, judged
+  before the standby loss, which is then fitted and scored on the
+  constant kept;
 - the compressor constant and the evaporator approach: its reached
   recoveries;
 - the power scale: the metered compressor cycles it can use;

{nwp500_python-9.8.0 → nwp500_python-9.9.0}/docs/reference/python_api/sim.rst

@@ -169,6 +169,8 @@ Hot water and the heat book
       metered_withdrawn, metered_lead,
       path_to_end, with_power, snapshots, recoveries, quiet_windows,
       busy_intervals, fit_window, fit_ua_law, fit_gap_tau, with_standby,
+      fit_loss, LossFit, loss_windows, standby_ends, standby_error,
+      walk_tau, gap_paths, gap_error,
       with_compressor, UA_SEARCH_BOUNDS, UA_EXPONENT_BOUNDS, DRAW_LEAD
 
 .. automodule:: nwp500.sim.profile
@@ -250,7 +252,7 @@ The pieces the entry points are built from.
       vapor_enthalpy, dew_point_f
 
 .. automodule:: nwp500.sim.physics.tank
-   :members: ua_at
+   :members: ua_at, bottom_loss_reach, bottom_loss_drop_f
 
 .. automodule:: nwp500.sim.physics.element
    :members: mode_recovery, ModeRecovery, mode_plan, ModePlan,

{nwp500_python-9.8.0 → nwp500_python-9.9.0}/src/nwp500/sim/api.py

@@ -78,7 +78,7 @@ from nwp500.sim.inputs import (
     Schedules,
     Settings,
 )
-from nwp500.sim.params import HeaterParams
+from nwp500.sim.params import TAU_GAP_PRIOR_H, HeaterParams
 from nwp500.sim.physics.compressor import MAX_MINUTES, predict_physics_detailed
 from nwp500.sim.physics.element import (
     DEVICE_MODE,
@@ -224,10 +224,6 @@ LOW_CONFIDENCE_FLOOR = 0.6
 #: start was never searched (the TOU-opening start still was), so an
 #: answer may miss a start the heater makes.
 HP_LOWER_ON_UNKNOWN = "hp_lower_on_unknown"
-#: The gap time constant served when the parameters carry none
-#: (``TankParams.stratification_gap_tau_h``), h: history puts it near
-#: 60 h on this product.
-TAU_GAP_PRIOR_H = 60.0
 #: Draws opened a gap that closes on that prior, not a fitted constant:
 #: under no draws it only shapes how an existing gap closes.
 TAU_GAP_PRIOR = "tau_gap_prior"

{nwp500_python-9.8.0 → nwp500_python-9.9.0}/src/nwp500/sim/calibration.py

@@ -50,7 +50,12 @@ from zoneinfo import ZoneInfo
 
 import numpy as np
 import pandas as pd
-from scipy.optimize import OptimizeResult, minimize, minimize_scalar
+from scipy.optimize import (
+    OptimizeResult,
+    least_squares,
+    minimize,
+    minimize_scalar,
+)
 
 from nwp500.sim.book import Booked, full_tank, house_gpm, is_full
 from nwp500.sim.book import Step as BookStep
@@ -61,6 +66,7 @@ from nwp500.sim.heating_trajectory import path_cop
 from nwp500.sim.inputs import ELECTRIC, ENERGY_SAVER, HIGH_DEMAND
 from nwp500.sim.params import (
     INSTALLATION_TERMS,
+    TAU_GAP_PRIOR_H,
     UA_MIN_DELTA_T_F,
     UA_REF_DELTA_T_F,
     UNFITTED_TERMS,
@@ -104,6 +110,26 @@ _BAND_WIDTH_F = 20.0
 MIN_GAP_FIT_START_F = 2.0
 MIN_GAP_FIT_WINDOWS = 20
 GAP_TAU_BOUNDS_HOURS = (1.0, 2000.0)
+#: The loss law is fitted on windows opening with a gap of at most
+#: this, °F: a wider one is a draw's front closing, the gap's constant's
+#: regime, not the standby loss's.
+MAX_LOSS_FIT_GAP_F = 10.0
+#: A window opening with at least this gap, °F, shows the bottom loss
+#: (``physics.tank``); the bottom loss is fitted only on this many.
+MIN_BOTTOM_FIT_GAP_F = 1.0
+MIN_BOTTOM_FIT_WINDOWS = 10
+#: Bounds of the bottom loss, BTU/hr, and of its gate, °F.
+BOTTOM_LOSS_BOUNDS = (0.0, 1000.0)
+BOTTOM_GATE_BOUNDS = (0.05, 30.0)
+#: The joint fit's soft_l1 scale, °F/h·√h: a window's end error
+#: per hour, weighted by the root of its hours, past which a residual
+#: counts linearly (``scipy.optimize.least_squares``' ``soft_l1``).
+_LOSS_FIT_SCALE = 0.05
+#: The gap's constant and the loss are fitted in turn
+#: (``fit_standby``) until the constant moves less than this share, or
+#: this many rounds.
+_STANDBY_ROUNDS_RTOL = 0.005
+_MAX_STANDBY_ROUNDS = 20
 
 
 def _instants(frame: pd.DataFrame) -> list[datetime]:
@@ -191,6 +217,11 @@ def quiet_windows(
     return out
 
 
+def _no_series() -> np.ndarray:
+    """An empty series: a window made without its probes."""
+    return np.zeros(0)
+
+
 @dataclass(frozen=True)
 class StandbyWindow:
     """One quiet window's fit: the UA that decays the tank's mean as
@@ -206,6 +237,12 @@ class StandbyWindow:
     #: the stratification fit's input.
     gap_hours: np.ndarray = field(repr=False)
     gap_f: np.ndarray = field(repr=False)
+    #: The probes and the air on ``gap_hours``' grid, °F: the loss law's
+    #: input (``fit_loss``). Empty, a window made without them, is not
+    #: fitted on.
+    upper_f: np.ndarray = field(default_factory=_no_series, repr=False)
+    lower_f: np.ndarray = field(default_factory=_no_series, repr=False)
+    air_f: np.ndarray = field(default_factory=_no_series, repr=False)
 
 
 def fit_window(
@@ -272,6 +309,9 @@ def fit_window(
         duration_hours=(end - start).total_seconds() / 3600.0,
         gap_hours=np.concatenate(([0.0], np.cumsum(dt_h))),
         gap_f=(wide["upper_f"] - wide["lower_f"]).to_numpy(dtype=float),
+        upper_f=wide["upper_f"].to_numpy(dtype=float),
+        lower_f=wide["lower_f"].to_numpy(dtype=float),
+        air_f=air,
     )
 
 
@@ -313,16 +353,55 @@ def fit_ua_law(
     return float(np.exp(intercept)), exponent
 
 
+def gap_paths(
+    windows: Sequence[tuple[np.ndarray, np.ndarray]],
+    tau_gap_hours: float,
+    loss: LossParams | None = None,
+    tank: TankParams = TankParams(),
+) -> list[np.ndarray]:
+    """Each window's gap, ``(hours, gap)``, as the standby walk takes it
+    from its first value: relaxing on ``tau_gap_hours``, and opened by
+    ``loss``' bottom loss (``physics.tank``) where it has one. Without
+    one, the closed form ``gap_0 exp(-t / tau)``."""
+    if loss is None or loss.bottom_loss_btu_hr <= 0.0:
+        return [g[0] * np.exp(-t / tau_gap_hours) for t, g in windows]
+    q, gate = loss.bottom_loss_btu_hr, loss.bottom_gate_f
+    lower_mass = tank.lower_zone_thermal_mass_btu_f
+    n = len(windows)
+    if n == 0:
+        return []
+    steps = max(len(g) for _, g in windows) - 1
+    dt = np.zeros((n, max(steps, 0)))
+    for i, (t, _) in enumerate(windows):
+        dt[i, : len(t) - 1] = np.diff(np.asarray(t, dtype=float))
+    gap = np.maximum(np.array([g[0] for _, g in windows], dtype=float), 0.0)
+    path = np.zeros((n, steps + 1))
+    path[:, 0] = gap
+    for j in range(steps):
+        step = dt[:, j]
+        if gate > 0.0:
+            # The bottom loss at the step's start, as the walk charges it.
+            gap = gap + q * (1.0 - np.exp(-gap / gate)) * step / lower_mass
+        gap = gap * np.exp(-step / tau_gap_hours)
+        path[:, j + 1] = gap
+    return [path[i, : len(g)] for i, (_, g) in enumerate(windows)]
+
+
 def fit_gap_tau(
     windows: Sequence[tuple[np.ndarray, np.ndarray]],
     min_start_gap_f: float = MIN_GAP_FIT_START_F,
     min_windows: int = MIN_GAP_FIT_WINDOWS,
+    *,
+    loss: LossParams | None = None,
+    tank: TankParams = TankParams(),
 ) -> tuple[float | None, int]:
     """The time constant the stratification gap relaxes on, hours: one
-    constant minimising the squared gap error of ``gap_0 exp(-t/tau)``
-    pooled over every sample of every window starting with a gap of at
-    least ``min_start_gap_f``. ``(None, n)`` with fewer than
-    ``min_windows``."""
+    constant minimising the squared gap error of ``gap_paths`` (with no
+    bottom loss, ``gap_0 exp(-t/tau)``) pooled over every sample of
+    every window starting with a gap of at least ``min_start_gap_f``.
+    ``loss``' bottom loss opens the gaps it relaxes, as the walk does,
+    so a gap it widens is not read as one relaxing slowly. ``(None, n)``
+    with fewer than ``min_windows``."""
     used = [
         (t, g)
         for t, g in windows
@@ -332,9 +411,10 @@ def fit_gap_tau(
         return None, len(used)
 
     def sse(log_tau: float) -> float:
-        tau = float(np.exp(log_tau))
+        paths = gap_paths(used, float(np.exp(log_tau)), loss, tank)
         return sum(
-            float(np.sum((g - g[0] * np.exp(-t / tau)) ** 2)) for t, g in used
+            float(np.sum((g - path) ** 2))
+            for (_, g), path in zip(used, paths, strict=True)
         )
 
     low, high = GAP_TAU_BOUNDS_HOURS
@@ -347,6 +427,225 @@ def fit_gap_tau(
     return float(np.exp(found.x)), len(used)
 
 
+def gap_error(
+    windows: Sequence[StandbyWindow],
+    tau_gap_hours: float | None,
+    loss: LossParams | None = None,
+    tank: TankParams = TankParams(),
+) -> float | None:
+    """The gap's mean squared error on ``windows``, °F², as
+    ``gap_paths`` takes it. None with no window or no constant."""
+    if not windows or tau_gap_hours is None or not tau_gap_hours > 0.0:
+        return None
+    pairs = [(w.gap_hours, w.gap_f) for w in windows]
+    paths = gap_paths(pairs, tau_gap_hours, loss, tank)
+    squared = [
+        (g - path) ** 2 for (_, g), path in zip(pairs, paths, strict=True)
+    ]
+    return float(np.mean(np.concatenate(squared)))
+
+
+def walk_tau(tank: TankParams, tau: float | None = None) -> float:
+    """The gap's constant the standby loss is walked on, hours: ``tau``,
+    else ``tank``'s, else ``TAU_GAP_PRIOR_H``, as the simulation serves
+    an unfitted one."""
+    if tau is not None:
+        return tau
+    if tank.stratification_gap_tau_h is not None:
+        return tank.stratification_gap_tau_h
+    return TAU_GAP_PRIOR_H
+
+
+def loss_windows(
+    windows: Sequence[StandbyWindow],
+) -> list[StandbyWindow]:
+    """The windows ``fit_loss`` fits on: with their probes and air,
+    opening with a gap of at most ``MAX_LOSS_FIT_GAP_F``, and a UA, a
+    ΔT and hours above zero (``fit_ua_law``'s own test)."""
+    return [
+        w
+        for w in windows
+        if len(w.upper_f) >= 2
+        and len(w.upper_f) == len(w.lower_f) == len(w.air_f)
+        and len(w.gap_hours) == len(w.upper_f)
+        and bool(np.isfinite(w.upper_f).all())
+        and bool(np.isfinite(w.lower_f).all())
+        and bool(np.isfinite(w.air_f).all())
+        and w.upper_f[0] - w.lower_f[0] <= MAX_LOSS_FIT_GAP_F
+        and w.ua_btu_hr_f > 0.0
+        and w.delta_t_mean_f > 0.0
+        and w.duration_hours > 0.0
+    ]
+
+
+def standby_ends(
+    windows: Sequence[StandbyWindow],
+    loss: LossParams,
+    tau_gap_hours: float,
+    tank: TankParams = TankParams(),
+) -> tuple[np.ndarray, np.ndarray]:
+    """Each window's upper and lower probe at its end, °F, as the
+    standby walk (``decay.project_decay``) takes them there from its
+    first reading on ``loss``: the UA law on the bulk, the bottom loss
+    on the lower zone, the gap relaxing on ``tau_gap_hours``. Windows
+    from ``loss_windows``; a UA of None is ``ua_baseline_btu_hr_f``."""
+    n = len(windows)
+    if n == 0:
+        return np.zeros(0), np.zeros(0)
+    steps = max(len(w.upper_f) for w in windows) - 1
+    dt = np.zeros((n, steps))
+    air = np.zeros((n, steps))
+    for i, w in enumerate(windows):
+        k = len(w.upper_f) - 1
+        dt[i, :k] = np.diff(np.asarray(w.gap_hours, dtype=float))
+        air[i, :k] = w.air_f[:k]
+    ua_ref = (
+        loss.ua_baseline_btu_hr_f
+        if loss.ua_btu_hr_f is None
+        else loss.ua_btu_hr_f
+    )
+    mass = tank.thermal_mass_btu_f
+    lower_mass = tank.lower_zone_thermal_mass_btu_f
+    upper0 = np.array([w.upper_f[0] for w in windows], dtype=float)
+    lower0 = np.array([w.lower_f[0] for w in windows], dtype=float)
+    bulk = (upper0 + lower0) / 2.0
+    gap = np.maximum(upper0 - lower0, 0.0)
+    q, gate = loss.bottom_loss_btu_hr, loss.bottom_gate_f
+    for j in range(steps):
+        step = dt[:, j]
+        if q > 0.0 and gate > 0.0:
+            # At the step's start, as the walk charges it.
+            drop = q * (1.0 - np.exp(-gap / gate)) * step / lower_mass
+            bulk = bulk - drop / 2.0
+            gap = gap + drop
+        delta = bulk - air[:, j]
+        if loss.ua_exponent == 0.0:
+            ua = np.full(n, ua_ref)
+        else:
+            scaled = (
+                np.maximum(np.abs(delta), UA_MIN_DELTA_T_F)
+                / loss.ua_ref_delta_t_f
+            )
+            ua = ua_ref * scaled**loss.ua_exponent
+        bulk = bulk - ua / mass * delta * step
+        gap = gap * np.exp(-step / tau_gap_hours)
+    return bulk + gap / 2.0, bulk - gap / 2.0
+
+
+def standby_error(
+    windows: Sequence[StandbyWindow],
+    loss: LossParams,
+    tau_gap_hours: float,
+    tank: TankParams = TankParams(),
+) -> float | None:
+    """The probes' mean absolute error in each window's fall, °F/h:
+    ``standby_ends`` against each window's last readings, both probes
+    alike. None with no window."""
+    if not windows:
+        return None
+    upper, lower = standby_ends(windows, loss, tau_gap_hours, tank)
+    hours = np.array([w.duration_hours for w in windows], dtype=float)
+    seen_u = np.array([w.upper_f[-1] for w in windows], dtype=float)
+    seen_l = np.array([w.lower_f[-1] for w in windows], dtype=float)
+    errors = np.concatenate(
+        [np.abs(upper - seen_u) / hours, np.abs(lower - seen_l) / hours]
+    )
+    return float(np.mean(errors))
+
+
+@dataclass(frozen=True)
+class LossFit:
+    """The loss law ``fit_loss`` found: the UA law's pair, the bottom
+    loss and its gate (0.0 and None without the evidence for them), and
+    the windows it stood on, and of those, the stratified ones."""
+
+    ua_ref: float
+    ua_exponent: float
+    bottom_loss_btu_hr: float
+    bottom_gate_f: float | None
+    n_windows: int
+    n_stratified: int
+
+
+def fit_loss(
+    windows: Sequence[StandbyWindow],
+    tau_gap_hours: float,
+    tank: TankParams = TankParams(),
+) -> LossFit | None:
+    """The standby loss on ``windows`` (``loss_windows`` of them).
+
+    With ``MIN_BOTTOM_FIT_WINDOWS`` opening with a gap of at least
+    ``MIN_BOTTOM_FIT_GAP_F``, the UA law and the bottom loss are fitted
+    together through the standby walk (``standby_ends``): each window's
+    upper and lower probe at its end against what it read, per hour,
+    weighted by the root of its hours, ``soft_l1``. A mixed window
+    holds the UA law; a stratified one, the bottom loss and its gate
+    (``physics.tank``). The exponent is fitted only where ``fit_ua_law``
+    would fit one. Without that evidence, ``fit_ua_law``'s law and no
+    bottom loss. None with no window."""
+    used = loss_windows(windows)
+    if not used:
+        return None
+    ua_ref, exponent = fit_ua_law(
+        [w.delta_t_mean_f for w in used],
+        [w.ua_btu_hr_f for w in used],
+        [w.duration_hours for w in used],
+    )
+    stratified = [
+        w for w in used if w.upper_f[0] - w.lower_f[0] >= MIN_BOTTOM_FIT_GAP_F
+    ]
+    if len(stratified) < MIN_BOTTOM_FIT_WINDOWS:
+        return LossFit(ua_ref, exponent, 0.0, None, len(used), len(stratified))
+    bands = np.floor(np.array([w.delta_t_mean_f for w in used]) / _BAND_WIDTH_F)
+    with_exponent = (
+        len(used) >= _MIN_WINDOWS_FOR_LAW
+        and len(np.unique(bands)) >= _MIN_BANDS_FOR_LAW
+    )
+    hours = np.array([w.duration_hours for w in used], dtype=float)
+    seen_u = np.array([w.upper_f[-1] for w in used], dtype=float)
+    seen_l = np.array([w.lower_f[-1] for w in used], dtype=float)
+    weight = np.sqrt(hours) / hours
+
+    def law(x: np.ndarray) -> LossParams:
+        return LossParams(
+            ua_btu_hr_f=float(x[0]),
+            ua_exponent=float(x[3]) if with_exponent else 0.0,
+            bottom_loss_btu_hr=float(x[1]),
+            bottom_gate_f=float(x[2]),
+        )
+
+    def residuals(x: np.ndarray) -> np.ndarray:
+        upper, lower = standby_ends(used, law(x), tau_gap_hours, tank)
+        return np.concatenate(
+            [(upper - seen_u) * weight, (lower - seen_l) * weight]
+        )
+
+    lo = [UA_SEARCH_BOUNDS[0], BOTTOM_LOSS_BOUNDS[0], BOTTOM_GATE_BOUNDS[0]]
+    hi = [UA_SEARCH_BOUNDS[1], BOTTOM_LOSS_BOUNDS[1], BOTTOM_GATE_BOUNDS[1]]
+    x0 = [ua_ref, 50.0, 1.0]
+    if with_exponent:
+        lo.append(UA_EXPONENT_BOUNDS[0])
+        hi.append(UA_EXPONENT_BOUNDS[1])
+        x0.append(min(max(exponent, 0.05), UA_EXPONENT_BOUNDS[1] - 0.05))
+    x0[0] = min(max(x0[0], lo[0] + 1e-6), hi[0] - 1e-6)
+    found = least_squares(
+        residuals,
+        np.array(x0, dtype=float),
+        bounds=(np.array(lo), np.array(hi)),
+        loss="soft_l1",
+        f_scale=_LOSS_FIT_SCALE,
+    )
+    fitted = law(found.x)
+    return LossFit(
+        cast(float, fitted.ua_btu_hr_f),
+        fitted.ua_exponent,
+        fitted.bottom_loss_btu_hr,
+        fitted.bottom_gate_f,
+        len(used),
+        len(stratified),
+    )
+
+
 @dataclass(frozen=True)
 class StandbyFit:
     """The standby fits: the windows kept, the law, the gap's constant,
@@ -364,6 +663,12 @@ class StandbyFit:
     #: The quiet test: ``meter`` with draws and circulation recorded,
     #: ``dhw_in_use`` without them, ``meter+dhw_in_use`` with one.
     quiet_by: str
+    #: The bottom loss and its gate (``fit_loss``): 0.0 and None
+    #: without the stratified windows to fit them on, and how many
+    #: there were.
+    bottom_loss_btu_hr: float = 0.0
+    bottom_gate_f: float | None = None
+    n_stratified: int = 0
 
 
 def fit_standby(
@@ -372,34 +677,63 @@ def fit_standby(
     *,
     min_quiet_hours: float = MIN_QUIET_HOURS,
     settle_minutes: float = SETTLE_MINUTES,
+    tank: TankParams | None = None,
+    loss: LossParams | None = None,
 ) -> StandbyFit:
-    """The standby loss law and the gap's time constant from the
-    history's quiet windows."""
+    """The standby loss and the gap's time constant from the history's
+    quiet windows: the gap's constant first, then the loss
+    (``fit_loss``) walked on it, or on ``tank``'s where too few windows
+    open with a gap to fit one. ``tank`` (default the default tank of
+    ``thermal_mass_btu_f``'s mass) is the walk's lower zone. ``loss``
+    is the loss the parameters hold: where no loss is fitted (no window
+    the loss can use), its bottom loss opens the gaps the constant is
+    fitted on, as the simulation will run them."""
+    if tank is None:
+        tank = replace(
+            TankParams(),
+            volume_gal=thermal_mass_btu_f / WATER_BTU_PER_GAL_F,
+        )
     quiet = quiet_windows(history, min_quiet_hours, settle_minutes)
     kept: list[StandbyWindow] = []
     for window in quiet:
         fit = fit_window(history, window, thermal_mass_btu_f)
         if fit is not None and fit.rmse_f < MAX_WINDOW_RMSE_F:
             kept.append(fit)
-    ua_ref = exponent = None
-    if kept:
-        ua_ref, exponent = fit_ua_law(
-            [w.delta_t_mean_f for w in kept],
-            [w.ua_btu_hr_f for w in kept],
-            # A long cold soak constrains the decay far better than a
-            # short window.
-            [w.duration_hours for w in kept],
+    # The gap's constant and the bottom loss each shape the other's
+    # evidence: the loss is walked on the constant, and the bottom loss
+    # opens the gaps the constant relaxes. Fitted in turn, the constant
+    # first on the gaps alone, until the constant settles.
+    gaps = [(w.gap_hours, w.gap_f) for w in kept]
+    tau, n_gap = fit_gap_tau(gaps)
+    found = fit_loss(kept, walk_tau(tank, tau), tank)
+    if found is None and loss is not None and loss.bottom_loss_btu_hr > 0.0:
+        # No loss to fit: the parameters keep theirs, so the constant is
+        # fitted on the gaps their bottom loss opens.
+        tau, n_gap = fit_gap_tau(gaps, loss=loss, tank=tank)
+    for _ in range(_MAX_STANDBY_ROUNDS):
+        if found is None or found.bottom_gate_f is None or tau is None:
+            break
+        opened = LossParams(
+            bottom_loss_btu_hr=found.bottom_loss_btu_hr,
+            bottom_gate_f=found.bottom_gate_f,
         )
-    tau, n_gap = fit_gap_tau([(w.gap_hours, w.gap_f) for w in kept])
+        before = tau
+        tau, n_gap = fit_gap_tau(gaps, loss=opened, tank=tank)
+        found = fit_loss(kept, walk_tau(tank, tau), tank)
+        if tau is None or abs(tau - before) <= _STANDBY_ROUNDS_RTOL * before:
+            break
     tier1 = [c for c in ("drawing", "circulating") if c in history.columns]
     return StandbyFit(
         windows=tuple(kept),
         n_quiet=len(quiet),
         n_dropped=len(quiet) - len(kept),
-        ua_ref=ua_ref,
-        ua_exponent=exponent,
+        ua_ref=None if found is None else found.ua_ref,
+        ua_exponent=None if found is None else found.ua_exponent,
         tau_gap_hours=tau,
         n_gap_windows=n_gap,
+        bottom_loss_btu_hr=0.0 if found is None else found.bottom_loss_btu_hr,
+        bottom_gate_f=None if found is None else found.bottom_gate_f,
+        n_stratified=0 if found is None else found.n_stratified,
         quiet_by=(
             "meter"
             if len(tier1) == 2
@@ -997,12 +1331,20 @@ def with_standby(params: HeaterParams, fit: StandbyFit) -> HeaterParams:
     loss, tank = params.loss, params.tank
     if fit.ua_ref is not None and fit.ua_exponent is not None:
         # Quoted at the ΔT ``fit_standby``'s law was fitted at, not
-        # whatever ``params`` held.
+        # whatever ``params`` held. The bottom loss goes with it: a law
+        # fitted without one has the bottom's heat in its UA, so the
+        # parameters' own would count it twice.
         loss = replace(
             loss,
             ua_btu_hr_f=fit.ua_ref,
             ua_exponent=fit.ua_exponent,
             ua_ref_delta_t_f=UA_REF_DELTA_T_F,
+            bottom_loss_btu_hr=fit.bottom_loss_btu_hr,
+            bottom_gate_f=(
+                loss.bottom_gate_f
+                if fit.bottom_gate_f is None
+                else fit.bottom_gate_f
+            ),
         )
     if fit.tau_gap_hours is not None:
         tank = replace(tank, stratification_gap_tau_h=fit.tau_gap_hours)
@@ -1544,7 +1886,9 @@ def calibrate(
     ``gap_tau``. ``base``'s record of the installation's terms
     (``INSTALLATION_TERMS``) is kept: they are fitted apart, and a
     caller applying its own fits drops each from ``unfitted``."""
-    standby = fit_standby(history, base.tank.thermal_mass_btu_f)
+    standby = fit_standby(
+        history, base.tank.thermal_mass_btu_f, tank=base.tank, loss=base.loss
+    )
     params = with_standby(base, standby)
     rows = snapshots(
         history, air=recovery_air, draws=draws, circulation=circulation