Battery storage cost constant version 2

src/core/energy_storage/electric_storage.jl

@@ -36,6 +36,10 @@ worth factor is used in two different ways, depending on the `maintenance_strate
     - `replace_cost_per_kwh`
     - `inverter_replacement_year`
     - `battery_replacement_year`
+    - `replace_cost_per_kw`
+    - `replace_cost_per_kwh`
+    - `inverter_replacement_year`
+    - `battery_replacement_year`
     The are replaced by the `maintenance_cost_per_kwh` vector.
 
 !!! note
@@ -149,10 +153,13 @@ end
     can_grid_charge::Bool = off_grid_flag ? false : true
     installed_cost_per_kw::Real = 910.0
     installed_cost_per_kwh::Real = 455.0
+    installed_cost_constant::Real = 0.0
     replace_cost_per_kw::Real = 715.0
     replace_cost_per_kwh::Real = 318.0
+    replace_cost_constant::Real = 0.0
     inverter_replacement_year::Int = 10
     battery_replacement_year::Int = 10
+    cost_constant_replacement_year::Int = 10
     macrs_option_years::Int = 7
     macrs_bonus_fraction::Float64 = 0.6
     macrs_itc_reduction::Float64 = 0.5
@@ -182,10 +189,13 @@ Base.@kwdef struct ElectricStorageDefaults
     can_grid_charge::Bool = off_grid_flag ? false : true
     installed_cost_per_kw::Real = 910.0
     installed_cost_per_kwh::Real = 455.0
+    installed_cost_constant::Real = 0.0
     replace_cost_per_kw::Real = 715.0
     replace_cost_per_kwh::Real = 318.0
+    replace_cost_constant::Real = 0.0
     inverter_replacement_year::Int = 10
     battery_replacement_year::Int = 10
+    cost_constant_replacement_year::Int = 10
     macrs_option_years::Int = 7
     macrs_bonus_fraction::Float64 = 0.6
     macrs_itc_reduction::Float64 = 0.5
@@ -221,10 +231,13 @@ struct ElectricStorage <: AbstractElectricStorage
     can_grid_charge::Bool
     installed_cost_per_kw::Real
     installed_cost_per_kwh::Real
+    installed_cost_constant::Real
     replace_cost_per_kw::Real
     replace_cost_per_kwh::Real
+    replace_cost_constant::Real
     inverter_replacement_year::Int
     battery_replacement_year::Int
+    cost_constant_replacement_year::Int
     macrs_option_years::Int
     macrs_bonus_fraction::Float64
     macrs_itc_reduction::Float64
@@ -236,6 +249,7 @@ struct ElectricStorage <: AbstractElectricStorage
     grid_charge_efficiency::Float64
     net_present_cost_per_kw::Real
     net_present_cost_per_kwh::Real
+    net_present_cost_cost_constant::Real
     model_degradation::Bool
     degradation::Degradation
     minimum_avg_soc_fraction::Float64
@@ -277,6 +291,19 @@ struct ElectricStorage <: AbstractElectricStorage
 
         net_present_cost_per_kwh -= s.total_rebate_per_kwh
 
+        net_present_cost_cost_constant = effective_cost(;
+            itc_basis = s.installed_cost_constant,
+            replacement_cost = s.cost_constant_replacement_year >= f.analysis_years ? 0.0 : s.replace_cost_constant,
+            replacement_year = s.cost_constant_replacement_year,
+            discount_rate = f.owner_discount_rate_fraction,
+            tax_rate = f.owner_tax_rate_fraction,
+            itc = s.total_itc_fraction,
+            macrs_schedule = s.macrs_option_years == 7 ? f.macrs_seven_year : f.macrs_five_year,
+            macrs_bonus_fraction = s.macrs_bonus_fraction,
+            macrs_itc_reduction = s.macrs_itc_reduction
+
+        )
+
         if haskey(d, :degradation)
             degr = Degradation(;dictkeys_tosymbols(d[:degradation])...)
         else
@@ -286,13 +313,16 @@ struct ElectricStorage <: AbstractElectricStorage
         # copy the replace_costs in case we need to change them
         replace_cost_per_kw = s.replace_cost_per_kw 
         replace_cost_per_kwh = s.replace_cost_per_kwh
+        replace_cost_constant = s.replace_cost_constant
         if s.model_degradation
             if haskey(d, :replace_cost_per_kw) && d[:replace_cost_per_kw] != 0.0 || 
-                haskey(d, :replace_cost_per_kwh) && d[:replace_cost_per_kwh] != 0.0
+                haskey(d, :replace_cost_per_kwh) && d[:replace_cost_per_kwh] != 0.0 ||
+                haskey(d, :replace_cost_constant) && d[:replace_cost_constant] != 0.0
                 @warn "Setting ElectricStorage replacement costs to zero. Using degradation.maintenance_cost_per_kwh instead."
             end
             replace_cost_per_kw = 0.0
             replace_cost_per_kwh = 0.0
+            replace_cost_constant = 0.0
         end
 
         return new(
@@ -309,10 +339,13 @@ struct ElectricStorage <: AbstractElectricStorage
             s.can_grid_charge,
             s.installed_cost_per_kw,
             s.installed_cost_per_kwh,
+            s.installed_cost_constant,
             replace_cost_per_kw,
             replace_cost_per_kwh,
+            replace_cost_constant,
             s.inverter_replacement_year,
             s.battery_replacement_year,
+            s.cost_constant_replacement_year,
             s.macrs_option_years,
             s.macrs_bonus_fraction,
             s.macrs_itc_reduction,
@@ -324,6 +357,7 @@ struct ElectricStorage <: AbstractElectricStorage
             s.grid_charge_efficiency,
             net_present_cost_per_kw,
             net_present_cost_per_kwh,
+            net_present_cost_cost_constant,
             s.model_degradation,
             degr,
             s.minimum_avg_soc_fraction

src/core/reopt.jl

@@ -387,9 +387,19 @@ function build_reopt!(m::JuMP.AbstractModel, p::REoptInputs)
         end
     end
 
+	# Include the electric storage cost constants only if the installed_cost_constant or the replace_cost_constant is not zero
+	for b in p.s.storage.types.elec
+		if p.s.storage.attr[b].installed_cost_constant != 0 || p.s.storage.attr[b].replace_cost_constant != 0
+			@constraint(m, [b in p.s.storage.types.elec], m[:dvStorageEnergy][b] <= p.s.storage.attr[b].max_kwh * m[:dvBatteryIncluded][b]) # if the dvBatteryIncluded binary is 1, then the storage energy capacity can be greater than 0, but then the battery cost constant is also included in the costs		
+		else
+			m[:dvBatteryIncluded][b] == 0
+		end
+	end
+
 	@expression(m, TotalStorageCapCosts, p.third_party_factor * (
 		sum( p.s.storage.attr[b].net_present_cost_per_kw * m[:dvStoragePower][b] for b in p.s.storage.types.elec) + 
-		sum( p.s.storage.attr[b].net_present_cost_per_kwh * m[:dvStorageEnergy][b] for b in p.s.storage.types.all )
+		sum( p.s.storage.attr[b].net_present_cost_per_kwh * m[:dvStorageEnergy][b] for b in p.s.storage.types.all ) +
+		sum( p.s.storage.attr[b].net_present_cost_cost_constant * m[:dvBatteryIncluded][b] for b in p.s.storage.types.elec)
 	))
 
 	@expression(m, TotalPerUnitSizeOMCosts, p.third_party_factor * p.pwf_om *
@@ -594,6 +604,7 @@ function add_variables!(m::JuMP.AbstractModel, p::REoptInputs)
 		dvPeakDemandMonth[p.months, 1:p.s.electric_tariff.n_monthly_demand_tiers] >= 0  # Peak electrical power demand during month m [kW]
 		MinChargeAdder >= 0
         binGHP[p.ghp_options], Bin  # Can be <= 1 if require_ghp_purchase=0, and is ==1 if require_ghp_purchase=1
+		dvBatteryIncluded[p.s.storage.types.elec], Bin # 0 if no battery is included, 1 if battery is included
 	end
 
 	if !isempty(p.techs.gen)  # Problem becomes a MILP

src/core/reopt_multinode.jl

@@ -14,6 +14,7 @@ function add_variables!(m::JuMP.AbstractModel, ps::AbstractVector{REoptInputs{T}
 	dvs_idx_on_storagetypes = String[
 		"dvStoragePower",
 		"dvStorageEnergy",
+		"dvBatteryIncluded"
 	]
 	dvs_idx_on_storagetypes_time_steps = String[
 		"dvDischargeFromStorage"
@@ -66,6 +67,15 @@ function add_variables!(m::JuMP.AbstractModel, ps::AbstractVector{REoptInputs{T}
             m[Symbol(dv)] = @variable(m, [p.techs.elec, p.s.electric_tariff.export_bins, p.time_steps], base_name=dv, lower_bound=0)
         end
 
+		# Include the electric storage cost constants only if the installed_cost_constant or the replace_cost_constant is not zero
+		for b in p.s.storage.types.elec
+			if p.s.storage.attr[b].installed_cost_constant != 0 || p.s.storage.attr[b].replace_cost_constant != 0
+				@constraint(m, [b in p.s.storage.types.elec], m[Symbol("dvStorageEnergy"*_n)][b] <= p.s.storage.attr[b].max_kwh * m[Symbol("dvBatteryIncluded"*_n)][b]) # if the dvBatteryIncluded binary is 1, then the storage energy capacity can be greater than 0, but then the battery cost constant is also included in the costs		
+			else
+				m[Symbol("dvBatteryIncluded"*_n)][b] == 0
+			end
+		end
+
 		ex_name = "TotalTechCapCosts"*_n
 		m[Symbol(ex_name)] = @expression(m, p.third_party_factor *
 			sum( p.cap_cost_slope[t] * m[Symbol("dvPurchaseSize"*_n)][t] for t in p.techs.all ) 
@@ -75,6 +85,7 @@ function add_variables!(m::JuMP.AbstractModel, ps::AbstractVector{REoptInputs{T}
 		m[Symbol(ex_name)] = @expression(m, p.third_party_factor * 
 			sum(p.s.storage.attr[b].net_present_cost_per_kw * m[Symbol("dvStoragePower"*_n)][b] for b in p.s.storage.types.elec)
 			+ sum(p.s.storage.attr[b].net_present_cost_per_kwh * m[Symbol("dvStorageEnergy"*_n)][b] for b in p.s.storage.types.all)
+			+ sum(p.s.storage.attr[b].net_present_cost_cost_constant * m[Symbol("dvBatteryIncluded"*_n)][b] for b in p.s.storage.types.elec)
 		)
 
 		ex_name = "TotalPerUnitSizeOMCosts"*_n

src/results/electric_storage.jl

@@ -32,7 +32,8 @@ function add_electric_storage_results(m::JuMP.AbstractModel, p::REoptInputs, d::
         r["storage_to_load_series_kw"] = round.(value.(discharge), digits=3)
 
         r["initial_capital_cost"] = r["size_kwh"] * p.s.storage.attr[b].installed_cost_per_kwh +
-            r["size_kw"] * p.s.storage.attr[b].installed_cost_per_kw
+            r["size_kw"] * p.s.storage.attr[b].installed_cost_per_kw +
+            p.s.storage.attr[b].installed_cost_constant
 
         if p.s.storage.attr[b].model_degradation
             r["state_of_health"] = value.(m[:SOH]).data / value.(m[:dvStorageEnergy])["ElectricStorage"];

src/results/financial.jl

@@ -146,7 +146,8 @@ function initial_capex(m::JuMP.AbstractModel, p::REoptInputs; _n="")
     for b in p.s.storage.types.elec
         if p.s.storage.attr[b].max_kw > 0
             initial_capex += p.s.storage.attr[b].installed_cost_per_kw * value.(m[Symbol("dvStoragePower"*_n)])[b] + 
-                p.s.storage.attr[b].installed_cost_per_kwh * value.(m[Symbol("dvStorageEnergy"*_n)])[b]
+                p.s.storage.attr[b].installed_cost_per_kwh * value.(m[Symbol("dvStorageEnergy"*_n)])[b] +
+                (p.s.storage.attr[b].installed_cost_constant * ceil(value.(m[Symbol("dvStorageEnergy"*_n)])[b]/(value.(m[Symbol("dvStorageEnergy"*_n)])[b] + 1)))
         end
     end
 
@@ -238,12 +239,20 @@ function replacement_costs_future_and_present(m::JuMP.AbstractModel, p::REoptInp
         else
             future_cost_storage = p.s.storage.attr[b].replace_cost_per_kwh * value.(m[Symbol("dvStorageEnergy"*_n)])[b]
         end
-        future_cost += future_cost_inverter + future_cost_storage
+        if p.s.storage.attr[b].cost_constant_replacement_year >= p.s.financial.analysis_years
+            future_cost_cost_constant = 0
+        else
+            future_cost_cost_constant = p.s.storage.attr[b].replace_cost_constant * value.(m[Symbol("dvBatteryIncluded"*_n)])[b]
+        end
+
+        future_cost += future_cost_inverter + future_cost_storage + future_cost_cost_constant
 
         present_cost += future_cost_inverter * (1 - p.s.financial.owner_tax_rate_fraction) / 
             ((1 + p.s.financial.owner_discount_rate_fraction)^p.s.storage.attr[b].inverter_replacement_year)
         present_cost += future_cost_storage * (1 - p.s.financial.owner_tax_rate_fraction) / 
             ((1 + p.s.financial.owner_discount_rate_fraction)^p.s.storage.attr[b].battery_replacement_year)
+        present_cost += future_cost_cost_constant * (1 - p.s.financial.owner_tax_rate_fraction) / 
+            ((1 + p.s.financial.owner_discount_rate_fraction)^p.s.storage.attr[b].cost_constant_replacement_year)  
     end
 
     if !isempty(p.techs.gen) # Generator replacement 

test/runtests.jl

@@ -101,6 +101,66 @@ else  # run HiGHS tests
         @test r["ElectricStorage"]["size_kwh"] ≈ 83.3 atol=0.1
     end
 
+    @testset "Solar and ElectricStorage w/ zero ElectricStorage cost constants" begin
+        m1 = Model(optimizer_with_attributes(HiGHS.Optimizer, "output_flag" => false, "log_to_console" => false))
+        m2 = Model(optimizer_with_attributes(HiGHS.Optimizer, "output_flag" => false, "log_to_console" => false))
+        d = JSON.parsefile("./scenarios/pv_storage.json");
+
+        d["ElectricStorage"]["installed_cost_constant"] = 0
+        d["ElectricStorage"]["replace_cost_constant"] = 0
+        d["ElectricStorage"]["cost_constant_replacement_year"] = 10
+
+        d["Settings"] = Dict{Any,Any}("add_soc_incentive" => false)
+        s = Scenario(d)
+        inputs = REoptInputs(s)
+        results = run_reopt([m1,m2], inputs)
+
+        UpfrontCosts_NoIncentive = (results["ElectricStorage"]["size_kw"]*d["ElectricStorage"]["installed_cost_per_kw"] ) +
+                                   (results["ElectricStorage"]["size_kwh"]*d["ElectricStorage"]["installed_cost_per_kwh"]) + 
+                                   d["ElectricStorage"]["installed_cost_constant"] +
+                                   (results["PV"]["size_kw"]*d["PV"]["installed_cost_per_kw"])
+
+        @test results["PV"]["size_kw"] ≈ 216.6667 atol=0.01 
+        @test results["PV"]["lcoe_per_kwh"] ≈ 0.0469 atol = 0.001 
+        @test results["Financial"]["lcc"] ≈ 1.23917861648e7 rtol=1e-5 
+        @test results["Financial"]["lcc_bau"] ≈ 1.27663970441e7 rtol=1e-5 
+        @test results["ElectricStorage"]["size_kw"] ≈ 49.05 atol=0.1 
+        @test results["ElectricStorage"]["size_kwh"] ≈ 83.32 atol=0.1 
+        @test results["Financial"]["initial_capital_costs"] ≈ UpfrontCosts_NoIncentive rtol=1e-5
+        @test results["Financial"]["lifecycle_storage_capital_costs"] ≈ 66248.8454 rtol=1e-5
+
+    end 
+
+    @testset "Solar and ElectricStorage w/ non-zero ElectricStorage cost constants" begin
+        m1 = Model(optimizer_with_attributes(HiGHS.Optimizer, "output_flag" => false, "log_to_console" => false))
+        m2 = Model(optimizer_with_attributes(HiGHS.Optimizer, "output_flag" => false, "log_to_console" => false))
+        d = JSON.parsefile("./scenarios/pv_storage.json");
+
+        d["ElectricStorage"]["installed_cost_constant"] = 7500
+        d["ElectricStorage"]["replace_cost_constant"] = 5025
+        d["ElectricStorage"]["cost_constant_replacement_year"] = 10
+
+        d["Settings"] = Dict{Any,Any}("add_soc_incentive" => false)
+        s = Scenario(d)
+        inputs = REoptInputs(s)
+        results = run_reopt([m1,m2], inputs)
+
+        UpfrontCosts_NoIncentive = (results["ElectricStorage"]["size_kw"]*d["ElectricStorage"]["installed_cost_per_kw"] ) +
+                                   (results["ElectricStorage"]["size_kwh"]*d["ElectricStorage"]["installed_cost_per_kwh"]) + 
+                                   d["ElectricStorage"]["installed_cost_constant"] +
+                                   (results["PV"]["size_kw"]*d["PV"]["installed_cost_per_kw"])
+
+        @test results["PV"]["size_kw"] ≈ 216.667 atol=0.01 
+        @test results["PV"]["lcoe_per_kwh"] ≈ 0.0469 atol = 0.001 
+        @test results["Financial"]["lcc"] ≈ 1.23981029171e7 rtol=1e-5 
+        @test results["Financial"]["lcc_bau"] ≈ 1.27663970441e7 rtol=1e-5 
+        @test results["ElectricStorage"]["size_kw"] ≈ 49.05 atol=0.1 
+        @test results["ElectricStorage"]["size_kwh"] ≈ 83.32 atol=0.1 
+        @test results["Financial"]["initial_capital_costs"] ≈ UpfrontCosts_NoIncentive rtol=1e-5
+        @test results["Financial"]["lifecycle_storage_capital_costs"] ≈ 72565.5977 rtol=1e-5
+
+    end 
+
     @testset "Outage with Generator" begin
         model = Model(optimizer_with_attributes(HiGHS.Optimizer, "output_flag" => false, "log_to_console" => false))
         results = run_reopt(model, "./scenarios/generator.json")

test/test_with_xpress.jl

@@ -439,6 +439,37 @@ end
     @test round(sum(r["ElectricStorage"]["soc_series_fraction"]), digits=2) / 8760 >= 0.7199
 end
 
+@testset "Solar and ElectricStorage w/ ElectricStorage cost constants" begin
+    m1 = Model(optimizer_with_attributes(Xpress.Optimizer, "OUTPUTLOG" => 0))
+    m2 = Model(optimizer_with_attributes(Xpress.Optimizer, "OUTPUTLOG" => 0))
+    d = JSON.parsefile("./scenarios/pv_storage.json");
+
+    d["ElectricStorage"]["installed_cost_constant"] = 10000
+    d["ElectricStorage"]["replace_cost_constant"] = 5000
+    d["ElectricStorage"]["cost_constant_replacement_year"] = 10
+
+    d["Settings"] = Dict{Any,Any}("add_soc_incentive" => false)
+    s = Scenario(d)
+    inputs = REoptInputs(s)
+    results = run_reopt([m1,m2], inputs)
+
+    UpfrontCosts_NoIncentive = (results["ElectricStorage"]["size_kw"]*d["ElectricStorage"]["installed_cost_per_kw"] ) +
+                               (results["ElectricStorage"]["size_kwh"]*d["ElectricStorage"]["installed_cost_per_kwh"]) + 
+                               d["ElectricStorage"]["installed_cost_constant"] +
+                               (results["PV"]["size_kw"]*d["PV"]["installed_cost_per_kw"])
+
+    @test results["PV"]["size_kw"] ≈ 216.667 atol=0.01
+    @test results["PV"]["lcoe_per_kwh"] ≈ 0.0469 atol = 0.001
+    @test results["Financial"]["lcc"] ≈ 1.23997e7 rtol=1e-5
+    @test results["Financial"]["lcc_bau"] ≈ 1.27664e7 rtol=1e-5
+    @test results["ElectricStorage"]["size_kw"] ≈ 49.05 atol=0.1
+    @test results["ElectricStorage"]["size_kwh"] ≈ 83.32 atol=0.1
+    @test results["Financial"]["initial_capital_costs"] ≈ UpfrontCosts_NoIncentive rtol=1e-5
+    @test results["Financial"]["lifecycle_storage_capital_costs"] ≈ 74203.0768 rtol=1e-5
+
+end
+
+
 @testset "Outage with Generator, outage simulator, BAU critical load outputs" begin
     m1 = Model(optimizer_with_attributes(Xpress.Optimizer, "OUTPUTLOG" => 0))
     m2 = Model(optimizer_with_attributes(Xpress.Optimizer, "OUTPUTLOG" => 0))