Anda di halaman 1dari 26

TÉCNICAS COMPUTACIONALES DE SISTEMAS DE POTENCIA

INFORME TAREA 4
ELABORACIÓN DE UN SCRIPT PARA CÁLCULOS DE FLUJO DE CARGA

PRESENTADO POR:

CRISTIAN ANDRÉS MELO LOZADA


ALEXANDER RODRÍGUEZ SÁNCHEZ
OSCAR FELIPE VELÁSQUEZ ALBINO

PRESENTADO A:

M.Sc. ALEXANDER MOLINA CABRERA

PROGRAMA DE MAESTRÍA EN INGENIERÍA ELÉCTRICA


FACULTAD DE INGENIERÍA ELÉCTRICA
UNIVERSIDAD TECNOLÓGICA DE PEREIRA
PEREIRA, 7 DE JUNIO DE 2017
TAREA 4 TÉCNICAS COMPUTACIONALES

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:

A. Potencia inyectada por cada generador.


B. Potencia consumida por cada demanda.
C. Tensión y ángulo en PU.
D. Flujo de carga en cada sentido de las líneas.
E. Pérdidas en cada línea.

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.

Consideraciones para resolver el problema de Flujo de carga

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:

A. Variables controladas: Potencia activa generada 𝑃𝐺 y Potencia reactiva generada 𝑄𝐺 .


B. Variables no controladas: Potencia activa demandada 𝑃𝐷 y Potencia reactiva demandada 𝑄𝐷 .
C. Variables de estado: Magnitud de los Voltajes |𝑉| y ángulo de los voltajes 𝜃.

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.

𝑃𝐺𝑚𝑖𝑛 ≤ 𝑃𝐺 ≤ 𝑃𝐺𝑚𝑎𝑥 ; 𝑄𝐺𝑚𝑖𝑛 ≤ 𝑄𝐺 ≤ 𝑄𝐺𝑚𝑎𝑥

Límites para las variables de estado.

|𝑉| 𝑚𝑖𝑛 ≤ |𝑉| ≤ |𝑉|𝑚𝑎𝑥 ; |𝜃𝑖 − 𝜃𝑗 | ≤ 𝑚𝑎𝑥|𝜃𝑖 − 𝜃𝑗 |

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.

MÉTODOS DE SOLUCIÓN AL PROBLEMA DE FLUJO DE CARGA

Los métodos más empleados para solucionar el problema de flujo de carga, se pueden clasificar de la siguiente
manera:

A. Iterativo (Lineales y no Lineales)


• Gauss.
• Gauss Seidel.
B. No Lineales (Linealizados)
• Acoplado: Método de Newton Raphson.
• Desacoplados: Desacoplado de Newton, Desacoplado rápido de Newton y Ward y Hale.
PROCEDIMIENTO EMPLEADO

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:

• Nodo i: Nodo inicial.


• Nodo j: Nodo final.
• Rij: Resistencia de la línea que conecta el Nodo i con el Nodo j.
• Xij: Reactancia de la línea que conecta el Nodo i con el Nodo j.
• Yshunt: Admitancia shunt de la línea.

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.

En caso de seleccionar el método de Newton Raphson el procedimiento iterativo correspondiente, será:

INICIO

Lectura de los parámetros de las líneas,


información nodal, condiciones iniciales y
matriz YBUS.

Inicialización del contador


de iteraciones (Iter=0)

Cálculo de P y Q iniciales:
𝑛

𝑃𝑐𝑎𝑙 𝑘 = 𝑉𝑘 𝑉𝑚 (𝐺𝑘𝑚 cos 𝜃𝑘𝑚 − 𝐵𝑘𝑚 sin 𝜃𝑘𝑚 )


𝑚 =1
𝑛

𝑄 𝑐𝑎𝑙 𝑘 = 𝑉𝑘 𝑉𝑚 (𝐺𝑘𝑚 sin 𝜃𝑘𝑚 − 𝐵𝑘𝑚 cos 𝜃𝑘𝑚 )


𝑚 =1

Cálculo de los errores ∆P y ∆Q, considerando el tipo de nodo:

∆P𝑘 = 𝑃𝑒𝑠𝑝 𝑘 − 𝑃𝑐𝑎𝑙 𝑘


∆Q 𝑘 = 𝑄 𝑒𝑠𝑝 𝑘 − 𝑄 𝑐𝑎𝑙 𝑘

Cálculo del Jacobino:


Se incrementa el número 𝐻 𝐽
de iteraciones 𝑁 𝐿
𝐼𝑡𝑒𝑟 = 𝐼𝑡𝑒𝑟 + 1

Solución del modelo linealizado:


∆𝜃 −1
∆𝑣 = 𝐻 𝐽 ∆𝑃
𝑁 𝐿 ∆𝑄
𝑣

No
Actualización de las variables (𝑉, 𝜃)

Comprobación del error:

𝑚𝑎𝑥| ∆P𝑘 , ∆Q 𝑘 ≤ 𝜉|

SI

Se calculan 𝑃, 𝑄 𝑒 𝐼 para líneas y nodos

FINAL
En caso de seleccionar el método de Gauss Seidel el procedimiento iterativo correspondiente, será:

INICIO

Lectura de los parámetros de las líneas,


información nodal, condiciones iniciales y
matriz YBUS.

Inicialización del contador


de iteraciones (Iter=0)

Cálculo de voltajes para los nodos PV y PQ:

𝑛
1 𝑃𝑘 − 𝑗𝑄𝑘
𝑉𝑘 = − 𝑌𝑘𝑚 𝑉𝑚
𝑌𝑘𝑘 𝑉 ∗𝑘
𝑚 =1 (𝑚≠𝑘)

Cálculo potencia reactiva en los nodos PV y


verificación de límites de reactiva:
Se incrementa el número 𝑛
de iteraciones 𝑄𝑘 = 𝑉𝑘 𝑉𝑚 (𝐺𝑘𝑚 sin 𝜃𝑘𝑚 − 𝐵𝑘𝑚 cos 𝜃𝑘𝑚 )
𝐼𝑡𝑒𝑟 = 𝐼𝑡𝑒𝑟 + 1 𝑚 =1

Actualización de los voltajes 𝑉.


No

Comprobación del error:


𝑚𝑎𝑥|𝑣𝑖 𝑖𝑡𝑒𝑟 +1 − 𝑣𝑖 𝑖𝑡𝑒𝑟 ≤ 𝜉|

SI

Se calculan 𝑃, 𝑄 𝑒 𝐼 para líneas y nodos

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:

• Hoja 1 voltajes nodales.


• Hoja 2 corrientes inyectadas en los nodos.
• Hoja 3 flujo de corrientes por las líneas.
• Hoja 4 flujo de potencia activa y reactiva por las líneas.
• Hoja 5 perdida de potencia activa y reactiva en las líneas.
• Hoja 6 potencia inyectadas y generadas en los nodos.
PRUEBAS Y RESULTADOS

Para comprobar la eficiencia del aplicativo programado en MATLAB, se realizaron dos pruebas distintas:

1. SISTEMA DE PRUEBA DE 4 NODOS.

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:

Tabla 1. Datos de las líneas.

Tabla 2. Datos de los nodos.


RESULTADOS SISTEMA DE PRUEBA 4 NODOS

Método de Newton Raphson

• Hoja 1 voltajes nodales.

• Hoja 2 corrientes inyectadas en los nodos.

• Hoja 3 flujo de corrientes por las líneas.


• Hoja 4 flujo de potencia activa y reactiva por las líneas.

• Hoja 5 perdida de potencia activa y reactiva en las líneas.

• Hoja 6 potencia inyectadas y generadas en los nodos.


RESULTADOS SISTEMA DE PRUEBA 4 NODOS

Método Gauss Seidel

• Hoja 1 voltajes nodales.

• Hoja 2 corrientes inyectadas en los nodos.

• Hoja 3 flujo de corrientes por las líneas.


• Hoja 4 flujo de potencia activa y reactiva por las líneas.

• Hoja 5 perdida de potencia activa y reactiva en las líneas.

• Hoja 6 potencia inyectadas y generadas en los nodos.


2. SISTEMA DE PRUEBA DE 8 NODOS.

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.

Tabla 2. Datos de las líneas.

Tabla 4. Datos de los nodos.


RESULTADOS SISTEMA DE PRUEBA 8 NODOS

Método de Newton Raphson

• Hoja 1 voltajes nodales.

• Hoja 2 corrientes inyectadas en los nodos.

• Hoja 3 flujo de corrientes por las líneas.


• Hoja 4 flujo de potencia activa y reactiva por las líneas.

• Hoja 5 perdida de potencia activa y reactiva en las líneas.

• Hoja 6 potencia inyectadas y generadas en los nodos.


CONCLUISONES

• 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

% --- Executes just before FLUJO is made visible.


function FLUJO_OpeningFcn(hObject, eventdata, handles, varargin)

handles.output = hObject;

% Update handles structure


guidata(hObject, handles);

% --- Outputs from this function are returned to the command line.
function varargout = FLUJO_OutputFcn(hObject, eventdata, handles)
varargout{1} = handles.output;

% Selecciona el metodo de solucion.


function popupmenu1_Callback(hObject, eventdata, handles)
Decision=get(handles.popupmenu1,'Value');

switch Decision
case 1

Decision=1;
case 2

Decision=2;
end

% --- Executes during object creation, after setting all properties.


function popupmenu1_CreateFcn(hObject, eventdata, handles)
if ispc && isequal(get(hObject,'BackgroundColor'),
get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end
% GENERA BASE DE DATOS
function pushbutton1_Callback(hObject, eventdata, handles)
nn=str2num(get(handles.edit2,'String')); %Toma el valor de nodos digitado en el GUI
Nodos_entrega=[1:nn]; %Nodos de entrega
Nodos_recibo=Nodos_entrega; %Nodos LLegada

DATOS=zeros(nn,10);%genera la matriz vacia de datos de los nodos


Lineas=zeros(1,5);%genera la matriz vacia de datos de las lineas

fprintf('\n\nEN EL SIGUIENTE ARCHIVO DE EXCEL INTRODUZCA LA INFORMACION DEL SISTEMA


Y GUARDELA\n\n');
fprintf('HOJA 1 DATOS DE LAS LINEAS');
fprintf('\nHOJA 2 DATOS DE LOS NODOS\n\n');

for h=1:nn

DATOS(h,1)=h;
end

%Se genera el archivo en excel que contendra los datos


warning('off','MATLAB:xlswrite:AddSheet');
headers = {'Nodo i','Nodo j','Rij','Xij','Yshuntij'};
headers3={'Nodo','Tipo de Nodo','Pg[Pu]','Qg[Pu]','Pd[Pu]','Qd[Pu]','V pu','Delta'
,'Qmin[Pu]','Qmax[Pu]'};
headers4={'Tipo 1:Slack';'Tipo 2:PV';'Tipo 3:PQ'};
xlswrite('DATOS_RED.xls',headers,1,'A1');
xlswrite('DATOS_RED.xls',Lineas,1,'A2');
xlswrite('DATOS_RED.xls',headers3,2,'A1');
xlswrite('DATOS_RED.xls',headers4,2,'M1');
xlswrite('DATOS_RED.xls',DATOS,2,'A2');
winopen( 'DATOS_RED.xls')

function edit2_Callback(hObject, eventdata, handles)

% --- Executes during object creation, after setting all properties.


function edit2_CreateFcn(hObject, eventdata, handles)

if ispc && isequal(get(hObject,'BackgroundColor'),


get(0,'defaultUicontrolBackgroundColor'))
set(hObject,'BackgroundColor','white');
end

% REALIZA LOS CALCULOS FINALES


function pushbutton2_Callback(hObject, eventdata, handles)
nn=str2num(get(handles.edit2,'String')); %Toma el valor de nodos digitado en el GUI
Nodos_entrega=[1:nn]; %Nodos de entrega
Nodos_recibo=Nodos_entrega; %Nodos LLegada
Lineas=xlsread('DATOS_RED.xls',1,'A2:F100');
DATOS=xlsread('DATOS_RED.xls',2,'A2:j100');
Ni= Lineas(:,1); %Nodo de inicial
Nf= Lineas(:,2);%Nodo final
R = Lineas(:,3); %Resistencia
X = Lineas(:,4);%Reactancia
Yshunt = Lineas(:,5);% Suceptancia
Z=R+i*X; %Impedancia de la linea
y=1./Z; %Admitancia de las lineas
Yshunt=i*Yshunt; %Yshunt
nl=length(Ni); %Numero de Lineas
Y=zeros(nn,nn);%Genera una matriz de nxn para guardar los valores de la YBUS

%Calculos matriz YBUS


for k = 1:nl
Y(Ni(k),Nf(k)) =- y(k);
Y(Nf(k),Ni(k)) = Y(Ni(k),Nf(k));
end
for m = 1:nn
for n = 1:nl
if Ni(n) == m | Nf(n) == m
Y(m,m) = Y(m,m) + y(n) + Yshunt(n);
end
end
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

%Calculo submatriz N del Jacobiano: Derivada de las potecias inyectadas al sistema


con tensiones

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

%Calculo submatriz J del Jacobiano: Derivadas de las potecias reactivas inyectadas


al sistema variables - angulos

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

%Calculo submatriz L del Jacobiano:Derivadas de las potecias reactivas inyectadas al


sistema variables - tensiones
L = zeros(npq,npq);
for h = 1:npq
m = pq(h);
for k = 1:npq
n = pq(k);
if n == m
for n = 1:Nnodos
L(h,k) = L(h,k) + V(m)*abs(YBUS(m,n))*V(n)*sin(del(m)-del(n)-
angle(YBUS(m,n)));
end
L(h,k) = L(h,k) - V(m)^2*B(m,m);
else
L(h,k) = V(m)*abs(YBUS(m,n))*V(n)*sin(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);

del(2:Nnodos) = dTh + del(2:Nnodos); % Angulo en las tensiones nodales


k = 1;
for h = 2:Nnodos
if tipo(h) == 3
V(h) = dV(k) + V(h); % magnitud de las tensiones nodales
k = k+1;

if (V(h)<0.95 | V(h)>1.05) %Si la tension en un nodo PQ es menor a los


limites nodo PQ pasa a PV
tipo(h)=2;
end
end
end
Iter = Iter + 1;
Tol = max(abs(M)); % Revision nivel de toleracia
end

Del = 180/pi*del; %conversion radianes grados


%Voltajes nodales en coordenadas rectangulares
Vm=V.*cos(del) + i*V.*sin(del);
% Corrientes inyectadas en los Nodos
In = YBUS*Vm;
Inm = abs(In);
Ina = angle(In)*180/pi;
%%Calculo Corrientes Inyectadas en los Nodos
for m = 1:nn
if Ina(m) >= 90
Ina(m) = Ina(m)-180;
elseif Ina(m) <= -90
Ina(m) = Ina(m)+180;
else
Ina(m)=Ina(m);
end
end
% Matrices iniciales Para el calculo de Corrientes inyectadas y potencias
Iij = zeros(nn,nn);
Sij = zeros(nn,nn);
Si = zeros(nn,1);
%Flujos de corrientes por las lineas
for m = 1:nl
p = Ni(m); q = Nf(m);
Iij(p,q) =-(Vm(p) - Vm(q))*YBUS(p,q); % Y(m,n) = -y(m,n)=1/Z %
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
%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

Titulo5={'SOLUCIÓN EMPLEANDO METODO NEWTON RAPHSON'};


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

if tipo(h) == 2 % Calculo Qi para los nodos PV

Q(h) = -imag(conj(V(h))*(SumV + YBUS(h,h)*V(h)));


if Qmin(h)~=0 & Qmax(h)~=0
if (Q(h) > Qmax(h)) || (Q(h) < Qmin(h)) % Verifica si se violaron
limites para Qi.
if Q(h) < Qmin(h) % Limite inferior no violado.
Q(h) = Qmin(h);
else % No se viola limite superior.
Q(h) = Qmax(h);
end
tipo(h) = 3; % Si el limite es violado, cambia de nodo PV a PQ .
end
end
end
V(h) = (1/YBUS(h,h))*((P(h)-j*Q(h))/conj(V(h)) - SumV); % Calculo voltajes
nodales.
if tipo(h) == 2 % Para los nodos Pv, la magnitus del voltaje se mantiene
igual, pero el angulo cambia.

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

Vm=V; % Voltajes nodales.


In=YBUS*Vm; %Corrientes nodales
Inm= abs(In); % Magnitud de las corrientes
Ina=angle(In)*180/pi; %Angulo de las corrientes
Vmag= abs(Vm); % Magnitud voltaje.
Del=180/pi*angle(Vm); % Angulo en grados del voltaje.

%%Calculo Corrientes Inyectadas en los Nodos


for m = 1:nn
if Ina(m) >= 90
Ina(m)=Ina(m)-180;
elseif Ina(m) <= -90
Ina(m)=Ina(m)+180;
else
Ina(m)=Ina(m);
end
end
%%Matrices iniciales Para el calculo de Corrientes inyectadas y potencias
Iij=zeros(nn,nn);
Sij=zeros(nn,nn);
Si=zeros(nn,1);

%%Flujos de corrientes por las lineas

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

%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
Titulo5={'SOLUCIÓN EMPLEANDO METODO GAUSS SEIDEL'};
end

%Mensaje informativo para el susuario


fprintf('\n\nEN EL SIGUIENTE ARCHIVO DE EXCEL (RESULTADOS), ENCONTRARA:\n\n');
fprintf('HOJA 1 VOLTAJES NODALES');
fprintf('\nHOJA 2 CORRIENTES INYECTADAS EN LOS NODOS');
fprintf('\nHOJA 3 FLUJO DE CORRIENTES POR LAS LINEAS');
fprintf('\nHOJA 4 FLUJO DE POTENCIA ACTIVA Y REACTIVA POR LAS LINEAS');
fprintf('\nHOJA 5 PERDIDA DE POTENCIA ACTIVA Y REACTIVA EN LAS LINEAS');
fprintf('\nHOJA 6 POTENCIA INYECTADAS Y GENERADAS EN LOS NODOS\n\n');
fprintf('\nESPERE MIENTRAS SE GENERA EL ARCHIVO\n\n');

%Genera el archivo en excel con los resultados


warning('off','MATLAB:xlswrite:AddSheet');
Titulo6={'VOLTAJES NODALES'};
headers6={'Nodo','V[Pu]','Angulo en Grados'};
headersN={'ITERACIONES'};
xlswrite('RESULTADOS.xls',Titulo5,1,'A1');
xlswrite('RESULTADOS.xls',Titulo6,1,'A2');
xlswrite('RESULTADOS.xls',headers6,1,'A3');
xlswrite('RESULTADOS.xls',Nodos_entrega',1,'A4');
xlswrite('RESULTADOS.xls',headersN,1,'F1');
xlswrite('RESULTADOS.xls',Iter,1,'G1');
xlswrite('RESULTADOS.xls',V,1,'B4');
xlswrite('RESULTADOS.xls',Del,1,'C4');
Titulo7={'CORRIENTES INYECTADAS EN LOS NODOS'};
headers7={'Nodo','I[Pu]','Angulo en Grados'};
xlswrite('RESULTADOS.xls',Titulo7,2,'A1');
xlswrite('RESULTADOS.xls',headers7,2,'A2');
xlswrite('RESULTADOS.xls',Nodos_entrega',2,'A3');
xlswrite('RESULTADOS.xls',Inm,2,'B3');
xlswrite('RESULTADOS.xls',Ina,2,'C3');
Titulo8={'FLUJO DE CORRIENTES POR LAS LINEAS'};
headers8={'Nodo i','Nodo j','I lineas[Pu]','Angulo en Grados'};
xlswrite('RESULTADOS.xls',Titulo8,3,'A1');
xlswrite('RESULTADOS.xls',headers8,3,'A2');
xlswrite('RESULTADOS.xls',Ni,3,'A3');
xlswrite('RESULTADOS.xls',Nf,3,'B3');
xlswrite('RESULTADOS.xls',Iijm',3,'C3');
xlswrite('RESULTADOS.xls', Iija',3,'D3');
Titulo9={'FLUJO DE POTENCIA ACTIVA Y REACTIVA POR LAS LINEAS'};
headers9={'Nodo i','Nodo j','Potencia Activa[Pu]','Potencia Reactiva[Pu]'};
xlswrite('RESULTADOS.xls',Titulo9,4,'A1');
xlswrite('RESULTADOS.xls',headers9,4,'A2');
xlswrite('RESULTADOS.xls',ini',4,'A3');
xlswrite('RESULTADOS.xls',fini',4,'B3');
xlswrite('RESULTADOS.xls',real(Sij1)',4,'C3');
xlswrite('RESULTADOS.xls',imag(Sij1)',4,'D3');
Titulo10={'PERDIDA DE POTENCIA ACTIVA Y REACTIVA EN LAS LINEAS'};
headers10={'Nodo i','Nodo j','Perdidas Potencia Activa[Pu]','Perdidas Potencia
Reactiva[Pu]'};
xlswrite('RESULTADOS.xls',Titulo10,5,'A1');
xlswrite('RESULTADOS.xls',headers10,5,'A2');
xlswrite('RESULTADOS.xls',Ni,5,'A3');
xlswrite('RESULTADOS.xls',Nf,5,'B3');
xlswrite('RESULTADOS.xls',Lpij,5,'C3');
xlswrite('RESULTADOS.xls',Lqij,5,'D3');
Titulo11={'POTENCIA INYECTADAS Y GENERADAS EN LOS NODOS'};
headers11={'Nodo','P inyectada[Pu]','Q inyectada[Pu] ','P generada[Pu]','Q
generada[Pu]'};
xlswrite('RESULTADOS.xls',Titulo11,6,'A1');
xlswrite('RESULTADOS.xls',headers11,6,'A2');
xlswrite('RESULTADOS.xls',Nodos_entrega',6,'A3');
xlswrite('RESULTADOS.xls',Pi,6,'B3');
xlswrite('RESULTADOS.xls',Qi,6,'C3');
xlswrite('RESULTADOS.xls',Pg,6,'D3');
xlswrite('RESULTADOS.xls',Qg,6,'E3');
winopen( 'RESULTADOS.xls')