From 38c20d40db9af90bcf6d1f1e9475341608ae60ee Mon Sep 17 00:00:00 2001 From: Abel Soares Siqueira Date: Mon, 25 Nov 2024 16:25:24 +0100 Subject: [PATCH] Refactor variables to use TulipaVariable (#925) --- docs/src/20-tutorials.md | 8 +- src/constraints/group.jl | 4 +- src/constraints/investment.jl | 19 +-- src/create-model.jl | 35 ++--- src/expressions/multi-year.jl | 13 +- src/expressions/storage.jl | 7 +- src/objective.jl | 16 +- src/solve-model.jl | 20 ++- src/structures.jl | 9 +- src/time-resolution.jl | 16 +- src/variables/create.jl | 136 ++++++++++++++++ src/variables/investments.jl | 145 +++++++++--------- .../Multi-year Investments/asset-both.csv | 3 +- test/test-case-studies.jl | 4 +- test/test-pipeline.jl | 4 +- 15 files changed, 292 insertions(+), 147 deletions(-) create mode 100644 src/variables/create.jl diff --git a/docs/src/20-tutorials.md b/docs/src/20-tutorials.md index 33185275..54e52097 100644 --- a/docs/src/20-tutorials.md +++ b/docs/src/20-tutorials.md @@ -121,7 +121,7 @@ We need the sets and the variables indices. ```@example manual sets = create_sets(graph, years) -variables = compute_variables_indices(dataframes) +variables = compute_variables_indices(connection, dataframes) ``` Now we can compute the model. @@ -133,13 +133,13 @@ model = create_model(graph, sets, variables, representative_periods, dataframes, Finally, we can compute the solution. ```@example manual -solution = solve_model(model) +solution = solve_model(model, variables) ``` or, if we want to store the `flow`, `storage_level_intra_rp`, and `storage_level_inter_rp` optimal value in the dataframes: ```@example manual -solution = solve_model!(dataframes, model) +solution = solve_model!(dataframes, model, variables) ``` This `solution` structure is the same as the one returned when using an `EnergyProblem`. @@ -174,7 +174,7 @@ or ```@example manual using GLPK -solution = solve_model(model, GLPK.Optimizer) +solution = solve_model(model, variables, GLPK.Optimizer) ``` Notice that, in any of these cases, we need to explicitly add the GLPK package diff --git a/src/constraints/group.jl b/src/constraints/group.jl index d9b4c97c..006d5829 100644 --- a/src/constraints/group.jl +++ b/src/constraints/group.jl @@ -5,11 +5,13 @@ export add_group_constraints! Adds group constraints for assets that share a common limits or bounds """ -function add_group_constraints!(model, graph, sets, assets_investment, groups) +function add_group_constraints!(model, variables, graph, sets, groups) # unpack from sets Ai = sets[:Ai] Y = sets[:Y] + assets_investment = variables[:assets_investment].lookup + # - Group constraints for investments at each year assets_at_year_in_group = Dict( group => ( diff --git a/src/constraints/investment.jl b/src/constraints/investment.jl index 7b5a3c38..a5e2b71e 100644 --- a/src/constraints/investment.jl +++ b/src/constraints/investment.jl @@ -1,24 +1,25 @@ export add_investment_constraints! """ -add_investment_constraints!(graph, Ai, Ase, Fi, assets_investment, assets_investment_energy, flows_investment) + add_investment_constraints!(graph, Ai, Ase, Fi, assets_investment, assets_investment_energy, flows_investment) Adds the investment constraints for all asset types and transport flows to the model """ - -function add_investment_constraints!( - graph, - sets, - assets_investment, - assets_investment_energy, - flows_investment, -) +function add_investment_constraints!(graph, sets, variables) + # TODO: Since this function is defining bound constraints, it doesn't need the `model` + # When we refactor the signatures to look the same, we should consider naming it differently + # TODO: Verify if it's possible and reasonable to move the bound definition to when the + # indices are created # unpack from sets Ai = sets[:Ai] Ase = sets[:Ase] Fi = sets[:Fi] Y = sets[:Y] + assets_investment = variables[:assets_investment].lookup + assets_investment_energy = variables[:assets_investment_energy].lookup + flows_investment = variables[:flows_investment].lookup + # - Maximum (i.e., potential) investment limit for assets for y in Y, a in Ai[y] if graph[a].capacity > 0 && !ismissing(graph[a].investment_limit[y]) diff --git a/src/create-model.jl b/src/create-model.jl index bc69a338..eefaf0e6 100644 --- a/src/create-model.jl +++ b/src/create-model.jl @@ -76,7 +76,7 @@ function create_model( ## Variables @timeit to "add_flow_variables!" add_flow_variables!(model, variables) - @timeit to "add_investment_variables!" add_investment_variables!(model, graph, sets) + @timeit to "add_investment_variables!" add_investment_variables!(model, graph, sets, variables) @timeit to "add_unit_commitment_variables!" add_unit_commitment_variables!( model, sets, @@ -84,15 +84,6 @@ function create_model( ) @timeit to "add_storage_variables!" add_storage_variables!(model, graph, sets, variables) - # TODO: This should change heavily, so I just moved things to the function and unpack them here from model - assets_decommission_compact_method = model[:assets_decommission_compact_method] - assets_decommission_simple_method = model[:assets_decommission_simple_method] - assets_decommission_energy_simple_method = model[:assets_decommission_energy_simple_method] - assets_investment = model[:assets_investment] - assets_investment_energy = model[:assets_investment_energy] - flows_decommission_using_simple_method = model[:flows_decommission_using_simple_method] - flows_investment = model[:flows_investment] - # TODO: This should disapear after the changes on add_expressions_to_dataframe! and storing the solution model[:flow] = df_flows.flow = variables[:flow].container model[:units_on] = df_units_on.units_on = variables[:units_on].container @@ -125,7 +116,7 @@ function create_model( ) ## Expressions for multi-year investment - create_multi_year_expressions!(model, graph, sets) + create_multi_year_expressions!(model, graph, sets, variables) accumulated_flows_export_units = model[:accumulated_flows_export_units] accumulated_flows_import_units = model[:accumulated_flows_import_units] accumulated_initial_units = model[:accumulated_initial_units] @@ -136,12 +127,20 @@ function create_model( accumulated_units_simple_method = model[:accumulated_units_simple_method] ## Expressions for storage assets - add_storage_expressions!(model, graph, sets) + add_storage_expressions!(model, graph, sets, variables) accumulated_energy_units_simple_method = model[:accumulated_energy_units_simple_method] accumulated_energy_capacity = model[:accumulated_energy_capacity] ## Expressions for the objective function - add_objective!(model, graph, dataframes, representative_periods, sets, model_parameters) + add_objective!( + model, + variables, + graph, + dataframes, + representative_periods, + sets, + model_parameters, + ) # TODO: Pass sets instead of the explicit values ## Constraints @@ -210,20 +209,14 @@ function create_model( accumulated_flows_import_units, ) - @timeit to "add_investment_constraints!" add_investment_constraints!( - graph, - sets, - assets_investment, - assets_investment_energy, - flows_investment, - ) + @timeit to "add_investment_constraints!" add_investment_constraints!(graph, sets, variables) if !isempty(groups) @timeit to "add_group_constraints!" add_group_constraints!( model, + variables, graph, sets, - assets_investment, groups, ) end diff --git a/src/expressions/multi-year.jl b/src/expressions/multi-year.jl index 2888e314..763e6c77 100644 --- a/src/expressions/multi-year.jl +++ b/src/expressions/multi-year.jl @@ -1,11 +1,12 @@ -function create_multi_year_expressions!(model, graph, sets) +function create_multi_year_expressions!(model, graph, sets, variables) @timeit to "multi-year investment expressions" begin # Unpacking - assets_investment = model[:assets_investment] - assets_decommission_simple_method = model[:assets_decommission_simple_method] - assets_decommission_compact_method = model[:assets_decommission_compact_method] - flows_investment = model[:flows_investment] - flows_decommission_using_simple_method = model[:flows_decommission_using_simple_method] + assets_investment = variables[:assets_investment].lookup + assets_decommission_simple_method = variables[:assets_decommission_simple_method].lookup + assets_decommission_compact_method = variables[:assets_decommission_compact_method].lookup + flows_investment = variables[:flows_investment].lookup + flows_decommission_using_simple_method = + variables[:flows_decommission_using_simple_method].lookup accumulated_initial_units = @expression( model, diff --git a/src/expressions/storage.jl b/src/expressions/storage.jl index 6af86275..f296b515 100644 --- a/src/expressions/storage.jl +++ b/src/expressions/storage.jl @@ -1,6 +1,7 @@ -function add_storage_expressions!(model, graph, sets) - assets_investment_energy = model[:assets_investment_energy] - assets_decommission_energy_simple_method = model[:assets_decommission_energy_simple_method] +function add_storage_expressions!(model, graph, sets, variables) + assets_investment_energy = variables[:assets_investment_energy].lookup + assets_decommission_energy_simple_method = + variables[:assets_decommission_energy_simple_method].lookup accumulated_investment_units_using_simple_method = model[:accumulated_investment_units_using_simple_method] accumulated_decommission_units_using_simple_method = diff --git a/src/objective.jl b/src/objective.jl index 76b42f70..268e2624 100644 --- a/src/objective.jl +++ b/src/objective.jl @@ -1,10 +1,18 @@ -function add_objective!(model, graph, dataframes, representative_periods, sets, model_parameters) - assets_investment = model[:assets_investment] +function add_objective!( + model, + variables, + graph, + dataframes, + representative_periods, + sets, + model_parameters, +) + assets_investment = variables[:assets_investment].lookup accumulated_units_simple_method = model[:accumulated_units_simple_method] accumulated_units_compact_method = model[:accumulated_units_compact_method] - assets_investment_energy = model[:assets_investment_energy] + assets_investment_energy = variables[:assets_investment_energy].lookup accumulated_energy_units_simple_method = model[:accumulated_energy_units_simple_method] - flows_investment = model[:flows_investment] + flows_investment = variables[:flows_investment].lookup accumulated_flows_export_units = model[:accumulated_flows_export_units] accumulated_flows_import_units = model[:accumulated_flows_import_units] diff --git a/src/solve-model.jl b/src/solve-model.jl index fd175c32..823aac48 100644 --- a/src/solve-model.jl +++ b/src/solve-model.jl @@ -17,8 +17,13 @@ function solve_model!( error("Model is not created, run create_model(energy_problem) first.") end - energy_problem.solution = - solve_model!(energy_problem.dataframes, model, optimizer; parameters = parameters) + energy_problem.solution = solve_model!( + energy_problem.dataframes, + model, + energy_problem.variables, + optimizer; + parameters = parameters, + ) energy_problem.termination_status = JuMP.termination_status(model) if energy_problem.solution === nothing # Warning has been given at internal function @@ -34,7 +39,7 @@ function solve_model!( for ((y, a), value) in energy_problem.solution.assets_investment_energy graph[a].investment_energy[y] = - graph[a].investment_integer_storage_energy[y] ? round(Int, value) : value + graph[a].investment_integer_storage_energy ? round(Int, value) : value end for row in eachrow(energy_problem.dataframes[:storage_level_intra_rp]) @@ -158,11 +163,12 @@ The `solution` object is a mutable struct with the following fields: ```julia parameters = Dict{String,Any}("presolve" => "on", "time_limit" => 60.0, "output_flag" => true) -solution = solve_model(model, HiGHS.Optimizer; parameters = parameters) +solution = solve_model(model, variables, HiGHS.Optimizer; parameters = parameters) ``` """ function solve_model( model::JuMP.Model, + variables, optimizer = HiGHS.Optimizer; parameters = default_parameters(optimizer), ) @@ -181,9 +187,9 @@ function solve_model( end return Solution( - JuMP.value.(model[:assets_investment]).data, # .data returns a OrderedDict since variable is SparseAxisArray - JuMP.value.(model[:assets_investment_energy]).data, - JuMP.value.(model[:flows_investment]).data, + Dict(k => JuMP.value(v) for (k, v) in variables[:assets_investment].lookup), + Dict(k => JuMP.value(v) for (k, v) in variables[:assets_investment_energy].lookup), + Dict(k => JuMP.value(v) for (k, v) in variables[:flows_investment].lookup), JuMP.value.(model[:storage_level_intra_rp]), JuMP.value.(model[:storage_level_inter_rp]), JuMP.value.(model[:max_energy_inter_rp]), diff --git a/src/structures.jl b/src/structures.jl index d89c37d8..c4984307 100644 --- a/src/structures.jl +++ b/src/structures.jl @@ -38,9 +38,10 @@ Structure to hold the JuMP variables for the TulipaEnergyModel mutable struct TulipaVariable indices::DataFrame container::Vector{JuMP.VariableRef} + lookup::OrderedDict # TODO: This is probably not type stable so it's only used for strangling - function TulipaVariable(indices, container) - return new(indices, container) + function TulipaVariable(indices, container = JuMP.VariableRef[]) + return new(indices, container, Dict()) end end @@ -218,7 +219,7 @@ end mutable struct Solution assets_investment::Dict{Tuple{Int,String},Float64} assets_investment_energy::Dict{Tuple{Int,String},Float64} # for storage assets with energy method - flows_investment::Dict{Tuple{Int,Tuple{String,String}},Float64} + flows_investment::Any # TODO: Fix this type storage_level_intra_rp::Vector{Float64} storage_level_inter_rp::Vector{Float64} max_energy_inter_rp::Vector{Float64} @@ -307,7 +308,7 @@ mutable struct EnergyProblem end elapsed_time_vars = @elapsed begin - variables = compute_variables_indices(dataframes) + variables = compute_variables_indices(connection, dataframes) end energy_problem = new( diff --git a/src/time-resolution.jl b/src/time-resolution.jl index 02d5f570..97704f89 100644 --- a/src/time-resolution.jl +++ b/src/time-resolution.jl @@ -1,4 +1,4 @@ -export compute_rp_partition, compute_constraints_partitions, compute_variables_indices +export compute_rp_partition, compute_constraints_partitions using SparseArrays @@ -259,17 +259,3 @@ function compute_rp_partition( end return rp_partition end - -function compute_variables_indices(dataframes) - variables = Dict( - :flow => TulipaVariable(dataframes[:flows], Vector()), - :units_on => TulipaVariable(dataframes[:units_on], Vector()), - :storage_level_intra_rp => - TulipaVariable(dataframes[:storage_level_intra_rp], Vector()), - :storage_level_inter_rp => - TulipaVariable(dataframes[:storage_level_inter_rp], Vector()), - :is_charging => TulipaVariable(dataframes[:lowest_in_out], Vector()), - ) - - return variables -end diff --git a/src/variables/create.jl b/src/variables/create.jl new file mode 100644 index 00000000..e578668f --- /dev/null +++ b/src/variables/create.jl @@ -0,0 +1,136 @@ +export compute_variables_indices + +# TODO: Allow changing table names to make unit tests possible +# The signature should be something like `...(connection; assets_data="t_assets_data", ...)` +function compute_variables_indices(connection, dataframes) + variables = Dict( + :flow => TulipaVariable(dataframes[:flows]), + :units_on => TulipaVariable(dataframes[:units_on]), + :storage_level_intra_rp => TulipaVariable(dataframes[:storage_level_intra_rp]), + :storage_level_inter_rp => TulipaVariable(dataframes[:storage_level_inter_rp]), + :is_charging => TulipaVariable(dataframes[:lowest_in_out]), + ) + + variables[:flows_investment] = TulipaVariable( + DuckDB.query( + connection, + "SELECT + flow.from_asset, + flow.to_asset, + flow_milestone.milestone_year, + flow.investment_integer, + FROM flow_milestone + LEFT JOIN flow + ON flow.from_asset = flow_milestone.from_asset + AND flow.to_asset = flow_milestone.to_asset + WHERE + flow_milestone.investable = true", + ) |> DataFrame, + ) + dataframes[:flows_investment] = variables[:flows_investment].indices + + variables[:assets_investment] = TulipaVariable( + DuckDB.query( + connection, + "SELECT + asset.asset, + asset_milestone.milestone_year, + asset.investment_integer, + FROM asset_milestone + LEFT JOIN asset + ON asset.asset = asset_milestone.asset + WHERE + asset_milestone.investable = true", + ) |> DataFrame, + ) + dataframes[:assets_investment] = variables[:assets_investment].indices + + variables[:assets_decommission_simple_method] = TulipaVariable( + DuckDB.query( + connection, + "SELECT + asset.asset, + asset_milestone.milestone_year, + asset.investment_integer, + FROM asset_milestone + LEFT JOIN asset + ON asset.asset = asset_milestone.asset + WHERE + asset.investment_method = 'simple'", + ) |> DataFrame, + ) + + variables[:assets_decommission_compact_method] = TulipaVariable( + DuckDB.query( + connection, + "SELECT + asset_both.asset, + asset_both.milestone_year, + asset_both.commission_year, + asset_both.decommissionable, + asset.investment_integer + FROM asset_both + LEFT JOIN asset + ON asset.asset = asset_both.asset + WHERE + asset_both.decommissionable = true + AND asset.investment_method = 'compact' + ", + ) |> DataFrame, + ) + + variables[:flows_decommission_using_simple_method] = TulipaVariable( + DuckDB.query( + connection, + "SELECT + flow.from_asset, + flow.to_asset, + flow_milestone.milestone_year + FROM flow_milestone + LEFT JOIN flow + ON flow.from_asset = flow_milestone.from_asset + AND flow.to_asset = flow_milestone.to_asset + WHERE + flow.is_transport = true + ", + ) |> DataFrame, + ) + + variables[:assets_investment_energy] = TulipaVariable( + DuckDB.query( + connection, + "SELECT + asset.asset, + asset_milestone.milestone_year, + asset.investment_integer_storage_energy, + FROM asset_milestone + LEFT JOIN asset + ON asset.asset = asset_milestone.asset + WHERE + asset.storage_method_energy = true + AND asset_milestone.investable = true + AND asset.type = 'storage' + AND asset.investment_method = 'simple' + ", + ) |> DataFrame, + ) + + variables[:assets_decommission_energy_simple_method] = TulipaVariable( + DuckDB.query( + connection, + "SELECT + asset.asset, + asset_milestone.milestone_year, + asset.investment_integer_storage_energy, + FROM asset_milestone + LEFT JOIN asset + ON asset.asset = asset_milestone.asset + WHERE + asset.storage_method_energy = true + AND asset.type = 'storage' + AND asset.investment_method = 'simple'", + ) |> DataFrame, + ) + + return variables +end diff --git a/src/variables/investments.jl b/src/variables/investments.jl index 6fdb653f..339bc4a8 100644 --- a/src/variables/investments.jl +++ b/src/variables/investments.jl @@ -1,5 +1,28 @@ export add_investment_variables! +function _create_investment_variable!( + model, + variables, + name, + keys_from_row; + lower_bound_from_row = row -> -Inf, + integer_from_row = row -> false, +) + this_var = variables[name] + this_var.container = [ + @variable( + model, + lower_bound = lower_bound_from_row(row), + integer = integer_from_row(row), + base_name = "$name[" * join(keys_from_row(row), ",") * "]" + ) for row in eachrow(this_var.indices) + ] + this_var.lookup = OrderedDict( + keys_from_row(row) => var for + (var, row) in zip(this_var.container, eachrow(this_var.indices)) + ) +end + """ add_investment_variables!(model, graph, sets) @@ -7,75 +30,59 @@ Adds investment, decommission, and energy-related variables to the optimization and sets integer constraints on selected variables based on the `graph` data. """ -function add_investment_variables!(model, graph, sets) - @variable(model, 0 ≤ flows_investment[y in sets.Y, (u, v) in sets.Fi[y]]) - - @variable(model, 0 ≤ assets_investment[y in sets.Y, a in sets.Ai[y]]) - - @variable( - model, - 0 ≤ assets_decommission_simple_method[ - y in sets.Y, - a in sets.decommissionable_assets_using_simple_method, - ] - ) - - @variable( - model, - 0 <= - assets_decommission_compact_method[(a, y, v) in sets.decommission_set_using_compact_method] - ) - - @variable(model, 0 ≤ flows_decommission_using_simple_method[y in sets.Y, (u, v) in sets.Ft]) - - @variable(model, 0 ≤ assets_investment_energy[y in sets.Y, a in sets.Ase[y]∩sets.Ai[y]]) - - @variable( - model, - 0 ≤ assets_decommission_energy_simple_method[ - y in sets.Y, - a in sets.Ase[y]∩sets.decommissionable_assets_using_simple_method, - ] - ) - - ### Integer Investment Variables - for y in sets.Y, a in sets.Ai[y] - if graph[a].investment_integer - JuMP.set_integer(assets_investment[y, a]) - end - end - - for y in sets.Y, a in sets.decommissionable_assets_using_simple_method - if graph[a].investment_integer - JuMP.set_integer(assets_decommission_simple_method[y, a]) - end - end - - for (a, y, v) in sets.decommission_set_using_compact_method - # We don't do anything with existing units (because it can be integers or non-integers) - if !( - v in sets.V_non_milestone && a in sets.existing_assets_by_year_using_compact_method[y] - ) && graph[a].investment_integer - JuMP.set_integer(assets_decommission_compact_method[(a, y, v)]) - end - end - - for y in sets.Y, (u, v) in sets.Fi[y] - if graph[u, v].investment_integer - JuMP.set_integer(flows_investment[y, (u, v)]) - end - end - - for y in sets.Y, a in sets.Ase[y] ∩ sets.Ai[y] - if graph[a].investment_integer_storage_energy[y] - JuMP.set_integer(assets_investment_energy[y, a]) - end - end - - for y in sets.Y, a in sets.Ase[y] ∩ sets.decommissionable_assets_using_simple_method - if graph[a].investment_integer_storage_energy[y] - JuMP.set_integer(assets_decommission_energy_simple_method[y, a]) - end +function add_investment_variables!(model, graph, sets, variables) + for (name, keys_from_row, lower_bound_from_row, integer_from_row) in [ + ( + :flows_investment, + row -> (row.milestone_year, (row.from_asset, row.to_asset)), + _ -> 0.0, + row -> row.investment_integer, + ), + ( + :assets_investment, + row -> (row.milestone_year, row.asset), + _ -> 0.0, + row -> row.investment_integer, + ), + ( + :assets_decommission_simple_method, + row -> (row.milestone_year, row.asset), + _ -> 0.0, + row -> row.investment_integer, + ), + ( + :flows_decommission_using_simple_method, + row -> (row.milestone_year, (row.from_asset, row.to_asset)), + _ -> 0.0, + _ -> false, + ), + ( + :assets_decommission_compact_method, + row -> (row.asset, row.milestone_year, row.commission_year), + _ -> 0.0, + row -> row.investment_integer, + ), + ( + :assets_investment_energy, + row -> (row.milestone_year, row.asset), + _ -> 0.0, + row -> row.investment_integer_storage_energy, + ), + ( + :assets_decommission_energy_simple_method, + row -> (row.milestone_year, row.asset), + _ -> 0.0, + row -> row.investment_integer_storage_energy, + ), + ] + _create_investment_variable!( + model, + variables, + name, + keys_from_row; + lower_bound_from_row, + integer_from_row, + ) end return diff --git a/test/inputs/Multi-year Investments/asset-both.csv b/test/inputs/Multi-year Investments/asset-both.csv index 96881273..0d9c1fbd 100644 --- a/test/inputs/Multi-year Investments/asset-both.csv +++ b/test/inputs/Multi-year Investments/asset-both.csv @@ -12,7 +12,8 @@ ens,2030,2030,true,true,1.0,0.0 demand,2030,2030,true,true,0.0,0.0 ocgt,2050,2050,true,false,0.0,0.0 ccgt,2050,2028,true,true,1.0,0.0 -ccgt,2050,2050,true,true,0.0,0.0 +ccgt,2050,2030,true,true,0.0,0.0 +ccgt,2050,2050,true,false,0.0,0.0 battery,2050,2030,true,true,0.02,0.0 battery,2050,2050,true,false,0.0,0.0 wind,2050,2030,true,true,0.02,0.0 diff --git a/test/test-case-studies.jl b/test/test-case-studies.jl index ba7fda10..fc8cdb1b 100644 --- a/test/test-case-studies.jl +++ b/test/test-case-studies.jl @@ -2,7 +2,9 @@ dir = joinpath(INPUT_FOLDER, "Norse") parameters_dict = Dict( HiGHS.Optimizer => Dict("mip_rel_gap" => 0.01, "output_flag" => false), - GLPK.Optimizer => Dict("mip_gap" => 0.01, "msg_lev" => 0, "presolve" => GLPK.GLP_ON), + # TODO: Find a different way to test parameters of GLPK + # Removing because it's finding bad bases (ill-conditioned) randomly + # GLPK.Optimizer => Dict("mip_gap" => 0.01, "msg_lev" => 0, "presolve" => GLPK.GLP_ON), ) if !Sys.isapple() parameters_dict[Cbc.Optimizer] = Dict("ratioGap" => 0.01, "logLevel" => 0) diff --git a/test/test-pipeline.jl b/test/test-pipeline.jl index 4e09f12c..cb50df47 100644 --- a/test/test-pipeline.jl +++ b/test/test-pipeline.jl @@ -32,7 +32,7 @@ end ) model_parameters = ModelParameters(connection) sets = create_sets(graph, years) - variables = compute_variables_indices(dataframes) + variables = compute_variables_indices(connection, dataframes) # Create model model = create_model( @@ -48,6 +48,6 @@ end ) # Solve model - solution = solve_model(model, HiGHS.Optimizer) + solution = solve_model(model, variables, HiGHS.Optimizer) save_solution_to_file(mktempdir(), graph, dataframes, solution) end