1

Proyecto 2 Funcin en MatPower para la bsqueda

de costos marginales de un sistema Lambda con
actualizacin de Newton
Departamento de Ingeniera Elctrica, Electrnica y Computacin
Universidad Nacional De Colombia sede Manizales
Docente: Carlos Murillo
Juan Gabriel Reyes - Anderson Ivn Arenas - Jhony Alexander Moncayo - Andrs Felipe Rebolledo
Noviembre del 2014
Anlisis de Sistemas de Potencia
I.

mpopt = mpoption;

DESCRIPCIN DEL PROGRAMA

Se muestra un diseo de una funcin edlb en MatPower

que resuelve un despacho econmico de energa elctrica de
costos cuadrticos, esto incluye una aproximacin de la
frmula de prdidas de Kron y una bsqueda de costos
marginales del sistema (Lambda) con el complemento de
actualizacin de Newton.
II.

EJECUCIN Y CDIGO DEL PROGRAMA

mpopt.opf.violation = 1e-4;
end
if ischar(mpc)
mpc=loadcase(mpc);

Para la ejecucin del programa en Matlab se realizan 3

pasos bsicos:
Cargamos el caso a analizar:
mpc = loadcase(caseXX);

end

GTOL = mpopt.opf.violation;
Se obtienen las matrices para el mdulo de perdidas:
[B, b1, b0] = makeBloss2(mpc);

Tolerancia de terminacin de Newton

Se ejecuta la funcin para la bsqueda de Lambda:

[Pg, f, lambda, exito, mu_l, mu_u]
edlb(mpc,B,b1,b0);

PF_MAX_IT = mpopt.pf.nr.max_it;
=

Ahora se cargan los apuntadores para el mpc

Ahora, se hace la descripcin de la funcin:

function [Pg, f, lambda, exito,
mu_u] = edlb(mpc,B,b1,b0,mpopt)
Donde:
Pg: cuanto se est generando
f: costo total del sistema
lambda: costo marginal del sistema
exito: Si el programa converge
mu_l: cuando el generador est al lmite inferior
mu_u: cuando el generador est al lmite superior
t0 = clock;
if nargin < 5

Mximo nmero de iteraciones

mu_l,

[PQ, PV, REF, NONE, BUS_I, BUS_TYPE, PD,

QD, GS, BS, BUS_AREA, VM, ...
VA, BASE_KV, ZONE, VMAX, VMIN, LAM_P,
LAM_Q, MU_VMAX, MU_VMIN] = idx_bus;
[GEN_BUS, PG, QG, QMAX, QMIN, VG, MBASE,
GEN_STATUS, PMAX, PMIN, ...
MU_PMAX, MU_PMIN, MU_QMAX, MU_QMIN, PC1,
PC2, QC1MIN, QC1MAX, ...
QC2MIN, QC2MAX, RAMP_AGC, RAMP_10,
RAMP_30, RAMP_Q, APF] = idx_gen;
[F_BUS, T_BUS, BR_R, BR_X, BR_B, RATE_A,
RATE_B, RATE_C, ...
TAP, SHIFT, BR_STATUS, PF, QF, PT, QT,
MU_SF, MU_ST, ...
ANGMIN, ANGMAX, MU_ANGMIN, MU_ANGMAX] =
idx_brch;

mu_u = 0;

Se extrae lo ms importante de cada caso como la potencia,

las ramas, costos, bus etc. Como se muestra a continuacin,
estas seran las matrices necesarias para el programa.

lambda = 0;

baseMVA = mpc.baseMVA;
bus = mpc.bus;
gen = mpc.gen;
branch = mpc.branch;
cost = mpc.gencost;
GTOL = GTOL * baseMVA;

Pg = 0;
f = 0;
exito

Se define el nmero de generadores:

ng = size(mpc.gen,1);
Se define la demanda:
Pd = sum(bus(:,PD));
L = Pd;
U = L;
Se definen las matrices H, h1 y h0 que son las matrices de
costos cuadrticos:

return
end
Pg0 = Xopt;
e = 1;
Para efectos del programa se ingresa el 2 ya que en
MatPower significa costos cuadrticos
[L, U] = lu(H + lambda0*B);

for i=1:ng
H(i,i) = 2 * cost(i,5);
end
h = cost(:,6);

lambda = lambda0;
Son los costos marginales donde es acumulativo y ya
dependiendo del caso muestra el lambda que necesite.

h0 = cost(:,7);

m = 0;

A = sparse( ones(1,ng) );

Nmero de iteraciones

Pgmin = gen(:,PMIN);

S = ones(ng,1);

Pgmax = gen(:,PMAX);

Es la mscara, es una columna que me permite saber que

generadores pudo mover y cuales no segn el limite donde se
encuentren.

A continuacin se muestra como se realiza una solucin de un

modelo GP para obtener un valor de lambda inicial

mu_l = zeros(ng,1);

[Xopt,
fopt,
exito,
solvout,
lambda0]
=
qps_matpower(H,h,A,L,U,Pgmin,Pgmax);

mu_u = zeros(ng,1);

lambda0 = lambda0.mu_l;

mu_l y mu_u simplemente generan un vector y ah es

donde se van a guardar los datos.
Ya teniendo estas matrices y vectores se realiza la frmula
de actualizacin de datos de Newton que es:

if isnan(lambda0) == 1
fprintf(\nError
en
la
funcin,
verifique la potencia demandada.\n);
exito = 0;
mu_l = 0;

Pg = (H + lambda*B)\(- h - lambda * (b1

- ones(ng,1)));
Despus se hace una comparacin de lo que se est
generando con el lmite inferior que este caso seran 10 MW,
de ser el caso sean iguales pg(i) con pg min entonces la
maquina automticamente se para.

dlambda = e / ( S' * M );

Si pg es menor que pg min entonces la maquina generara lo

mismo que en pgmin, y viceversa para pgmax.

lambda = lambda + dlambda;

for i = 1:ng

fprintf( %2i %12.6f %12.6f\n, m,

lambda, e);

if Pg(i) < Pgmin(i)

Pg(i) = Pgmin(i);
S(i) = 0;
mu_l(i) = H(i,i) * Pgmin(i) +
h(i) - lambda;
end
if Pg(i) > Pgmax(i)
Pg(i) = Pgmax(i);
S(i) = 0;
mu_u(i) = lambda - H(i,i) *
Pgmax(i) + h(i);
end
Ahora se saca la frmula del error que sera:
e = Pd + 0.5 * Pg' * B * Pg + b1' * Pg +
b0 - sum(Pg);
Despus se cran dos iteraciones acumulativas para que cada
vez que calcule lo que cambio el lambda.
ech1 = Pd + 0.5 * Pgmin * B * Pgmin +
b1 * Pgmin + b0 - sum(Pgmin);
ech2 = Pd + 0.5 * Pgmax * B * Pgmax +
b1 * Pgmax + b0 - sum(Pgmax);
if ech1 < 0
fprintf(\nGeneradores al mnimo,
la demanda es baja.\n);
return
end
if ech2 > 0
fprintf(\nGeneradores al mximo,
la demanda alta.\n);
return
end
M = U \ (L \ (ones(ng,1) - B * Pg b1));

m = m + 1;
end
Ya con esta lambda se da la ms aproximada al real,
recordando que para el programa la variable M es el contador
de iteraciones; podemos ver una Dlambda que sera la suma de
los pequeos lambda, despus de eso se puede dar el valor
real.
Despus de esto se hacen los respectivos ciclos y avisos de
verificacin de valores como la convergencia de la funcin
despus de cierto nmero de iteraciones y tambin avisos y
plots correspondientes a arrojar los resultados de la funcin
if (m == PF_MAX_IT)
exito = 0;
mu_l = 0;
mu_u = 0;
lambda = 0;
Pg = 0;
f = 0;
fprintf(\nLa funcin no converge
despus de %2i iteraciones.\n, m);
return
end
f1 = [];
for i = 1:ng
f1(i) = H(i,i)/2 * Pg(i)2 + h(i) * Pg(i)
+ h0(i);
end
if (isnan(e) == 1)
exito = 0;
mu_l = 0;
mu_u = 0;
lambda = 0;
Pg = 0;
f = 0;
fprintf(\nLa funcion no
convergio, error en el
programa.\n);
return
end
III.

RESULTADOS DE LA APLICACIN A EJEMPLOS

MATLAB

Se realiza una aplicacin de la funcin en los casos 9 y 30 de

MatPower.
III-A: Aplicacin al caso 9 (case9.m):

lambda

---------------------------------

lambda

---------------------------------

24.876028

10.980685

3.751980

-4.828217

24.895635

0.258208

3.752506

0.068292

24.896119

0.006377

3.752498

-0.001027

edlb convergi en 3 iteraciones y 0.453 segundos.

edlb convergi en 3 iteraciones y 0.469 segundos.

Pg =

Pg =

90.4347

43.8126

134.2580

57.9876

94.1734

23.1027
32.2327

f=
5.3106e+03
lambda =
24.8961
exito =
1
mu_l =

16.8229
17.4502
f=
573.7288
lambda =
3.7525

exito =

mu_l =

mu_u =

0
0

II-B: Aplicacin al caso 30 (case30.m):

0

mu_u =
0
0
0
0
0
0
En ambos casos se hacen 3 iteraciones con xito y con una
respuesta baja de tiempo.

IV.

La actualizacin de Newton es un modelo

matemtico que permite por medio de iteraciones
realizar una aplicacin al despacho econmico de
energa elctrica para realizar una estimacin del
valor del costo marginal Lambda en un sistema de
potencia.
Los modelos matemticos aplicados al despacho
econmico tienden a optimizar el sistema elctrico en
general para reducir costos tanto en la generacin
como en la transmisin.
Analizar casos de estudio de MatPower ayuda no
solo a tener una lectura visible de lo que sucede en
un escenario de despacho econmico sino tambin
ilustra en lo referente al comportamiento de un
sistema elctrico general y especifico.
Desarrollar funciones en MatPower aplicando
modelos matemticos hace que se tenga un enfoque
de un punto especfico de la red.
V.

[1]
[2]

CONCLUSIONES

REFERENCIAS

Notas de clase del profesor Carlos Murillo

Manual de MatPower