Remove system-level outputs from storage and replace with demand component (follow-on to 631)

docs/_toc.yml

@@ -72,6 +72,7 @@ parts:
   - caption: Demand
     chapters:
       - file: demand/demand_components
+      - file: demand/demand_demo
   - caption: Finance Models
     chapters:
       - file: finance_models/financial_analyses

docs/control/controller_demonstrations.md

@@ -17,28 +17,39 @@ kernelspec:
 from pathlib import Path
 from matplotlib import pyplot as plt
 from h2integrate.core.h2integrate_model import H2IntegrateModel
+from h2integrate import EXAMPLE_DIR
+
 ```
 
 ## Hydrogen Dispatch
 
 The following example is an expanded form of `examples/14_wind_hydrogen_dispatch`.
 
 Here, we're highlighting the dispatch controller setup from
-`examples/14_wind_hydrogen_dispatch/inputs/tech_config.yaml`. Please note some sections are removed
-simply to highlight the controller sections
+`examples/14_wind_hydrogen_dispatch/inputs/tech_config.yaml`. Please note some sections are removed simply to highlight the controller sections
+
+```{literalinclude} ../../examples/14_wind_hydrogen_dispatch/inputs/tech_config.yaml
+:language: yaml
+:lineno-start: 52
+:linenos: true
+:lines: 52,53-54,57-58,59-71
+```
+
+We also include a demand technology to calculate how much demand is met, how much commodity is unused to meet the demand, and how much demand is remaining:
 
 ```{literalinclude} ../../examples/14_wind_hydrogen_dispatch/inputs/tech_config.yaml
 :language: yaml
-:lineno-start: 54
+:lineno-start: 79
 :linenos: true
-:lines: 54,59-61,67-74
+:lines: 79-86
 ```
 
+
 Using the primary configuration, we can create, run, and postprocess an H2Integrate model.
 
 ```{code-cell} ipython3
 # Create an H2Integrate model
-model = H2IntegrateModel(Path("../../examples/14_wind_hydrogen_dispatch/inputs/h2i_wind_to_h2_storage.yaml"))
+model = H2IntegrateModel(EXAMPLE_DIR/"14_wind_hydrogen_dispatch"/"inputs"/"h2i_wind_to_h2_storage.yaml")
 
 # Run the model
 model.run()
@@ -50,15 +61,8 @@ Now, we can visualize the demand profiles over time.
 ```{code-cell} ipython3
 fig, (ax1, ax2) = plt.subplots(2, 1, sharex=True, figsize=(8, 6), layout="tight")
 
-start_hour = 0
-end_hour = 200
-total_time_steps = model.prob.get_val("h2_storage.SOC").size
-demand_profile = [
-    model.technology_config["technologies"]["h2_storage"]["model_inputs"]["shared_parameters"][
-        "demand_profile"
-    ]
-    * 1e-3
-] * total_time_steps
+start_hour = 800
+end_hour = 1000
 xvals = list(range(start_hour, end_hour))
 
 ax1.plot(
@@ -74,41 +78,41 @@ ax2.plot(
 )
 ax2.plot(
     xvals,
-    model.prob.get_val("h2_storage.unused_hydrogen_out", units="t/h")[start_hour:end_hour],
+    model.prob.get_val("h2_load_demand.unused_hydrogen_out", units="t/h")[start_hour:end_hour],
     linestyle=":",
     label="H$_2$ Unused (kg)",
 )
 ax2.plot(
     xvals,
-    model.prob.get_val("h2_storage.unmet_hydrogen_demand_out", units="t/h")[start_hour:end_hour],
+    model.prob.get_val("h2_load_demand.unmet_hydrogen_demand_out", units="t/h")[start_hour:end_hour],
     linestyle=":",
     label="H$_2$ Unmet Demand (kg)",
 )
 ax2.plot(
     xvals,
-    model.prob.get_val("h2_storage.hydrogen_out", units="t/h")[start_hour:end_hour],
+    model.prob.get_val("h2_load_demand.hydrogen_out", units="t/h")[start_hour:end_hour],
     linestyle="-",
     label="H$_2$ Delivered (kg)",
 )
 ax2.plot(
     xvals,
-    demand_profile[start_hour:end_hour],
+    model.prob.get_val("h2_load_demand.hydrogen_demand", units="t/h")[start_hour:end_hour],
     linestyle="--",
     label="H$_2$ Demand (kg)",
 )
 
 ax1.set_ylabel("SOC (%)")
 ax1.grid()
 ax1.set_axisbelow(True)
-ax1.set_xlim(0, 200)
-ax1.set_ylim(0, 50)
+ax1.set_xlim(start_hour, end_hour)
+ax1.set_ylim(60, 100)
 
 ax2.set_ylabel("H$_2$ Hourly (t)")
 ax2.set_xlabel("Timestep (hr)")
 ax2.grid()
 ax2.set_axisbelow(True)
-ax2.set_ylim(0, 20)
-ax2.set_yticks(range(0, 21, 2))
+ax2.set_ylim(0, 18)
+ax2.set_yticks(range(0, 19, 2))
 
 plt.legend(ncol=3)
 fig.show()

docs/demand/demand_components.md

@@ -88,3 +88,23 @@ model_inputs:
     ramp_up_rate_fraction: 0.5
     min_utilization: 0
 ```
+
+(demand-component-inputs-and-outputs)=
+## Demand component inputs and outputs
+The inputs to the demand components are the `{commodity}_demand` profile and the `{commodity}_in` profile. The `{commodity}_in` profile is the initial commodity used to satisfy the demand. Suppose the `{commodity}_in` (pink) and `{commodity}_demand` (green) profiles look like whats shown below:
+
+![](./figures/demand_inputs.png)
+
+The demand components then compute the following output profiles:
+- `unmet_{commodity}_demand_out`: Unmet demand (non-zero when supply < demand, otherwise 0.)
+- `unused_{commodity}_out`: Unused commodity (non-zero when supply > demand, otherwise 0.)
+
+![](./figures/demand_calcs.png)
+
+- `commodity_out`: Delivered output (commodity supplied to demand sink)
+
+![](./figures/demand_commodity_out.png)
+
+The demand components also compute the following outputs:
+- `capacity_factor`: the ratio of the demand that's been met to the full demand
+- `rated_commodity_production`: the maximum value of the demand profile

docs/demand/demand_demo.md

@@ -0,0 +1,213 @@
+---
+jupytext:
+  text_representation:
+    extension: .md
+    format_name: myst
+    format_version: 0.13
+    jupytext_version: 1.18.1
+kernelspec:
+  display_name: native-ard-h2i
+  language: python
+  name: python3
+---
+
+# Demand Demonstration
+Different usage of demand components is shown in the following examples:
+- `13_dispatch_for_electrolyzer`: sets the battery demand differently than the demand profile of the demand component
+- `23_solar_wind_ng_demand`: compares usage of the `GenericDemandComponent` and `FlexibleDemandComponent`
+- `24_solar_battery_grid`: sells excess electricity to grid
+
+This demonstration will focus on the `13_dispatch_for_electrolyzer` example
+
+## Electrolyzer load demand
+
+The following example is an expanded form of `examples/13_dispatch_for_electrolyzer`.
+
+The technology interconnections:
+
+```{literalinclude} ../../examples/13_dispatch_for_electrolyzer/plant_config.yaml
+:language: yaml
+:lineno-start: 16
+:linenos: true
+:lines: 16-27
+```
+
+
+The electrolyzer system is comprised of 6 stacks, each rated at 10 MW, resulting in a total capacity of 60 MW. The minimum operating point of the electrolyzer (`turndown_ratio`) is 10% of the rated capacity, meaning that the electrolyzer is turned off if there is less than 6 MW of input electricity.
+
+```{literalinclude} ../../examples/13_dispatch_for_electrolyzer/tech_config.yaml
+:language: yaml
+:lineno-start: 121
+:linenos: true
+:lines: 121-123,126-127,130,131,135
+```
+
+We want to dispatch the battery to *keep the electrolyzer on*. We set the demand profile for the battery as the minimum power required to keep the electrolyzer on, 6 MW.
+
+```{note}
+Note: the demand profile for the battery is only used by the battery controller and is not used in the battery performance model for any calculations.
+```
+
+
+```{literalinclude} ../../examples/13_dispatch_for_electrolyzer/tech_config.yaml
+:language: yaml
+:lineno-start: 79
+:linenos: true
+:lines: 79-90, 100
+```
+
+We don't want to send more electricity to the electrolyzer than the electrolyzer can use. We use the demand component to saturate the electricity generation to the electrolyzer's rated capacity (equal to 60 MW).
+
+```{literalinclude} ../../examples/13_dispatch_for_electrolyzer/tech_config.yaml
+:language: yaml
+:lineno-start: 113
+:linenos: true
+:lines: 113-120
+```
+
+
+
+We initialize and setup the H2I model
+
+```{code-cell} ipython3
+from matplotlib import pyplot as plt
+from h2integrate.core.h2integrate_model import H2IntegrateModel
+from h2integrate import EXAMPLE_DIR
+
+# Create an H2Integrate model
+h2i = H2IntegrateModel(EXAMPLE_DIR/"13_dispatch_for_electrolyzer"/"inputs"/"h2i_wind_to_h2_storage.yaml")
+
+# Setup the model
+h2i.setup()
+```
+
+If we wanted to change the demand profiles for the battery (`battery`) or the demand component (`elec_load_demand`) to be different than the demand profiles specified in the technology config, we can do that using `set_val`:
+
+```{code-cell} ipython3
+electrolyzer_capacity_MW = 60
+
+# Set the battery demand equal to the minimum electricity needed to keep the electrolyzer on
+h2i.prob.set_val("battery.electricity_demand", 0.1 * electrolyzer_capacity_MW, units="MW")
+
+# Set the demand of the demand component equal to the rated electrical capacity of the electrolyzer
+h2i.prob.set_val("elec_load_demand.electricity_demand", electrolyzer_capacity_MW, units="MW")
+```
+
+We then run the model:
+```{code-cell} ipython3
+# Run the model
+h2i.run()
+h2i.prob.get_val("finance_subgroup_hydrogen.LCOH", units="USD/kg")[0]
+```
+
+
+### Plotting outputs
+
+First, we get the main inputs and outputs of the `GenericDemandComponent` technology:
+
+```{code-cell} ipython3
+generation_with_battery = h2i.prob.get_val("elec_load_demand.electricity_in", units="MW")
+full_demand = h2i.prob.get_val("elec_load_demand.electricity_demand", units="MW")
+unmet_demand = h2i.prob.get_val("elec_load_demand.unmet_electricity_demand_out", units="MW")
+excess_electricity = h2i.prob.get_val("elec_load_demand.unused_electricity_out", units="MW")
+```
+
+Plot the inputs to the `GenericDemandComponent` and outputs calculated in the `GenericDemandComponent`:
+
+```{code-cell} ipython3
+import matplotlib.pyplot as plt
+fig, ax = plt.subplots(1, 1, figsize=[6.4, 2.4])
+
+start_hour = 800
+end_hour = 1000
+
+x = list(range(start_hour, end_hour))
+where_unmet_demand = [True if d>0 else False for d in unmet_demand[start_hour:end_hour]]
+where_excess_commodity = [True if d>0 else False for d in excess_electricity[start_hour:end_hour]]
+
+ax.fill_between(x, full_demand[start_hour:end_hour], generation_with_battery[start_hour:end_hour], where=where_unmet_demand, color="tab:red", alpha=0.5, zorder=0, label="unmet_commodity_demand_out")
+ax.fill_between(x, full_demand[start_hour:end_hour], generation_with_battery[start_hour:end_hour], where=where_excess_commodity, color="tab:blue", alpha=0.5, zorder=1, label="unused_commodity_out")
+ax.plot(x, full_demand[start_hour:end_hour], color="tab:green", lw=2.0, ls='solid', zorder=4, label="commodity_demand")
+ax.plot(x, generation_with_battery[start_hour:end_hour], color="tab:pink", lw=2.0, ls='solid', zorder=3, label="commodity_in")
+
+ax.set_xlim([start_hour,end_hour])
+ax.spines[['right', 'top']].set_visible(False)
+ax.legend(bbox_to_anchor=(0.10, 0.95), loc="lower left", borderaxespad=0.0, framealpha=0.0,  ncols=2)
+ax.set_ylabel("GenericDemandComponent \nElectricity (MW)")
+ax.set_xlabel("Time (hours)")
+```
+
+
+Plot the main inputs and outputs of the `GenericDemandComponent`:
+
+```{code-cell} ipython3
+fig, ax = plt.subplots(1, 1, figsize=[6.4, 2.4])
+ax.fill_between(x, full_demand[start_hour:end_hour], generation_with_battery[start_hour:end_hour], where=where_excess_commodity, color="tab:grey", alpha=0.25, zorder=1, label="_unused_commodity_out")
+ax.plot(x, generation_with_battery[start_hour:end_hour], color="tab:grey", lw=2.0, ls='solid', zorder=2, label="commodity_in", alpha=0.25)
+
+ax.plot(x, full_demand[start_hour:end_hour], color="tab:green", alpha=0.5, lw=1.5, ls='-.', zorder=3, label="commodity_demand")
+
+ax.plot(x, h2i.prob.get_val("elec_load_demand.electricity_out", units="MW")[start_hour:end_hour], color="tab:purple", lw=2.0, ls='solid', zorder=4, label="commodity_out")
+ax.spines[['right', 'top']].set_visible(False)
+ax.set_xlim([start_hour, end_hour])
+ax.set_ylabel("GenericDemandComponent \nElectricity (MW)")
+ax.set_xlabel("Time (hours)")
+ax.legend(bbox_to_anchor=(0.0, 0.95), loc="lower left", ncols=3, borderaxespad=0.0, framealpha=0.0)
+```
+
+
+Plot the battery performance:
+
+```{code-cell} ipython3
+fig, ax = plt.subplots(1, 1, figsize=[7.2, 2.4])
+
+start_hour = 900
+end_hour = 1000
+x = list(range(start_hour, end_hour))
+
+generation = h2i.prob.get_val("battery.electricity_in", units="MW")
+battery_demand = h2i.prob.get_val("battery.electricity_demand", units="MW")
+battery_charge_discharge = h2i.prob.get_val("battery.electricity_out", units="MW")
+
+where_charge =  [True if d<0 else False for d in battery_charge_discharge[start_hour:end_hour]]
+where_discharge =  [True if d>0 else False for d in battery_charge_discharge[start_hour:end_hour]]
+
+ax.plot(x, battery_demand[start_hour:end_hour], color="tab:green", alpha=0.5, lw=1.5, ls='-.', zorder=2, label="battery.electricity_demand")
+ax.plot(x, generation[start_hour:end_hour], color="tab:blue", alpha=1.0, lw=1.5, ls='--', zorder=3, label="battery.electricity_in")
+ax.plot(x, generation_with_battery[start_hour:end_hour], color="tab:pink", alpha=1.0, lw=1.5, ls='-', zorder=3, label="elec_combiner.electricity_out")
+ax.fill_between(x, generation[start_hour:end_hour], generation_with_battery[start_hour:end_hour], where=where_charge, color="tab:cyan", alpha=0.5, zorder=0, label="battery charging")
+ax.fill_between(x, generation[start_hour:end_hour], generation_with_battery[start_hour:end_hour], where=where_discharge, color="tab:orange", alpha=0.5, zorder=0, label="battery discharging")
+
+
+ax.spines[['right', 'top']].set_visible(False)
+ax.set_xlim([start_hour, end_hour])
+ax.set_ylim([0, 70])
+ax.legend(bbox_to_anchor=(1.0, 0.5), loc="center left", borderaxespad=0, framealpha=0.0)
+ax.set_ylabel("Electricity (MW)")
+ax.set_xlabel("Time (hours)")
+```
+
+
+### Changing the battery demand
+
+Lets see what the LCOH is when the battery is used to keep the electrolyzer on:
+```{code-cell} ipython3
+h2i.prob.get_val("finance_subgroup_hydrogen.LCOH", units="USD/kg")[0]
+```
+
+If we re-run H2I and set the battery demand equal to the electrolyzer capacity instead, we can see that the LCOH increases:
+
+```{code-cell} ipython3
+
+# Set the battery demand equal to the rated electrical capacity of the electrolyzer
+h2i.prob.set_val("battery.electricity_demand",electrolyzer_capacity_MW, units="MW")
+
+# Set the demand of the demand component equal to the rated electrical capacity of the electrolyzer
+h2i.prob.set_val("elec_load_demand.electricity_demand", electrolyzer_capacity_MW, units="MW")
+
+# Re-run H2I
+h2i.run()
+
+# Get the LCOH
+h2i.prob.get_val("finance_subgroup_hydrogen.LCOH", units="USD/kg")[0]
+```

examples/01_onshore_steel_mn/plant_config.yaml

@@ -22,8 +22,15 @@ technology_interconnections:
   - [wind, combiner, electricity, cable]
   - [solar, combiner, electricity, cable]
   - [combiner, battery, electricity, cable]
-  - [battery, electrolyzer, electricity, cable]
+  # combine the battery output with the wind and solar generation
+  - [battery, elec_combiner, electricity, cable]
+  - [combiner, elec_combiner, electricity, cable]
+  # connect the electricity supply to the electrolyzer
+  - [elec_combiner, electrolyzer, electricity, cable]
   - [electrolyzer, h2_storage, hydrogen, pipe]
+  # combine the h2 from the electrolyzer and the h2_storage
+  - [electrolyzer, h2_combiner, hydrogen, pipe]
+  - [h2_storage, h2_combiner, hydrogen, pipe]
   - [finance_subgroup_hydrogen, steel, [LCOH_delivered, LCOH]]
   # etc
 tech_to_dispatch_connections: