Framework to allow for variable dt

CHANGELOG.md

@@ -51,6 +51,7 @@
   - The `FlexibleDemandOpenLoopConverterController` has been renamed to `FlexibleDemandComponent`
   - The `DemandOpenLoopConverterController` has been renamed to `GenericDemandComponent`
 - Modified CI setup so Windows is temporarily disabled and also so unit, regression, and integration tests are run in separate jobs to speed up testing and provide more information on test failures. [PR 668](https://github.com/NatLabRockies/H2Integrate/pull/668)
+- Added infrastructure for running models with non-hourly time steps via a class attribute `_time_step_bounds` and sets new time step bounds of 5-minutes to 1-hour for the grid components. [PR 653](https://github.com/NatLabRockies/H2Integrate/pull/653)
 
 ## 0.7.2 [April 9, 2026]
 

docs/developer_guide/adding_a_new_technology.md

@@ -258,6 +258,19 @@ In the middle-ground case where the models might use a shared object that is com
 This would require additional logic to first check if the cached object exists and is valid before attempting to load it, otherwise it would create the object from scratch.
 There is an example of this in the `hopp_wrapper.py` file.
 
+### Specifying allowable time step for your model
+If you want your model to run with time steps other than 1 hour (3600 s), then you must specify the `_time_step_bounds` as a class attribute in each of your model classes. To run a simulation with a given time step, all models in the plant must be compatible with the desired time step.
+
+```python
+class ECOElectrolyzerPerformanceModel(ElectrolyzerPerformanceBaseClass):
+    """
+    An OpenMDAO component that wraps the PEM electrolyzer model.
+    Takes electricity input and outputs hydrogen and oxygen generation rates.
+    """
+
+    # (min, max) time step lengths (in seconds) compatible with this model
+    _time_step_bounds = (300, 3600) # (5-min, 1-hour)
+```
 
 ### Other cases
 

docs/intro.md

@@ -64,11 +64,17 @@ H2Integrate was previously known as GreenHEART. The name was updated to H2Integr
 
 ## How does H2Integrate work?
 
-H2Integrate models energy systems on a yearly basis using hourly timesteps (i.e., 8760 operational data points across a year).
+H2Integrate typically models energy systems on a yearly basis using hourly timesteps (i.e., 8760 operational data points across a year).
 Results from these simulations are then processed across the project's lifecycle to provide insights into the system's performance, costs, and financial viability.
 Depending on the models used and the size of the system, H2Integrate can simulate systems ranging from the kW to GW scale in seconds on a personal computer.
 Additionally, H2Integrate tracks the flow of electricity, molecules (e.g., hydrogen, ammonia, methanol), and other products (e.g., steel) between different technologies in the energy system.
 
+```{note}
+Some models are now able to operate with non-hourly time steps.
+Appropriate time step bounds are included as class attributes when non-hourly time steps are permitted.
+Check individual model docs and definitions for time step bounds for individual models. All models in a given simulation must be compatible with the specified time step.
+```
+
 For each technology there are 4 different types of models: control, performance, cost, and finance. These model categories allow for modular pieces to be brought in or re-used throughout H2Integrate, as well as ease of development and organization. Note that the only required models for a technology are performance and cost, while control and finance are optional. The figure below shows these four categories and some of the technologies included in H2Integrate. For a full list of models available, please see [Model Overview](user_guide/model_overview.md).
 ![A representation of a single technology model in H2Integrate](tech-model.png)
 

docs/technology_models/grid.md

@@ -67,3 +67,7 @@ The **revenue** of selling electricity to the grid is represented as a variable
 ```{note}
 If you're using a price-maker financial model (e.g., calculating the LCOE) and selling all of the electricity to the grid, then the `electricity_sell_price` should most likely be set to 0. since you want to know the breakeven price of selling that electricity.
 ```
+
+```{note}
+The grid components are currently compatible with 5-minute (300-second) to 1-hour (3600-second) time steps.
+```

examples/06_custom_tech/user_defined_model/paper_mill.py

@@ -16,6 +16,8 @@ class PaperMillConfig(BaseConfig):
 
 
 class PaperMillPerformance(om.ExplicitComponent):
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         self.options.declare("driver_config", types=dict)
         self.options.declare("plant_config", types=dict)
@@ -53,6 +55,8 @@ class PaperMillCostConfig(CostModelBaseConfig):
 
 
 class PaperMillCost(CostModelBaseClass):
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         self.config = PaperMillCostConfig.from_dict(
             merge_shared_inputs(self.options["tech_config"]["model_inputs"], "cost")

h2integrate/control/control_rules/converters/generic_converter.py

@@ -9,6 +9,8 @@
 
 
 class PyomoDispatchGenericConverter(PyomoRuleBaseClass):
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         self.config = PyomoRuleBaseConfig.from_dict(
             merge_shared_inputs(self.options["tech_config"]["model_inputs"], "dispatch_rule"),

h2integrate/control/control_rules/pyomo_rule_baseclass.py

@@ -22,6 +22,8 @@ class PyomoRuleBaseConfig(BaseConfig):
 
 
 class PyomoRuleBaseClass(om.ExplicitComponent):
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         self.options.declare("driver_config", types=dict)
         self.options.declare("plant_config", types=dict)

h2integrate/control/control_rules/storage/pyomo_storage_rule_baseclass.py

@@ -24,6 +24,8 @@ class PyomoStorageRuleBaseConfig(PyomoRuleBaseConfig):
 class PyomoRuleStorageBaseclass(PyomoRuleBaseClass):
     """Base class defining Pyomo rules for generic commodity storage components."""
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         self.config = PyomoStorageRuleBaseConfig.from_dict(
             merge_shared_inputs(self.options["tech_config"]["model_inputs"], "dispatch_rule"),

h2integrate/control/control_strategies/heuristic_pyomo_controller.py

@@ -70,6 +70,8 @@ class HeuristicLoadFollowingController(PyomoControllerBaseClass):
 
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         """Initialize the heuristic load-following controller."""
         self.config = HeuristicLoadFollowingControllerConfig.from_dict(

h2integrate/control/control_strategies/optimized_pyomo_controller.py

@@ -100,6 +100,8 @@ class OptimizedDispatchController(PyomoControllerBaseClass):
 
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         """Initialize the optimized dispatch controller."""
         self.config = OptimizedDispatchControllerConfig.from_dict(

h2integrate/control/control_strategies/pyomo_controller_baseclass.py

@@ -75,6 +75,8 @@ def __attrs_post_init__(self):
 
 
 class PyomoControllerBaseClass(om.ExplicitComponent):
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         """
         Declare options for the component. See "Attributes" section in class doc strings for

h2integrate/control/control_strategies/storage/demand_openloop_storage_controller.py

@@ -115,6 +115,8 @@ class DemandOpenLoopStorageController(StorageOpenLoopControlBase):
     commodity to charge, discharge, or curtail at each time step.
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         self.config = DemandOpenLoopStorageControllerConfig.from_dict(
             merge_shared_inputs(self.options["tech_config"]["model_inputs"], "control"),

h2integrate/control/control_strategies/storage/openloop_storage_control_base.py

@@ -38,6 +38,8 @@ class StorageOpenLoopControlBase(om.ExplicitComponent):
     dispatch command profile.
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         self.options.declare("driver_config", types=dict)
         self.options.declare("plant_config", types=dict)

h2integrate/control/control_strategies/storage/simple_openloop_controller.py

@@ -56,6 +56,8 @@ class SimpleStorageOpenLoopController(StorageOpenLoopControlBase):
     uncontrolled frameworks.
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         self.config = SimpleStorageOpenLoopControllerConfig.from_dict(
             merge_shared_inputs(self.options["tech_config"]["model_inputs"], "control"),

h2integrate/converters/ammonia/ammonia_synloop.py

@@ -139,6 +139,8 @@ class AmmoniaSynLoopPerformanceModel(ResizeablePerformanceModelBaseClass):
     conversion efficiency up to the limiting reagent or energy input.
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         super().initialize()
         self.commodity = "ammonia"
@@ -423,6 +425,8 @@ class AmmoniaSynLoopCostModel(CostModelBaseClass):
         Annual maintenance cost
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         target_cost_year = self.options["plant_config"]["finance_parameters"][
             "cost_adjustment_parameters"

h2integrate/converters/ammonia/simple_ammonia_model.py

@@ -30,6 +30,8 @@ class SimpleAmmoniaPerformanceModel(PerformanceModelBaseClass):
     Computes annual ammonia production based on plant capacity and capacity factor.
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         super().initialize()
         self.commodity = "ammonia"
@@ -108,6 +110,8 @@ class SimpleAmmoniaCostModel(CostModelBaseClass):
     Includes CapEx, OpEx, and byproduct credits, and exposes all detailed cost outputs.
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         self.config = AmmoniaCostModelConfig.from_dict(
             merge_shared_inputs(self.options["tech_config"]["model_inputs"], "cost"),

h2integrate/converters/co2/marine/direct_ocean_capture.py

@@ -76,6 +76,8 @@ class DOCPerformanceModel(PerformanceModelBaseClass):
     An OpenMDAO component for modeling the performance of a Direct Ocean Capture (DOC) plant.
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         super().initialize()
         self.commodity = "co2"
@@ -153,6 +155,8 @@ class DOCCostModel(CostModelBaseClass):
     direct ocean capture (DOC) system.
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         super().initialize()
 

h2integrate/converters/co2/marine/ocean_alkalinity_enhancement.py

@@ -69,6 +69,8 @@ class OAEPerformanceConfig(BaseConfig):
 class OAEPerformanceModel(PerformanceModelBaseClass):
     """OpenMDAO component for modeling Ocean Alkalinity Enhancement (OAE) performance."""
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         super().initialize()
         self.commodity = "co2"
@@ -255,6 +257,8 @@ class OAECostModel(CostModelBaseClass):
     ocean alkalinity enhancement (OAE) system.
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         super().initialize()
 
@@ -347,6 +351,8 @@ class OAECostAndFinancialModel(CostModelBaseClass):
         - Carbon Credit Value
     """
 
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         super().initialize()
 

h2integrate/converters/generic_converter_cost.py

@@ -50,6 +50,8 @@ def __attrs_post_init__(self):
 
 
 class GenericConverterCostModel(CostModelBaseClass):
+    _time_step_bounds = (3600, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         self.config = GenericConverterCostConfig.from_dict(
             merge_shared_inputs(self.options["tech_config"]["model_inputs"], "cost"),

h2integrate/converters/grid/grid.py

@@ -36,6 +36,8 @@ class GridPerformanceModel(PerformanceModelBaseClass):
     different grid connection points (for example, one for buying upstream and
     another for selling downstream).
 
+    This model is compatible with time steps ranging from 5-minutes to 1-hour.
+
     Inputs
         interconnection_size (float): Maximum power capacity for grid connection (kW).
         electricity_in (array): Power flowing into the grid (selling) (kW).
@@ -45,6 +47,8 @@ class GridPerformanceModel(PerformanceModelBaseClass):
         electricity_out (array): Power flowing out of the grid (buying) (kW).
     """
 
+    _time_step_bounds = (300, 3600)  # (min, max) time step lengths compatible with this model
+
     def initialize(self):
         super().initialize()
         self.commodity = "electricity"
@@ -174,10 +178,12 @@ class GridCostModel(CostModelBaseClass):
     - Revenue from electricity sales (sell mode)
     - Support for time-varying electricity prices
 
-    Note: Although the electricity units are in kW and the prices are in USD/kWh,
-    this model assumes that each timestep represents 1 hour.
+    This model is compatible with time steps ranging from 5-minutes to 1-hour.
+
     """
 
+    _time_step_bounds = (300, 3600)  # (min, max) time step lengths compatible with this model
+
     def setup(self):
         self.config = GridCostModelConfig.from_dict(
             merge_shared_inputs(self.options["tech_config"]["model_inputs"], "cost"),
@@ -277,13 +283,13 @@ def compute(self, inputs, outputs, discrete_inputs, discrete_outputs):
             electricity_out = inputs["electricity_out"]
             buy_price = inputs["electricity_buy_price"]
             # Buying costs money (positive VarOpEx)
-            varopex += np.sum(electricity_out * buy_price)
+            varopex += np.sum((self.dt / 3600) * electricity_out * buy_price)
 
         # Add selling revenue if sell price is configured
         # electricity_sold represents power flowing INTO grid (selling)
         if self.config.electricity_sell_price is not None:
             sell_price = inputs["electricity_sell_price"]
             # Selling generates revenue (negative VarOpEx)
-            varopex -= np.sum(inputs["electricity_sold"] * sell_price)
+            varopex -= np.sum((self.dt / 3600) * inputs["electricity_sold"] * sell_price)
 
         outputs["VarOpEx"] = varopex