Merge branch 'ghp-select-hybrid-aux-unit' into test-hvac-costs-with-presized-ghp

Author: An Pham

CHANGELOG.md

@@ -77,6 +77,7 @@ Classify the change according to the following categories:
 ## v0.50.0
 ### Added
 - New parameter `force_dispatch` in the **ASHPSpaceHeater** and **ASHPWaterHeater** technologies (default = `true`).  When kept at `true`, the ASHP's thermal output will be the minimum of the site load(s) served and the system size (adjusted for timestep-specific capacity factor) in each period. If set to `false`, ASHP will do economic dispatch considering COP and CF along with electricity prices.
+- Allow the user to overwrite "Automatic" GHP hybrid sizing by specifying if the auxiliary unit is a "Heater" or "Cooler" through the `GHP.ghpghx_inputs.hybrid_ghx_sizing_method` variable.
 ### Fixed
 - Align heating and cooling load profiles based on electric load year input, if using custom electric load profile with simulated (CRB or schedule-based flatloads) heating/cooling loads
 - Handling of leap years for `ElectricLoad.loads_kw` inputs to align with URDB rate structures

src/core/ghp.jl

@@ -125,6 +125,14 @@ Base.@kwdef mutable struct GHP <: AbstractGHP
 
     # Process and populate these parameters needed more directly by the model
     om_cost_year_one::Float64 = NaN
+    test_hybrid_case::String = "" # automatic_guess_correct, flipped_guess, nonhybrid_solution
+    number_of_boreholes_auto_guess::Float64 = -1.0
+    number_of_boreholes_flipped_guess::Float64 = -1.0
+    number_of_boreholes_nonhybrid::Float64 = -1.0
+
+    iterations_auto_guess::Float64 = -1.0
+    iterations_flipped_guess::Float64 = -1.0
+    iterations_nonhybrid::Float64 = -1.0
 
     # Account for expenses avoided by addition of GHP.
     avoided_capex_by_ghp_present_value::Float64 = 0.0

src/core/scenario.jl

@@ -561,33 +561,63 @@ function Scenario(d::Dict; flex_hvac_from_json=false)
 
             if hybrid_ghx_sizing_method == "Automatic"
 
-                # Call GhpGhx.jl to size GHP and GHX
-                determine_heat_cool_results_resp_dict = Dict()
+                # Call GhpGhx.jl to size GHP and GHX in non-hybrid mode
+                nonhybrid_results_resp_dict = Dict()
                 try
-                    ghpghx_inputs["hybrid_auto_ghx_sizing_flag"] = true
-
+                    ghpghx_inputs["hybrid_auto_ghx_sizing_flag"] = false
+                    ghpghx_inputs["hybrid_sizing_flag"] = 1.0
                     # Call GhpGhx.jl to size GHP and GHX
-                    @info "Starting GhpGhx.jl for automatic hybrid GHX sizing"
+                    @info "Starting GhpGhx.jl for non-hybrid GHX sizing"
                     # Call GhpGhx.jl to size GHP and GHX
-                    results, inputs_params = GhpGhx.ghp_model(ghpghx_inputs)
+                    results_nonhybrid, inputs_params_nonhybrid = GhpGhx.ghp_model(ghpghx_inputs)
                     # Create a dictionary of the results data needed for REopt
-                    determine_heat_cool_results_resp_dict = GhpGhx.get_results_for_reopt(results, inputs_params)
-                    @info "Automatic hybrid GHX sizing complete using GhpGhx.jl"
+                    nonhybrid_results_resp_dict = GhpGhx.get_results_for_reopt(results_nonhybrid, inputs_params_nonhybrid)
+                    @info "Non-hybrid GHX sizing complete using GhpGhx.jl"
                 catch e
                     @info e
                     throw(@error("The GhpGhx package was not added (add https://github.com/NREL/GhpGhx.jl) or 
                         loaded (using GhpGhx) to the active Julia environment"))
                 end
-
-                temp_diff = determine_heat_cool_results_resp_dict["end_of_year_ghx_lft_f"][2] \
-                - determine_heat_cool_results_resp_dict["end_of_year_ghx_lft_f"][1]
+                d["GHP"]["number_of_boreholes_nonhybrid"] = nonhybrid_results_resp_dict["number_of_boreholes"]
+                d["GHP"]["iterations_nonhybrid"] = nonhybrid_results_resp_dict["ghx_soln_number_of_iterations"]
+
+                # # Call GhpGhx.jl to size GHP and GHX
+                # determine_heat_cool_results_resp_dict = Dict()
+                # try
+                #     ghpghx_inputs["hybrid_auto_ghx_sizing_flag"] = true
+
+                #     # Call GhpGhx.jl to size GHP and GHX
+                #     @info "Starting GhpGhx.jl for automatic hybrid GHX sizing"
+                #     # Call GhpGhx.jl to size GHP and GHX
+                #     results, inputs_params = GhpGhx.ghp_model(ghpghx_inputs)
+                #     # Create a dictionary of the results data needed for REopt
+                #     determine_heat_cool_results_resp_dict = GhpGhx.get_results_for_reopt(results, inputs_params)
+                #     @info "Automatic hybrid GHX sizing complete using GhpGhx.jl"
+                # catch e
+                #     @info e
+                #     throw(@error("The GhpGhx package was not added (add https://github.com/NREL/GhpGhx.jl) or 
+                #         loaded (using GhpGhx) to the active Julia environment"))
+                # end
+
+                # temp_diff = determine_heat_cool_results_resp_dict["end_of_year_ghx_lft_f"][2] \
+                # - determine_heat_cool_results_resp_dict["end_of_year_ghx_lft_f"][1]
+
+                # ORIGINAL GUESS
+                temp_diff = nonhybrid_results_resp_dict["end_of_year_ghx_lft_f"][length(nonhybrid_results_resp_dict["end_of_year_ghx_lft_f"])] \
+                - nonhybrid_results_resp_dict["end_of_year_ghx_lft_f"][1]
+
+                # FLIPPED GUESS
+                # temp_diff = nonhybrid_results_resp_dict["end_of_year_ghx_lft_f"][1] - nonhybrid_results_resp_dict["end_of_year_ghx_lft_f"][length(nonhybrid_results_resp_dict["end_of_year_ghx_lft_f"])]
 
                 hybrid_sizing_flag = 1.0 # non hybrid
+                hybrid_sizing_flag_opposite_guess = 1.0 # non hybrid
                 if temp_diff > 0
                     hybrid_sizing_flag = -2.0 #heating
+                    hybrid_sizing_flag_opposite_guess = -1.0 #cooling
                     is_ghx_hybrid = true
                 elseif temp_diff < 0
                     hybrid_sizing_flag = -1.0 #cooling
+                    hybrid_sizing_flag_opposite_guess = -2.0 #heating
                     is_ghx_hybrid = true
                 else
                     # non hybrid if exactly 0.
@@ -620,7 +650,7 @@ function Scenario(d::Dict; flex_hvac_from_json=false)
             end
 
             ghpghx_results = Dict()
-
+            max_ghx_sizing_interations = 0
             try
                 # Call GhpGhx.jl to size GHP and GHX
                 @info "Starting GhpGhx.jl"
@@ -683,37 +713,6 @@ function Scenario(d::Dict; flex_hvac_from_json=false)
                     end
                 end
                 results, inputs_params = GhpGhx.ghp_model(ghpghx_inputs)
-                # If max_number_of_boreholes is specified, check if number of boreholes sized by GhpGhx.jl greater than user-specified max_number_of_boreholes,
-                # and if max_number_of_boreholes is less, reduce thermal load served by GHP until max_number_of_boreholes = number of boreholses sized by GhpGhx.jl                
-                if haskey(d["GHP"],"max_number_of_boreholes")
-                    optimal_number_of_boreholes = GhpGhx.get_results_for_reopt(results, inputs_params)["number_of_boreholes"]
-                    if optimal_number_of_boreholes > d["GHP"]["max_number_of_boreholes"]
-                        @info "Max number of boreholes specified is less than number of boreholes sized in GhpGhx.jl, reducing thermal load served by GHP further"
-                        max_iter = 10
-                        for iter = 1:max_iter
-                            borehole_ratio = d["GHP"]["max_number_of_boreholes"]/optimal_number_of_boreholes
-                            heating_load_mmbtu .*= borehole_ratio
-                            if haskey(ghpghx_inputs,"cooling_thermal_load_ton")
-                                cooling_load_ton .*= borehole_ratio
-                            # if cooling load is not included, cut down heating load only and send to GhpGhx.jl
-                            end
-                            ghpghx_inputs["heating_thermal_load_mmbtu_per_hr"] = heating_load_mmbtu                              
-                            ghpghx_inputs["cooling_thermal_load_ton"] = cooling_load_ton   
-                            
-                            # Rerun GhpGhx.jl
-                            results, inputs_params = GhpGhx.ghp_model(ghpghx_inputs)
-                            optimal_number_of_boreholes = GhpGhx.get_results_for_reopt(results, inputs_params)["number_of_boreholes"]
-                            # Solution is found if the new optimal number of boreholes sized by GhpGhx.jl = user-specified max number of boreholes,
-                            # Otherwise, continue solving until reaching max iteration
-                            if -0.5 < optimal_number_of_boreholes-d["GHP"]["max_number_of_boreholes"] < 0.5
-                                break
-                            else
-                                iter += 1
-                            end
-                        end
-                    end
-                end
-
                 # Create a dictionary of the results data needed for REopt
                 ghpghx_results = GhpGhx.get_results_for_reopt(results, inputs_params)
                 # Return results from GhpGhx.jl without load scaling if user does not provide GHP size or if user entered GHP size is greater than GHP size output
@@ -725,6 +724,49 @@ function Scenario(d::Dict; flex_hvac_from_json=false)
                     to the GhpGhx.jl package."))
             end
 
+            if is_ghx_hybrid
+                
+                d["GHP"]["number_of_boreholes_auto_guess"] = ghpghx_results["number_of_boreholes"]
+                d["GHP"]["iterations_auto_guess"] = ghpghx_results["ghx_soln_number_of_iterations"]
+                
+                # Invalid hybrid results
+                if (ghpghx_results["number_of_boreholes"] >= nonhybrid_results_resp_dict["number_of_boreholes"]) || (ghpghx_results["ghx_soln_number_of_iterations"] == max_ghx_sizing_interations)
+                    new_hybrid_ghpghx_results = Dict()
+                    max_ghx_sizing_interations = 0
+                    try
+                        ghpghx_inputs["hybrid_sizing_flag"] = hybrid_sizing_flag_opposite_guess
+
+                        # Call GhpGhx.jl to size GHP and GHX
+                        @info "Initial guess for hybrid GHP auxiliary unit was incorrect. Starting GhpGhx.jl for new hybrid GHX sizing"
+                        # Call GhpGhx.jl to size GHP and GHX
+                        results_new_hybrid, inputs_params_new_hybrid = GhpGhx.ghp_model(ghpghx_inputs)
+                        max_ghx_sizing_interations = inputs_params_new_hybrid.max_sizing_iterations
+                        # Create a dictionary of the results data needed for REopt
+                        new_hybrid_ghpghx_results = GhpGhx.get_results_for_reopt(results_new_hybrid, inputs_params_new_hybrid)
+                        @info "New hybrid GHX sizing complete using GhpGhx.jl"
+                    catch e
+                        @info e
+                        throw(@error("The GhpGhx package was not added (add https://github.com/NREL/GhpGhx.jl) or 
+                            loaded (using GhpGhx) to the active Julia environment, or an error occurred during the call 
+                            to the GhpGhx.jl package."))
+                    end
+                    d["GHP"]["number_of_boreholes_flipped_guess"] = new_hybrid_ghpghx_results["number_of_boreholes"]
+                    d["GHP"]["iterations_flipped_guess"] = new_hybrid_ghpghx_results["ghx_soln_number_of_iterations"]
+
+                    if (new_hybrid_ghpghx_results["number_of_boreholes"] >= nonhybrid_results_resp_dict["number_of_boreholes"]) || (new_hybrid_ghpghx_results["ghx_soln_number_of_iterations"] == max_ghx_sizing_interations)
+                        @info "Hybrid GHX results are unavailable for this scenario. Returning non-hybrid results"
+                        is_ghx_hybrid = false
+                        ghpghx_results = nonhybrid_results_resp_dict
+                        d["GHP"]["test_hybrid_case"] = "nonhybrid_solution"
+                    else
+                        ghpghx_results = new_hybrid_ghpghx_results
+                        d["GHP"]["test_hybrid_case"] = "flipped_guess"
+                    end
+                else
+                    d["GHP"]["test_hybrid_case"] = "automatic_guess_correct"
+                end
+            end
+                        
             ghpghx_response = Dict([("inputs", ghpghx_inputs), ("outputs", ghpghx_results)])
             ghp_inputs_removed_ghpghx_params = deepcopy(d["GHP"])
             for param in ["ghpghx_inputs", "ghpghx_responses", "ghpghx_response_uuids"]

src/results/ghp.jl

@@ -34,6 +34,16 @@ function add_ghp_results(m::JuMP.AbstractModel, p::REoptInputs, d::Dict; _n="")
         p.s.ghp_option_list[ghp_option_chosen].heatpump_capacity_sizing_factor_on_peak_load = 1.0
     end
     if ghp_option_chosen >= 1
+        
+        r["test_hybrid_case"] = p.s.ghp_option_list[ghp_option_chosen].test_hybrid_case
+        r["number_of_boreholes_nonhybrid"] = p.s.ghp_option_list[ghp_option_chosen].number_of_boreholes_nonhybrid
+        r["number_of_boreholes_auto_guess"] = p.s.ghp_option_list[ghp_option_chosen].number_of_boreholes_auto_guess
+        r["number_of_boreholes_flipped_guess"] = p.s.ghp_option_list[ghp_option_chosen].number_of_boreholes_flipped_guess
+
+        r["iterations_nonhybrid"] = p.s.ghp_option_list[ghp_option_chosen].iterations_nonhybrid
+        r["iterations_auto_guess"] = p.s.ghp_option_list[ghp_option_chosen].iterations_auto_guess
+        r["iterations_flipped_guess"] = p.s.ghp_option_list[ghp_option_chosen].iterations_flipped_guess
+
         r["ghpghx_chosen_outputs"] = p.s.ghp_option_list[ghp_option_chosen].ghpghx_response["outputs"]
 
         if r["ghpghx_chosen_outputs"]["heat_pump_configuration"] == "WSHP"