NatLabRockies · jaredthomas68 · Apr 14, 2026 · Apr 21, 2026 · Apr 28, 2026 · May 12, 2026
diff --git a/CHANGELOG.md b/CHANGELOG.md
@@ -73,6 +73,7 @@
 - Updated `commodity_sell_price` input to `ProFastNPV` to be per year of the plant life. Also updated `BasicProFASTParameterConfig.as_dict()` so explicitly input escalation values are not overwritten to the general inflation rate [PR 799](https://github.com/NatLabRockies/H2Integrate/pull/799)
 - Added `calc_azimuth_angle()` to `PYSAMSolarPlantPerformanceModel` to provide default azimuth angle based on whether the site is in the northern or southern hemisphere [PR 806](https://github.com/NatLabRockies/H2Integrate/pull/806)
 - Corrected water rate units in pipe feedstock from galUS to galUS/h [PR 813](https://github.com/NatLabRockies/H2Integrate/pull/813)
+- Added a thermal-nuclear (light-water reactor) model and a high-temperature steam electrolysis model. [PR 807](https://github.com/NatLabRockies/H2Integrate/pull/807)
 
 ## 0.8 [April 15, 2026]
 

diff --git a/docs/_static/class_hierarchy.html b/docs/_static/class_hierarchy.html
diff --git a/docs/technology_models/h2_htse.md b/docs/technology_models/h2_htse.md
@@ -0,0 +1,103 @@
+# High-Temperature Steam Electrolysis (HTSE) Model
+
+The HTSE model in H2Integrate represents hydrogen production from high-temperature steam electrolysis using electricity and thermal input. It is implemented as two components:
+
+- `HTSEPerformanceModel`
+- `HTSECostModel`
+
+The performance model converts electricity and heat into hydrogen, water demand, and operating signals for connected technologies. The cost model computes installed capital cost and fixed operating cost from installed HTSE size.
+
+## Model Overview
+
+This is a simplified HTSE representation with constant nominal specific energy requirements:
+
+- `nominal_electricity_required` in `kWh/kg`
+- `nominal_heat_required` in `kWh/kg`
+
+At each timestep, hydrogen production is determined from:
+
+- installed HTSE size
+- available `electricity_in`
+- available `heat_in`
+- optional `hydrogen_command_value` when system-level control is enabled
+- turndown behavior
+
+The model also exposes internal operating signals that are useful for coupled systems, including:
+
+- `heat_demand`
+- `electricity_demand`
+- `electricity_consumed`
+- `water_demand`
+
+```{note}
+The current implementation uses `electricity_demand` to report installed electrical demand equal to nameplate size, while `electricity_consumed` reports the timestep electricity required by the energy balance. For coupled analyses, `electricity_consumed` is the more literal consumption signal.
+```
+
+## Performance Model
+
+Use this model by setting:
-Use this model by setting:
+To use this model, within your `tech_config.yaml` file set:
-Use this model by setting:
+To use this model, within your `tech_config.yaml` file set:
+
+- performance model: `HTSEPerformanceModel`
+
+The HTSE performance model inherits from the electrolyzer base classes, so it is treated as a hydrogen-producing, dispatchable technology with an `electricity_in` input and a `hydrogen_out` output.
+
+```{figure} images/HTSE.png
+:alt: HTSE schematic
+:width: 100%
+:align: center
+```
+
+### Dispatch and sizing behavior
+
+Installed size is first inferred from:
-Installed size is first inferred from:
+Installed size is first calculated as:
-Installed size is first inferred from:
+Installed size is first calculated as:
+
+$$
+\text{electrolyzer\_size\_mw} = n_{clusters} \times cluster\_rating\_MW
+$$
+
+The model supports additional sizing modes inherited from the resizeable performance base class:
+
+- `normal`
+- `resize_by_max_feedstock`
+- `resize_by_max_commodity`
+
+In the current implementation:
+
+- `resize_by_max_feedstock` supports sizing from `electricity`
+- `resize_by_max_commodity` supports sizing from `hydrogen`
+
+When system-level control is enabled, hydrogen demand is taken from `hydrogen_command_value`. Otherwise, the model assumes demand equal to rated hydrogen production implied by installed electrical size.
+
+### Energy balance behavior
+
+The model forms:
+
+$$
+\text{total\_specific\_energy} = nominal\_heat\_required + nominal\_electricity\_required
+$$
+
+and computes a nominal heat-to-electricity ratio:
+
+$$
+\text{ratio\_heat\_elec\_nom} = \frac{nominal\_heat\_required}{nominal\_electricity\_required}
+$$
+
+Available heat is used first up to the requested `heat_demand`. The remaining required energy is supplied electrically when possible. Hydrogen production is then limited by the combined energy available and by the turndown threshold.
+
+```{note}
+The current implementation is intentionally simple and should be interpreted as a reduced-order plant representation, not a detailed SOEC stack model with thermal transients, degradation coupling, startup dynamics, or detailed balance-of-plant behavior.
+```
+
+### API details
+For API details, see the [`HTSEPerformanceModel` and `HTSECostModel` API documentation](../_autosummary/h2integrate.converters.hydrogen.htse_electrolyzer).
+
+## Cost Model
+
+Use this model by setting:
-Use this model by setting:
+To use this model, in your `tech_config.yaml` file, set:
-Use this model by setting:
+To use this model, in your `tech_config.yaml` file, set:
+
+- cost model: `HTSECostModel`
+
+The cost model is size-based and currently depends only on installed HTSE size.
+
+### API details
+For API details, see the [`HTSEPerformanceModel` and `HTSECostModel` API documentation](../_autosummary/h2integrate.converters.hydrogen.htse_electrolyzer).
diff --git a/docs/technology_models/images/HTSE.png b/docs/technology_models/images/HTSE.png
diff --git a/docs/technology_models/images/ThermalNucReactor-H2I.png b/docs/technology_models/images/ThermalNucReactor-H2I.png
diff --git a/docs/technology_models/nuclear.md b/docs/technology_models/nuclear.md
@@ -1,83 +1,33 @@
-# Nuclear power plant model
-
-The nuclear power plant model provides a simple, size-based performance model and a type-based cost model.
-Cost defaults are intended to be populated from literature, such as Quinn et al. (2023) on SMR LWR techno-economic analysis.
-See the paper here: [Quinn et al. (2023)](#references).
-
-To use this model, set the performance model to `QuinnNuclearPerformanceModel` and the cost model to `QuinnNuclearCostModel` in your `tech_config`.
-
-## Performance model
-
-The performance model limits electricity production by the rated capacity and an optional demand signal.
-
-**Inputs**
-| Name | Shape | Units | Description |
-| --- | --- | --- | --- |
-| `system_capacity` | scalar | kW | Rated electrical capacity. |
-| `electricity_set_point` | array[n_timesteps] | kW | Optional set point profile; defaults to rated capacity. |
-
-**Outputs**
-| Name | Shape | Units | Description |
-| --- | --- | --- | --- |
-| `electricity_out` | array[n_timesteps] | kW | Electricity produced, capped at `system_capacity`. |
-| `rated_electricity_production` | scalar | kW | Rated production (capacity). |
-| `total_electricity_produced` | scalar | kW*h | Sum of production over the simulation. |
-| `annual_electricity_produced` | array[plant_life] | kW*h/year | Annualized production. |
-| `capacity_factor` | array[plant_life] | unitless | Ratio of actual to maximum production. |
-| `replacement_schedule` | array[plant_life] | unitless | Placeholder replacement schedule (zeros). |
-| `operational_life` | scalar | yr | Operational life (defaults to plant life). |
-
-## Cost model
-
-The cost model uses direct cost parameters to compute capital and operating costs.
-It supports optional scaling of capex with size using a reference capacity and scaling exponent.
-
-**Inputs**
-| Name | Shape | Units | Description |
-| --- | --- | --- | --- |
-| `system_capacity` | scalar | kW | Plant capacity used for cost scaling. |
-| `electricity_out` | array[n_timesteps] | kW | Output from performance model. |
-
-**Cost parameters (tech_config)**
-| Key | Type | Description |
-| --- | --- | --- |
-| `system_capacity_kw` | float | Rated electrical capacity (kW). |
-| `capex_per_kw` | float | Capital cost per kW. |
-| `fixed_opex_per_kw_year` | float | Fixed O&M per kW per year. |
-| `variable_opex_per_mwh` | float | Variable O&M per MWh. |
-| `reference_capacity_kw` | float | Reference capacity for capex scaling (defaults to `system_capacity_kw`). |
-| `capex_scaling_exponent` | float | Capex scaling exponent (defaults to 1.0). |
-| `cost_year` | int | Dollar year for the input costs. |
-
-The capex calculation follows:
+# Nuclear power plant models
 
-$$
-C_{\text{capex}} = (c_{\text{capex}} \cdot (P / P_{\text{ref}})^{(k-1)}) \cdot P
-$$
+H2Integrate currently includes two nuclear converter options:
+
+- `QuinnNuclearPerformanceModel` with `QuinnNuclearCostModel` for an electricity-only nuclear plant
+- `SimpleThermalNuclearReactorPerformanceModel` with `SimpleThermalNuclearReactorCostModel` for a thermal reactor that can trade off electricity production and process heat delivery
+
+The first model is based on Quinn et al. (2023). The second is a simplified thermal reactor representation intended for coupled workflows such as nuclear plus HTSE.
 
-Where $c_{\text{capex}}$ is `capex_per_kw`, $P$ is plant capacity (kW), $P_{\text{ref}}$ is `reference_capacity_kw`, and $k$ is `capex_scaling_exponent`.
+## Quinn electricity-only nuclear model
 
-**Outputs**
-| Name | Shape | Units | Description |
-| --- | --- | --- | --- |
-| `CapEx` | scalar | USD | Total capital expenditure. |
-| `OpEx` | scalar | USD/year | Fixed plus variable O&M. |
-| `VarOpEx` | array[plant_life] | USD/year | Variable O&M (repeated each year). |
-| `cost_year` | scalar | year | Dollar year of costs. |
+Use this model by setting:
 
-## Example tech_config
+- performance model: `QuinnNuclearPerformanceModel`
+- cost model: `QuinnNuclearCostModel`
-Use this model by setting:
-
-## Example tech_config
- performance model: `QuinnNuclearPerformanceModel`
- cost model: `QuinnNuclearCostModel`
-Use this model by setting:
-
-## Example tech_config
- performance model: `QuinnNuclearPerformanceModel`
- cost model: `QuinnNuclearCostModel`
+
+This model produces electricity only and clips commanded output to rated plant capacity.
+
+### Example `tech_config`
 
 ```yaml
 technologies:
   nuclear:
     performance_model:
-      model: "QuinnNuclearPerformanceModel"
+      model: QuinnNuclearPerformanceModel
     cost_model:
-      model: "QuinnNuclearCostModel"
+      model: QuinnNuclearCostModel
     model_inputs:
       performance_parameters:
         system_capacity_kw: 300000.0
-        capacity_factor: 0.9
       cost_parameters:
         system_capacity_kw: 450000.0
         capex_per_kw: 6000.0
@@ -88,7 +38,51 @@ technologies:
         cost_year: 2023
 ```
 
-(references)=
-## References
+### API details
+For API details, see the [`QuinnNuclearPerformanceModel` and `QuinnNuclearCostModel` API documentation](../_autosummary/h2integrate.converters.nuclear.nuclear_plant).
 
+(references)=
+### References
 - Quinn, J. et al., 2023. Small modular reactor light water reactor techno-economic analysis. Applied Energy 120669. https://doi.org/10.1016/j.apenergy.2023.120669
+
+## Simple thermal nuclear reactor model
+
+Use this model by setting:
-Use this model by setting:
+You can use this model by setting (in your `tech_config.yaml`):
-Use this model by setting:
+You can use this model by setting (in your `tech_config.yaml`):
+
+- performance model: `SimpleThermalNuclearReactorPerformanceModel`
+- cost model: `SimpleThermalNuclearReactorCostModel`
+
+This model represents a reactor with:
+
+- a high-pressure electric conversion stage
+- a low-pressure electric conversion stage
+- an extractable process heat stream, extracted upstream of the low-pressure turbine stages (dashed red arrow in the figure)
+
+It supports two operating modes:
+
+- `heat`: In `heat` mode, delivered heat is limited by available process heat and requested heat demand. Remaining low-pressure heat is converted to electricity.
+
+- `electricity`: In `electricity` mode, electricity is limited by the command value and rated capacity. Remaining process heat is then sent as `heat_out`.
+
+```{figure} images/ThermalNucReactor-H2I.png
+:alt: Thermal nuclear reactor schematic
+:width: 100%
+:align: center
+```
+
+### Thermal reactor dispatch logic
+
+The model computes a combined electric efficiency:
+
+$$
+\eta_{combined} = \eta_{hp} + (1 - \eta_{hp}) \eta_{lp}
+$$
+
+Then infers thermal capacity from rated electrical capacity:
+
+$$
+P_{thermal} = \frac{P_{electric,rated}}{\eta_{combined}}
+$$
+
+### API details
+For API details, see the [`SimpleThermalNuclearReactorPerformanceModel` and `SimpleThermalNuclearReactorCostModel` API documentation](../_autosummary/h2integrate.converters.nuclear.nuclear_plant_thermal).
diff --git a/docs/user_guide/model_overview.md b/docs/user_guide/model_overview.md
@@ -150,12 +150,14 @@ auto-generated API page.
 - `hydrogen`: hydrogen production
   - performance models:
     + {py:class}`~h2integrate.converters.hydrogen.pem_electrolyzer.ECOElectrolyzerPerformanceModel` - An OpenMDAO component that wraps the PEM electrolyzer model.
+    + {py:class}`~h2integrate.converters.hydrogen.htse_electrolyzer.HTSEPerformanceModel` - A simplified high-temperature steam electrolysis (HTSE) model.
     + {py:class}`~h2integrate.converters.hydrogen.h2_fuel_cell.LinearH2FuelCellPerformanceModel` - Performance model for a hydrogen fuel cell.
     + {py:class}`~h2integrate.converters.hydrogen.steam_methane_reformer.SteamMethaneReformerPerformanceModel` - Performance model for steam methane reforming (SMR) hydrogen production plants.
   - cost models:
     + {py:class}`~h2integrate.converters.hydrogen.basic_cost_model.BasicElectrolyzerCostModel` - An OpenMDAO component that computes the cost of a PEM electrolyzer.
     + {py:class}`~h2integrate.converters.hydrogen.custom_electrolyzer_cost_model.CustomElectrolyzerCostModel` - An OpenMDAO component that computes the cost of a PEM electrolyzer.
     + {py:class}`~h2integrate.converters.hydrogen.h2_fuel_cell.H2FuelCellCostModel` - Cost model for a hydrogen fuel cell system.
+    + {py:class}`~h2integrate.converters.hydrogen.htse_electrolyzer.HTSECostModel` - A simple size-based cost model for HTSE.
     + {py:class}`~h2integrate.converters.hydrogen.singlitico_cost_model.SingliticoCostModel` - An OpenMDAO component that computes the cost of a PEM electrolyzer.
     + {py:class}`~h2integrate.converters.hydrogen.steam_methane_reformer.SteamMethaneReformerCostModel` - Cost model for steam methane reforming hydrogen production plants.
   - combined performance and cost models:
@@ -202,8 +204,10 @@ auto-generated API page.
 - `nuclear`: nuclear power plants
   - performance models:
     + {py:class}`~h2integrate.converters.nuclear.nuclear_plant.QuinnNuclearPerformanceModel` - Simple nuclear performance model producing electricity.
+    + {py:class}`~h2integrate.converters.nuclear.nuclear_plant_thermal.SimpleThermalNuclearReactorPerformanceModel` - Simple thermal nuclear reactor model with heat and electricity outputs.
   - cost models:
     + {py:class}`~h2integrate.converters.nuclear.nuclear_plant.QuinnNuclearCostModel` - Cost model for nuclear power plants.
+    + {py:class}`~h2integrate.converters.nuclear.nuclear_plant_thermal.SimpleThermalNuclearReactorCostModel` - Simple cost model for the thermal nuclear reactor.
 
 - `solar`: solar-PV panels
   - performance models:

diff --git a/examples/36_nuclear_reactor_htse/driver_config.yaml b/examples/36_nuclear_reactor_htse/driver_config.yaml
@@ -0,0 +1,52 @@
+name: driver_config
+description: Runs a thermal nuclear plant with simple optimization
+general:
+  folder_output: nuclear_thermal_plant
+### Use This For Parameter Sweep
+# driver:
+#   design_of_experiments:
+#     flag: true
+#     generator: "FullFact" #type of generator to use
+#     levels: 3  # input is specific to this generator
+#     debug_print: true
+driver:
+  optimization:
+    flag: false
+    solver: COBYLA
+    tol: 0.1
+    catol: 100000
+    max_iter: 100
+    rhobeg: 0.1
+    disp: 3
+    debug_print: true
+design_variables:
+  nuclear:
+    electricity_command_value:
+      flag: true
+      lower: 1000
+      upper: 500000
+      units: kW
+  htse:
+    n_clusters:
+      flag: true
+      lower: 2.0
+      upper: 40.0
+      units: unitless
+# Add constraints later to the code
+# constraints:
+  # nuclear:
+    # electricity_out:
+      # flag: true
+      # upper: 5000.0
+      # units: MW
+  #   ramping_rate:
+  #     flag: true
+  #     upper: 500
+  #     units: kW/hr
+  # electrolyzer:
+  #   total_hydrogen_produced:
+  #     flag: false
+  #     lower: 60500000.
+  #     units: kg/year
+objective:
+  name: finance_subgroup_hydrogen.LCOH
diff --git a/examples/36_nuclear_reactor_htse/nuclear_reactor_thermal_htse.yaml b/examples/36_nuclear_reactor_htse/nuclear_reactor_thermal_htse.yaml
@@ -0,0 +1,6 @@
+name: H2Integrate_config
+system_summary: This is an example plant with a nuclear plant capable of dispatching thermal and electrical energy to an HTSE
+  system
+driver_config: driver_config.yaml
+technology_config: tech_config.yaml
+plant_config: plant_config.yaml