Documentos de Académico
Documentos de Profesional
Documentos de Cultura
INFORME TAREA 4
ELABORACIÓN DE UN SCRIPT PARA CÁLCULOS DE FLUJO DE CARGA
PRESENTADO POR:
PRESENTADO A:
OBJETIVO PRINCIPAL
El presente trabajo tiene como finalidad el desarrollo de un aplicativo que permita resolver el problema de flujo
de carga para cualquier sistema eléctrico de potencia, empleando los métodos de Gauss Seidel o Newton Raphson.
El aplicativo debe poder calcular:
INTRODUCCIÓN
Dentro del análisis de sistemas de potencia en estado estable, el estudio de flujo de carga es una herramienta
ampliamente empleada, tanto en la fase operativa de la red, como en una fase previa de construcción de la misma;
dicha herramienta tiene como prioridad obtener los voltajes nodales, a partir de los cuales es posible calcular
variables de interés, tales como potencia en las líneas, flujos de corriente e inyección de reactivos en los
generadores.
El flujo de carga en términos generales permite conocer el comportamiento del sistema eléctrico de potencia bajo
condiciones operativas detalladas; estas condiciones están definidas a través de las variables de control del
sistema, es decir, potencia activa y voltajes en los generadores, así como la potencia reactiva en los nodos de
carga; de manera adicional, se deben considerar las restricciones propias e inherentes al sistema eléctrico de
potencia, límites de generación de reactivos, límites de transmisión, entre otras.
En términos matemáticos, el problema consiste en resolver un sistema de ecuaciones constituido por funciones
no lineales dependientes de los voltajes nodales (𝑓(𝑣) = 0), estas funciones representan condiciones de
operación específicas del sistema.
Pese a que existen diversos métodos de solución para resolver el problema de flujo de carga, los métodos más
empleados son los métodos de Newton Raphson y Gauss Seidel, esto se debe a que presentan buenas
características de convergencia en tiempos de computo pequeños.
Para entender y dar solución al problema de flujo de carga se debe considerar la naturaleza de las variables que
lo conforman y su comportamiento. Dichas variables se clasifican de la siguiente manera:
Se deben fijar límites a las variables de control y a las variables estado. Estos límites corresponden al estado
operativo del sistema.
Límites para las variables de control.
Por último, se clasifican los nodos del sistema según sus características específicas y de acuerdo a esto se establece
el tipo de variable que representa a el nodo.
A. Nodo Slack (𝑽, 𝜽): Este nodo se encarga de establecer el balance global de potencia del sistema,
asumiendo los faltantes de carga de otros nodos, más las pérdidas del sistema. Por norma general, se
selecciona como nodo slack, aquel con mayor generación y deberá tener la cantidad suficiente de
reactivos, como para controlar la magnitud del voltaje. En este nodo se asumen como conocidas las
variables (|𝑉|, 𝜃) y desconocidas las variables (𝑃, 𝑄).
B. Nodo de voltaje controlado (𝑷𝑽): Generalmente los nodos seleccionados como nodos de voltaje
controlado, son nodos con alta generación. En este tipo de nodo se asumen como conocidas las variables
(𝑃, 𝑉) y desconocidas las variables (𝑄, 𝜃 ). A este tipo de nodo pertenecen aquellos que presentan
elementos con capacidad para controlar la magnitud del voltaje.
C. Nodo de carga (𝑷𝑸): Representa nodos donde la carga predomina sobre la generación o nodos de paso.
En este tipo de nodos se requiere que el voltaje este dentro de unos límites preestablecidos; su
importancia radica en que permiten establecer la cantidad de potencia reactiva que se necesita inyectar
en la red a fin de mantener una operación adecuada.
Los métodos más empleados para solucionar el problema de flujo de carga, se pueden clasificar de la siguiente
manera:
Para el desarrollo del aplicativo se empleó el software matemático MATLAB, el script programado solicita
mediante una interfaz gráfica de usuario (Figura 1) el número de nodos 𝒏 de la red.
Figura 1.
Establecida la cantidad de nodos de la red, se genera un archivo en Microsoft Excel (DATOS_RED.xls), donde se le
indica al usuario que introduzca en la hoja 1 del archivo información referente a las líneas que conectan los nodos
del sistema, y en la hoja 2 información operativa de los nodos.
Información Hoja 1:
Información Hoja 2:
• Tipo de Nodo: Establece el tipo de nodo; Nodo Slack (1), Nodo PV (2) o Nodo PQ (3).
• Pg[pu]: Potencia activa generada por el nodo.
• Qg[pu]: Potencia reactiva generada por el nodo.
• Pd[pu]: Potencia activa demandada por el nodo.
• Qd[pu]: Potencia reactiva demandada por el nodo.
• V[pu]: Magnitud del Voltaje del nodo en por unidad.
• Delta: Fase del voltaje del nodo en grados.
Establecidos los datos de los corredores y los nodos del sistema, se calcula la matriz YBUS que representa la red
para posteriores cálculos, y se le indica al usuario que seleccione un método de solución entre Newton Raphson
o Gauss Seidel.
INICIO
Cálculo de P y Q iniciales:
𝑛
No
Actualización de las variables (𝑉, 𝜃)
𝑚𝑎𝑥| ∆P𝑘 , ∆Q 𝑘 ≤ 𝜉|
SI
FINAL
En caso de seleccionar el método de Gauss Seidel el procedimiento iterativo correspondiente, será:
INICIO
𝑛
1 𝑃𝑘 − 𝑗𝑄𝑘
𝑉𝑘 = − 𝑌𝑘𝑚 𝑉𝑚
𝑌𝑘𝑘 𝑉 ∗𝑘
𝑚 =1 (𝑚≠𝑘)
SI
FINAL
Después de haber seleccionado cualquiera de los dos métodos iterativos descritos, se genera un archivo en
Microsoft Excel (RESULTADOS.xls), con la siguiente distribución:
Para comprobar la eficiencia del aplicativo programado en MATLAB, se realizaron dos pruebas distintas:
Figura 2.
Se ingresan los datos de las líneas y los nodos en el archivo de DATOS_RED.xls, como se muestra a continuación:
Con el fin de comprobar si el aplicativo funciona adecuadamente independiente de la red y su cantidad de nodos,
se empleó del sistema de la figura 3, al cual se aplicó el método de Newton Raphson para resolver el problema de
flujo de carga.
Figura 3.
• En términos generales, la importancia del estudio de flujo de carga, radica en que permiten conocer
información sumamente importante acerca de las condiciones operativas del sistema eléctrico de
potencia, como por ejemplo voltajes nodales, flujos de potencia por las líneas, perdidas, etc.
• Al ser un método iterativo que linealiza las funciones en el punto de operación, el método de Newton
Raphson resulta ideal en la solución de las ecuaciones nodales de potencia inyectada que describen a los
sistemas de potencia eléctrica en estado estable.
• En las pruebas realizadas, tanto con el método de Gauss Seidel, como con el método de Newton Raphson
los resultados obtenidos son satisfactorios y presentan tiempos de computo reducidos, sin embargo, el
método de Gauss Seidel presenta una convergencia pobre a medida que se incluyen restricciones y se
incrementa el número de nodos al problema.
• Pese a que el método de Newton Raphson requiere una gran cantidad de cálculos, estos no implican una
dificulta, o no presentan gran complejidad a la hora de implementarlos en un lenguaje de programación.
ANEXO
CODIGO EN MATLAB
function varargout = FLUJO(varargin)
gui_Singleton = 1;
gui_State = struct('gui_Name', mfilename, ...
'gui_Singleton', gui_Singleton, ...
'gui_OpeningFcn', @FLUJO_OpeningFcn, ...
'gui_OutputFcn', @FLUJO_OutputFcn, ...
'gui_LayoutFcn', [] , ...
'gui_Callback', []);
if nargin && ischar(varargin{1})
gui_State.gui_Callback = str2func(varargin{1});
end
if nargout
[varargout{1:nargout}] = gui_mainfcn(gui_State, varargin{:});
else
gui_mainfcn(gui_State, varargin{:});
end
handles.output = hObject;
% --- Outputs from this function are returned to the command line.
function varargout = FLUJO_OutputFcn(hObject, eventdata, handles)
varargout{1} = handles.output;
switch Decision
case 1
Decision=1;
case 2
Decision=2;
end
for h=1:nn
DATOS(h,1)=h;
end
%MAtriz YBUS
YBUS=Y;
% Nodos
nodos=DATOS(:,1);
% Tipo de Nodo
tipo=DATOS(:,2);
% Pg pu
Pg=DATOS(:,3);
% Qg pu
Qg=DATOS(:,4);
% Pd pu
Pd=DATOS(:,5);
% Qd pu
Qd=DATOS(:,6);
% Voltaje iniciales en los nodos
V=DATOS(:,7);
% Angulo delta de los voltajes nodales
del=DATOS(:,8);
% Limite minimo de Potencia reactiva
Qmin=DATOS(:,9);
% Limite maximo de Potencia reactiva
Qmax=DATOS(:,10);
% Sistemas de Ecuaciones
P=Pg-Pd;
Q = Qg - Qd;
% P especificada
Psp=P;
% Q especificada
Qsp=Q;
% Matrx de conductacias
G=real(YBUS);
% Matrix de Suceptancias
B=imag(YBUS);
% TIPO DE NODO
% PV
pv=find(tipo==2 | tipo==1);
% PQ
pq=find(tipo==3);
% Numero de Nodos PV
npv=length(pv);
% Numeros de Nodos PQ
npq=length(pq);
Nnodos =nn;
Tol = 1;% Criterio inicial de Tolerancia
Iter = 0;% Inicializa el contador de iteraciones
Decision=get(handles.popupmenu1,'Value');
if Decision==1
%% Calculo Jacobiano
while (Tol > 0.1*10e-3) % toleracia Metodo
P=zeros(Nnodos,1);
Q=zeros(Nnodos,1);
% calculos de P y Q
for h = 1:Nnodos
for k = 1:Nnodos
P(h) = P(h) + V(h)*abs(YBUS(h,k))*V(k)*cos(del(h)-del(k)-
angle(YBUS(h,k)));
Q(h) = Q(h) + V(h)*abs(YBUS(h,k))*V(k)*sin(del(h)-del(k)-
angle(YBUS(h,k)));
end
end
% Verificacion limites de Potencia Reactiva
if Iter <= 7 && Iter > 2 % Verificando para 7 iteraciones
for n = 2:Nnodos
if tipo(n) == 2
if Qmin(n)~=0 & Qmax(n)~=0
QG = Q(n)+Qd(n);
if QG < Qmin(n)
V(n) = V(n) + 0.01;
elseif QG > Qmax(n)
V(n) = V(n) - 0.01;
end
end
end
end
end
% Correcion de las variables
dPa = Psp-P;
dQa = Qsp-Q;
k = 1;
dQ = zeros(npq,1);
for h = 1:Nnodos
if tipo(h) == 3
dQ(k,1) = dQa(h);
k = k+1;
end
end
dP = dPa(2:Nnodos);
M = [dP; dQ];% Vector de Errores
% Calculo submatriz H del Jacobiano: Derivadas de las potecias inyectadas al sistema
variables - angulos
H = zeros(Nnodos-1,Nnodos-1);
for h = 1:(Nnodos-1)
m = h+1;
for k = 1:(Nnodos-1)
n = k+1;
if n == m
for n = 1:Nnodos
H(h,k) = H(h,k) - (V(m)*abs(YBUS(m,n))*V(n)*sin(del(m)-del(n)-
angle(YBUS(m,n))));
end
H(h,k) = H(h,k) - V(m)^2*B(m,m);
else
H(h,k) = V(m)*abs(YBUS(m,n))*V(n)*sin(del(m)-del(n)-
angle(YBUS(m,n)));
end
end
end
N = zeros(Nnodos-1,npq);
for h = 1:(Nnodos-1)
m = h+1;
for k = 1:npq
n = pq(k);
if n == m
for n = 1:Nnodos
N(h,k) = N(h,k) + V(m)*abs(YBUS(m,n))*V(n)*cos(del(m)-del(n)-
angle(YBUS(m,n)));
end
N(h,k) = N(h,k) + V(m)^2*G(m,m);
else
N(h,k) = V(m)*abs(YBUS(m,n))*V(n)*cos(del(m)-del(n)-
angle(YBUS(m,n)));
end
end
end
J = zeros(npq,Nnodos-1);
for h = 1:npq
m = pq(h);
for k = 1:(Nnodos-1)
n = k+1;
if n == m
for n = 1:Nnodos
J(h,k) = J(h,k) + V(m)*abs(YBUS(m,n))*V(n)*cos(del(m)-del(n)-
angle(YBUS(m,n)));
end
J(h,k) = J(h,k) - V(m)^2*G(m,m);
else
J(h,k) = -(V(m)*abs(YBUS(m,n))*V(n)*cos(del(m)-del(n)-
angle(YBUS(m,n))));
end
end
end
% JACOBIANO
JACOBIANO = [H N;
J L];
% Vector de Correccion
X = inv(JACOBIANO)*M;
% Correcion de las variables estado
dTh = X(1:Nnodos-1);
dV = X(Nnodos:end);
if Iija(m) >= 90
Iija(m)=Iija(m)-180;
elseif Iija(m) <= -90
Iija(m)=Iija(m)+180;
else
Iija(m)=Iija(m);
end
end
%% Flujo de potencias en las lineas
for m = 1:nn
for n = 1:nn
if m ~= n
Sij(m,n) = Vm(m)*conj(Iij(m,n));
end
if Sij(m,n)~=0
ini(m,n)=m;
fini(m,n)=n;
end
end
end
%Nodos de inicio y llegada
ini(ini==0)=[];
fini(fini==0)=[];
%Potencia Aparente
Sij1=Sij;
Sij1(Sij1==0)=[];
%Perdidas en las lineas
Lij = zeros(nl,1);
for m = 1:nl
p = Ni(m); q = Nf(m);
Lij(m) = Sij(p,q) + Sij(q,p);
Lpij =real(Lij); Lqij =imag(Lij);
end
%potencia inyectada en los Nodos
for h = 1:nn
for k = 1:nn
Si(h) = Si(h) + conj(Vm(h))* Vm(k)*YBUS(h,k);
end
Pi=real(Si);
Qi=-imag(Si);
Pg=Pi+Pd;
Qg=Qi+Qd;
end
if Decision==2
Vini = V;
%Inicialiazacion metodo Gauss
while (Tol > 0.00001)
for h = 2:nn
SumV = 0;
for k = 1:Nnodos
if h ~= k
SumV = SumV + YBUS(h,k)* V(k); % Vk * Yik
end
end
V(h)=abs(Vini(h))*cos(angle(V(h)))+i*abs(Vini(h))*sin(angle(V(h)));
end
if tipo(h) == 3
if (V(h)<0.95 | V(h)>1.05)
tipo(h)=2;
end
end
end
Iter = Iter + 1; % Se incrementa el contador de iteraciones.
Tol = max(abs(abs(V) - abs(Vini))); % Verificacion de la tolerancia.
Vini = V; % El voltaje inicial se emplea en la siguiente iteracion, V(i) =
pol2rect(abs(Vprev(i)), angle(V(i)));
end
for m = 1:nl
p = Ni(m); q = Nf(m);
Iij(p,q) =-(Vm(p) - Vm(q))*YBUS(p,q);
Iij(q,p) = -Iij(p,q);
Iijm(m) = abs(-(Vm(p) - Vm(q))*YBUS(p,q));
Iija(m) = angle(-(Vm(p) - Vm(q))*YBUS(p,q))*180/pi;
if Iija(m) >= 90
Iija(m)=Iija(m)-180;
elseif Iija(m) <= -90
Iija(m)=Iija(m)+180;
else
Iija(m)=Iija(m);
end
end
%% Flujo de potencias en las lineas
for m = 1:nn
for n = 1:nn
if m ~= n
Sij(m,n) = Vm(m)*conj(Iij(m,n));
end
if Sij(m,n)~=0
ini(m,n)=m;
fini(m,n)=n;
end
end
end
%Potencia Aparente
Sij1=Sij;
Sij1(Sij1==0)=[];
for m = 1:nl
p = Ni(m); q = Nf(m);
Lij(m) = Sij(p,q) + Sij(q,p);
Lpij =real(Lij); Lqij =imag(Lij);
end