# Ipopt solves large-scale nonlinear problems

I’m new to Julia, I’m working on optimal power flow problems in the direction of power systems, and when solving large-scale problems with Julia (there are thousands of variables and constraints, of course, most of them are the same), I run out of memory and don’t know how to solve it

Is the problem sparse? If so, are you making use of sparse arrays to define the problem? The Hessian of the lagrangian and the constraint Jacobian are often sparse for such large problems, and using sparse matrices is then important for performance.

1 Like

I think you will find this post interesting,

And this talk,

2 Likes

The problem is sparse, but I don’t know how to modify and invoke it in Ipopt, and I always thought that in Julia, ipopt would be able to create and process sparse matrices on its own based on the model I provided

If you use JuMP or PowerModels, we do create sparse Jacobians and Hessians. See the benchmarks mentioned by Carleton. You can scale Ipopt to 10^5 and 10^6 variables and constraints on a laptop for optimal power flow.

If you still have trouble, it would be useful if you provided a reproducible example of exactly how you’re setting up and solving your models.

I’m not quite sure where benchmarks should look. I’m researching the most basic ACOPF model, and below is my code, which would be very grateful if you could provide me with some valuable input

``````using DataFrames
using CSV
using JuMP, Ipopt,Pardiso

bus_data_row = findfirst(x -> x == "bus data", mpc[:, 1])
gen_data_row = findfirst(x -> x == "gen data", mpc[:, 1])
branch_data_row = findfirst(x -> x == "branch data", mpc[:, 1])
gencost_data_row = findfirst(x -> x == "gencost data", mpc[:, 1])
baseMVA_row = findfirst(x -> x == "baseMVA", mpc[:, 1])
baseMVA =  parse(Int, mpc[baseMVA_row+1,1])
bus_num = gen_data_row -bus_data_row-2
gen_num = branch_data_row -gen_data_row -2
branch_num = gencost_data_row-branch_data_row -2

bus_i = parse.(Int,mpc[3:bus_num+2,1])
bus_type = parse.(Int,mpc[3:bus_num+2,2])
bus_Pd =parse.(Float64,mpc[3:bus_num+2,3] )/baseMVA
bus_Qd =parse.(Float64,mpc[3:bus_num+2,4] )/baseMVA
bus_Gs =parse.(ComplexF64,mpc[3:bus_num+2,5])/baseMVA
bus_Bs =parse.(ComplexF64,mpc[3:bus_num+2,6])/baseMVA
bus_Vmax =parse.(Float64,mpc[3:bus_num+2,12])
bus_Vmin =parse.(Float64,mpc[3:bus_num+2,13])
balance_bus =  findall(bus_type .== 3)
bus_Omax = fill(2*pi, bus_num)
bus_Omax[balance_bus] = 0
bus_Omin = fill(-2*pi, bus_num)
bus_Omin[balance_bus] = 0

gen_bus = parse.(Int,mpc[gen_data_row+2:gen_data_row+gen_num+1,1])
gen_PG = parse.(Float64,mpc[gen_data_row+2:gen_data_row+gen_num+1,2])
gen_QG = parse.(Float64,mpc[gen_data_row+2:gen_data_row+gen_num+1,3])
gen_Qmax = parse.(Float64,mpc[gen_data_row+2:gen_data_row+gen_num+1,4])
gen_Qmin = parse.(Float64,mpc[gen_data_row+2:gen_data_row+gen_num+1,5])
g_status = parse.(Int,mpc[gen_data_row+2:gen_data_row+gen_num+1,8])
gen_Pmax = parse.(Float64,mpc[gen_data_row+2:gen_data_row+gen_num+1,9])
gen_Pmin= parse.(Float64,mpc[gen_data_row+2:gen_data_row+gen_num+1,10])
gencost_cs = parse.(Float64,mpc[gencost_data_row+2:gencost_data_row+gen_num+1,7])
gencost_yc = parse.(Float64,mpc[gencost_data_row+2:gencost_data_row+gen_num+1,6])
gencost_ec = parse.(Float64,mpc[gencost_data_row+2:gencost_data_row+gen_num+1,5])
##############################################################################
gstart_num = count(x -> x == 1, g_status)
gen_on_bus = [gen_bus[i] for i in eachindex(g_status) if g_status[i] != 0]
gon_PG = [gen_PG[i] for i in eachindex(g_status) if g_status[i] != 0]/baseMVA
gon_QG = [gen_QG[i] for i in eachindex(g_status) if g_status[i] != 0]/baseMVA
gon_Qmax = [gen_Qmax[i] for i in eachindex(g_status) if g_status[i] != 0]/baseMVA
gon_Qmin = [gen_Qmin[i] for i in eachindex(g_status) if g_status[i] != 0]/baseMVA
gon_Pmax = [gen_Pmax[i] for i in eachindex(g_status) if g_status[i] != 0]/baseMVA
gon_Pmin = [gen_Pmin[i] for i in eachindex(g_status) if g_status[i] != 0]/baseMVA
goncost_cs = [gencost_cs[i] for i in eachindex(g_status) if g_status[i] != 0]
goncost_yc = [gencost_yc[i] for i in eachindex(g_status) if g_status[i] != 0]*baseMVA
goncost_ec = [gencost_ec[i] for i in eachindex(g_status) if g_status[i] != 0]*baseMVA^2
##############################################################################
ybranch_fbus = parse.(Int,mpc[branch_data_row+2:branch_data_row+branch_num+1,1])
ybranch_tbus = parse.(Int,mpc[branch_data_row+2:branch_data_row+branch_num+1,2])
branch_fbus =zeros(Int,length(ybranch_fbus))
branch_tbus =zeros(Int,length(ybranch_tbus))
for i in 1:branch_num
branch_fbus[i] = findall(bus_i .== ybranch_fbus[i])
branch_tbus[i] = findall(bus_i .== ybranch_tbus[i])
end
branch_r = parse.(ComplexF64,mpc[branch_data_row+2:branch_data_row+branch_num+1,3])
branch_x = parse.(ComplexF64,mpc[branch_data_row+2:branch_data_row+branch_num+1,4])
branch_b = parse.(ComplexF64,mpc[branch_data_row+2:branch_data_row+branch_num+1,5])
branch_rate = parse.(Float64,mpc[branch_data_row+2:branch_data_row+branch_num+1,6])/baseMVA
branch_ratio = parse.(Float64,mpc[branch_data_row+2:branch_data_row+branch_num+1,9])
branch_ratio =[if x == 0 1 else x end for x in branch_ratio]
branch_status =mpc[branch_data_row+2:branch_data_row+branch_num+1,11]

Y = zeros(ComplexF64,bus_num, bus_num)
for k in 1:branch_num
k1 =  branch_fbus[k]
k2 =  branch_tbus[k]
Y[k1, k2] -=  1 / ((branch_r[k] + im*branch_x[k])* branch_ratio[k])
Y[k2, k1]  = Y[k1, k2]
Y[k1, k1] +=  1 / ((branch_r[k] + im*branch_x[k]) * branch_ratio[k] ^ 2) + im*branch_b[k]/2
Y[k2, k2] +=  1 / (branch_r[k] + im*branch_x[k]) + im*branch_b[k]/2
end

for u in 1:bus_num
if bus_Gs[u] != 0 || bus_Bs[u] != 0
Y[u, u] += bus_Gs[u] + bus_Bs[u] * im
end
end
G = real(Y)
B = imag(Y)

y = zeros(ComplexF64, branch_num, 2)
for i in 1:branch_num
y[i, 1] = 1 / ((branch_r[i] + im*branch_x[i]) * branch_ratio[i])
y[i, 2] = y[i, 1]
end
g = real(y)
b = imag(y)

#################Yijo = Yi0+Yij############
Yijo = zeros(ComplexF64, branch_num, 2)
for l in 1:branch_num
if branch_ratio[l] == 1
Yijo[l, 1] = im*branch_b[l]/2 + 1/((branch_r[l] + im*branch_x[l])* branch_ratio[l])
Yijo[l, 2] = Yijo[l, 1]
else
Yijo[l, 1] = 1 /((branch_r[l] + im*branch_x[l]) * branch_ratio[l] ^ 2 )
Yijo[l, 2] = 1 /(branch_r[l] + im*branch_x[l])
end
end

for u in 1:branch_num
k1 = branch_fbus[u]
k2 = branch_tbus[u]
if bus_Gs[k1] != 0 || bus_Bs[k1] != 0 || bus_Gs[k2] != 0 || bus_Bs[k2] != 0
Yijo[u, 1] += bus_Gs[k1] + bus_Bs[k1]*im
Yijo[u, 2] += bus_Gs[k2] + bus_Bs[k2]*im
end
end
Gijo = real(Yijo)
Bijo = imag(Yijo)

######################################################################
# Create model objects
model = Model(
optimizer_with_attributes(
Ipopt.Optimizer,
"print_level" => 4

)
)

# Define decision variables
@variable(model, V[1:bus_num])
@variable(model, O[1:bus_num])
@variable(model, PG[1:gstart_num])
@variable(model, QG[1:gstart_num])

# Define the objective function
OPF_Object =sum(goncost_ec[i]*PG[i]^2+goncost_yc[i]*PG[i]+goncost_cs[i] for i in 1:gstart_num)
@objective(model, Min, OPF_Object)

# Define constraints
# local t = 0
for i in 1:bus_num
if bus_i[i] in gen_on_bus #Generator node
local q = findall(gen_on_bus .== bus_i[i])
@NLconstraint(model, sum(PG[j] for j in q)-bus_Pd[i]-V[i]^2*G[i,i]-V[i]*sum(V[j]*(G[i,j]*cos(O[i]-O[j])+B[i,j]*sin(O[i]-O[j])) for j in 1:bus_num if j!=i) == 0)
@NLconstraint(model, sum(QG[j] for j in q)-bus_Qd[i]+V[i]^2*B[i,i]-V[i]*sum(V[j]*(G[i,j]*sin(O[i]-O[j])-B[i,j]*cos(O[i]-O[j])) for j in 1:bus_num if j!=i) == 0)
else #Non-generator nodes
@NLconstraint(model, -bus_Pd[i]-V[i]^2*G[i,i]-V[i]*sum(V[j]*(G[i,j]*cos(O[i]-O[j])+B[i,j]*sin(O[i]-O[j])) for j in 1:bus_num if j!=i) == 0)
@NLconstraint(model, -bus_Qd[i]+V[i]^2*B[i,i]-V[i]*sum(V[j]*(G[i,j]*sin(O[i]-O[j])-B[i,j]*cos(O[i]-O[j])) for j in 1:bus_num if j!=i) == 0)
end
end

#Line constraints
for i in 1:branch_num
if branch_rate[i] !=0
local p = branch_fbus[i]
local q = branch_tbus[i]
@NLconstraint(model, -branch_rate[i]<=Gijo[i,1]*V[p]^2-V[p]*V[q]*(g[i,1]*cos(O[p]-O[q])+b[i,1]*sin(O[p]-O[q]))<=branch_rate[i])
@NLconstraint(model, -branch_rate[i]<=Gijo[i,2]*V[q]^2-V[p]*V[q]*(g[i,2]*cos(O[q]-O[p])+b[i,2]*sin(O[q]-O[p]))<=branch_rate[i])
end
end

#Variable constraints
for i in 1:bus_num
@NLconstraint(model,bus_Vmin[i]<=V[i]<=bus_Vmax[i])
@NLconstraint(model,bus_Omin[i]<=O[i]<=bus_Omax[i])
end
for i in 1:gstart_num
@NLconstraint(model,gon_Pmin[i]<=PG[i]<=gon_Pmax[i])
@NLconstraint(model,gon_Qmin[i]<=QG[i]<=gon_Qmax[i])
end

# Set the initial value
for i in 1:bus_num
set_start_value(V[i], 1)
set_start_value(O[i], 0)
end
for i in 1:gstart_num
set_start_value(PG[i], gon_PG[i])
set_start_value(QG[i], gon_QG[i])
end

# Solve optimization problems
optimize!(model)

println("Optimal objective value: ", JuMP.objective_value(model))
``````

I can’t run your code because I don’t have the `.csv`. The main thing I’d change with your code would be:

``````# Define decision variables
@variable(model, bus_Vmin[i] <= V[i=1:bus_num] <= bus_Vmax[i])
@variable(model, bus_Omin[i] <= O[i=1:bus_num] <= bus_Omax[i])
@variable(model, gon_Pmin[i] <= PG[i=1:gstart_num] <= gon_Pmax[i])
@variable(model, gon_Qmin[i] <= QG[i=1:gstart_num] <= gon_Qmax[i])
``````

and delete the `#Variable constraints` blocks. My way adds variable bounds. Your way adds new rows to the constraint matrix.

Have you considered using PowerModels.jl? GitHub - lanl-ansi/PowerModels.jl: A Julia/JuMP Package for Power Network Optimization

You should also take a look at @ccoffrin’s `rosetta-opf` project: rosetta-opf/jump.jl at main · lanl-ansi/rosetta-opf · GitHub

If you’re just wanting to solve problems, there are plenty of examples in the PowerModels documentation: Getting Started · PowerModels.

If you want to build a JuMP model of the formulation and then do stuff to it, you can use:

``````using JuMP, PowerModels, Ipopt
"https://raw.githubusercontent.com/power-grid-lib/pglib-opf/master/pglib_opf_case118_ieee.m",
"pglib_opf_case118_ieee.m",
)
model = Model(Ipopt.Optimizer)
power_model = PowerModels.instantiate_model(
PowerModels.parse_file("pglib_opf_case118_ieee.m"),
PowerModels.ACPPowerModel,
PowerModels.build_opf;
jump_model = model,
)
optimize!(model)
``````

On my laptop, this solves in 0.4 seconds:

``````julia> optimize!(model)
This is Ipopt version 3.14.4, running with linear solver MUMPS 5.4.1.

Number of nonzeros in equality constraint Jacobian...:     4552
Number of nonzeros in inequality constraint Jacobian.:     1460
Number of nonzeros in Lagrangian Hessian.............:     8198

Total number of variables............................:     1053
variables with only lower bounds:        0
variables with lower and upper bounds:      935
variables with only upper bounds:        0
Total number of equality constraints.................:      981
Total number of inequality constraints...............:      730
inequality constraints with only lower bounds:      179
inequality constraints with lower and upper bounds:        0
inequality constraints with only upper bounds:      551

iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls
0  4.7812282e+02 2.76e+00 2.19e+01  -1.0 0.00e+00    -  0.00e+00 0.00e+00   0
1  3.4413674e+04 2.00e+00 7.98e+01  -1.0 2.86e+00    -  3.58e-03 2.74e-01h  1
2  3.5528977e+04 1.90e+00 7.55e+01  -1.0 6.95e+00    -  8.37e-02 5.16e-02h  1
3  3.6121278e+04 1.78e+00 6.94e+01  -1.0 9.60e+00    -  2.78e-01 6.39e-02h  1
4  4.3035932e+04 1.56e+00 6.06e+01  -1.0 5.99e+00    -  3.79e-01 1.25e-01h  1
5  6.1165471e+04 9.99e-01 3.88e+01  -1.0 6.58e+00    -  5.19e-01 3.58e-01h  1
6  7.0545871e+04 7.30e-01 3.17e+01  -1.0 8.66e+00    -  5.33e-01 2.69e-01h  1
7  8.3787955e+04 3.59e-01 2.24e+01  -1.0 1.00e+01    -  9.37e-01 5.08e-01h  1
8  9.0768955e+04 1.66e-01 8.62e+00  -1.0 1.30e+01    -  2.12e-01 5.38e-01h  1
9  9.2115541e+04 1.22e-01 9.08e+00  -1.0 1.78e+01    -  8.00e-01 2.67e-01h  1
iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls
10  9.4118086e+04 7.71e-02 5.72e+00  -1.0 8.50e+00    -  2.88e-01 3.66e-01h  1
11  9.7131618e+04 1.91e-02 1.64e+00  -1.0 3.65e+00    -  1.00e+00 8.42e-01h  1
12  9.7745336e+04 1.85e-03 6.29e+01  -1.0 4.66e+00    -  2.24e-01 1.00e+00H  1
13  9.7687599e+04 7.47e-03 7.32e+00  -1.0 2.01e+00    -  1.00e+00 1.00e+00f  1
14  9.7695486e+04 4.71e-04 1.96e-01  -1.0 7.26e-01    -  1.00e+00 1.00e+00h  1
15  9.7487469e+04 4.57e-03 1.23e+00  -2.5 5.77e+00    -  7.89e-01 5.54e-01f  1
16  9.7309870e+04 2.44e-03 2.29e-01  -2.5 1.86e+00    -  7.38e-01 7.83e-01f  1
17  9.7248611e+04 2.04e-03 1.10e+00  -2.5 2.50e+00    -  9.51e-01 7.64e-01h  1
18  9.7231319e+04 1.11e-03 1.34e-02  -2.5 9.23e-01    -  1.00e+00 1.00e+00h  1
19  9.7233035e+04 2.49e-06 8.98e-05  -2.5 5.66e-02    -  1.00e+00 1.00e+00h  1
iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls
20  9.7219104e+04 2.56e-04 1.84e-01  -3.8 6.46e-01    -  8.60e-01 7.15e-01f  1
21  9.7214346e+04 6.81e-05 1.40e-01  -3.8 1.78e-01    -  8.75e-01 1.00e+00h  1
22  9.7214571e+04 4.67e-06 1.27e-04  -3.8 2.43e-02    -  1.00e+00 1.00e+00h  1
23  9.7213705e+04 6.33e-06 3.71e-03  -5.7 3.15e-02    -  9.22e-01 9.07e-01h  1
24  9.7213619e+04 7.25e-07 2.59e-05  -5.7 7.28e-03    -  1.00e+00 1.00e+00h  1
25  9.7213619e+04 1.13e-07 5.09e-06  -5.7 3.18e-03    -  1.00e+00 1.00e+00h  1
26  9.7213607e+04 4.76e-08 3.72e-05  -8.6 2.04e-03    -  9.88e-01 1.00e+00h  1
27  9.7213607e+04 1.05e-08 4.75e-07  -8.6 9.70e-04    -  1.00e+00 1.00e+00h  1
28  9.7213607e+04 1.93e-09 8.74e-08  -8.6 4.15e-04    -  1.00e+00 1.00e+00h  1
29  9.7213607e+04 1.51e-10 6.86e-09  -8.6 1.16e-04    -  1.00e+00 1.00e+00h  1

Number of Iterations....: 29

(scaled)                 (unscaled)
Objective...............:   7.8032097059689613e+02    9.7213606938959332e+04
Dual infeasibility......:   6.8594320180172386e-09    8.5455876895626375e-07
Constraint violation....:   1.5122502902698010e-10    1.5122502902698010e-10
Variable bound violation:   6.5043916031015669e-08    6.5043916031015669e-08
Complementarity.........:   6.1117630289071873e-09    7.6141299693863464e-07
Overall NLP error.......:   6.8594320180172386e-09    8.5455876895626375e-07

Number of objective function evaluations             = 31
Number of objective gradient evaluations             = 30
Number of equality constraint evaluations            = 31
Number of inequality constraint evaluations          = 31
Number of equality constraint Jacobian evaluations   = 30
Number of inequality constraint Jacobian evaluations = 30
Number of Lagrangian Hessian evaluations             = 29
Total seconds in IPOPT                               = 0.370

EXIT: Optimal Solution Found.
``````

You can find other cases at GitHub - power-grid-lib/pglib-opf: Benchmarks for the Optimal Power Flow Problem

1 Like

Thank you very much for your help, my code does have shortcomings, I also tried to run the PowerModels you mentioned and it worked

``````using JuMP, PowerModels, Ipopt
"https://raw.githubusercontent.com/power-grid-lib/pglib-opf/master/pglib_opf_case2736sp_k.m",
"pglib_opf_case2736sp_k__api.m",
)
model = Model(Ipopt.Optimizer)
power_model = PowerModels.instantiate_model(
PowerModels.parse_file("pglib_opf_case2736sp_k__api.m"),
PowerModels.ACPPowerModel,
PowerModels.build_opf;
jump_model = model,
)
optimize!(model)
println("Optimal objective value: ", JuMP.objective_value(model))
``````

Here is the result of my output

``````This is Ipopt version 3.13.4, running with linear solver mumps.
NOTE: Other linear solvers might be more efficient (see Ipopt documentation).

Number of nonzeros in equality constraint Jacobian...:    78762
Number of nonzeros in inequality constraint Jacobian.:    26128
Number of nonzeros in Lagrangian Hessian.............:   143837

Total number of variables............................:    18852
variables with only lower bounds:        0
variables with lower and upper bounds:    16116
variables with only upper bounds:        0
Total number of equality constraints.................:    18549
Total number of inequality constraints...............:    13064
inequality constraints with only lower bounds:     3263
inequality constraints with lower and upper bounds:        0
inequality constraints with only upper bounds:     9801

iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls
0  9.5127271e+05 7.87e+00 1.00e+02  -1.0 0.00e+00    -  0.00e+00 0.00e+00   0
1  9.5469096e+05 7.79e+00 9.89e+01  -1.0 5.30e+00    -  6.92e-03 1.00e-02h  1
2  9.5073275e+05 7.68e+00 9.81e+01  -1.0 1.65e+01    -  2.31e-03 1.42e-02f  1
3  9.4740076e+05 7.56e+00 9.48e+01  -1.0 1.48e+01    -  3.95e-02 1.63e-02f  1
4  9.4701858e+05 6.93e+00 8.21e+01  -1.0 9.56e+00    -  1.50e-01 8.32e-02f  1
5  9.4725378e+05 6.41e+00 7.33e+01  -1.0 3.00e+01    -  1.37e-01 7.44e-02f  1
6  9.4770877e+05 6.30e+00 7.66e+01  -1.0 4.81e+01    -  4.01e-02 1.82e-02h  1
7  9.6460459e+05 5.94e+00 6.06e+01  -1.0 1.71e+01    -  4.50e-04 5.65e-02h  1
8  9.8599397e+05 5.48e+00 5.58e+01  -1.0 1.97e+01    -  4.35e-02 7.80e-02h  1
9  1.0047233e+06 5.08e+00 5.15e+01  -1.0 2.22e+01    -  3.91e-02 7.21e-02h  1
iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls
10  1.0184715e+06 4.81e+00 4.88e+01  -1.0 2.21e+01    -  6.14e-02 5.45e-02h  1
11  1.0354602e+06 4.50e+00 4.48e+01  -1.0 2.11e+01    -  2.40e-02 6.27e-02h  1
12  1.1000420e+06 3.36e+00 3.30e+01  -1.0 2.59e+01    -  3.03e-02 2.55e-01h  1
13  1.1207195e+06 3.00e+00 2.94e+01  -1.0 2.19e+01    -  1.37e-01 1.06e-01h  1
14  1.1473702e+06 2.56e+00 2.51e+01  -1.0 1.74e+01    -  1.30e-01 1.49e-01h  1
15  1.1718054e+06 2.16e+00 2.11e+01  -1.0 1.22e+01    -  2.24e-01 1.56e-01h  1
16  1.2179292e+06 1.42e+00 1.40e+01  -1.0 1.17e+01    -  2.55e-01 3.44e-01h  1
17  1.2462822e+06 9.74e-01 9.86e+00  -1.0 9.13e+00    -  5.15e-01 3.12e-01h  1
18  1.2628349e+06 7.23e-01 9.08e+00  -1.0 6.47e+00    -  4.00e-01 2.58e-01h  1
19  1.2968734e+06 2.15e-01 1.12e+01  -1.0 7.15e+00    -  9.91e-01 7.02e-01h  1
iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls
20  1.3105249e+06 1.73e-02 3.45e+00  -1.0 2.23e+00    -  1.00e+00 9.20e-01h  1
21  1.3117980e+06 8.26e-05 3.24e-02  -1.0 3.58e-01    -  1.00e+00 1.00e+00h  1
22  1.3109731e+06 6.05e-04 1.18e+01  -2.5 9.02e-01    -  6.56e-01 5.72e-01f  1
23  1.3099179e+06 2.55e-03 3.75e+00  -2.5 7.06e-01    -  2.45e-01 7.33e-01f  1
24  1.3089933e+06 2.59e-03 1.62e+00  -2.5 3.43e-01    -  6.00e-01 8.98e-01f  1
25  1.3085161e+06 1.71e-03 4.04e+00  -2.5 1.84e-01    -  2.80e-01 5.64e-01f  1
26  1.3083348e+06 1.14e-03 7.77e+00  -2.5 3.12e-01    -  9.47e-01 3.89e-01f  1
27  1.3082912e+06 9.33e-04 2.59e+01  -2.5 3.16e-01    -  1.00e+00 1.78e-01h  1
28  1.3081319e+06 5.77e-04 3.64e+01  -2.5 2.42e-01    -  1.62e-01 9.66e-01f  1
29  1.3081541e+06 3.35e-05 1.30e-02  -2.5 9.10e-02    -  1.00e+00 1.00e+00h  1
iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls
30  1.3081003e+06 6.51e-05 2.75e+01  -3.8 1.80e-01    -  6.77e-01 3.07e-01f  1
31  1.3080502e+06 1.95e-04 2.29e+01  -3.8 1.97e-01    -  7.50e-01 5.09e-01f  1
32  1.3080315e+06 1.65e-04 1.62e+01  -3.8 1.74e-01    -  9.40e-01 5.14e-01h  1
33  1.3080210e+06 9.02e-05 6.38e+00  -3.8 1.26e-01    -  1.00e+00 7.83e-01h  1
34  1.3080197e+06 5.43e-06 2.19e-04  -3.8 3.17e-02    -  1.00e+00 1.00e+00h  1
35  1.3080166e+06 7.57e-06 2.29e+00  -5.7 1.09e-01    -  8.60e-01 6.40e-01h  1
36  1.3080154e+06 5.62e-06 1.72e+00  -5.7 1.01e-01    -  9.22e-01 7.20e-01h  1
37  1.3080150e+06 1.70e-06 1.91e-02  -5.7 5.09e-02    -  1.00e+00 9.91e-01h  1
38  1.3080150e+06 2.89e-08 8.45e-07  -5.7 3.68e-03    -  1.00e+00 1.00e+00h  1
39  1.3080150e+06 1.85e-08 3.48e-02  -8.6 4.85e-03    -  8.25e-01 9.73e-01h  1
iter    objective    inf_pr   inf_du lg(mu)  ||d||  lg(rg) alpha_du alpha_pr  ls
40  1.3080150e+06 1.16e-09 5.34e-04  -8.6 1.05e-03    -  9.88e-01 1.00e+00h  1
41  1.3080150e+06 2.67e-11 5.68e-09  -8.6 4.31e-05    -  1.00e+00 1.00e+00h  1

Number of Iterations....: 41

(scaled)                 (unscaled)
Objective...............:   1.1275019335795156e+04    1.3080149931455960e+06
Dual infeasibility......:   5.6835424466209047e-09    6.5934775923249118e-07
Constraint violation....:   2.6710969373844318e-11    2.6710969373844318e-11
Complementarity.........:   5.5561117961707670e-09    6.4456452947377074e-07
Overall NLP error.......:   5.6835424466209047e-09    6.5934775923249118e-07

Number of objective function evaluations             = 42
Number of objective gradient evaluations             = 42
Number of equality constraint evaluations            = 42
Number of inequality constraint evaluations          = 42
Number of equality constraint Jacobian evaluations   = 42
Number of inequality constraint Jacobian evaluations = 42
Number of Lagrangian Hessian evaluations             = 41
Total CPU secs in IPOPT (w/o function evaluations)   =      4.523
Total CPU secs in NLP function evaluations           =      1.397

EXIT: Optimal Solution Found.
Optimal objective value: 1.308014993145596e6
``````

This result is consistent with the MATPOWER result，but what I wanted to do was how to add some new constraints and variables to the original OPF model, which has been bothering me for a long time, but I see hope in PowerModels。

1 Like

`download(...)` is a tool that I did not know about until this post. Thanks for the tip @odow. If you want an even more Julia friendly version of PGLib data there is this package,

2 Likes

See PowerModelsAnnex.jl/ac-opf.jl at master · lanl-ansi/PowerModelsAnnex.jl · GitHub for a selection of models that you could use as the base to make modifications

How to call a class function you wrote in another file, something like this
`mutable struct PyClass
a::Float64
b::Float64
n::Int
end

PyClass() = PyClass(0.0, 0.0, 0)
function init(self::PyClass)
self.a = 1.0
self.b = 2.0
self.n = 10
end

function method1(self::PyClass)
self.n += 1
nothing
end

function method2(self::PyClass)
return self.a + self.b
end

mim = init(PyClass())
method1(mim)
method2(mim)`

You can use `include("path/to/file.jl")` to load another file.

Note that unlike Python, Julia doesn’t have classes, and it doesn’t have file-level namespaces.

Can I ask you again how to use the ‘OPFLearn’ package, if there are examples of running it, I think I can grasp it a little faster

ok

``````using JuMP, PowerModels, Ipopt,SCS

file_name = "E:/Vscode——data/data/case300.m"

model = Model(Ipopt.Optimizer)
power_model = PowerModels.instantiate_model(
PowerModels.parse_file(file_name),
# println(PowerModels.parse_file(file_name)),
PowerModels.DCPLLPowerModel,
PowerModels.build_opf;
jump_model = model,
)
optimize!(model)
println("Optimal objective value: ", JuMP.objective_value(model))
``````

Can I replace the .m file here with a csv file and import it directly into this model to run. Or is there a way to modify the data directly in the .m file and import it into a later model

What is the format of the CSV file you want to use?

You could just edit the file manually?

Otherwise you can modify the elements of the dictionary returned by `parse_file`.

Manual editing is very difficult, my intention is to modify the load in the case300 study, I need to modify it thousands of times, and then output their final result

Then you may want to call `parse_file` once, and programmatically edit the elements inside it for each solve.