ecoengine 3.3.0__tar.gz → 3.3.2__tar.gz

{ecoengine-3.3.0 → ecoengine-3.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ecoengine
-Version: 3.3.0
+Version: 3.3.2
 Requires-Python: >=3.11
 Requires-Dist: numpy<3.0,>=2.4
 Requires-Dist: scipy<2.0,>=1.17

{ecoengine-3.3.0 → ecoengine-3.3.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ecoengine"
-version = "3.3.0"
+version = "3.3.2"
 requires-python = ">=3.11"
 
 # Ranges are bounded on purpose, and the shared ones are kept in sync with

ecoengine-3.3.2/src/ecoengine/constants/constants.py

@@ -0,0 +1,18 @@
+# Volumetric heat capacity of water [BTU / (gallon · °F)]
+_RHO_CP: float = 8.353535
+
+# Unit conversion: 1 W = 3.412142 BTU/hr  (equivalently, 1 kW = 3.412142 kBTU/hr)
+_BTUH_PER_W: float = 3.412142
+
+# Default Nominal COPs
+_ELECTRIC_RESISTANCE_COP = 0.95
+_GAS_COP = 0.95 # ER equivellant
+_HEAT_PUMP_COP = 2.5
+
+# Nominal COP by water heater heating type (used by NominalPerformanceMap)
+_NOMINAL_COP_BY_HEATING_TYPE: dict[str, float] = {
+    "electric_resistance": _ELECTRIC_RESISTANCE_COP,
+    "gas":                 _GAS_COP,
+    "heat_pump":           _HEAT_PUMP_COP,
+}
+_HEATING_TYPES: tuple[str, ...] = tuple(_NOMINAL_COP_BY_HEATING_TYPE)

{ecoengine-3.3.0 → ecoengine-3.3.2}/src/ecoengine/interfaces/EcoBuilder.py

@@ -26,6 +26,7 @@ from __future__ import annotations
 
 import warnings
 
+from ecoengine.constants.constants import _HEATING_TYPES
 from ecoengine.objects.building.Building import Building
 from ecoengine.objects.components.heating.Controls import AlwaysOffControls, Controls
 from ecoengine.objects.components.heating.PerformanceMap import (
@@ -46,7 +47,6 @@ from .system_assembly_utils import (
 )
 
 _SYSTEM_SLOTS  = ("primary", "tm", "in_series")
-_FUEL_TYPES    = ("electric", "gas")
 _MP_SCHEMATICS = frozenset({"multi_pass_rtp", "mprtp_in_series"})
 
 # assemble_dhw_system argument name → EcoBuilder field name (for error messages)
@@ -76,7 +76,7 @@ class EcoBuilder:
     water_heaters : list[WaterHeater]
         Heaters heating the primary storage tank. For ``sprtp_in_parallel``
         this list also holds the single gas backup heater
-        (``fuel_type='gas'``).
+        (``heating_type='gas'``).
     tm_water_heaters : list[WaterHeater]
         Heaters for the temperature-maintenance tank, if applicable.
     in_series_water_heaters : list[WaterHeater]
@@ -217,7 +217,8 @@ class EcoBuilder:
             minimum OAT.
         nominal_capacity_kbtuh : float, optional
             Without ``model_name``: the constant total capacity [kBTU/hr] of a
-            ``NominalPerformanceMap``.
+            ``NominalPerformanceMap``. Its power input uses the nominal COP
+            of the heater's ``heating_type``, set in ``build_water_heater()``.
         num_units : int
             Number of identical units (model maps only). Default 1.
         design_inlet_temp_f : float
@@ -337,7 +338,7 @@ class EcoBuilder:
         performance_map: PerformanceMap,
         control_schedule: list[str],
         control_map: dict[str, Controls],
-        fuel_type: str = "electric",
+        heating_type: str = "heat_pump",
         system: str | None = "primary",
     ) -> WaterHeater:
         """
@@ -351,8 +352,10 @@ class EcoBuilder:
             24-element schedule, e.g. from ``build_control_schedule()``.
         control_map : dict[str, Controls]
             Controls for every mode in ``control_schedule``.
-        fuel_type : str
-            ``'electric'`` or ``'gas'``.
+        heating_type : str
+            ``'heat_pump'`` (default), ``'electric_resistance'`` or ``'gas'``.
+            With a nominal performance map this sets the nominal COP used
+            for power input.
         system : str | None
             ``'primary'`` → ``water_heaters``, ``'tm'`` → ``tm_water_heaters``,
             ``'in_series'`` → ``in_series_water_heaters``, None → not added
@@ -361,15 +364,15 @@ class EcoBuilder:
         Raises
         ------
         ValueError
-            On an unknown ``system`` or ``fuel_type``, a schedule that is not
+            On an unknown ``system`` or ``heating_type``, a schedule that is not
             24 entries long, or schedule modes missing from ``control_map``.
         TypeError
             If ``performance_map`` is not a PerformanceMap.
         """
         if system is not None and system not in _SYSTEM_SLOTS:
             raise ValueError(f"system must be one of {_SYSTEM_SLOTS} or None, got {system!r}.")
-        if fuel_type not in _FUEL_TYPES:
-            raise ValueError(f"fuel_type must be one of {_FUEL_TYPES}, got {fuel_type!r}.")
+        if heating_type not in _HEATING_TYPES:
+            raise ValueError(f"heating_type must be one of {_HEATING_TYPES}, got {heating_type!r}.")
         if not isinstance(performance_map, PerformanceMap):
             raise TypeError(
                 "performance_map must be a PerformanceMap; use build_performance_map()."
@@ -386,7 +389,7 @@ class EcoBuilder:
             performance_map  = performance_map,
             control_schedule = list(control_schedule),
             control_map      = dict(control_map),
-            fuel_type        = fuel_type,
+            heating_type     = heating_type,
         )
         if system is not None:
             getattr(self, "water_heaters" if system == "primary" else f"{system}_water_heaters").append(heater)
@@ -435,7 +438,7 @@ class EcoBuilder:
         Schematic notes
         ---------------
         * ``sprtp_in_parallel``: exactly one primary heater must have
-          ``fuel_type='gas'``; it becomes the gas backup heater.
+          ``heating_type='gas'``; it becomes the gas backup heater.
         * ``parallel_loop``: the TM tank's cycling temperatures are taken
           from the TM heater's hour-0 controls (``on_trigger_t_f`` /
           ``off_trigger_t_f``).
@@ -456,11 +459,11 @@ class EcoBuilder:
         primary_heaters = list(self.water_heaters)
         gas_heater = None
         if name == "sprtp_in_parallel":
-            gas_heaters = [wh for wh in primary_heaters if wh.fuel_type == "gas"]
+            gas_heaters = [wh for wh in primary_heaters if wh.heating_type == "gas"]
             if len(gas_heaters) != 1:
                 raise ValueError(
                     "sprtp_in_parallel requires exactly one primary heater with "
-                    f"fuel_type='gas'; found {len(gas_heaters)}."
+                    f"heating_type='gas'; found {len(gas_heaters)}."
                 )
             gas_heater      = gas_heaters[0]
             primary_heaters = [wh for wh in primary_heaters if wh is not gas_heater]

{ecoengine-3.3.0 → ecoengine-3.3.2}/src/ecoengine/interfaces/EcosizerEngine.py

@@ -1265,8 +1265,19 @@ class EcosizerEngine:
                 f"Schematic '{self.schematic}' requires gas_storage_vol_gal in pre-sized mode."
             )
 
-    def _build_tm_water_heater(self, tm_controls, force_electric_resistance : bool = False):
-        """Build the TM WaterHeater (single unit) from tm_model or tm_capacity_kbtuh."""
+    def _build_tm_water_heater(
+        self,
+        tm_controls,
+        force_electric_resistance: bool = False,
+        nominal_heating_type: str = "electric_resistance",
+    ):
+        """
+        Build the TM WaterHeater (single unit) from tm_model or tm_capacity_kbtuh.
+
+        ``nominal_heating_type`` sets the heating type of a nominal-capacity TM
+        heater: ``'electric_resistance'`` for TM elements, ``'gas'`` for the
+        ``swing_dual_fuel`` gas swing tank.
+        """
         from ecoengine.objects.components.heating.WaterHeater import WaterHeater
         if force_electric_resistance:
             self.num_tm_heaters = 1
@@ -1288,6 +1299,7 @@ class EcosizerEngine:
             nominal_capacity_kbtuh=per_unit_kbtuh,
             control_schedule=["normal"] * 24,
             control_map={"normal": tm_controls},
+            heating_type=nominal_heating_type,
         )
 
     def _build_presized_dhw_system(self):
@@ -1369,9 +1381,12 @@ class EcosizerEngine:
             tm_controls = default_tm_controls(
                 schematic, self.supply_temp_f, self.tm_on_temp_f, self.tm_off_temp_f
             )
-            # Swing variants always use an electric-resistance TM element
+            # Swing variants always use a nominal TM element: electric
+            # resistance for swing_tank, gas for the swing_dual_fuel swing tank.
             tm_water_heater = self._build_tm_water_heater(
-                tm_controls, force_electric_resistance=(schematic != "parallel_loop")
+                tm_controls,
+                force_electric_resistance=(schematic != "parallel_loop"),
+                nominal_heating_type="gas" if schematic == "swing_dual_fuel" else "electric_resistance",
             )
 
         gas_water_heater = None
@@ -1385,6 +1400,7 @@ class EcosizerEngine:
                 nominal_capacity_kbtuh=self.gas_capacity_kbtuh,
                 control_schedule=["normal"] * 24,
                 control_map={"normal": gas_controls},
+                heating_type="gas",
             )
 
         system = assemble_dhw_system(
@@ -1536,6 +1552,58 @@ class EcosizerEngine:
         """
         return {"monthly_energy_kwh": simulation_run.get_monthly_energy_kwh()}
 
+    def get_parameters(self) -> dict:
+        """
+        Return every public engine field and its current value.
+
+        Private fields (``_building``, ``_dhw_system``) are left out; use
+        ``print_parameters()`` to also see the built system's heaters and tanks.
+
+        Returns
+        -------
+        dict
+            ``{field_name: value}`` in the order the fields were set.
+        """
+        return {k: v for k, v in vars(self).items() if not k.startswith("_")}
+
+    def print_parameters(self, include_system: bool = True) -> None:
+        """
+        Print every public engine field and its current value, for debugging.
+
+        Parameters
+        ----------
+        include_system : bool
+            Also print the built DHWSystem: class, storage tanks, and for each
+            heater its role, heating type, performance map class, model name
+            and nominal capacity. Default True.
+        """
+        params = self.get_parameters()
+        width  = max(len(k) for k in params)
+        print("EcosizerEngine parameters")
+        for k, v in params.items():
+            print(f"  {k:<{width}} = {v!r}")
+
+        if not include_system or self._dhw_system is None:
+            return
+        system = self._dhw_system
+        print(f"Built system: {type(system).__name__}")
+        for attr in ("storage_tank", "tm_storage_tank", "gas_storage_tank"):
+            tank = getattr(system, attr, None)
+            if tank is not None:
+                print(f"  {attr}: {type(tank).__name__}, "
+                      f"{getattr(tank, 'total_volume_gal', None)} gal")
+        heaters = [("primary", wh) for wh in getattr(system, "water_heaters", None) or []]
+        for role, attr in (("tm", "tm_water_heater"), ("gas", "gas_water_heater")):
+            wh = getattr(system, attr, None)
+            if wh is not None:
+                heaters.append((role, wh))
+        for role, wh in heaters:
+            pm = wh.performance_map
+            print(f"  {role} heater: heating_type={wh.heating_type!r}, "
+                  f"map={type(pm).__name__}, model={getattr(pm, 'model_name', '') or None!r}, "
+                  f"nominal_capacity_kbtuh={getattr(pm, 'nominal_capacity_kbtuh', None)!r}, "
+                  f"num_units={getattr(pm, 'num_units', None)!r}")
+
     def get_hw_magnitude(self) -> float:
         """
         Return the total daily DHW usage for the building [gallons at supply temperature].

{ecoengine-3.3.0 → ecoengine-3.3.2}/src/ecoengine/objects/components/heating/PerformanceMap.py

@@ -4,8 +4,9 @@ import json
 import math
 import os
 import pickle
+from typing import Literal
 
-from ecoengine.constants.constants import _BTUH_PER_W
+from ecoengine.constants.constants import _BTUH_PER_W, _NOMINAL_COP_BY_HEATING_TYPE
 
 # Bundled data directory — used as a fallback when perf_map_dir is not supplied.
 # Will be removed once the data is fully externalised.
@@ -60,9 +61,9 @@ class PerformanceMap:
         - ``PklPerformanceMap``    — pickle-based LinearND interpolator (lab data)
         - ``HPWHsimPerformanceMap``— coefficient-based polynomial (HPWHsim model)
 
-    * ``NominalPerformanceMap(nominal_capacity_kbtuh)``
-        Constant-output placeholder for use during preliminary sizing.
-        **Do not change this subclass.**
+    * ``NominalPerformanceMap(nominal_capacity_kbtuh, heating_type)``
+        Constant-output placeholder for use during preliminary sizing. Power
+        input uses a fixed nominal COP for the heating type.
 
     API notes
     ---------
@@ -236,7 +237,7 @@ class PerformanceMap:
 
 
 # ---------------------------------------------------------------------------
-# NominalPerformanceMap — constant-output placeholder (do not change)
+# NominalPerformanceMap — constant-output placeholder
 # ---------------------------------------------------------------------------
 
 class NominalPerformanceMap(PerformanceMap):
@@ -247,10 +248,16 @@ class NominalPerformanceMap(PerformanceMap):
     Every capacity query returns the fixed nominal_capacity_kbtuh regardless of
     outdoor air temperature or water temperature — analogous to how
     ClimateZone.from_design_conditions() returns a constant OAT for all timesteps.
-    Power and COP queries remain stubs until a real map is assigned.
+    Power input is the nominal capacity divided by a fixed COP chosen by
+    ``heating_type`` (see ``_NOMINAL_COP_BY_HEATING_TYPE`` in constants.py).
     """
 
-    def __init__(self, nominal_capacity_kbtuh: float, model_name: str = "") -> None:
+    def __init__(
+        self,
+        nominal_capacity_kbtuh: float,
+        model_name: str = "",
+        heating_type: Literal["electric_resistance", "gas", "heat_pump"] = "heat_pump",
+    ) -> None:
         """
         Parameters
         ----------
@@ -258,14 +265,37 @@ class NominalPerformanceMap(PerformanceMap):
             Fixed heating output capacity [kBTU/hr] returned for all conditions.
         model_name : str
             Optional human-readable identifier.
+        heating_type : "electric_resistance" | "gas" | "heat_pump"
+            Selects the nominal COP used by ``get_power_in_kw()``.
+            Default "heat_pump".
+
+        Raises
+        ------
+        ValueError
+            If ``heating_type`` is not a known heating type.
         """
+        if heating_type not in _NOMINAL_COP_BY_HEATING_TYPE:
+            raise ValueError(
+                f"heating_type must be one of {tuple(_NOMINAL_COP_BY_HEATING_TYPE)}, "
+                f"got {heating_type!r}."
+            )
         super().__init__(map_data=None, model_name=model_name)
         self.nominal_capacity_kbtuh = nominal_capacity_kbtuh
+        self.heating_type           = heating_type
+        self.cop                    = _NOMINAL_COP_BY_HEATING_TYPE[heating_type]
 
     def get_capacity_kbtuh(self, oat_f: float, outlet_temp_f: float, inlet_temp_f: float | None = None) -> float:
         """Return the fixed nominal capacity [kBTU/hr] regardless of conditions."""
         return self.nominal_capacity_kbtuh
 
+    def get_power_in_kw(self, oat_f: float, outlet_temp_f: float, inlet_temp_f: float | None = None) -> float:
+        """Return power input [kW]: nominal capacity / nominal COP for the heating type."""
+        return self.nominal_capacity_kbtuh / _BTUH_PER_W / self.cop
+
+    def is_within_operating_bounds(self, oat_f: float) -> bool:
+        """A nominal map has no operating limits."""
+        return True
+
 
 # ---------------------------------------------------------------------------
 # PklPerformanceMap — pickle-based LinearND interpolator

{ecoengine-3.3.0 → ecoengine-3.3.2}/src/ecoengine/objects/components/heating/WaterHeater.py

@@ -2,8 +2,11 @@ from __future__ import annotations
 
 from typing import TYPE_CHECKING, Literal
 
+from ecoengine.constants.constants import _HEATING_TYPES
 from ecoengine.objects.components.heating.PerformanceMap import NominalPerformanceMap, PerformanceMap
 
+HeatingType = Literal["electric_resistance", "gas", "heat_pump"]
+
 if TYPE_CHECKING:
     from ecoengine.objects.components.heating.Controls import Controls
     from ecoengine.objects.components.storage.StorageTank import StorageTank
@@ -49,7 +52,7 @@ class WaterHeater:
         performance_map: PerformanceMap | None,
         control_schedule: list[str] | None,
         control_map: dict[str, Controls] | None,
-        fuel_type: Literal["electric", "gas"] = "electric",
+        heating_type: HeatingType = "heat_pump",
     ) -> None:
         """
         Parameters
@@ -63,13 +66,29 @@ class WaterHeater:
         control_map : dict[str, Controls] | None
             Maps schedule strings to Controls objects.
             None when no control logic is configured.
-        fuel_type : "electric" | "gas"
-            Fuel source for this heater. Default is "electric".
+        heating_type : "electric_resistance" | "gas" | "heat_pump"
+            Heating technology. Default is "heat_pump". When
+            ``performance_map`` is a ``NominalPerformanceMap``, the heater
+            stores a copy of it with this heating type, so its power uses the
+            matching nominal COP. The passed map is not modified.
+
+        Raises
+        ------
+        ValueError
+            If ``heating_type`` is not a known heating type.
         """
+        if heating_type not in _HEATING_TYPES:
+            raise ValueError(f"heating_type must be one of {_HEATING_TYPES}, got {heating_type!r}.")
+        if isinstance(performance_map, NominalPerformanceMap) and performance_map.heating_type != heating_type:
+            performance_map = NominalPerformanceMap(
+                performance_map.nominal_capacity_kbtuh,
+                model_name=performance_map.model_name,
+                heating_type=heating_type,
+            )
         self.performance_map  = performance_map
         self.control_schedule = control_schedule
         self.control_map      = control_map
-        self.fuel_type        = fuel_type
+        self.heating_type     = heating_type
         self._active          = False
 
     # ------------------------------------------------------------------
@@ -82,7 +101,7 @@ class WaterHeater:
         nominal_capacity_kbtuh: float,
         control_schedule: list[str] | None,
         control_map: dict[str, Controls] | None,
-        fuel_type: Literal["electric", "gas"] = "electric",
+        heating_type: HeatingType = "heat_pump",
     ) -> WaterHeater:
         """
         Create a WaterHeater with a constant-capacity placeholder performance map.
@@ -99,18 +118,19 @@ class WaterHeater:
             24-element list mapping each hour to a key in control_map.
         control_map : dict[str, Controls] | None
             Maps schedule strings to Controls objects.
-        fuel_type : "electric" | "gas"
-            Fuel source for this heater. Default is "electric".
+        heating_type : "electric_resistance" | "gas" | "heat_pump"
+            Heating technology; selects the nominal COP used for power input.
+            Default is "heat_pump".
 
         Returns
         -------
         WaterHeater
         """
         return cls(
-            performance_map=NominalPerformanceMap(nominal_capacity_kbtuh),
+            performance_map=NominalPerformanceMap(nominal_capacity_kbtuh, heating_type=heating_type),
             control_schedule=control_schedule,
             control_map=control_map,
-            fuel_type=fuel_type,
+            heating_type=heating_type,
         )
 
     @classmethod
@@ -122,7 +142,7 @@ class WaterHeater:
         num_units: int = 1,
         design_inlet_temp_f: float = 50.0,
         nominal_capacity_kbtuh: float | None = None,
-        fuel_type: Literal["electric", "gas"] = "electric",
+        heating_type: HeatingType = "heat_pump",
         perf_map_dir: str | None = None,
     ) -> WaterHeater:
         """
@@ -144,8 +164,9 @@ class WaterHeater:
             Cold-water inlet temperature used when not supplied per-call. Default 50 °F.
         nominal_capacity_kbtuh : float | None
             Total system capacity for ER fallback sizing. Default None.
-        fuel_type : "electric" | "gas"
-            Fuel source for this heater. Default is "electric".
+        heating_type : "electric_resistance" | "gas" | "heat_pump"
+            Heating technology label. Default is "heat_pump". Does not change
+            the model map, which has its own power data.
         perf_map_dir : str | None
             Path to directory containing ``maps.json`` and ``pkls/``.
             Passed through to ``PerformanceMap.from_model_name()``.
@@ -164,7 +185,7 @@ class WaterHeater:
             ),
             control_schedule=control_schedule,
             control_map=control_map,
-            fuel_type=fuel_type,
+            heating_type=heating_type,
         )
 
     # ------------------------------------------------------------------
@@ -242,9 +263,10 @@ class WaterHeater:
         oat_f: float,
         outlet_temp_f: float,
         inlet_temp_f: float | None = None,
-    ) -> float | None:
+    ) -> float:
         """
-        Return electrical power input [kW] at current conditions.
+        Return actual power input this timestep [kW]: the performance map's
+        power if active, 0 if not.
 
         Parameters
         ----------
@@ -256,11 +278,14 @@ class WaterHeater:
 
         Returns
         -------
-        float | None
+        float
+            0.0 when the heater is inactive, has no performance map, or the
+            map has no power data.
         """
-        if self.performance_map is not None:
-            return self.performance_map.get_power_in_kw(oat_f, outlet_temp_f, inlet_temp_f)
-        return None
+        if not self._active or self.performance_map is None:
+            return 0.0
+        kw = self.performance_map.get_power_in_kw(oat_f, outlet_temp_f, inlet_temp_f)
+        return kw if kw is not None else 0.0
 
     def get_output_kbtuh(
         self,
@@ -307,33 +332,44 @@ class WaterHeater:
             raise ValueError(f"No Controls configured for hour {hour_of_day}.")
         return controls.outlet_temp_f
 
-    def update_state(self, storage_tank: StorageTank, hour_of_day: int) -> None:
+    def update_state(
+        self,
+        storage_tank: StorageTank,
+        timestep_interval: int,
+        interval_min: int = 1,
+    ) -> None:
         """
-        Look up the active Controls for the given hour, then update
+        Look up the active Controls for this timestep's hour, then update
         active/inactive state based on current tank condition.
 
+        On the first interval after a mode change in the control schedule,
+        the heater is turned off before the control check.
         If the heater is currently ON, check should_turn_off().
         If the heater is currently OFF, check should_turn_on().
 
         Parameters
         ----------
         storage_tank : StorageTank
-        hour_of_day : int
-            Hour of the day (0-23), used to select the active Controls from
-            the control schedule.
+        timestep_interval : int
+            Number of elapsed intervals since the start of the simulation.
+        interval_min : int
+            Length of each interval [minutes]. Default 1.
 
         Raises
         ------
         ValueError
-            If no Controls are configured for the given hour.
+            If no Controls are configured for this timestep's hour.
         """
+        hour_of_day = (timestep_interval * interval_min // 60) % 24
         controls = self.get_controls_for_hour(hour_of_day)
         if controls is None:
             raise ValueError(f"No Controls configured for hour {hour_of_day}.")
-        
+
         # QPL Alignment block : QPL states Upon change of load shift operation, disable all heaters if “on sensor” is warmer than “on temperature”.
-        # To do this in EcosizerEngine, we simply turn off water heaters at the beginning of a mode change
-        previous_hour = 23 if hour_of_day == 0 else hour_of_day - 1
+        # To do this in EcosizerEngine, we turn off water heaters on the first interval of a mode change.
+        # previous_hour is the hour of the previous timestep, so it differs from hour_of_day
+        # only on the first interval of an hour (timestep 0 → hour 23).
+        previous_hour = ((timestep_interval - 1) * interval_min // 60) % 24
         if self.control_schedule[hour_of_day] != self.control_schedule[previous_hour]:
             self.turn_off()
 

{ecoengine-3.3.0 → ecoengine-3.3.2}/src/ecoengine/objects/dhwsystems/DHWSystem.py

@@ -1632,21 +1632,17 @@ class DHWSystem:
         if self.storage_tank is not None:
             # Update on/off state for each heater based on current tank condition
             for wh in self.water_heaters:
-                wh.update_state(self.storage_tank, hour_of_day)
+                wh.update_state(self.storage_tank, timestep_interval, interval_min)
 
             # Apply heating from all active heaters to the tank
             total_kbtuh    = sum(
                 wh.get_output_kbtuh(oat_f, wh.get_outlet_temp_f(hour_of_day), inlet_temp_f)
                 for wh in self.water_heaters
             )
-            total_kw: float | None = None
-            active_kws = [
+            total_kw = sum(
                 wh.get_power_in_kw(oat_f, wh.get_outlet_temp_f(hour_of_day), inlet_temp_f)
                 for wh in self.water_heaters
-                if wh.is_active()
-            ]
-            if any(kw is not None for kw in active_kws):
-                total_kw = sum(kw or 0.0 for kw in active_kws)
+            )
 
             self.storage_tank.heat(total_kbtuh, interval_min, outlet_temp_f)
             top_temp_f     = self.storage_tank.get_temperature_at_fraction(1.0)

{ecoengine-3.3.0 → ecoengine-3.3.2}/src/ecoengine/objects/dhwsystems/recirc_systems/ParallelLoopSystem.py

@@ -228,6 +228,7 @@ class ParallelLoopSystem(RecircSystem):
             nominal_capacity_kbtuh=system._minimum_tm_capacity_kbtuh / system.num_tm_heaters,
             control_schedule=["normal"] * 24,
             control_map={"normal": tm_controls},
+            heating_type="electric_resistance",
         )
 
         return system
@@ -373,7 +374,9 @@ class ParallelLoopSystem(RecircSystem):
         -------
         dict
             Same keys as DHWSystem.simulate_step(). heater_output_kbtuh and
-            heater_power_in_kw include both primary and TM heater contributions.
+            heater_power_in_kw are primary-only; TM heater output and power are
+            in tm_heater_output_kbtuh / tm_heater_input_kw. SimulationRun
+            combines the power series.
         """
         # Run primary system: super() → RecircSystem → DHWSystem
         step = super().simulate_step(building, timestep_interval, interval_min, mode)
@@ -388,27 +391,19 @@ class ParallelLoopSystem(RecircSystem):
             self.return_flow_gpm, self.return_temp_f, interval_min
         )
 
-        self.tm_water_heater.update_state(self.tm_storage_tank, hour_of_day)
+        self.tm_water_heater.update_state(self.tm_storage_tank, timestep_interval, interval_min)
 
         tm_top_temp_f   = self.tm_storage_tank.get_temperature_at_fraction(1.0)
         tm_inlet_temp_f = (self.tm_off_temp_f + self.tm_on_temp_f) / 2.0
         tm_kbtuh        = self.tm_water_heater.get_output_kbtuh(oat_f, tm_top_temp_f, tm_inlet_temp_f) * self.num_tm_heaters
-        tm_kw_per_unit  = (
-            self.tm_water_heater.get_power_in_kw(oat_f, tm_top_temp_f, tm_inlet_temp_f)
-            if self.tm_water_heater.is_active()
-            else None
-        )
-        tm_kw = tm_kw_per_unit * self.num_tm_heaters if tm_kw_per_unit is not None else None
+        tm_kw           = self.tm_water_heater.get_power_in_kw(oat_f, tm_top_temp_f, tm_inlet_temp_f) * self.num_tm_heaters
         self.tm_storage_tank.heat(tm_kbtuh, interval_min, self.tm_off_temp_f)
 
         # ------------------------------------------------------------------
-        # Merge TM outputs into primary step dict
+        # Add TM outputs to the step dict
         # ------------------------------------------------------------------
-        # heater_output_kbtuh stays PRIMARY-ONLY (used for gal/hr plot in top chart).
-        # TM thermal output is tracked separately in tm_heater_output_kbtuh.
-        # heater_power_in_kw merges both so get_total_energy_kwh() is accurate.
-        # if tm_kw is not None:
-        #     step["heater_power_in_kw"] = (step["heater_power_in_kw"] or 0.0) + tm_kw
+        # heater_output_kbtuh and heater_power_in_kw stay PRIMARY-ONLY. TM output
+        # and power are recorded separately; SimulationRun combines the power.
 
         # TM panel data (consumed by SimulationRun for the TM subplot)
         step["tm_tank_temp_f"]         = self.tm_storage_tank.get_temperature_at_fraction(0.5)