Debugging and minor improvements

Author: toddleif

src/constraints/storage_constraints.jl

@@ -83,7 +83,7 @@ function add_elec_storage_dispatch_constraints(m, p, b; _n="")
             #+  (p.s.storage.attr[b].charge_efficiency * m[Symbol("dvHydroToStorage")][ts])
             - ((m[Symbol("dvDischargeFromStorage"*_n)][b,ts]+m[Symbol("dvStorageToGrid")][ts])  / p.s.storage.attr[b].discharge_efficiency)
         )
-        - (p.s.storage.attr[b].per_timestep_self_discharge_fraction * m[Symbol("dvStoredEnergy"*_n)][b, ts])
+        #- (p.s.storage.attr[b].per_timestep_self_discharge_fraction * m[Symbol("dvStoredEnergy"*_n)][b, ts])
 	)
 
     # Note: Hydro to storage not added for off-grid scenarios

src/constraints/water_power_constraints.jl

@@ -308,9 +308,16 @@ function add_water_power_constraints(m,p)
 		dvs = ["binTurbineActive"]
 	end
 
+	solvers_incompatible_with_indicator_constraints = ["HiGHS", "Cbc"]
 
 	# Define the minimum operating time (in time steps) for the water_power turbine
 	if p.s.water_power.minimum_operating_time_steps_individual_turbine > 1
+		@warn "Setting minimum_operating_time_steps_individual_turbine to greater than 1 requires an optimization solver that can handle indicator constraints."
+		
+		if p.s.settings.solver_name in solvers_incompatible_with_indicator_constraints
+			throw(@error("A solver that can handle indicator constraints must be used if minimum_turbine_off_time_steps is set to greater than 1"))
+		end
+
 		print("\n Adding minimum operating time constraint \n")
 		@variable(m, indicator_min_operating_time[t in p.techs.water_power, ts in p.time_steps, dv in dvs], Bin)
 		for dv in dvs
@@ -332,6 +339,12 @@ function add_water_power_constraints(m,p)
 
 	# Define the minimum operating time for the maximum water flow (in time steps) for a water_power turbine
 	if p.s.water_power.minimum_operating_time_steps_at_local_maximum_turbine_output > 1
+		@warn "Setting minimum_operating_time_steps_at_local_maximum_turbine_output to greater than 1 requires an optimization solver that can handle indicator constraints."
+		
+		if p.s.settings.solver_name in solvers_incompatible_with_indicator_constraints
+			throw(@error("A solver that can handle indicator constraints must be used if minimum_turbine_off_time_steps is set to greater than 1"))
+		end
+
 		print("\n Adding a constraint for the minimum operating time at a local maximum water flow \n")
 		@variable(m, indicator_turn_down[t in p.techs.water_power_turbines, ts in p.time_steps, dv in dvs], Bin)	
 		for dv in dvs
@@ -354,6 +367,12 @@ function add_water_power_constraints(m,p)
 	end
 
 	if p.s.water_power.minimum_turbine_off_time_steps > 1
+		@warn "Setting minimum_turbine_off_time_steps to greater than 1 requires an optimization solver that can handle indicator constraints."
+		
+		if p.s.settings.solver_name in solvers_incompatible_with_indicator_constraints
+			throw(@error("A solver that can handle indicator constraints must be used if minimum_turbine_off_time_steps is set to greater than 1"))
+		end
+	
 		print("\n Adding minimum off duration for the turbines \n")
 		@variable(m, indicator_turbine_turn_off[t in p.techs.water_power_turbines, ts in p.time_steps], Bin)
 		for t in p.techs.water_power_turbines, ts in 1:Int(length(p.time_steps)- p.s.water_power.minimum_turbine_off_time_steps - 1 )

src/mpc/structs.jl

@@ -242,7 +242,7 @@ Base.@kwdef struct MPCElectricStorage <: AbstractElectricStorage
     max_kw::Float64 = size_kw
     max_kwh::Float64 = size_kwh
     minimum_avg_soc_fraction::Float64 = 0.0
-    per_timestep_self_discharge_fraction::Float64 = 0.0
+    #per_timestep_self_discharge_fraction::Float64 = 0.0
 end
 
 

src/results/electric_storage.jl

@@ -37,8 +37,9 @@ function add_electric_storage_results(m::JuMP.AbstractModel, p::REoptInputs, d::
             r["size_kw"] * p.s.storage.attr[b].installed_cost_per_kw +
             p.s.storage.attr[b].installed_cost_constant
 
-        StoragePerUnitOMCosts = p.third_party_factor * p.pwf_om * (p.s.storage.attr[b].om_cost_per_kw * m[Symbol("dvStoragePower"*_n)][b] +
-                                                                 p.s.storage.attr[b].om_cost_per_kwh * m[Symbol("dvStorageEnergy"*_n)][b])
+        # TODO: correct the StoragePerUnitOMCosts
+        StoragePerUnitOMCosts = -9999999 #p.third_party_factor * p.pwf_om * (p.s.storage.attr[b].om_cost_per_kw * m[Symbol("dvStoragePower"*_n)][b] +
+                                          #                       p.s.storage.attr[b].om_cost_per_kwh * m[Symbol("dvStorageEnergy"*_n)][b])
 
         r["lifecycle_om_cost_after_tax"] = round(value(StoragePerUnitOMCosts) * (1 - p.s.financial.owner_tax_rate_fraction), digits=0)
         r["year_one_om_cost_before_tax"] = round(value(StoragePerUnitOMCosts) / (p.pwf_om * p.third_party_factor), digits=0)
@@ -71,7 +72,7 @@ function add_electric_storage_results(m::JuMP.AbstractModel, p::REoptInputs, d::
 
         BattExport = (m[Symbol("dvStorageToGrid")][ts] for ts in p.time_steps)
         r["storage_to_grid_series_kw"] = round.(value.(BattExport), digits = 3)
-            r["residual_value"] = value(m[:residual_value])
+           # r["residual_value"] = value(m[:residual_value])
 
     else
         r["soc_series_fraction"] = []

src/results/water_power.jl

@@ -73,7 +73,7 @@ function add_water_power_results(m::JuMP.AbstractModel, p::REoptInputs, d::Dict;
 	# Upstream reservoir volume
 	upstream_reservoir_volume = @expression(m, [ts in p.time_steps], m[:dvWaterVolume][ts])
 	r["upstream_reservoir_water_volume_cubic_meters"] = round.(value.(upstream_reservoir_volume).data, digits=3) 
-	r["upstream_reservoir_water_capacity_cubic_meters"] = round.(value.(m[:dvUpperReservoirCapacity]).data, digits=3)
+	r["upstream_reservoir_water_capacity_cubic_meters"] = round.(value.(m[:dvUpperReservoirCapacity]), digits=3)
 
 
 	# Water flow into upstream reservoir (input into the model)
@@ -100,14 +100,12 @@ function add_water_power_results(m::JuMP.AbstractModel, p::REoptInputs, d::Dict;
 			for t in p.techs.water_power, ts in p.time_steps)
 	)
 	r["annual_energy_produced_kwh"] = round(value(AnnualWaterPowerProd), digits=0) # includes curtailment
-    
-	
+    	
 	if p.s.water_power.model_downstream_reservoir
 		# Downstream reservoir volume
 		downstream_reservoir_volume = @expression(m, [ts in p.time_steps], m[:dvDownstreamReservoirWaterVolume][ts])
 		r["downstream_reservoir_water_volume_cubic_meters"] = round.(value.(downstream_reservoir_volume).data, digits=3) 
-		
-		r["downstream_reservoir_water_capacity_cubic_meters"] = round.(value.(m[:dvDownstreamReservoirCapacity]).data, digits=3)
+		r["downstream_reservoir_water_capacity_cubic_meters"] = round.(value.(m[:dvDownstreamReservoirCapacity]), digits=3)
 
 	end
 	# Compile results for the pumps
@@ -130,11 +128,13 @@ function add_water_power_results(m::JuMP.AbstractModel, p::REoptInputs, d::Dict;
 		r["individual_pump_results"] = Dict([])
 
 		print("\n **** p.techs.water_power_pumps are: $(p.techs.water_power_pumps)")
+		print("\n **** p.techs.water_power_turbines are: $(p.techs.water_power_turbines)")
+		print("\n ")
 
 		for i in p.techs.water_power_pumps		
 			r["individual_pump_results"][string(i)*"_results"] = Dict([])
 
-			r["individual_pump_results"][string(i)*"_results"]["pump_power_rating"] = value.(m[:pump_power_rating][i])
+			r["individual_pump_results"][string(i)*"_results"]["pump_power_rating"] = round(value.(m[:pump_power_rating][i]), digits=3)
 
 			IndividualPumpedWaterFlow = @expression(m, [ts in p.time_steps], m[:dvPumpedWaterFlow][i, ts])
 			r["individual_pump_results"][string(i)*"_results"]["pump_water_flow"] = round.(value.(IndividualPumpedWaterFlow).data, digits=3)
@@ -152,7 +152,7 @@ function add_water_power_results(m::JuMP.AbstractModel, p::REoptInputs, d::Dict;
 
 		r["individual_turbine_results"][string(i)*"_results"] = Dict([])
 
-		r["individual_turbine_results"][string(i)*"_results"]["turbine_power_rating"] = value.(m[:turbine_power_rating][i])
+		r["individual_turbine_results"][string(i)*"_results"]["turbine_power_rating"] = round(value.(m[:turbine_power_rating][i]), digits=3)
 
 		water_outflow_individual = @expression(m, [ts in p.time_steps], m[:dvWaterOutFlow][i, ts])
 		r["individual_turbine_results"][string(i)*"_results"]["water_outflow"] = round.(value.(water_outflow_individual).data, digits=3)