Merge branch 'master' into loa_two_models

Author: dnguyen227

Project.toml

@@ -1,7 +1,7 @@
 name = "DisjunctiveProgramming"
 uuid = "0d27d021-0159-4c7d-b4a7-9ccb5d9366cf"
 authors = ["hdavid16 <hperez16@gmail.com>"]
-version = "0.6.0"
+version = "0.6.1"
 
 [deps]
 JuMP = "4076af6c-e467-56ae-b986-b466b2749572"
@@ -21,6 +21,9 @@ JuMP = "1.18"
 Juniper = "0.9.3"
 Reexport = "1"
 julia = "1.10"
+Juniper = "0.9.3"
+Ipopt = "1.9.0"
+InfiniteOpt = "0.6.3"
 
 [extras]
 Aqua = "4c88cf16-eb10-579e-8560-4a9242c79595"

ext/InfiniteDisjunctiveProgramming.jl

@@ -1056,4 +1056,83 @@ _add_to_transcribed_dict(
     ) =
     (d[ts] = values[1]; nothing)
 
+################################################################################
+
+# Build CP subproblem: reformulate the InfiniteModel in-place, transcribe,
+# copy, and wrap in GDPSubmodel with forward variable map.
+function DP.copy_and_reformulate(
+    model::InfiniteOpt.InfiniteModel,
+    decision_vars::Vector{InfiniteOpt.GeneralVariableRef},
+    reform_method::DP.AbstractReformulationMethod,
+    method::DP.CuttingPlanes
+    )
+    DP.reformulate_model(model, reform_method)
+    InfiniteOpt.build_transformation_backend!(model)
+    transcribed = InfiniteOpt.transformation_model(model)
+    transcription_fwd = Dict{InfiniteOpt.GeneralVariableRef,
+        Vector{JuMP.VariableRef}}()
+    for v in DP.collect_all_vars(model)
+        transcription_var = InfiniteOpt.transformation_variable(v)
+        var_prefs = InfiniteOpt.parameter_refs(v)
+        transcription_fwd[v] = isempty(var_prefs) ?
+            [transcription_var] : vec(transcription_var)
+    end
+    sub_copy, copy_map = JuMP.copy_model(transcribed)
+    fwd_map = Dict{InfiniteOpt.GeneralVariableRef, Vector{JuMP.VariableRef}}()
+    for v in decision_vars
+        haskey(transcription_fwd, v) || continue
+        fwd_map[v] = [copy_map[transcribed_var] for transcribed_var in transcription_fwd[v]]
+    end
+    sub = DP.GDPSubmodel(sub_copy, decision_vars, fwd_map)
+    JuMP.set_optimizer(sub.model, method.optimizer)
+    JuMP.set_silent(sub.model)
+    return sub
+end
+
+# Read per-support values from the transformation backend.
+function DP.extract_solution(model::InfiniteOpt.InfiniteModel)
+    dvars = DP.collect_cutting_planes_vars(model)
+    V = eltype(dvars)
+    T = JuMP.value_type(typeof(model))
+    sol = Dict{V, Vector{T}}()
+    for v in dvars
+        transcription_var = InfiniteOpt.transformation_variable(v)
+        var_prefs = InfiniteOpt.parameter_refs(v)
+        sol[v] = isempty(var_prefs) ? [JuMP.value(transcription_var)] :
+            JuMP.value.(vec(transcription_var))
+    end
+    return sol
+end
+
+# Add a pointwise-sum cut directly to the transformation backend and mark
+# it ready so the next optimize! doesn't re-transcribe and wipe the cut.
+function DP.add_cut(
+    model::InfiniteOpt.InfiniteModel,
+    decision_vars::Vector{InfiniteOpt.GeneralVariableRef},
+    rBM_sol::Dict{<:JuMP.AbstractVariableRef, <:Vector{<:Number}},
+    sep_sol::Dict{<:JuMP.AbstractVariableRef, <:Vector{<:Number}}
+    )
+    transcribed = InfiniteOpt.transformation_model(model)
+    cut_expr = zero(JuMP.GenericAffExpr{
+        JuMP.value_type(typeof(transcribed)),
+        JuMP.variable_ref_type(transcribed)})
+    for var in decision_vars
+        haskey(rBM_sol, var) || continue
+        haskey(sep_sol, var) || continue
+        rbm_vals = rBM_sol[var]
+        sep_vals = sep_sol[var]
+        transcription_var = InfiniteOpt.transformation_variable(var)
+        transcribed_vars = transcription_var isa AbstractArray ?
+            vec(transcription_var) : [transcription_var]
+        for k in eachindex(transcribed_vars)
+            xi = 2 * (sep_vals[k] - rbm_vals[k])
+            JuMP.add_to_expression!(cut_expr, xi, transcribed_vars[k])
+            JuMP.add_to_expression!(cut_expr, -xi * sep_vals[k])
+        end
+    end
+    JuMP.@constraint(transcribed, cut_expr >= 0)
+    InfiniteOpt.set_transformation_backend_ready(model, true)
+    return
+end
+
 end

test/extensions/InfiniteDisjunctiveProgramming.jl

@@ -513,6 +513,76 @@ function test_mbm_finite_and_integer_var()
         [MOI.OPTIMAL, MOI.LOCALLY_SOLVED]
 end
 
+function test_mbm_infinite_simple()
+    model = InfiniteGDPModel(HiGHS.Optimizer)
+    set_silent(model)
+    model = InfiniteGDPModel(HiGHS.Optimizer)
+    set_silent(model)
+    K = 4
+    @infinite_parameter(model, t ∈ [0, 1], num_supports = K)
+    @variable(model, 0 <= x <= 10, Infinite(t))
+    @variable(model, Y[1:2], InfiniteLogical(t))
+    @constraint(model, x >= 5, Disjunct(Y[1]))
+    @constraint(model, x <= 3, Disjunct(Y[2]))
+    @disjunction(model, Y)
+    JuMP.fix(Y[2], true)  # force disj 2 active
+    @objective(model, Min, ∫(x, t))
+    DP.reformulate_model(model, BigM(10.0))
+    set_optimizer(model, HiGHS.Optimizer)
+    set_silent(model)
+    optimize!(model, ignore_optimize_hook = true)
+    sol = DP.extract_solution(model)
+    @test haskey(sol, x)
+    @test length(sol[x]) == K
+    @test all(v -> isapprox(v, 0.0; atol=1e-6), sol[x])
+end
+
+# add_cut adds one pointwise-sum cut to the transformation backend and
+# marks the backend ready so the next optimize! does NOT re-transcribe.
+function test_add_cut_infinite()
+    model = InfiniteGDPModel(HiGHS.Optimizer)
+    set_silent(model)
+    K = 3
+    @infinite_parameter(model, t ∈ [0, 1], num_supports = K)
+    @variable(model, 0 <= x <= 10, Infinite(t))
+    @variable(model, Y[1:2], InfiniteLogical(t))
+    @constraint(model, x >= 5, Disjunct(Y[1]))
+    @constraint(model, x <= 3, Disjunct(Y[2]))
+    @disjunction(model, Y)
+    DP.reformulate_model(model, BigM(10.0))
+    InfiniteOpt.build_transformation_backend!(model)
+    transcribed = InfiniteOpt.transformation_model(model)
+    n_before = JuMP.num_constraints(transcribed;
+        count_variable_in_set_constraints = false)
+    rBM_sol = Dict(x => [1.0, 2.0, 3.0])
+    sep_sol = Dict(x => [0.5, 1.5, 2.5])
+    DP.add_cut(model, [x], rBM_sol, sep_sol)
+    n_after = JuMP.num_constraints(transcribed;
+        count_variable_in_set_constraints = false)
+    @test n_after == n_before + 1
+    # set_transformation_backend_ready(true) — next optimize! should
+    # reuse without re-transcribing (otherwise our cut would be lost)
+    @test InfiniteOpt.transformation_backend_ready(model)
+end
+
+# MBM with finite + integer variables in an InfiniteModel.
+function test_mbm_finite_and_integer_var()
+    model = InfiniteGDPModel(HiGHS.Optimizer)
+    set_silent(model)
+    @infinite_parameter(model, t ∈ [0, 1], num_supports = 10)
+    @variable(model, 0 <= x <= 10, Infinite(t))
+    @variable(model, 0 <= w <= 5, Int)
+    @variable(model, Y[1:2], InfiniteLogical(t))
+    @constraint(model, x + w >= 5, Disjunct(Y[1]))
+    @constraint(model, x + w <= 3, Disjunct(Y[2]))
+    @disjunction(model, Y)
+    @objective(model, Min, ∫(x, t) + w)
+    @test optimize!(model,
+        gdp_method = MBM(HiGHS.Optimizer)) isa Nothing
+    @test termination_status(model) in
+        [MOI.OPTIMAL, MOI.LOCALLY_SOLVED]
+end
+
 function test_mbm_infinite_simple()
     model = InfiniteGDPModel(HiGHS.Optimizer)
     set_silent(model)