reset;

set BUS; # set of buses

set BRANCH within {1..4000} cross BUS cross BUS; # set of branches

# Dados das Barras

#
param bus_type {BUS};
param bus_name {BUS} symbolic;
param bus_voltage0 {BUS};
param bus_angle0 {BUS};
param bus_p_gen {BUS};
param bus_q_gen {BUS};
param bus_q_min {BUS};
param bus_q_max {BUS};
param bus_p_load {BUS};
param bus_q_load {BUS};
param bus_g_shunt {BUS};
param bus_b_shunt0 {BUS};
param bus_b_shunt_min{BUS};
param bus_b_shunt_max{BUS};
param bus_b_dispatch {BUS};
param bus_area {BUS};
#
# LIMITES DE TENSO
#
param bus_voltage_min{0..3};
param bus_voltage_max{0..3};
#
# DADOS DAS LINHAS
#
param branch_type {BRANCH};
param branch_r {BRANCH};
param branch_x {BRANCH};
param branch_c {BRANCH};
param branch_tap0 {BRANCH};
param branch_tap_min0{BRANCH};
param branch_tap_max0{BRANCH};
param branch_def {BRANCH};
param branch_def_min {BRANCH};
param branch_def_max {BRANCH};
param branch_g {(l,k,m) in BRANCH} := branch_r[l,k,m]/
(branch_r[l,k,m]^2+branch_x[l,k,m]^2);
param branch_b {(l,k,m) in BRANCH} :=-branch_x[l,k,m]/
(branch_r[l,k,m]^2+branch_x[l,k,m]^2);

# tap limits

param TAP_min;
param TAP_max;

# variables

var V{i in BUS} >= V_min[V_type[i]], <= V_max[V_type[i]];

var B_shunt {i in BUS} >= B_shunt_min[i], <= bus_b_shunt_max[i];
var TETA{i in BUS};
var TAP {(l,k,m) in BRANCH} >= V_tap_min, <= V_tap_max;

# auxiliar variables
var p_g {BUS}; # final active power generation, used to output data
var q_g {BUS}; # final reactive power generation, used to output data

var p_d {BRANCH}; # final active direct flow, used to output data
var q_d {BRANCH}; # final reactive direct flow, used to output data
var p_r {BRANCH}; # final active reverse flow, used to output data
var q_r {BRANCH}; # final reactive reverse flow, used to output data

# matrix YBUS

set YBUS := setof{i in BUS} (i,i) union

setof {(l,k,m) in BRANCH} (k,m) union
setof {(l,k,m) in BRANCH} (m,k);

var G{(k,m) in YBUS} =

if(k == m) then (bus_g_shunt[k] + sum{(l,k,i) in BRANCH}
branch_g[l,k,i]*branch_tap[l,k,i]^2
+ sum{(l,i,k) in BRANCH} branch_g[l,i,k])
else if(k != m) then (sum{(l,k,m) in BRANCH} (-
branch_g[l,k,m]*cos(branch_def[l,k,m])-
branch_b[l,k,m]*sin(branch_def[l,k,m]))*branch_tap[l,k,m]
+sum{(l,m,k) in BRANCH} (-
branch_g[l,m,k]*cos(branch_def[l,m,k])
+branch_b[l,m,k]*sin(branch_def[l,m,k]))*branch_tap[l,m,k]);

var B{(k,m) in YBUS} =

if(k == m) then (bus_b_shunt[k] + sum{(l,k,i) in BRANCH}
(branch_b[l,k,i]*branch_tap[l,k,i]^2 + branch_c[l,k,i]/2)
+ sum{(l,i,k) in BRANCH} (branch_b[l,i,k]
+branch_c[l,i,k]/2))
else if(k != m) then (sum{(l,k,m) in BRANCH}
(branch_g[l,k,m]*sin(branch_def[l,k,m])-
branch_b[l,k,m]*cos(branch_def[l,k,m]))*branch_tap[l,k,m]
+sum{(l,m,k) in BRANCH} (-
branch_g[l,m,k]*sin(branch_def[l,m,k])-
branch_b[l,m,k]*cos(branch_def[l,m,k]))*branch_tap[l,m,k]);

# important information

var reactive_generation = sum {k in BUS} abs(bus_q_load[k] + sum{(k,m) in YBUS}

(bus_voltage[k]*bus_voltage[m]*
(G[k,m]*sin(bus_angle[k]-bus_angle[m])-
B[k,m]*cos(bus_angle[k]-bus_angle[m]))));

var inductive_generation = sum {k in BUS} min(bus_q_load[k] + sum{(k,m) in YBUS}

(bus_voltage[k]*bus_voltage[m]*
(G[k,m]*sin(bus_angle[k]-bus_angle[m])-
B[k,m]*cos(bus_angle[k]-bus_angle[m]))),0);

var capacitive_generation = sum {k in BUS} max(bus_q_load[k] + sum{(k,m) in YBUS}

(bus_voltage[k]*bus_voltage[m]*
(G[k,m]*sin(bus_angle[k]-bus_angle[m])-
B[k,m]*cos(bus_angle[k]-bus_angle[m]))),0);

#*************************** OBJETIVOS ****************************

#
# MINIMIZAO DE PERDAS
# minimize losses : sum{(l,k,m) in BRANCH}
(branch_g[l,k,m]*(bus_voltage[k]^2*branch_tap[l,k,m]^2 + bus_voltage[m]^2
#-2*bus_voltage[k]*bus_voltage[m]*branch_tap[l,k,m]*cos(bus_angle[k]-
bus_angle[m])));
#
# Minimizar a potencia reativa
#minimize reactive_power : sum{k in BUS : bus_type[k] == 2 || bus_type[k] == 3}
# ( bus_q_load[k] + sum{(k,m) in YBUS} (bus_voltage[k]*bus_voltage[m]*
# (G[k,m]*sin(bus_angle[k]-bus_angle[m])-B[k,m]*cos(bus_angle[k]-
bus_angle[m]))))^2;
#

# MINIMIZAR O PERFIL DE TENS

minimize voltage_profile : sum{i in BUS} (bus_voltage[i]-1)^2;
#

#*************************** RESTRIES ***************************

#
#
subject to p_load {k in BUS : bus_type[k] == 0 || bus_type[k] == 2}:
bus_p_gen[k] - bus_p_load[k] - sum{(k,m) in YBUS} (V[k]*V[m]*
(G[k,m]*cos(TETA[k]-TETA[m])+B[k,m]*sin(TETA[k]-
TETA[m]))) = 0;
#
#
subject to q_load {k in BUS : bus_type[k] == 0}:
bus_q_gen[k] - bus_q_load[k] - sum{(k,m) in YBUS}
(bus_voltage[k]*bus_voltage[m]*
(G[k,m]*sin(bus_angle[k]-bus_angle[m])-
B[k,m]*cos(bus_angle[k]-bus_angle[m]))) = 0;
#
#
subject to q_inj {k in BUS : bus_type[k] == 2 || bus_type[k] == 3}:
bus_q_min[k] <= bus_q_load[k] + sum{(k,m) in YBUS}
(bus_voltage[k]*bus_voltage[m]*
(G[k,m]*sin(bus_angle[k]-bus_angle[m])-
B[k,m]*cos(bus_angle[k]-bus_angle[m]))) <= bus_q_max[k];
#
#
#*************************** ESPECIFICAES DE DADOS ****************
#
data;
#
param: BUS: bus_type bus_name bus_voltage0 bus_angle0 bus_p_gen bus_q_gen
bus_q_min bus_q_max bus_p_load bus_q_load bus_g_shunt bus_b_shunt0
bus_b_shunt_min bus_b_shunt_max bus_b_dispatch bus_area :=
include IEEE014a_30-07-17-semcarga.bus;
#
#
param: BRANCH: branch_type branch_r branch_x branch_c
branch_tap0 branch_tap_min0 branch_tap_max0 branch_def
branch_def_min branch_def_max :=
include IEEE014a_30-07-17.branch;
#
#
#*************************** LIMITES DE TENSO E TAPS *****************
#
# LIMITES DE TENSO
param bus_voltage_min := 0 0.85 1 0.85 2 0.85 3 0.85;
param bus_voltage_max := 0 1.05 1 1.05 2 1.05 3 1.05;
#
#
# TAPS
param branch_tap_min = 0.85;
param branch_tap_max = 1.15;
#
# data scaling and initialization
# cargas das barras
for{i in BUS} {
let bus_voltage[i] := 1;
let bus_b_shunt[i] := bus_b_shunt0[i];
let bus_angle[i] := 0;
let bus_p_gen[i] := bus_p_gen[i]/100;
let bus_q_gen[i] := bus_q_gen[i]/100;
let bus_q_min[i] := bus_q_min[i]/100;
let bus_q_max[i] := bus_q_max[i]/100;
let bus_p_load[i] := 1.0*bus_p_load[i]/100;
let bus_q_load[i] := 1.0*bus_q_load[i]/100;
};

for{(l,k,m) in BRANCH} {
let branch_def[l,k,m] := -branch_def[l,k,m]*3.14159/180;
let branch_def_min[l,k,m] := branch_def_min[l,k,m]*3.14159/180;
let branch_def_max[l,k,m] := branch_def_max[l,k,m]*3.14159/180;
let branch_tap[l,k,m] := 1;
};

# VARIVEIS FIXAS
#
fix {i in BUS : bus_type[i] == 3} bus_angle[i]; # slack angle fixed
fix {i in BUS : bus_b_dispatch[i] == 0} bus_b_shunt[i]; # no dispatchable shunts
fixed
fix {(l,k,m) in BRANCH : branch_type[l,k,m] == 0 || branch_type[l,k,m] == 3 ||
branch_type[l,k,m] == 4} branch_tap[l,k,m]; # branch taps fixed
#
#*************************** CHAMANDO O SOLVER DE OTIMIZAO **********
printf "\nChamando o solver de otimizacao:\n\n";
#
# SOLVER SELECIONADO
option solver knitroampl;
option knitro_options "outlev=6 alg=0 ";
#
# OBJETIVO SELECIONADO
solve voltage_profile;
#solve losses;

printf "\nKnitro terminou, consulte o arquivo de solucao -

'Solucao_final_opf.txt'\n\n";

# CALCULO DA GERAO DAS POTENCIAS ATIVA E REATIVA

#
for{k in BUS} {
let P_g[k] := P_load[k] + sum{(k,m) in YBUS} (V[k]*V[m]*
(G[k,m]*cos(TETA[k]-TETA[m])+B[k,m]*sin(TETA[k]-TETA[m])));
 let q_g[k] := bus_q_load[k] + sum{(k,m) in YBUS} (V[k]*V[m]*
(G[k,m]*sin(TETA[k]-TETA[m])-B[k,m]*cos(TETA[k]-TETA[m])));
}
#
# CALCULO DAS POTENCIAS ATIVA E REATIVA DE FLUXO DIRETO E REVERSO
#
for{(l,k,m) in BRANCH} {
#
# FLUXO DIRETO
let P[l,k,m] := G[l,k,m]*V[k]^2*TAP[l,k,m]^2
-G[l,k,m]*V[k]*V[m]*TAP[l,k,m]*cos(TETA[k]-TETA[m]+branch_def[l,k,m])
-B[l,k,m]*V[k]*V[m]*TAP[l,k,m]*sin(TETA[k]-TETA[m]+branch_def[l,k,m]);
#
let Q[l,k,m] :=-(B[l,k,m]+branch_c[l,k,m]/2)*V[k]^2*TAP[l,k,m]^2
-G[l,k,m]*V[k]*V[m]*TAP[l,k,m]*sin(TETA[k]-TETA[m]+branch_def[l,k,m])
+B[l,k,m]*V[k]*V[m]*TAP[l,k,m]*cos(TETA[k]-TETA[m]+branch_def[l,k,m]);

#
# FLUXO REVERSO
let p_r[l,k,m] := branch_g[l,k,m]*bus_voltage[m]^2
-branch_g[l,k,m]*bus_voltage[k]*bus_voltage[m]*branch_tap[l,k,m]*cos(bus_angle[k]-
bus_angle[m]+branch_def[l,k,m])
+branch_b[l,k,m]*bus_voltage[k]*bus_voltage[m]*branch_tap[l,k,m]*sin(bus_angle[k]-
bus_angle[m]+branch_def[l,k,m]);
#
let q_r[l,k,m] :=-(branch_b[l,k,m]+branch_c[l,k,m]/2)*bus_voltage[m]^2
+branch_g[l,k,m]*bus_voltage[k]*bus_voltage[m]*branch_tap[l,k,m]*sin(bus_angle[k]-
bus_angle[m]+branch_def[l,k,m])
+branch_b[l,k,m]*bus_voltage[k]*bus_voltage[m]*branch_tap[l,k,m]*cos(bus_angle[k]-
bus_angle[m]+branch_def[l,k,m]);
}
#