Merge branch 'dev'

src/constraints.jl

@@ -61,7 +61,6 @@ function setup_node_balance(model_contents::OrderedDict, input_data::Predicer.In
 
     # consumer/producer flows and loads
     v_flow = model.obj_dict[:v_flow]
-    ("hp1", "elc", "hp1", "s1", "2022-04-20T00:00:00+00:00")
     reduced_v_flow_inds = unique(map(x -> (x[1:3]), process_topology_tuples(input_data)))
     for n in unique(map(nbt -> nbt[1], balance_node_tuples(input_data)))
         cons_flows = filter(rvfi -> rvfi[2] == n, reduced_v_flow_inds)
@@ -74,7 +73,7 @@ function setup_node_balance(model_contents::OrderedDict, input_data::Predicer.In
             if !isempty(prod_flows)
                 add_to_expression!(e_node_bal_eq_prod[(n, s, t)], sum(v_flow[Predicer.validate_tuple(model_contents, map(x -> (x..., s, t), prod_flows), 4)])) 
             end
-            add_to_expression!(e_constraint_node_bal_eq[(n, s, t)], e_node_bal_eq_prod[(n, s, t)] - e_node_bal_eq_cons[(n, s, t)])
+            add_to_expression!(e_constraint_node_bal_eq[(n, s, t)], (e_node_bal_eq_prod[(n, s, t)] - e_node_bal_eq_cons[(n, s, t)]) * input_data.temporals(t))
         end
     end
 
@@ -103,7 +102,7 @@ function setup_node_balance(model_contents::OrderedDict, input_data::Predicer.In
         v_res_real = model_contents["expression"]["v_res_real"]
         for tup in constraint_indices
             if tup in node_reserves(input_data)
-                add_to_expression!(e_node_bal_eq_res_real[tup], -v_res_real[tup])
+                add_to_expression!(e_node_bal_eq_res_real[tup], -v_res_real[tup] * input_data.temporals(tup[3]))
             end
             add_to_expression!(e_constraint_node_bal_eq[tup], e_node_bal_eq_res_real[tup])
         end
@@ -114,16 +113,16 @@ function setup_node_balance(model_contents::OrderedDict, input_data::Predicer.In
         vq_state_up = model.obj_dict[:vq_state_up]
         vq_state_dw = model.obj_dict[:vq_state_dw]
         for ci in constraint_indices
-            add_to_expression!(e_constraint_node_bal_eq[ci], - vq_state_dw[Predicer.validate_tuple(model_contents, ci, 2)])
-            add_to_expression!(e_constraint_node_bal_eq[ci], vq_state_up[Predicer.validate_tuple(model_contents, ci, 2)])
+            add_to_expression!(e_constraint_node_bal_eq[ci], - vq_state_dw[Predicer.validate_tuple(model_contents, ci, 2)] * input_data.temporals(ci[3]))
+            add_to_expression!(e_constraint_node_bal_eq[ci], vq_state_up[Predicer.validate_tuple(model_contents, ci, 2)] * input_data.temporals(ci[3]))
         end
     end
 
     # inflow expression
     for n in unique(map(nbt -> nbt[1], balance_node_tuples(input_data)))
         if input_data.nodes[n].is_inflow
             for s in scenarios(input_data), t in input_data.temporals.t
-                inflow_val = input_data.nodes[n].inflow(s, t)
+                inflow_val = input_data.nodes[n].inflow(s, t) * input_data.temporals(t)
                 if input_data.nodes[n].is_state
                     if input_data.nodes[n].state.is_temp
                         inflow_val = inflow_val * input_data.nodes[n].state.t_e_conversion
@@ -191,7 +190,7 @@ function setup_node_balance(model_contents::OrderedDict, input_data::Predicer.In
             end
         end
         for tup in constraint_indices
-            add_to_expression!(e_constraint_node_bal_eq[tup], e_node_bal_eq_diffusion[tup])
+            add_to_expression!(e_constraint_node_bal_eq[tup], e_node_bal_eq_diffusion[tup] * input_data.temporals(tup[3]))
         end
     end
 
@@ -219,6 +218,7 @@ function setup_node_balance(model_contents::OrderedDict, input_data::Predicer.In
         for ts_data in input_data.node_histories[n].steps.ts_data
             for ts in ts_data.series
                 add_to_expression!(e_node_bal_eq_history[(n, ts_data.scenario, ts[1])], ts[2])
+                add_to_expression!(e_constraint_node_bal_eq[(n, ts_data.scenario, ts[1])], e_node_bal_eq_history[(n, ts_data.scenario, ts[1])])
             end
         end
     end

src/model.jl

@@ -513,7 +513,7 @@ function write_bid_matrix(model_contents::OrderedDict, input_data::Predicer.Inpu
                 p_name = "PRICE-"*s
                 v_name = "VOLUME-"*s
                 price = map(t -> markets[m].price(s, t),temporals)
-                if markets[m].type == "energy"
+                if markets[m].m_type == "energy"
                     bid_tuple = unique(map(x->(x[1],x[3],x[4]),filter(x->x[1]==m && x[3]==s,tuples["balance_market_tuple"])))
                     volume = []
                     for tup in bid_tuple

test/runtests.jl

@@ -15,34 +15,45 @@ using HiGHS: Optimizer
 # comparison.
 cases = [
     "input_data.xlsx" => -10985.034456374564
+    "input_data_complete.xlsx" => -7139.999025659914
     "input_data_bidcurve.xlsx" => -4371.579033779262
     "demo_model.xlsx" => -1095.5118308122817
     "example_model.xlsx" => -11014.1278942231
-    "input_data_common_start.xlsx" => -1589.8038551373697
+    "input_data_common_start.xlsx" => -1574.9410327933133
     "input_data_delays.xlsx" => 62.22222222222222
     "input_data_temps.xlsx" => 65388.35282275837
     "simple_building_model.xlsx" => 563.7841038762567
     "simple_dh_model.xlsx" => 7195.372539092246
-#FIXME Does not load    "simple_hydropower_river_system.xlsx" => NaN
+    #"simple_hydropower_river_system.xlsx" => NaN
     "two_stage_dh_model.xlsx" => 9508.652488524222
 ]
 
-@testset "Predicer on $bn" for (bn, obj) in cases
-    inp = Predicer.get_data(joinpath("../input_data", bn))
-    inp = Predicer.tweak_input!(inp)
-    m = Model(Optimizer)
-    #set_silent(m)
-    mc = Predicer.generate_model(m, inp)
-    @test m == mc["model"]
-    Predicer.solve_model(mc)
-    @test termination_status(m) == MOI.OPTIMAL
-    rgap = relative_gap(m)
-    # Apparently infinite for LP
-    if rgap < 1e-8 || !isfinite(rgap)
-        rgap = 1e-8
-    end
-    if !isnan(obj)
-        @test objective_value(m) ≈ obj rtol=rgap
+function testrunner(cases)
+    test_results = Dict()
+    for _filename in map(x -> x[1], cases)
+        test_results[_filename] = []
+        mc, id = Predicer.generate_model(joinpath(pwd(), "..", "input_data", _filename));
+        Predicer.solve_model(mc)
+        if JuMP.termination_status(mc["model"]) == MOI.OPTIMAL
+            rgap = relative_gap(mc["model"])
+            if rgap < 1e-8 || !isfinite(rgap)
+                rgap = 1e-8
+            end
+            push!(test_results[_filename], (true, JuMP.objective_value(mc["model"]), rgap))
+        else
+            push!(test_results[_filename], (false, JuMP.termination_status(mc["model"]), ""))
+        end
     end
-    @show objective_value(m) obj relative_gap(m)
+    return test_results
+end
+
+test_results = testrunner(cases)
+
+@testset "Predicer on $bn" for (bn, obj) in cases
+    @test test_results[bn][1][1]
+    @test test_results[bn][1][2] ≈ obj rtol=(test_results[bn][1][3])
+    model_obj_val = test_results[bn][1][2]
+    expected_val = obj
+    rgap = test_results[bn][1][3]
+    @show model_obj_val expected_val rgap
 end