Framework to allow for variable dt (#653)

* add draft for variable timestep framework

* Changed error wording

* switch bounds to tuple

* minor test correction

* include time-series generation functions

* add tests for variable dt and update simulation length check for non-hourly dt

* update docs

* update changelog

* update docs and doc strings

* restore develop version of utilities.py

* update dt bounds error

* Apply suggestions from code review

Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

* Fixing tests

* Adding time step bounds to all models

* Adding time step bounds to the combiner/splitter/transporters

* Updates for tests

* Adding time step bounds to the custom paper mill performance model

* Added time step bounds to paper mill cost

---------

Co-authored-by: John Jasa <johnjasa11@gmail.com>
Co-authored-by: kbrunik <102193481+kbrunik@users.noreply.github.com>
Co-authored-by: John Jasa <john.jasa@nrel.gov>
Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>

Author: 4 people

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(