ecoengine 3.0.1__tar.gz → 3.0.2__tar.gz

{ecoengine-3.0.1 → ecoengine-3.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ecoengine
-Version: 3.0.1
+Version: 3.0.2
 Requires-Python: >=3.11
 Requires-Dist: numpy
 Requires-Dist: scipy

ecoengine-3.0.2/README.md

@@ -0,0 +1,183 @@
+# EcosizerEngine
+
+A Python simulation engine for sizing and simulating domestic hot water (DHW) systems in multi-family and commercial buildings, with a focus on heat pump water heater (HPWH) technology.
+
+Requires Python 3.11+. Dependencies: `numpy`, `scipy`, `plotly`.
+
+---
+
+## Installation
+
+To make the package available to other local apps without publishing it to PyPI, install it in editable mode from the repo root:
+
+```bash
+pip install -e .
+```
+
+Any app that shares the same Python environment can then import from `ecoengine` directly. Changes made to the source files take effect immediately without reinstalling.
+
+---
+
+## What the engine does
+
+The engine performs three core functions:
+
+1. **Sizing** — calculates the minimum heating capacity (kBTU/hr) and storage volume (gallons) needed to meet peak daily demand.
+2. **3-day design-day simulation** — models system performance at 1-minute timesteps over three consecutive peak-demand days.
+3. **Annual simulation** — full-year simulation at 10-minute timesteps for cost and efficiency analysis.
+
+---
+
+## Package structure
+
+```
+src/ecoengine/
+├── __init__.py                  # Re-exports EcosizerEngine and top-level helpers
+│
+├── interfaces/
+│   ├── EcosizerEngine.py        # Top-level orchestrator and public API
+│   └── Simulator.py             # simulate(), simulate_3day(), simulate_annual()
+│
+├── objects/
+│   ├── building/
+│   │   ├── Building.py          # Occupancy, daily demand, load shapes
+│   │   ├── ClimateZone.py       # Hourly OAT and monthly inlet water temps
+│   │   └── UtilityCostTracker.py
+│   │
+│   ├── components/
+│   │   ├── heating/
+│   │   │   ├── WaterHeater.py   # Single HPWH unit with on/off state
+│   │   │   ├── PerformanceMap.py # Capacity/power lookup (nominal, pkl, polynomial)
+│   │   │   └── Controls.py      # Aquastat setpoints per operating mode
+│   │   └── storage/
+│   │       ├── StorageTank.py   # Abstract base class
+│   │       ├── StratifiedTank.py    # Continuous linear temperature profile model
+│   │       ├── MixedStorageTank.py  # Fully-mixed single-node model (TM tanks)
+│   │       ├── EnergyTank.py        # Energy-based base for MPRTP
+│   │       └── SlugOverlayTank.py   # Slug overlay for multi-pass RTP simulation
+│   │
+│   ├── dhwsystems/
+│   │   ├── DHWSystem.py         # Base class: sizing, simulation step, sizing curve
+│   │   ├── InstantWHSystem.py   # Tankless (no storage)
+│   │   ├── MPNoRecircSystem.py  # Multi-pass, no recirculation
+│   │   ├── recirc_systems/
+│   │   │   ├── RecircSystem.py        # Base for systems with recirc loops
+│   │   │   ├── ParallelLoopSystem.py  # Parallel loop with separate TM tank
+│   │   │   ├── SwingSystem.py         # Swing tank system
+│   │   │   └── SwingERTrdOffSystem.py # Swing + ER element trade-off variant
+│   │   └── rtp_systems/
+│   │       ├── RTPSystem.py             # Base for return-to-primary systems
+│   │       ├── SinglePassRTPSystem.py   # SPRTP: recirc returns to primary tank
+│   │       ├── MultiPassRTPSystem.py    # MPRTP: growing-slug sizing and simulation
+│   │       ├── SP_RTPInParallelSystem.py
+│   │       ├── SP_RTPInSeriesSystem.py
+│   │       └── MP_RTPInSeriesSystem.py
+│   │
+│   └── simulation/
+│       └── SimulationRun.py     # Per-timestep output accumulator and reporting
+│
+└── data/
+    ├── load_shapes/             # 24-hr normalized DHW demand profiles (JSON)
+    ├── climate_data/            # CA climate zone weather data (CSV)
+    └── preformanceMaps/         # HPWH performance map pkl and JSON files
+```
+
+---
+
+## Entry point
+
+All normal usage goes through `EcosizerEngine`:
+
+```python
+from ecoengine import EcosizerEngine
+
+engine = EcosizerEngine(
+    building_type   = "multi_family",
+    num_units       = 100,
+    zip_code        = 94105,
+    supply_temp_f   = 120,
+    storage_temp_f  = 150,
+    system_type     = "parallel_loop",
+)
+
+engine.build()
+engine.size()
+results = engine.get_sizing_results()
+```
+
+Top-level helper functions are also importable directly:
+
+```python
+from ecoengine import get_oat_buckets, get_list_of_models, get_weather_stations
+```
+
+---
+
+## Simulation example
+
+The example below sizes a parallel loop system, runs a 3-day design-day simulation, and writes two HTML files: one with the simulation time-series and one with the sizing curve.
+
+```python
+from ecoengine import EcosizerEngine
+
+# 1. Configure and size the system.
+#    zip_code_or_climate_zone accepts a CA zip code, a zone ID (int),
+#    or a dict of design conditions (design_oat_f, design_inlet_water_temp_f).
+engine = EcosizerEngine(
+    building_type            = "multi_family",
+    magnitude                = 100,           # people
+    zip_code_or_climate_zone = 94105,         # San Francisco
+    supply_temp_f            = 120.0,
+    storage_temp_f           = 150.0,
+    schematic                = "parallel_loop",
+    gpdpp                    = 25.0,          # gallons per person per day
+    max_daily_run_hr         = 16.0,
+    aquastat_fract           = 0.4,           # ON sensor at 40% tank height
+    off_sensor_fract         = 0.2,           # OFF sensor at 20% tank height
+    on_trigger_t_f           = 120.0,
+    off_trigger_t_f          = 140.0,
+    return_flow_gpm          = 3.0,
+    return_temp_f            = 110.0,
+    tm_on_temp_f             = 115.0,
+    tm_off_temp_f            = 125.0,
+    tm_off_time_hr           = 0.5,
+)
+
+# 2. Check sizing results.
+sizing = engine.get_sizing_results()
+print(f"Capacity:  {sizing['min_capacity_kbtuh']:.1f} kBTU/hr")
+print(f"Storage:   {sizing['min_storage_storageT_gal']:.0f} gal")
+print(f"TM tank:   {sizing['min_tm_volume_gal']:.0f} gal")
+
+# 3. Run the 3-day design-day simulation (1-minute timesteps).
+result = engine.simulate_3day()
+
+# 4. Plot the simulation time-series and write to an HTML file.
+fig_sim = result.to_plotly(
+    title              = "3-Day Simulation — 100-Person Multi-Family Parallel Loop",
+    include_temperatures = True,
+)
+fig_sim.write_html("simulation.html")
+
+# 5. Plot the sizing curve (capacity vs. storage) and write to an HTML file.
+engine.plot_sizing_curve(
+    title    = "Sizing Curve — 100-Person Multi-Family Parallel Loop",
+    filepath = "sizing_curve.html",
+)
+
+print("Saved simulation.html and sizing_curve.html")
+```
+
+Open either HTML file in a browser to view the interactive Plotly chart.
+
+**Available schematics:** `"parallel_loop"`, `"swing_tank"`, `"single_pass_rtp"`, `"multi_pass_rtp"`, `"no_recirc"`, `"instant"`.
+
+For a full working example including load-shift scheduling across multiple system types, see `demo_3day_sim.py` in the repo root.
+
+---
+
+## Running tests
+
+```bash
+pytest src/ecoengine/tests/
+```

{ecoengine-3.0.1 → ecoengine-3.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ecoengine"
-version = "3.0.1"
+version = "3.0.2"
 requires-python = ">=3.11"
 dependencies = ["numpy", "scipy", "plotly"]
 

{ecoengine-3.0.1 → ecoengine-3.0.2}/src/ecoengine/interfaces/EcosizerEngine.py

@@ -878,6 +878,7 @@ class EcosizerEngine:
                     return_flow_gpm            = self.return_flow_gpm,
                     max_daily_run_hr           = self.max_daily_run_hr,
                     defrost_factor             = self.defrost_factor,
+                    tm_safety_factor           = self.tm_safety_factor,
                     control_schedule           = control_schedule,
                     control_map                = control_map,
                     load_shift_fract_total_vol = ls_fract,
@@ -896,6 +897,7 @@ class EcosizerEngine:
                     return_flow_gpm  = self.return_flow_gpm,
                     max_daily_run_hr = 14,
                     defrost_factor   = self.defrost_factor,
+                    tm_safety_factor = self.tm_safety_factor,
                     control_schedule = control_schedule,
                     control_map      = control_map,
                 )
@@ -1096,6 +1098,7 @@ class EcosizerEngine:
                 return_flow_gpm=self.return_flow_gpm,
                 max_daily_run_hr=self.max_daily_run_hr,
                 defrost_factor=self.defrost_factor,
+                tm_safety_factor=self.tm_safety_factor,
             )
 
         if self.schematic in ["multi_pass_rtp", "mprtp"]:
@@ -1120,6 +1123,7 @@ class EcosizerEngine:
                 return_flow_gpm=self.return_flow_gpm,
                 max_daily_run_hr=_MPRTP_MAX_DAILY_RUN_HR,
                 defrost_factor=self.defrost_factor,
+                tm_safety_factor=self.tm_safety_factor,
             )
 
         if self.schematic == "instant_wh":
@@ -1345,24 +1349,10 @@ class EcosizerEngine:
             If ``plotly`` is not installed.
         """
         control_schedule, control_map = self._build_control_map()
-        fig = self._dhw_system.plot_sizing_curve(
-            building           = self._building,
-            control_schedule   = control_schedule,
-            control_map        = control_map,
-            load_shift_percent = self.load_shift_percent,
-            strat_slope        = strat_slope,
-            title              = title,
-            filepath           = filepath,
-        )
-
-        result = fig.to_html(full_html=False, include_plotlyjs=False) if return_as_div else fig
-
-        if not return_with_x_y_points:
-            return result
-
         is_ls = "shed" in control_map
+
         if is_ls:
-            curve       = self._dhw_system.get_ls_sizing_curve(
+            curve = self._dhw_system.get_ls_sizing_curve(
                 self._building,
                 control_schedule   = control_schedule,
                 control_map        = control_map,
@@ -1378,4 +1368,9 @@ class EcosizerEngine:
             y_vals      = curve["capacity_kbtuh"][::-1]
             start_index = len(x_vals) - 1 - curve["recommended_index"]
 
-        return [result, x_vals, y_vals, start_index]
+        fig    = self._dhw_system._build_sizing_curve_figure(curve, is_ls, title, filepath)
+        result = fig.to_html(full_html=False, include_plotlyjs=False) if return_as_div else fig
+
+        if return_with_x_y_points:
+            return [result, x_vals, y_vals, start_index]
+        return result

{ecoengine-3.0.1 → ecoengine-3.0.2}/src/ecoengine/interfaces/Simulator.py

@@ -55,7 +55,8 @@ def simulate(dhw_system: DHWSystem, building: Building, duration: str = "3day",
     sim_run = SimulationRun(duration_min, timestep_min, **sim_run_kwargs)
 
     from ecoengine.objects.dhwsystems.recirc_systems.SwingSystem import SwingSystem
-    sim_run.show_tm_panel = isinstance(dhw_system, SwingSystem)
+    from ecoengine.objects.dhwsystems.recirc_systems.SwingERTrdOffSystem import SwingERTrdOffSystem
+    sim_run.show_tm_panel = isinstance(dhw_system, SwingSystem) or isinstance(dhw_system, SwingERTrdOffSystem)
 
     # Initialize storage tanks
     inlet_temp_f    = building.get_design_inlet_water_temp_f() or 50.0
@@ -99,7 +100,8 @@ def simulate(dhw_system: DHWSystem, building: Building, duration: str = "3day",
         )
 
         if step["usable_volume_supplyT_gal"] <= 0.0:
-            sim_run.record_outage(timestep_min)
+            if not sim_run.show_tm_panel or step.get("tm_tank_temp_f") < dhw_system.supply_temp_f:
+                sim_run.record_outage(timestep_min)
 
         # Check outlet-deficit stop condition. For systems where the TM/swing
         # tank is the actual delivery point (e.g. SwingSystem), use its

{ecoengine-3.0.1 → ecoengine-3.0.2}/src/ecoengine/objects/components/storage/StratifiedTank.py

@@ -37,7 +37,6 @@ class StratifiedTank(StorageTank):
     def __init__(
         self,
         total_volume_gal: float,
-        num_nodes: int = 12,
         strat_slope: float = _DEFAULT_STRAT_SLOPE,
     ) -> None:
         """
@@ -45,9 +44,6 @@ class StratifiedTank(StorageTank):
         ----------
         total_volume_gal : float
             Total physical tank volume [gallons].
-        num_nodes : int
-            Number of vertical temperature nodes (retained for future use;
-            the analytical profile model does not use discrete nodes).
         strat_slope : float
             Temperature gradient through the transition zone between cold and
             hot layers [°F per percentage-point of tank height]. Higher values
@@ -56,7 +52,6 @@ class StratifiedTank(StorageTank):
             that model different schematics may set a different value here.
         """
         self.total_volume_gal = total_volume_gal
-        self.num_nodes        = num_nodes
         self.strat_slope      = strat_slope
 
         # Internal state — set by initialize()
@@ -225,7 +220,7 @@ class StratifiedTank(StorageTank):
         avg_temp = self.get_average_draw_temp_f(physical_vol)
         if avg_temp >= outlet_temp_f - 1e-6:
             self._delta_gal -= physical_vol
-            self._delta_gal = max(self._delta_gal, self._delta_gal_floor(supply_temp_f))
+            self._delta_gal = max(self._delta_gal, self._delta_gal_floor())
             return
 
         # Slow path: draw dips into the transition / cold zone.
@@ -249,7 +244,7 @@ class StratifiedTank(StorageTank):
                 break
 
         self._delta_gal -= min((lo + hi) * 0.5, self.total_volume_gal)
-        self._delta_gal = max(self._delta_gal, self._delta_gal_floor(supply_temp_f))
+        self._delta_gal = max(self._delta_gal, self._delta_gal_floor())
 
     def heat(
         self,
@@ -415,7 +410,7 @@ class StratifiedTank(StorageTank):
         self._inlet_temp_f = inlet_temp_f
         if gal > 0.0:
             self._delta_gal -= gal
-            self._delta_gal = max(self._delta_gal, self._delta_gal_floor(supply_temp_f))
+            self._delta_gal = max(self._delta_gal, self._delta_gal_floor())
 
     # ------------------------------------------------------------------
     # Sizing support

{ecoengine-3.0.1 → ecoengine-3.0.2}/src/ecoengine/objects/dhwsystems/DHWSystem.py

@@ -22,6 +22,21 @@ _LS_NORM_STD:  float = 0.08236427664525116
 _LS_NORM_DIST: NormalDist = NormalDist(mu=_LS_NORM_MEAN, sigma=_LS_NORM_STD)
 
 
+class StorageVolumeTooSmallError(ValueError):
+    """
+    Raised when the sized storage volume is below the minimum required floor
+    (half the peak-hour demand at supply temperature).
+    """
+    def __init__(self, storage_storageT_gal: float, minimum_gal: float, capacity_kbtuh: float):
+        super().__init__(
+            f"Sized storage volume ({storage_storageT_gal:.1f} gal) is less than the "
+            f"minimum required volume ({minimum_gal:.1f} gal). "
+            "Increase the hours the heat pump runs per day to ensure adequate volume."
+        )
+        self.storage_storageT_gal = storage_storageT_gal
+        self.capacity_kbtuh       = capacity_kbtuh
+
+
 def _load_shift_fract_total_vol(load_shift_percent: float) -> float:
     """
     Convert a load-shift coverage percentile to a demand scaling fraction.
@@ -370,6 +385,10 @@ class DHWSystem:
                 capacity_kbtuh           = max(capacity_kbtuh, ls_capacity_kbtuh)
                 storage_vol_storageT_gal = max(storage_vol_storageT_gal, ls_storage_vol_storageT_gal)
 
+            min_vol_gal = self._calc_minimum_running_volume_supplyT_gal(building)
+            if storage_vol_storageT_gal < min_vol_gal:
+                raise StorageVolumeTooSmallError(storage_vol_storageT_gal, min_vol_gal, capacity_kbtuh)
+
             self._minimum_capacity_kbtuh       = capacity_kbtuh
             self._minimum_storage_storageT_gal = storage_vol_storageT_gal
             self._sizing_strat_slope           = strat_slope
@@ -501,9 +520,12 @@ class DHWSystem:
                         )
                     except (ValueError, RuntimeError):
                         break       # aquastat fraction or other sizing failure
-                    heat_hours_out.append(float(h))
-                    capacity_out.append(cap)
-                    storage_out.append(storage_vol)
+                    if storage_vol < self._calc_minimum_running_volume_supplyT_gal(building):
+                        break
+                    else:
+                        heat_hours_out.append(float(h))
+                        capacity_out.append(cap)
+                        storage_out.append(storage_vol)
             finally:
                 self.max_daily_run_hr = original_run_hr
 
@@ -704,16 +726,7 @@ class DHWSystem:
         ImportError
             If ``plotly`` is not installed.
         """
-        try:
-            import plotly.graph_objects as go
-        except ImportError:
-            raise ImportError(
-                "plotly is required for plot_sizing_curve(). "
-                "Install it with: pip install plotly"
-            )
-
         is_ls = self._is_load_shifting(control_map)
-
         if is_ls:
             curve = self.get_ls_sizing_curve(
                 building,
@@ -722,9 +735,46 @@ class DHWSystem:
                 strat_slope=strat_slope,
                 load_shift_percent=load_shift_percent,
             )
-            # X = coverage % (multiply fraction by 100 for readability)
+        else:
+            curve = self.get_sizing_curve(building, strat_slope=strat_slope)
+        return self._build_sizing_curve_figure(curve, is_ls, title, filepath)
+
+    def _build_sizing_curve_figure(
+        self,
+        curve: dict,
+        is_ls: bool,
+        title: str = "Primary Sizing Curve",
+        filepath: str | None = None,
+    ) -> "plotly.graph_objects.Figure":
+        """
+        Build and return a Plotly figure from pre-computed sizing curve data.
+
+        Separating figure assembly from data computation lets callers reuse
+        the curve dict (e.g. to extract x/y points) without computing it twice.
+
+        Parameters
+        ----------
+        curve : dict
+            Output of ``get_sizing_curve()`` or ``get_ls_sizing_curve()``.
+        is_ls : bool
+            True → load-shift curve layout; False → primary sizing curve layout.
+        title : str
+            Figure title.
+        filepath : str | None
+            If provided, write the figure to this path as a self-contained HTML file.
+        """
+        try:
+            import plotly.graph_objects as go
+        except ImportError:
+            raise ImportError(
+                "plotly is required for plot_sizing_curve(). "
+                "Install it with: pip install plotly"
+            )
+
+        if is_ls:
             x_vals  = [p * 100.0 for p in curve["load_shift_percent"]]
             y_vals  = curve["storage_storageT_gal"]
+            rec     = curve["recommended_index"]
             x_label = "Load-Shift Days Covered (%)"
             y_label = "Primary Tank Volume (gal at Storage Temperature)"
             hover   = (
@@ -738,13 +788,12 @@ class DHWSystem:
                     f"Storage: <b>{y_vals[i]:.1f} gal</b>"
                 )
         else:
-            curve = self.get_sizing_curve(
-                building,
-                strat_slope=strat_slope,
-            )
-            x_vals     = curve["storage_storageT_gal"]
-            y_vals     = curve["capacity_kbtuh"]
-            heat_hours = curve["heat_hours"]
+            # Reverse raw curve (high heat-hours first) so slider moves
+            # left-to-right with increasing storage on the x-axis.
+            x_vals     = curve["storage_storageT_gal"][::-1]
+            y_vals     = curve["capacity_kbtuh"][::-1]
+            heat_hours = curve["heat_hours"][::-1]
+            rec        = len(x_vals) - 1 - curve["recommended_index"]
             x_label    = "Primary Tank Volume (gal at Storage Temperature)"
             y_label    = "Heating Capacity (kBTU/hr)"
             hover      = (
@@ -752,15 +801,6 @@ class DHWSystem:
                 "Capacity: <b>%{y:.1f} kBTU/hr</b>"
                 "<extra></extra>"
             )
-            # The raw curve is ordered high→low storage (high heat hours first).
-            # Reverse so that the slider moves left-to-right in the same direction
-            # as the diamond moves along the x-axis (low storage → high storage).
-            _rec_raw = curve["recommended_index"]
-            x_vals     = x_vals[::-1]
-            y_vals     = y_vals[::-1]
-            heat_hours = heat_hours[::-1]
-            rec        = len(x_vals) - 1 - _rec_raw
-
             def _slider_label(i: int) -> str:
                 return (
                     f"Storage: <b>{x_vals[i]:.1f} gal</b>, "
@@ -768,8 +808,6 @@ class DHWSystem:
                     f"Run hours: <b>{heat_hours[i]:.2f} hr/day</b>"
                 )
 
-        if is_ls:
-            rec = curve["recommended_index"]
         fig = go.Figure()
 
         # Trace 0: the full sizing curve (always visible)
@@ -789,10 +827,9 @@ class DHWSystem:
                 marker=dict(symbol="diamond", color="#2EA3F2", size=12),
                 hovertemplate=hover,
                 showlegend=False,
-                visible=(i == rec),   # only the recommended point starts visible
+                visible=(i == rec),
             ))
 
-        # Build slider steps — each reveals one diamond trace
         steps = []
         for i in range(len(x_vals)):
             visibility = [True] + [j == i for j in range(len(x_vals))]
@@ -947,6 +984,10 @@ class DHWSystem:
         """
         return running_volume_supplyT_gal / stratification_factor
 
+    def _calc_minimum_running_volume_supplyT_gal(self, building) -> float:
+        """Return the floor running volume: half the peak-hour demand at supply temperature."""
+        return float(np.max(building.peak_load_shape)) * building.daily_dhw_use_supplyT_gal / 2.0
+
     def _calc_stratification_factor(
         self,
         control_map: dict[str, Controls] | None,
@@ -1681,7 +1722,6 @@ class DHWSystem:
                 wh.update_state(self.storage_tank, hour_of_day)
 
             # Apply heating from all active heaters to the tank
-            top_temp_f     = self.storage_tank.get_temperature_at_fraction(1.0)
             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
@@ -1696,11 +1736,15 @@ class DHWSystem:
                 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)
 
             # Draw hot water from tank to meet demand
-            self.storage_tank.draw(
-                demand_supplyT_gal, inlet_temp_f, self.supply_temp_f, outlet_temp_f
-            )
+            if top_temp_f >= self.supply_temp_f:
+                self.storage_tank.draw(
+                    demand_supplyT_gal, inlet_temp_f, self.supply_temp_f, outlet_temp_f
+                )
+            else:
+                self.storage_tank.draw_physical_gal(demand_supplyT_gal, inlet_temp_f, self.supply_temp_f)
 
             usable_vol_gal = self.storage_tank.get_usable_volume_supplyT_gal(
                 self.supply_temp_f

{ecoengine-3.0.1 → ecoengine-3.0.2}/src/ecoengine/objects/dhwsystems/recirc_systems/ParallelLoopSystem.py

@@ -414,5 +414,4 @@ class ParallelLoopSystem(RecircSystem):
         step["tm_tank_temp_f"]         = self.tm_storage_tank.get_temperature_at_fraction(0.5)
         step["tm_heater_output_kbtuh"] = tm_kbtuh
         step["tm_heater_input_kw"]     = tm_kw
-        print(f'{step["tm_heater_input_kw"]}, {step["tm_tank_temp_f"] }, {step["tm_heater_output_kbtuh"]}')
         return step

{ecoengine-3.0.1 → ecoengine-3.0.2}/src/ecoengine/objects/dhwsystems/recirc_systems/SwingSystem.py

@@ -7,7 +7,7 @@ from ecoengine.objects.components.heating.Controls import Controls
 from ecoengine.objects.components.heating.WaterHeater import WaterHeater
 from ecoengine.objects.components.storage.StratifiedTank import StratifiedTank
 from ecoengine.objects.components.storage.MixedStorageTank import MixedStorageTank
-from ecoengine.objects.dhwsystems.DHWSystem import _get_peak_indices
+from ecoengine.objects.dhwsystems.DHWSystem import _get_peak_indices, StorageVolumeTooSmallError
 from .RecircSystem import RecircSystem
 from ecoengine.constants.constants import _RHO_CP, _W_TO_KBTUH
 
@@ -260,6 +260,10 @@ class SwingSystem(RecircSystem):
                     storage_vol_storageT_gal = ls_storage_vol
                     self._eff_mix_fraction = ls_eff_mix
 
+            min_vol_gal = self._calc_minimum_running_volume_supplyT_gal(building)
+            if storage_vol_storageT_gal < min_vol_gal:
+                raise StorageVolumeTooSmallError(storage_vol_storageT_gal, min_vol_gal, capacity_kbtuh)
+
             self._minimum_capacity_kbtuh       = capacity_kbtuh
             self._minimum_storage_storageT_gal = storage_vol_storageT_gal
             self._sizing_strat_slope           = strat_slope
@@ -325,9 +329,12 @@ class SwingSystem(RecircSystem):
                         )
                     except (ValueError, RuntimeError):
                         break
-                    heat_hours_out.append(float(h))
-                    capacity_out.append(cap)
-                    storage_out.append(storage_vol)
+                    if storage_vol < self._calc_minimum_running_volume_supplyT_gal(building):
+                        break
+                    else:
+                        heat_hours_out.append(float(h))
+                        capacity_out.append(cap)
+                        storage_out.append(storage_vol)
             finally:
                 self.max_daily_run_hr = original_run_hr