Merge pull request #543 from NREL/develop

v0.56.1 Patch fixes for Peak Scaling, URDB meta, HT-TES Bypass

Author: Bill-Becker

CHANGELOG.md

@@ -25,6 +25,11 @@ Classify the change according to the following categories:
     ### Deprecated
     ### Removed
 
+## V0.56.1
+### Fixed
+- `CST` bypassing constraints for not serving (`can_serve_.. = false`) heating load types by going through the `HighTempThermalStorage`
+- Type error with `ElectricLoad.monthly_peaks_kw` so that it now converts Vector{Any} to Vector{<:Real}
+- `ElectricTariff.urdb_metadata.rate_effective_date` with the right URDB parameter
 
 ## v0.56.0
 ### Added

Project.toml

@@ -1,7 +1,7 @@
 name = "REopt"
 uuid = "d36ad4e8-d74a-4f7a-ace1-eaea049febf6"
 authors = ["Nick Laws", "Hallie Dunham <hallie.dunham@nrel.gov>", "Bill Becker <william.becker@nrel.gov>", "Bhavesh Rathod <bhavesh.rathod@nrel.gov>", "Alex Zolan <alexander.zolan@nrel.gov>", "Amanda Farthing <amanda.farthing@nrel.gov>", "Xiangkun Li <xiangkun.li@nrel.gov>", "An Pham <an.pham@nrel.gov>", "Byron Pullutasig <byron.pullatasig@nrel.gov>"]
-version = "0.56.0"
+version = "0.56.1"
 
 [deps]
 ArchGDAL = "c9ce4bd3-c3d5-55b8-8973-c0e20141b8c3"

src/constraints/storage_constraints.jl

@@ -306,4 +306,63 @@ function add_storage_sum_grid_constraints(m, p; _n="")
       sum(m[Symbol("dvGridPurchase"*_n)][ts, tier] for tier in 1:p.s.electric_tariff.n_energy_tiers) >= 
       sum(m[Symbol("dvGridToStorage"*_n)][b, ts] for b in p.s.storage.types.elec)
     )
+end
+
+"""
+	add_hot_tes_flow_restrictions!(m, p, b)
+
+Add flow restrictions from individual heating technologies to charge via dvHeatToStorage and 
+discharge via dvHeatFromStorage depending on the compatible loads served.
+"""
+function add_hot_tes_flow_restrictions!(m, p, b)
+    # If there are incompatible heating techs for the storage (i.e., TES fills load the tech cannot), all charge to storage from that tech is zero
+    for t in union(p.techs.heating, p.techs.chp)
+        incompatible_loads_served = []
+        if ("DomesticHotWater" in p.heating_loads_served_by_tes[b] && !(t in p.techs.can_serve_dhw)) 
+            push!(incompatible_loads_served, "DomesticHotWater")
+        end
+        if ("SpaceHeating" in p.heating_loads_served_by_tes[b] && !(t in p.techs.can_serve_space_heating))
+            push!(incompatible_loads_served, "SpaceHeating")
+        end
+        if ("ProcessHeat" in p.heating_loads_served_by_tes[b] && !(t in p.techs.can_serve_process_heat)) 
+            push!(incompatible_loads_served, "ProcessHeat")
+        end
+        if !isempty(incompatible_loads_served)
+            @warn "Technology "*t*" is ineligible to serve storage system "*b*" due to the following incompatible loads served "*string(incompatible_loads_served) 
+            for q in p.heating_loads_served_by_tes[b]
+                for ts in p.time_steps
+                    fix(m[:dvHeatToStorage][b,t,q,ts], 0.0, force=true)
+                end
+            end
+        end
+    end
+
+    #If load isn't served by storage, all charge or discharge flows of that quality heat are zero 
+    if !isempty(setdiff(p.heating_loads, p.heating_loads_served_by_tes[b]))
+        @constraint(m, [t in union(p.techs.heating, p.techs.chp), 
+            q in setdiff(p.heating_loads, p.heating_loads_served_by_tes[b]), 
+            ts in p.time_steps], 
+             m[:dvHeatToStorage][b,t,q,ts] == 0
+        )
+        @constraint(m, [q in setdiff(p.heating_loads, p.heating_loads_served_by_tes[b]), 
+            ts in p.time_steps], m[:dvHeatFromStorage][b,q,ts] == 0
+        )
+    end
+
+    # If a heating load is served by a storage vehicle, only allow charge from compatible techs. otherwise, allow no charge for that heat quality.
+    if "DomesticHotWater" in p.heating_loads_served_by_tes[b] && !isempty(setdiff(union(p.techs.heating, p.techs.chp), p.techs.can_serve_dhw))
+        @constraint(m, [t in setdiff(union(p.techs.heating, p.techs.chp), p.techs.can_serve_dhw), ts in p.time_steps], 
+            m[:dvHeatToStorage][b,t,"DomesticHotWater",ts] == 0
+        )
+    end
+    if "SpaceHeating" in p.heating_loads_served_by_tes[b] && !isempty(setdiff(union(p.techs.heating, p.techs.chp), p.techs.can_serve_space_heating))
+        @constraint(m, [t in setdiff(union(p.techs.heating, p.techs.chp), p.techs.can_serve_space_heating), ts in p.time_steps], 
+            m[:dvHeatToStorage][b,t,"SpaceHeating",ts] == 0
+        )
+    end
+    if "ProcessHeat" in p.heating_loads_served_by_tes[b] && !isempty(setdiff(union(p.techs.heating, p.techs.chp), p.techs.can_serve_process_heat))
+        @constraint(m, [t in setdiff(union(p.techs.heating, p.techs.chp), p.techs.can_serve_process_heat), ts in p.time_steps], 
+            m[:dvHeatToStorage][b,t,"ProcessHeat",ts] == 0
+        )
+    end
 end

src/core/electric_load.jl

@@ -271,26 +271,26 @@ end
 
 """
     scale_load_to_monthly_peaks(
-        initial_loads_kw::Vector{Float64}, 
-        target_monthly_peaks_kw::Vector{Float64}, 
+        initial_loads_kw::Vector{<:Real}, 
+        target_monthly_peaks_kw::Vector{<:Real}, 
         time_steps_per_hour::Int, 
         year::Int
     ) -> Vector{Float64}
 
 Scales an electric load profile to match specified monthly peak demands while preserving the overall shape of the load profile.
 
 # Arguments
-- `initial_loads_kw::Vector{Float64}`: The original load profile (kW) for the entire year, with a length of `8760 * time_steps_per_hour`.
-- `target_monthly_peaks_kw::Vector{Float64}`: A vector of 12 values representing the desired peak demand (kW) for each month.
+- `initial_loads_kw::Vector{<:Real}`: The original load profile (kW) for the entire year, with a length of `8760 * time_steps_per_hour`.
+- `target_monthly_peaks_kw::Vector{<:Real}`: A vector of 12 values representing the desired peak demand (kW) for each month.
 - `time_steps_per_hour::Int`: The number of time steps per hour (e.g., 1 for hourly data, 4 for 15-minute intervals).
 - `year::Int`: The year of the load profile, used to determine the number of days in each month (e.g., leap years).
 
 # Returns
 - `Vector{Float64}`: A scaled load profile (kW) with the same length as `initial_loads_kw`, adjusted to meet the specified monthly peak demands.
 """
 function scale_load_to_monthly_peaks(
-    initial_loads_kw::Vector{Float64}, 
-    target_monthly_peaks_kw::Vector{Float64}, 
+    initial_loads_kw::Vector{<:Real}, 
+    target_monthly_peaks_kw::Vector{<:Real}, 
     time_steps_per_hour::Int, 
     year::Int
     )
@@ -340,7 +340,7 @@ Args:
 Returns:
     Profile for given month, scaled to peak
 """
-function apply_linear_flattening(initial_load_series_kw::Vector{Float64}, target_peak_kw::Float64)
+function apply_linear_flattening(initial_load_series_kw::Vector{<:Real}, target_peak_kw::Real)
 
     # The flat load is the average power (kW) that sums to the same total energy over the time period
     flat_load_kw = sum(initial_load_series_kw) / length(initial_load_series_kw)
@@ -367,7 +367,7 @@ Args:
 Returns:
     Profile for given month, scaled to peak
 """
-function apply_exponential_stretching(initial_load_series_kw::Vector{Float64}, target_peak_kw::Float64, time_steps_per_hour::Int)
+function apply_exponential_stretching(initial_load_series_kw::Vector{<:Real}, target_peak_kw::Real, time_steps_per_hour::Int)
     initial_peak_kw = maximum(initial_load_series_kw)
     transformed_load_series_kw = initial_load_series_kw .* (target_peak_kw / initial_peak_kw)
     target_total_energy_kwh = sum(initial_load_series_kw) / time_steps_per_hour

src/core/reopt.jl

@@ -204,7 +204,6 @@ function build_reopt!(m::JuMP.AbstractModel, p::REoptInputs)
             end
         end
 	end
-
 	for b in p.s.storage.types.all
 		if p.s.storage.attr[b].max_kw == 0 || p.s.storage.attr[b].max_kwh == 0
 			@constraint(m, [ts in p.time_steps], m[:dvStoredEnergy][b, ts] == 0)
@@ -216,22 +215,8 @@ function build_reopt!(m::JuMP.AbstractModel, p::REoptInputs)
 				@constraint(m, [t in p.techs.elec, ts in p.time_steps_with_grid],
 						m[:dvProductionToStorage][b, t, ts] == 0)
 			elseif b in p.s.storage.types.hot
-				@constraint(m, [q in q in setdiff(p.heating_loads, p.heating_loads_served_by_tes[b]), ts in p.time_steps], m[:dvHeatFromStorage][b,q,ts] == 0)
-				if "DomesticHotWater" in p.heating_loads_served_by_tes[b]
-					@constraint(m, [t in setdiff(p.heating_techs, p.techs_can_serve_dhw), ts in p.time_steps], m[:dvHeatToStorage][b,t,"DomesticHotWater",ts] == 0)
-				else
-					@constraint(m, [t in p.heating_techs, ts in p.time_steps], m[:dvHeatToStorage][b,t,"DomesticHotWater",ts] == 0)
-				end
-				if "SpaceHeating" in p.heating_loads_served_by_tes[b]
-					@constraint(m, [t in setdiff(p.heating_techs, p.techs_can_serve_space_heating), ts in p.time_steps], m[:dvHeatToStorage][b,t,"SpaceHeating",ts] == 0)
-				else
-					@constraint(m, [t in p.heating_techs, ts in p.time_steps], m[:dvHeatToStorage][b,t,"SpaceHeating",ts] == 0)
-				end
-				if "ProcessHeat" in p.heating_loads_served_by_tes[b]
-					@constraint(m, [t in setdiff(p.heating_techs, p.techs_can_serve_process_heat), ts in p.time_steps], m[:dvHeatToStorage][b,t,"ProcessHeat",ts] == 0)
-				else
-					@constraint(m, [t in p.heating_techs, ts in p.time_steps], m[:dvHeatToStorage][b,t,"ProcessHeat",ts] == 0)
-				end
+				@constraint(m, [q in p.heating_loads, ts in p.time_steps], m[:dvHeatFromStorage][b,q,ts] == 0)
+				@constraint(m, [t in union(p.techs.heating, p.techs.chp), q in p.heating_loads, ts in p.time_steps], m[:dvHeatToStorage][b,t,q,ts] == 0)
 			end
 		else
 			add_storage_size_constraints(m, p, b)
@@ -244,6 +229,7 @@ function build_reopt!(m::JuMP.AbstractModel, p::REoptInputs)
 				end
 			elseif b in p.s.storage.types.hot
 				add_hot_thermal_storage_dispatch_constraints(m, p, b)
+				add_hot_tes_flow_restrictions!(m, p, b)
 			elseif b in p.s.storage.types.cold
 				add_cold_thermal_storage_dispatch_constraints(m, p, b)
 			else
@@ -714,6 +700,7 @@ function add_variables!(m::JuMP.AbstractModel, p::REoptInputs)
 			end
         end
 		if !isempty(p.s.storage.types.hot)
+			# TODO introduce these as sparse variables, add a set of techs charging storage?
 			@variable(m, dvHeatToStorage[p.s.storage.types.hot, union(p.techs.heating, p.techs.chp), p.heating_loads, p.time_steps] >= 0) # Power charged to hot storage b at quality q [kW]
 			@variable(m, dvHeatFromStorage[p.s.storage.types.hot, p.heating_loads, p.time_steps] >= 0) # Power discharged from hot storage system b for load q [kW]
 			if !isempty(p.techs.steam_turbine)

src/core/reopt_inputs.jl

@@ -246,13 +246,13 @@ function REoptInputs(s::AbstractScenario)
     if !isempty(s.storage.types.hot)
         for b in s.storage.types.hot
             heating_loads_served_by_tes[b] = String[]
-            if s.storage.attr[b].can_serve_dhw && !isnothing(s.dhw_load)
+            if s.storage.attr[b].can_serve_dhw && ("DomesticHotWater" in heating_loads) && sum(heating_loads_kw["DomesticHotWater"]) > 0.0
                 push!(heating_loads_served_by_tes[b],"DomesticHotWater")
             end
-            if s.storage.attr[b].can_serve_space_heating && !isnothing(s.space_heating_load)
+            if s.storage.attr[b].can_serve_space_heating && ("SpaceHeating" in heating_loads) && sum(heating_loads_kw["SpaceHeating"]) > 0.0
                 push!(heating_loads_served_by_tes[b],"SpaceHeating")
             end
-            if s.storage.attr[b].can_serve_process_heat && !isnothing(s.process_heat_load)
+            if s.storage.attr[b].can_serve_process_heat && ("ProcessHeat" in heating_loads) && sum(heating_loads_kw["ProcessHeat"]) > 0.0
                 push!(heating_loads_served_by_tes[b],"ProcessHeat")
             end
         end

src/core/urdb.jl

@@ -86,7 +86,7 @@ function URDBrate(urdb_response::Dict, year::Int; time_steps_per_hour=1)
     label = get(urdb_response, "label", "")
     rate_name = get(urdb_response, "name", "")
     utility = get(urdb_response, "utility", "")
-    latest_update_unix = get(urdb_response, "latest_update", 0.0)
+    latest_update_unix = get(urdb_response, "startdate", 0.0)
     voltage_level = get(urdb_response, "voltagecategory", "")
     rate_description = get(urdb_response, "description", "")
     peak_kw_capacity_min = get(urdb_response, "peakkwcapacitymin", 0.0)  
@@ -96,10 +96,10 @@ function URDBrate(urdb_response::Dict, year::Int; time_steps_per_hour=1)
     demand_comments = get(urdb_response, "demandcomments", "")
     url_link = get(urdb_response, "uri", "")
 
-    # Convert Unix timestamp to datetime string
+    # Convert Unix timestamp to date string
     rate_effective_date = ""
     if latest_update_unix > 0
-        rate_effective_date = string(Dates.unix2datetime(latest_update_unix))
+        rate_effective_date = string(Date(Dates.unix2datetime(latest_update_unix)))
     end
 
     # Convert matrix to array if needed

test/runtests.jl

@@ -813,6 +813,7 @@ else  # run HiGHS tests
                 d["ElectricHeater"]["installed_cost_per_mmbtu_per_hour"] = 1.0
                 d["ElectricTariff"]["monthly_energy_rates"] = [0,0,0,0,0,0,0,0,0,0,0,0]
                 d["HotThermalStorage"]["max_gal"] = 0.0
+                d["HotThermalStorage"]["min_gal"] = 0.0
                 s = Scenario(d)
                 inputs = REoptInputs(s)
                 m = Model(optimizer_with_attributes(HiGHS.Optimizer, "output_flag" => false, "log_to_console" => false))
@@ -3085,17 +3086,17 @@ else  # run HiGHS tests
             p = REoptInputs(s)
             m = Model(optimizer_with_attributes(HiGHS.Optimizer, "output_flag" => false, "log_to_console" => false))
             results = run_reopt(m, p)
-
-            annual_thermal_prod = 0.8 * 8760  #80% efficient boiler --> 0.8 MMBTU of heat load per hour
+            annual_thermal_prod = 0.64 * 8760  #80% efficient boiler --> 0.64 MMBTU of heat load per hour for electric heater
             annual_electric_heater_consumption = annual_thermal_prod * REopt.KWH_PER_MMBTU  #1.0 COP
             annual_energy_supplied = 87600 + annual_electric_heater_consumption
 
-            #Second run: ElectricHeater produces the required heat with free electricity
-            @test results["ElectricHeater"]["size_mmbtu_per_hour"] ≈ 0.8 atol=0.1
+            #Second run: ElectricHeater produces the required heat with free electricity for two of three heat sources
+            @test results["ElectricHeater"]["size_mmbtu_per_hour"] ≈ 0.64 atol=0.1
             @test results["ElectricHeater"]["annual_thermal_production_mmbtu"] ≈ annual_thermal_prod rtol=1e-4
             @test results["ElectricHeater"]["annual_electric_consumption_kwh"] ≈ annual_electric_heater_consumption rtol=1e-4
             @test results["ElectricUtility"]["annual_energy_supplied_kwh"] ≈ annual_energy_supplied rtol=1e-4
-
+            #no bypass of Electric Heater through Hot TES to process heat
+            @test sum(results["HotThermalStorage"]["storage_to_process_heat_load_series_mmbtu_per_hour"]) ≈ 0.0 atol=0.1
             finalize(backend(m))
             empty!(m)
             GC.gc()

test/scenarios/electric_heater.json

@@ -54,6 +54,11 @@
         "monthly_energy_rates": [0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1,0.1]
     },
     "HotThermalStorage":{
-        "max_gal":2500
+        "min_gal":2500,
+        "max_gal":2500,
+        "can_serve_dhw":true,
+        "can_serve_space_heating":true,
+        "can_serve_process_heat":false,
+        "thermal_decay_rate_fraction": 0.0
     }
 }