init

UnitCommitment_Trajectory_Test/src/model/formulations/xxx2005/powertrajectories.jl

@@ -0,0 +1,168 @@
+function _add_power_trajectory_eqs!(
+    model::JuMP.Model,
+    g::ThermalUnit,
+    formulation_prod_vars::Gar1962.ProdVars,
+    formulation_power_trajectories::xxx2005.PowerTrajectories,
+    formulation_status_vars::Gar1962.StatusVars,
+    sc::UnitCommitmentScenario,
+)::Nothing
+    if isempty(g.startup_curve) || isempty(g.shutdown_curve)
+        return
+    end
+
+    T_del = model[:instance].time
+    if haskey(model, :eq_ramp_up) && haskey(model, :eq_ramp_down)
+        for t in 1:T_del
+            key = (sc.name, g.name, t)
+            if haskey(model[:eq_ramp_up], key)
+                delete(model, model[:eq_ramp_up][key])
+                delete!(model[:eq_ramp_up], key)
+            end
+            if haskey(model[:eq_ramp_down], key)
+                delete(model, model[:eq_ramp_down][key])
+                delete!(model[:eq_ramp_down], key)
+            end
+        end
+    end
+
+    T  = model[:instance].time
+    UD = length(g.startup_curve)
+    DD = length(g.shutdown_curve)
+    P_U = g.startup_curve
+    P_D = g.shutdown_curve
+    if haskey(model, :segprod)
+        for t in 1:T_del
+            su_min = isempty(P_U) ? 0.0 : minimum(P_U)
+            if su_min < g.min_power[t]
+                key1 = (sc.name, g.name, t, 1)
+                if haskey(model[:segprod], key1)
+                    set_lower_bound(model[:segprod][key1], su_min - g.min_power[t])
+                end
+            end
+        end
+    end
+    RU  = g.ramp_up_limit
+    RD  = g.ramp_down_limit
+    gn  = g.name
+
+    is_on     = model[:is_on]
+    switch_on = model[:switch_on]
+    switch_off= model[:switch_off]
+
+    eq_startup_lb  = _init(model, :eq_arr_startup_lb)
+    eq_startup_ub  = _init(model, :eq_arr_startup_ub)
+    eq_shutdown_lb = _init(model, :eq_arr_shutdown_lb)
+    eq_shutdown_ub = _init(model, :eq_arr_shutdown_ub)
+    eq_ramp_up   = _init(model, :eq_arr_ramp_up)
+    eq_ramp_down = _init(model, :eq_arr_ramp_down)
+    eq_overlap_logic = _init(model, :eq_overlap_logic)
+    eq_overlap_su_lb = _init(model, :eq_overlap_su_lb)
+    eq_overlap_sd_lb = _init(model, :eq_overlap_sd_lb)
+
+    for t in 1:T
+        Pmax = g.max_power[t]
+        Pmin = g.min_power[t]
+        p_t   = _actual_power(model, g, sc, t)
+        su_prod = sum(
+            P_U[i] * switch_on[gn, t - i + 1]
+            for i in 1:UD if t - i + 1 >= 1;
+            init = 0.0
+        )
+        # Σ y(k-i+1)
+        su_sum = sum(
+            switch_on[gn, t - i + 1]
+            for i in 1:UD if t - i + 1 >= 1;
+            init = 0
+        )
+        # Σ P_D(i)·z(k+DD-i+1)
+        sd_prod = sum(
+            P_D[i] * switch_off[gn, t + DD - i + 1]
+            for i in 1:DD if t + DD - i + 1 <= T;
+            init = 0.0
+        )
+        # Σ z(k+i)
+        sd_sum = sum(
+            switch_off[gn, t + i]
+            for i in 1:DD if t + i <= T;
+            init = 0
+        )
+
+        # [1] 启动下限
+        eq_startup_lb[sc.name, gn, t] = @constraint(
+            model,
+            p_t >= Pmin * (is_on[gn, t] - su_sum - sd_sum) + su_prod
+        )
+
+        # [2] 停止下限
+        eq_shutdown_lb[sc.name, gn, t] = @constraint(
+            model,
+            p_t >= Pmin * (is_on[gn, t] - su_sum - sd_sum) + sd_prod
+        )
+
+        # [3] 启动上限
+        eq_startup_ub[sc.name, gn, t] = @constraint(
+            model,
+            p_t <= su_prod + Pmax * (is_on[gn, t] - su_sum)
+        )
+
+        # [4] 停止上限
+        eq_shutdown_ub[sc.name, gn, t] = @constraint(
+            model,
+            p_t <= sd_prod + Pmax * (is_on[gn, t] - sd_sum)
+        )
+        
+        # [10] 
+        eq_overlap_logic[sc.name, gn, t] = @constraint(
+            model,
+            switch_on[gn, t] + sum(
+                switch_off[gn, t + j]
+                for j in 0:(UD + DD - 2) if t + j <= T;
+                init = 0
+            ) <= 1
+        )
+
+        # [11] & [12] 
+        eq_overlap_su_lb[sc.name, gn, t] = @constraint(
+            model,
+            p_t >= P_U[UD] * (su_sum + sd_sum - 1)
+        )
+
+        eq_overlap_sd_lb[sc.name, gn, t] = @constraint(
+            model,
+            p_t >= P_D[1] * (su_sum + sd_sum - 1)
+        )
+
+        # [5]
+        if t == 1
+            g.initial_status > 0 || continue
+            p_prev = g.initial_power
+        else
+            p_prev = _actual_power(model, g, sc, t - 1)
+        end
+        eq_ramp_up[sc.name, gn, t] = @constraint(
+            model,
+            p_t - p_prev <= Pmax * su_sum + RU * (is_on[gn, t] - su_sum)
+        )
+
+        # [6]
+        if t > 1
+            p_prev_rd = _actual_power(model, g, sc, t - 1)
+            sd_sum_prev = sum(
+                switch_off[gn, (t-1) + i]
+                for i in 1:DD if (t-1) + i <= T;
+                init = 0
+            )
+            eq_ramp_down[sc.name, gn, t] = @constraint(
+                model,
+                p_prev_rd - p_t <= Pmax * sd_sum_prev + RD * (is_on[gn, t-1] - sd_sum_prev)
+            )
+        end
+
+        reserve_t = _total_reserves(model, g, sc)[t]
+        @constraint(
+            model,
+            reserve_t <= Pmax * (is_on[gn, t] - su_sum - sd_sum)
+        )
+    end        
+    return
+end

UnitCommitment_Trajectory_Test/src/model/formulations/xxx2005/structs.jl

@@ -0,0 +1,7 @@
+module xxx2005
+
+import ..PowerTrajectoriesFormulation
+
+struct PowerTrajectories <: PowerTrajectoriesFormulation end
+
+end