Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Assign names to constraints #942

Open
wants to merge 6 commits into
base: master
Choose a base branch
from
Open

Assign names to constraints #942

Changes from all commits
Commits
Show all changes
6 commits
Select commit Hold shift + click to select a range
f9b98cd
Added name to constraints for better acessibility
Andre-Alambert Jan 24, 2025
33e6d2c
Saving changes before switching branches
Andre-Alambert Feb 5, 2025
a50626e
fixing an error
Andre-Alambert Feb 5, 2025
13faf7a
Merge pull request #1 from SECQUOIA/add-constraint-names
alimaala2002 Feb 7, 2025
0d46f96
fix line endings
Andre-Alambert Feb 7, 2025
f7a0333
Merge pull request #2 from SECQUOIA/fix-line-endings
alimaala2002 Feb 7, 2025
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
172 changes: 110 additions & 62 deletions src/core/constraint.jl
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -14,99 +14,114 @@ end

# Generic thermal limit constraint
"`p[f_idx]^2 + q[f_idx]^2 <= rate_a^2`"
function constraint_thermal_limit_from(pm::AbstractPowerModel, n::Int, f_idx, rate_a)
function constraint_thermal_limit_from(pm::AbstractPowerModel, n::Int, f_idx, rate_a; name="thermal_limit_from[$f_idx]")
p_fr = var(pm, n, :p, f_idx)
q_fr = var(pm, n, :q, f_idx)

JuMP.@constraint(pm.model, p_fr^2 + q_fr^2 <= rate_a^2)
c = JuMP.@constraint(pm.model, p_fr^2 + q_fr^2 <= rate_a^2, base_name=name)
pm.model[Symbol(name)] = c
end

"`p[t_idx]^2 + q[t_idx]^2 <= rate_a^2`"
function constraint_thermal_limit_to(pm::AbstractPowerModel, n::Int, t_idx, rate_a)
function constraint_thermal_limit_to(pm::AbstractPowerModel, n::Int, t_idx, rate_a; name="thermal_limit_to[$t_idx]")
p_to = var(pm, n, :p, t_idx)
q_to = var(pm, n, :q, t_idx)

JuMP.@constraint(pm.model, p_to^2 + q_to^2 <= rate_a^2)
c = JuMP.@constraint(pm.model, p_to^2 + q_to^2 <= rate_a^2, base_name=name)
pm.model[Symbol(name)] = c
end

"`[rate_a, p[f_idx], q[f_idx]] in SecondOrderCone`"
function constraint_thermal_limit_from(pm::AbstractConicModels, n::Int, f_idx, rate_a)
function constraint_thermal_limit_from(pm::AbstractConicModels, n::Int, f_idx, rate_a; name="thermal_limit_from[$f_idx]_SOC")
p_fr = var(pm, n, :p, f_idx)
q_fr = var(pm, n, :q, f_idx)

JuMP.@constraint(pm.model, [rate_a, p_fr, q_fr] in JuMP.SecondOrderCone())
c = JuMP.@constraint(pm.model, [rate_a, p_fr, q_fr] in JuMP.SecondOrderCone(), base_name=name)
pm.model[Symbol(name)] = c
end

"`[rate_a, p[t_idx], q[t_idx]] in SecondOrderCone`"
function constraint_thermal_limit_to(pm::AbstractConicModels, n::Int, t_idx, rate_a)
function constraint_thermal_limit_to(pm::AbstractConicModels, n::Int, t_idx, rate_a; name="thermal_limit_to[$t_idx]_SOC")
p_to = var(pm, n, :p, t_idx)
q_to = var(pm, n, :q, t_idx)

JuMP.@constraint(pm.model, [rate_a, p_to, q_to] in JuMP.SecondOrderCone())
c = JuMP.@constraint(pm.model, [rate_a, p_to, q_to] in JuMP.SecondOrderCone(), base_name=name)
pm.model[Symbol(name)] = c
end

# Generic on/off thermal limit constraint

"`p[f_idx]^2 + q[f_idx]^2 <= (rate_a * z_branch[i])^2`"
function constraint_thermal_limit_from_on_off(pm::AbstractPowerModel, n::Int, i, f_idx, rate_a)
function constraint_thermal_limit_from_on_off(pm::AbstractPowerModel, n::Int, i, f_idx, rate_a; name="thermal_limit_from[$f_idx]_on_off")
p_fr = var(pm, n, :p, f_idx)
q_fr = var(pm, n, :q, f_idx)
z = var(pm, n, :z_branch, i)

JuMP.@constraint(pm.model, p_fr^2 + q_fr^2 <= rate_a^2*z^2)
c = JuMP.@constraint(pm.model, p_fr^2 + q_fr^2 <= rate_a^2*z^2, base_name=name)
pm.model[Symbol(name)] = c
end

"`p[t_idx]^2 + q[t_idx]^2 <= (rate_a * z_branch[i])^2`"
function constraint_thermal_limit_to_on_off(pm::AbstractPowerModel, n::Int, i, t_idx, rate_a)
function constraint_thermal_limit_to_on_off(pm::AbstractPowerModel, n::Int, i, t_idx, rate_a; name="thermal_limit_to[$t_idx]_on_off")
p_to = var(pm, n, :p, t_idx)
q_to = var(pm, n, :q, t_idx)
z = var(pm, n, :z_branch, i)

JuMP.@constraint(pm.model, p_to^2 + q_to^2 <= rate_a^2*z^2)
c = JuMP.@constraint(pm.model, p_to^2 + q_to^2 <= rate_a^2*z^2, base_name=name)
pm.model[Symbol(name)] = c
end

"`p_ne[f_idx]^2 + q_ne[f_idx]^2 <= (rate_a * branch_ne[i])^2`"
function constraint_ne_thermal_limit_from(pm::AbstractPowerModel, n::Int, i, f_idx, rate_a)
function constraint_ne_thermal_limit_from(pm::AbstractPowerModel, n::Int, i, f_idx, rate_a; name="ne_thermal_limit_from[$f_idx]")
p_fr = var(pm, n, :p_ne, f_idx)
q_fr = var(pm, n, :q_ne, f_idx)
z = var(pm, n, :branch_ne, i)

JuMP.@constraint(pm.model, p_fr^2 + q_fr^2 <= rate_a^2*z^2)
c = JuMP.@constraint(pm.model, p_fr^2 + q_fr^2 <= rate_a^2*z^2, base_name=name)
pm.model[Symbol(name)] = c
end

"`p_ne[t_idx]^2 + q_ne[t_idx]^2 <= (rate_a * branch_ne[i])^2`"
function constraint_ne_thermal_limit_to(pm::AbstractPowerModel, n::Int, i, t_idx, rate_a)
function constraint_ne_thermal_limit_to(pm::AbstractPowerModel, n::Int, i, t_idx, rate_a; name="ne_thermal_limit_to[$t_idx]")
p_to = var(pm, n, :p_ne, t_idx)
q_to = var(pm, n, :q_ne, t_idx)
z = var(pm, n, :branch_ne, i)

JuMP.@constraint(pm.model, p_to^2 + q_to^2 <= rate_a^2*z^2)
c = JuMP.@constraint(pm.model, p_to^2 + q_to^2 <= rate_a^2*z^2, base_name=name)
pm.model[Symbol(name)] = c
end

"`pg[i] == pg`"
function constraint_gen_setpoint_active(pm::AbstractPowerModel, n::Int, i, pg)
function constraint_gen_setpoint_active(pm::AbstractPowerModel, n::Int, i, pg; name="gen_setpoint_active[$i]")
pg_var = var(pm, n, :pg, i)

JuMP.@constraint(pm.model, pg_var == pg)
c = JuMP.@constraint(pm.model, pg_var == pg, base_name=name)
pm.model[Symbol(name)] = c
end

"`qq[i] == qq`"
function constraint_gen_setpoint_reactive(pm::AbstractPowerModel, n::Int, i, qg)
function constraint_gen_setpoint_reactive(pm::AbstractPowerModel, n::Int, i, qg; name="gen_setpoint_reactive[$i]")
qg_var = var(pm, n, :qg, i)

JuMP.@constraint(pm.model, qg_var == qg)
c = JuMP.@constraint(pm.model, qg_var == qg, base_name=name)
pm.model[Symbol(name)] = c
end

"on/off constraint for generators"
function constraint_gen_power_on_off(pm::AbstractPowerModel, n::Int, i::Int, pmin, pmax, qmin, qmax)
function constraint_gen_power_on_off(pm::AbstractPowerModel, n::Int, i::Int, pmin, pmax, qmin, qmax; name=
["gen_active_ub[$i]_on_off", "gen_active_lb[$i]_on_off", "gen_reactive_ub[$i]_on_off", "gen_reactive_lb[$i]_on_off"])
pg = var(pm, n, :pg, i)
qg = var(pm, n, :qg, i)
z = var(pm, n, :z_gen, i)

JuMP.@constraint(pm.model, pg <= pmax*z)
JuMP.@constraint(pm.model, pg >= pmin*z)
JuMP.@constraint(pm.model, qg <= qmax*z)
JuMP.@constraint(pm.model, qg >= qmin*z)
c1 = JuMP.@constraint(pm.model, pg <= pmax*z, base_name=name[1])
c2 = JuMP.@constraint(pm.model, pg >= pmin*z, base_name=name[2])
c3 = JuMP.@constraint(pm.model, qg <= qmax*z, base_name=name[3])
c4 = JuMP.@constraint(pm.model, qg >= qmin*z, base_name=name[4])
pm.model[Symbol(name[1])] = c1
pm.model[Symbol(name[2])] = c2
pm.model[Symbol(name[3])] = c3
pm.model[Symbol(name[4])] = c4
end


Expand All @@ -117,20 +132,25 @@ Creates Line Flow constraint for DC Lines (Matpower Formulation)
p_fr + p_to == loss0 + p_fr * loss1
```
"""
function constraint_dcline_power_losses(pm::AbstractPowerModel, n::Int, f_bus, t_bus, f_idx, t_idx, loss0, loss1)
function constraint_dcline_power_losses(pm::AbstractPowerModel, n::Int, f_bus, t_bus, f_idx, t_idx, loss0, loss1; name=
"dcline_power_losses_from[$f_idx]_to[$t_idx]")
p_fr = var(pm, n, :p_dc, f_idx)
p_to = var(pm, n, :p_dc, t_idx)

JuMP.@constraint(pm.model, (1-loss1) * p_fr + (p_to - loss0) == 0)

c = JuMP.@constraint(pm.model, (1-loss1) * p_fr + (p_to - loss0) == 0, base_name=name)
pm.model[Symbol(name)] = c
end

"`pf[i] == pf, pt[i] == pt`"
function constraint_dcline_setpoint_active(pm::AbstractPowerModel, n::Int, f_idx, t_idx, pf, pt)
function constraint_dcline_setpoint_active(pm::AbstractPowerModel, n::Int, f_idx, t_idx, pf, pt; name=
["dcline_setpoint_active_from[$f_idx]", "dcline_setpoint_active_to[$t_idx]"])
p_fr = var(pm, n, :p_dc, f_idx)
p_to = var(pm, n, :p_dc, t_idx)

JuMP.@constraint(pm.model, p_fr == pf)
JuMP.@constraint(pm.model, p_to == pt)

c1 = JuMP.@constraint(pm.model, p_fr == pf, base_name=name[1])
c2 = JuMP.@constraint(pm.model, p_to == pt, base_name=name[2])
pm.model[Symbol(name[1])] = c1
pm.model[Symbol(name[2])] = c2
end


Expand Down Expand Up @@ -160,98 +180,126 @@ end


""
function constraint_switch_state_open(pm::AbstractPowerModel, n::Int, f_idx)
function constraint_switch_state_open(pm::AbstractPowerModel, n::Int, f_idx; name=
["switch[$f_idx]_state_open_active", "switch[$f_idx]_state_open_reactive"])
psw = var(pm, n, :psw, f_idx)
qsw = var(pm, n, :qsw, f_idx)

JuMP.@constraint(pm.model, psw == 0.0)
JuMP.@constraint(pm.model, qsw == 0.0)
c1 = JuMP.@constraint(pm.model, psw == 0.0, base_name=name[1])
c2 = JuMP.@constraint(pm.model, qsw == 0.0, base_name=name[2])
pm.model[Symbol(name[1])] = c1
pm.model[Symbol(name[2])] = c2
end

""
function constraint_switch_thermal_limit(pm::AbstractPowerModel, n::Int, f_idx, rating)
function constraint_switch_thermal_limit(pm::AbstractPowerModel, n::Int, f_idx, rating; name=
"switch[$f_idx]_thermal_limit")
psw = var(pm, n, :psw, f_idx)
qsw = var(pm, n, :qsw, f_idx)

JuMP.@constraint(pm.model, psw^2 + qsw^2 <= rating^2)
c = JuMP.@constraint(pm.model, psw^2 + qsw^2 <= rating^2, base_name=name)
pm.model[Symbol(name)] = c
end

""
function constraint_switch_power_on_off(pm::AbstractPowerModel, n::Int, i, f_idx)
function constraint_switch_power_on_off(pm::AbstractPowerModel, n::Int, i, f_idx; name=
["switch[$f_idx]_active_ub_on_off", "switch[$f_idx]_active_lb_on_off", "switch[$f_idx]_reactive_ub_on_off", "switch[$f_idx]_reactive_lb_on_off"])
psw = var(pm, n, :psw, f_idx)
qsw = var(pm, n, :qsw, f_idx)
z = var(pm, n, :z_switch, i)

psw_lb, psw_ub = _IM.variable_domain(psw)
qsw_lb, qsw_ub = _IM.variable_domain(qsw)

JuMP.@constraint(pm.model, psw <= psw_ub*z)
JuMP.@constraint(pm.model, psw >= psw_lb*z)
JuMP.@constraint(pm.model, qsw <= qsw_ub*z)
JuMP.@constraint(pm.model, qsw >= qsw_lb*z)
c1 = JuMP.@constraint(pm.model, psw <= psw_ub*z, base_name=name[1])
c2 = JuMP.@constraint(pm.model, psw >= psw_lb*z, base_name=name[2])
c3 = JuMP.@constraint(pm.model, qsw <= qsw_ub*z, base_name=name[3])
c4 = JuMP.@constraint(pm.model, qsw >= qsw_lb*z, base_name=name[4])
pm.model[Symbol(name[1])] = c1
pm.model[Symbol(name[2])] = c2
pm.model[Symbol(name[3])] = c3
pm.model[Symbol(name[4])] = c4
end



""
function constraint_storage_thermal_limit(pm::AbstractPowerModel, n::Int, i, rating)
function constraint_storage_thermal_limit(pm::AbstractPowerModel, n::Int, i, rating; name="storage[$i]_thermal_limit")
ps = var(pm, n, :ps, i)
qs = var(pm, n, :qs, i)

JuMP.@constraint(pm.model, ps^2 + qs^2 <= rating^2)
c = JuMP.@constraint(pm.model, ps^2 + qs^2 <= rating^2, base_name=name)
pm.model[Symbol(name)] = c
end

""
function constraint_storage_state_initial(pm::AbstractPowerModel, n::Int, i::Int, energy, charge_eff, discharge_eff, time_elapsed)
function constraint_storage_state_initial(pm::AbstractPowerModel, n::Int, i::Int, energy, charge_eff, discharge_eff, time_elapsed; name=
"storage[$i]_state_initial")
sc = var(pm, n, :sc, i)
sd = var(pm, n, :sd, i)
se = var(pm, n, :se, i)

JuMP.@constraint(pm.model, se - energy == time_elapsed*(charge_eff*sc - sd/discharge_eff))
c = JuMP.@constraint(pm.model, se - energy == time_elapsed*(charge_eff*sc - sd/discharge_eff), base_name=name)
pm.model[Symbol(name)] = c
end

""
function constraint_storage_state(pm::AbstractPowerModel, n_1::Int, n_2::Int, i::Int, charge_eff, discharge_eff, time_elapsed)
function constraint_storage_state(pm::AbstractPowerModel, n_1::Int, n_2::Int, i::Int, charge_eff, discharge_eff, time_elapsed; name=
"storage[$i]_state")
sc_2 = var(pm, n_2, :sc, i)
sd_2 = var(pm, n_2, :sd, i)
se_2 = var(pm, n_2, :se, i)
se_1 = var(pm, n_1, :se, i)

JuMP.@constraint(pm.model, se_2 - se_1 == time_elapsed*(charge_eff*sc_2 - sd_2/discharge_eff))
c = JuMP.@constraint(pm.model, se_2 - se_1 == time_elapsed*(charge_eff*sc_2 - sd_2/discharge_eff), base_name=name)
pm.model[Symbol(name)] = c
end

""
function constraint_storage_complementarity_nl(pm::AbstractPowerModel, n::Int, i)
function constraint_storage_complementarity_nl(pm::AbstractPowerModel, n::Int, i; name="storage[$i]_complementarity_nl")
sc = var(pm, n, :sc, i)
sd = var(pm, n, :sd, i)

JuMP.@constraint(pm.model, sc*sd == 0.0)
c = JuMP.@constraint(pm.model, sc*sd == 0.0, base_name=name)
pm.model[Symbol(name)] = c
end

""
function constraint_storage_complementarity_mi(pm::AbstractPowerModel, n::Int, i, charge_ub, discharge_ub)
function constraint_storage_complementarity_mi(pm::AbstractPowerModel, n::Int, i, charge_ub, discharge_ub; name=
["storage[$i]_complementarity_mi", "storage[$i]_charge_ub", "storage[$i]_discharge_ub"])
sc = var(pm, n, :sc, i)
sd = var(pm, n, :sd, i)
sc_on = var(pm, n, :sc_on, i)
sd_on = var(pm, n, :sd_on, i)

JuMP.@constraint(pm.model, sc_on + sd_on == 1)
JuMP.@constraint(pm.model, sc_on*charge_ub >= sc)
JuMP.@constraint(pm.model, sd_on*discharge_ub >= sd)
c1 = JuMP.@constraint(pm.model, sc_on + sd_on == 1, base_name=name[1])
c2 = JuMP.@constraint(pm.model, sc_on*charge_ub >= sc, base_name=name[2])
c3 = JuMP.@constraint(pm.model, sd_on*discharge_ub >= sd, base_name=name[3])
pm.model[Symbol(name[1])] = c1
pm.model[Symbol(name[2])] = c2
pm.model[Symbol(name[3])] = c3
end


""
function constraint_storage_on_off(pm::AbstractPowerModel, n::Int, i, pmin, pmax, qmin, qmax, charge_ub, discharge_ub)
function constraint_storage_on_off(pm::AbstractPowerModel, n::Int, i, pmin, pmax, qmin, qmax, charge_ub, discharge_ub; name=
["storage[$i]_active_ub_on_off", "storage[$i]_active_lb_on_off", "storage[$i]_reactive_ub_on_off", "storage[$i]_reactive_lb_on_off",
"storage[$i]_reactive_charge_ub_on_off", "storage[$i]_reactive_charge_lb_on_off"])
z_storage = var(pm, n, :z_storage, i)
ps = var(pm, n, :ps, i)
qs = var(pm, n, :qs, i)
qsc = var(pm, n, :qsc, i)

JuMP.@constraint(pm.model, ps <= z_storage*pmax)
JuMP.@constraint(pm.model, ps >= z_storage*pmin)
JuMP.@constraint(pm.model, qs <= z_storage*qmax)
JuMP.@constraint(pm.model, qs >= z_storage*qmin)
JuMP.@constraint(pm.model, qsc <= z_storage*qmax)
JuMP.@constraint(pm.model, qsc >= z_storage*qmin)
end
c1 = JuMP.@constraint(pm.model, ps <= z_storage*pmax, base_name=name[1])
c2 = JuMP.@constraint(pm.model, ps >= z_storage*pmin, base_name=name[2])
c3 = JuMP.@constraint(pm.model, qs <= z_storage*qmax, base_name=name[3])
c4 = JuMP.@constraint(pm.model, qs >= z_storage*qmin, base_name=name[4])
c5 = JuMP.@constraint(pm.model, qsc <= z_storage*qmax, base_name=name[5])
c6 = JuMP.@constraint(pm.model, qsc >= z_storage*qmin, base_name=name[6])
pm.model[Symbol(name[1])] = c1
pm.model[Symbol(name[2])] = c2
pm.model[Symbol(name[3])] = c3
pm.model[Symbol(name[4])] = c4
pm.model[Symbol(name[5])] = c5
pm.model[Symbol(name[6])] = c6
end