FLUJO DE CARGA UTILIZANDO MATRIZ UNIDIMENCIONAL EN

SISTEMAS ELECTRICOS DE POTENCIA

JESS SOLRZANO MORENO
Escuela de Post Grado Elctrica y Electrnica
Universidad Nacional de Ingeniera

1/8
RESUMEN nuevas centrales por su circuito 2, por lo que no es
En el presente articulo se generadoras. nominal y donde: posible obtener
elabora el programa de flujo Estudiar los efectos sobre la Potencias complejas una solucin para
de carga aplicando una distribucin de potencias, netas de las barra 1 y ninguna de ellas a
matriz unidimensional, se cuando se producen 2 respectivamente, menos que se
calcula el numero de orden prdidas temporales de representadas como reduzca el nmero
de la matriz unidimensional generacin o circuitos de fuentes de potencia de incgnitas,
para todas las submatrices transmisin. activa y reactiva, que fijando de
se necesitan para el clculo Ayudar a determinar los corresponden a la antemano algunas
del flujo de potencia. programas de despacho de Potencia Generada variables.
Se ha desarrollado el cdigo carga para obtener un menos la Potencia
fuente en el lenguaje C++, funcionamiento ptimo. Consumida. En relacin a esto
para la compilacin se ha ltimo, una forma
utilizado el software libre 2. PROGRAMACIN Sistema elemental posible de resolver el
DEV C++. DE FLUJO DE problema es la
Se describen la tcnicas CARGA DE UN siguiente:
para utiliza las matrices SISTEMA SIMPLE 1 A partir de los
unidimensionales utilizando DE DOS BARRAS datos del consumo
una formula propia del suponer conocidas
autor. FLUJO DE CARGA EN e independientes
Para la aplicacin se ha UN SEP DE DOS del voltaje, las
tomado un sistema BARRAS potencias de las
elctrico de 4 barras del cargas PCi, QCi, con i
Libro de Harper Pg. 165 Considrese el SEP Figura 2 = 1,2n..
Anlisis Moderno de elemental de dos 2 Fijar a priori dos
Sistemas Elctricos de barras de la Figura 1 y En la Figura 2 variables de
Potencia, se compara los su circuito equivalente * * * generacin
* PG2 y
resultados. por fase que se S1 P1 jQ1 * Y i V 1 Q
V2G2 por ejemplo. No
muestra en la figura V1
Palabras Clave: Flujo de
*
V1
*
V1 2 RL jX Lpueden fijar las
se
cuatro variables de
Carga cdigo fuente generacin debido
matrices unidimensionales. SG y SC Flujos a que las prdidas
de potencia * * * en* el sistema no
1. INTRODUCCIN compleja que S2 P2 jQ2 * Y i V 2 son
V1 conocidas
El clculo y anlisis van desde la V2
del flujo de potencias en la
*
V2
*
V2 2 RL inicialmente.
jX L
barra 1 a la 3 Fijar el mdulo y
red de un Sistema Elctrico barra 2 y ngulo de la
de Potencia (SEP) es uno de viceversa. Estas ecuaciones, que tensin en barra 1;
los aspectos ms relacionan las es decir; suponer
importantes de su tensiones con las conocidos V1, 1. En
comportamiento en rgimen potencias activas y particular, puede
permanente. Consiste en reactivas, presentan tomarse esta
determinar los flujos de las siguientes tensin como
potencia activa y reactiva en caractersticas. referencia, o sea,
cada lnea del sistema y las Son algebraicas y 1=0
tensiones en cada una de las no lineales.
barras, para ciertas La frecuencia no En estas condiciones,
condiciones preestablecidas aparece en forma el sistema de 4
de operacin. explcita porque se ecuaciones (3.2)
El anlisis del flujo de Figura 1 la supone queda con slo 4
potencias (AFP) permite: constante. variables: PG1, QG1, V2,
Programar las ampliaciones * * *
El sistema de 2.
necesarias del SEP y S1 SG1 SC1 ( PG1 PC1 ) j (QG1 QC1 ) P1 jQ1
cuatro ecuaciones,
* * *
determinar su mejor modo
S 2 SG 2 SC 2 ( PG 2 PC 2 ) tiene
j (QG 2 12
QCvariables
2 ) P2 jQ3.2 PLANTEAMIENTO
de operacin, teniendo en en total: PG1, PG2,
En la figura 2 la lnea MATEMTICO DEL
cuenta posibles nuevos QG1, QG2, PC1, PC2,
L12 se ha representado PROBLEMA PARA
consumos, nuevas lneas o QC1, QC2, V1, 1, V2,

2/8
 UN SEP DE N barras que lineales, por lo tanto Una vez clculado el
BARRAS correspondan. es necesario Jacobiano se obtiene los
Empleando el mtodo resolverlo mediante voltajes y ngulos de las
Considrese una barra nodal de resolucin de tcnicas de barras y se recalcula hasta
p cualquiera de un circuitos, en forma aproximaciones reducir la diferencia de la
sistema tal como se matricial, para la red sucesivas. potencia especificada y la
muestra en la Figura de un SEP de n barras calculada
3.5. La potencia se puede escribir: 4. METODO NEWTON
compleja neta, y la RAPSHON 5. PROGRAMACIN
corriente inyectada en El mtodo mas UTILIZANDO
la barra p, &estn
relacionadas por las
I B VB YB empleado para la
solucin de los Flujos
MATRIZ
UNIDIMENCIONAL
siguientes ecuaciones, de carga es el Mtodo El problema de utilizar
que constituyen las de Newton Rapshon matrices bidimensionales es
ecuaciones de barras I1 V1 debido a que no se conoce a
I V priori el numero de barras
2 2 del sistema a calcular, en los
. .
1

P
V J .Q programas de computacin
I p = V p es indispensable definir el
tamao de las matrices lo
. . conlleva especificar
H N nmeros
que
I V P
n n V altos de matrices
Q M L .ocasionando a
Y11 Y12 . Y1 p . YIn sobredimensionar
V la
Representacin de
una Barra p en un SEP Y Y22 . Y2 p . Y memoria dinmica de la PC.
21 2Ppn
.H pq . .q
*
S P V P I P PP jQ P . . . Matrices Unidimensional
.
* Y p1 Yp 2 . Ypp . YpnPp
N pq Vq Vq
Una matriz unidimensional
. es una variable del tipo
SP PP * jQP . . . . .
IP Q p
array y es la unidad
*
VP
*
VP Yn1 Yn 2 M pq . Ynnq
. Ynp elemental de tamao indica
el nmero de elementos del
Ecuaciones del flujo Q p
de potencias se * L*pq Vq Vq*
array (o dimensin del
mismo).
S1 * * * *
puede escribir: *
Y11 V1 Y12 V2 .. Y1 pV p .. Y1n Vn
*
V Se determinan los Ejemplo de matriz
* * * Y i pq *1
* *
elementos de la unidimencional en C++:
I P (V p V q ) Ypq V p
2 S2 * * * * *
matriz * Jacobiana

*
Y21 V
*1
Y22 V2 ..* Ycomo
2 pV p .. Y2 n Vn
sigue: ndice 0 1 2 3
* * * * * V* 2 * Y i pq
* *
Y i pq * 2 * * * componente vacio vacio vaci vaci
S pq V p I pq V p (V p V q ) Ypq* V p ) (Y pq )V p p VpqV q Y pq
Para
Sp * 2* 2
V p (G sin pq B pqComocosse muestra en este
* * * *
H pq
Yp*1 V1 Yp 2 V2 *.. Y pq )Vq
* ppV p .. Y pn Vn ejemplo, la matriz
2 V p (G cos pq B pq sin pq )Vq
i
* * * * * *
V p * Y qp
* * Y i qp N* * * *
unidimensional en C++
S qp Vq I qp V q (Vq V p ) Yqp V q ) (Y qp )V q V q V p Y qp
pq

2 2 M pq V p (Gco pq B pq sin pq )Vq con el 0 como

empieza
Clculo de las * ndice del primer elemento.
S * * * * L pq* V p (G * sin pq B pq cos pq )Vq
tensiones de barras Yn1 V1 Yn 2 V2 .. Y =..
npV pp q Ynn Vn
n
* Para En la memoria del
Las ecuaciones
Vn 2
H pp B ppV p Q p ordenador, el compilador
anteriores indican reservara una direccin
2
claramente que para Este sistema de N pp G ppV p Pp para cada una de las
ecuaciones es similar componentes (la variables
resolver el problema M pp G ppV p Pp
2
al obtenido en el tipo double el tamao es 8
del flujo de potencias
problema elemental 2 bytes en el caso de DEV C+
se requiere L pp B ppV p Q p
de 2 barras; es decir; +), Z(6)=48 Bits
determinar
previamente las las ecuaciones son
tensiones en todas las algebraicas y no

3/8
Tipos de Variables Double El inconveniente de la CLCULO DE LA Sumando las rdenes de las
y Ventajas de reserva esttica es ORDEN DE LA submatrices el orden de la
Conocer el orden que la cantidad de MATRIZ matriz unidimensional para
de la Matriz memoria se reserva UNIDEMENCIONA N barras es:
Las variables de este tipo siempre antes de L
almacenan nmeros conocer los datos Orden= 14N2-10N+8
en formato de coma concretos del Datos del Programa
flotante, mantisa y problema a resolver. Se verifican el numero de
exponente, al igual Eso lleva a reservar Y = Modulo de Matriz de orden en funcin del
que float, pero usan siempre un mximo Admitancias Polar nmero de barras Z[14N2-
mayor precisin. de memoria que en = ngulos de Matriz de 10N+8]
Son aptos para la mayor parte de las Admitancias Polar
variables de tipo ocasiones no se va a V= Voltajes de Barras
real. Se usa este tipo necesitar. La reserva = ngulos de Voltajes de
en nmeros grandes esttica tampoco se Barras
y tambin de gran adapta bien a la Pesp = Potencia
precisin. memoria real Activa Especificada por Barras Orden bits
En el programa utiliza se disponible en el Barra 192 1.536
utilizado el tipo ordenador en que se Cesp = Potencia 10 1.308 10.464
double. La respuesta est ejecutando el Reactiva Especificada por
100 139.008 1.112.064
es que C siempre ha programa. Barra
200 558.008 4.464.064
estado orientado a la
economa de CONVERSIN DE Salida del Programa 500 3.495.008 27.960.064
recursos, tanto en MATRIZ 1000 13.990.008 111.920.064
cuanto al uso de BIDIMENSIONAL A P = Potencia 2000 55.980.008 447.840.064
memoria como al UNIDIMENCIONAL Activa Calculada Por Barra4000 223.960.008 1.791.680.064
uso de procesador Q = Potencia 6000 503.940.008 4.031.520.064
La memoria esttica es Como la mayora de los Reactiva Calculada Por
memoria que se algoritmos propuestos de la Barra
reserva en el literatura para los P = Delta de Utilizando Software libre
momento de la programas de flujo de carga Potencia Activa DEV C++ se ha podido
compilacin, antes utilizan matrices Q = Delta de correr
de comenzar a bidimensionales es Potencia Reactiva El programa para
ejecutarse el necesaria realizar una J = Jacobiano Z=[503940008], en Pentium
programa. Por conversin de ndices se JJ = Arreglo 4 512 RAM
ejemplo, para una realiza la siguiente igualdad Jacobiano Ecuacin Gauss
resolucin de un propuesta por el autor: Sidel Cuando se reserva memoria
sistema de J Orde = Jacobiano dinmicamente, es muy
ecuaciones lineales, Z i, j NxN Z N * i N
j ITER-1
N 2 importante liberar la
la memoria esttica V0 = Voltajes memoria que ya no se
se puede reservar Iniciales necesita. De otra forma los
Ejemplos
con sentencias del 0 = ngulos programas van creciendo a
tipo: Iniciales lo largo de una ejecucin
double x[100], b[100]; 1,1 1,2 1,3 hasta agotar la memoria
Z 2,1 2, 2 2,3 = Se muestra la Longitud de disponible
la Matriz unidimensional en
3,1 3,2 3,3 funcin del Nmero de DIAGRAMA DE FLUJO
Z[ 1, 2. 3 ,4 , 5, 6, 7 ,8 ,9 ] Barras DEL PROGRAMA
Z[2,3]=Z[3*2-3+3]=Z[6]
N*N N*N N N N
Z[2,3]=Z[6] Y V Pesp Qesp

2*(N-1)*2*(N-1) 2*(N-1)*(2*N-1) 2*(N-1)*2*(N-1)

J JJ

4/8
 8 0 9 * 1.9437
6. CASO DE ESTUDIO 9 1.9437 10 * 2.4224
SISTEMA DE 4 10 2.4224 11 * 7.6443
BARRAS (Pag 165 11 7.6443 12 * 3.3
Anlisis Moderno de 12 3.3 13 * 0
Sistema elctricos de 13 0 14 * 0
Potencia Gilberto 14 0 15 * 3.3
Harper ED Limusa 15 3.3 16 * 3.3
-1981) 16 3.3 * Matriz de
17 -77.7 Admitancia ngulos *
G 18 101.3 17 * -77.7
1 V1=1.05 0 S2=0.55+j0.13
19 103.5 18 * 101.3
20 0 19 * 103.5

=0.

+j0
Z13

12
1 Z12=0.08+j0.4 21 101.3 2 20 * 0

.5
22 -77.32 21 * 101.3
Z23=0.1+j0.4 23 104 22 * -77.32
24 0 23 * 104
25 103.5 24 * 0
26 104 25 * 103.5
Z34=j0.3
27 -82.2 26 * 104
3 28 90 27 * -82.2
29 0 4 V=1.10 0 28 * 90
S3= 0.3+j0.18
30G0 29 * 0
31290 30 * 0
32 -90 31 * 90
33 1.05 32 * -90
34 1 * Voltaje de Barras
El ingreso de datos se 35 1 Mdulos *
realiza en el archivo 36 1.1 33 * 1.05
datos.txt 37 0 34 * 0.957519
38 0 35 * 0.968017
Se ingresa los datos a 39 0 36 * 0.979015
un archivo txt 40 0 * Voltaje de Barras
41 0 ngulos *
0 4 // numero de barras 42 -0.55 37 * 0
1 Matriz de 43 -0.3 38 * -6.0077
admitancias 44 0.5 39 * -0.184768
2 45 0 40 * 7.70709
. 46 -0.13 * Potencia Activa por
10 .Voltajes prefijados 47 -0.18 Barra *
. 48 0 41 * 0
15 Potencia Activa 42 * -0.55
especificada 43 * -0.3
Salida Archivo 44 * 0.5
20 Potencia Reactiva salidasjes.txt Para la * Potencia Reactiva
especificada. primera Iteracin por Barra *
45 * 0
0 Nmero de Barras 4 46 * -0.13
Archivo datos.txt * Matriz de 47 * -0.18
Admitancia Mdulos * 48 * 0
04 1 * 4.3924 * Potencia Activa
1 4.3924 2 * 2.4495 Calculada por Barra *
2 2.4495 3 * 1.9437 49 * 0.0512339
3 1.9437 4*0 50 * -0.0208851
40 5 * 2.4495 51 * -0.0249956
5 2.4495 6 * 4.8705 52 * 1.01142e-005
6 4.8705 7 * 2.4224 * Potencia Reactiva
7 2.4224 8*0 Calculada por Barra *
5/8
 53 * 0.224847 102 * 0 158 * -3.63 despus de leer los
54 * -0.120849 103 * 0 159 * 3.63 datos y de conocer el
55 * -0.391369 104 * 0 160 * 0 tamao exacto del
56 * 0.363 105 * 0 161 * 4.81627e-006 problema a resolver.
* Delta de Potencia 106 * 0 162 * 1.4011e-005 Como consecuencia, la
Activa Calculada por Barra 107 * -0.104854 163 * 0.49999 reserva dinmica de
* 108 * 0 164 * -1.08999 memoria se adapta
57 * 0 109 * 1 165 * 0.586028 mucho mejor a las
58 * -0.529115 110 * 0 166 * 0 necesidades de cada
59 * -0.275004 111 * 0 167 * 4.63086 caso. Como
60 * 0.49999 112 * 0 168 * -2.35045 contrapartida, es algo
* Delta de Potencia 113 * 0 169 * 0 ms difcil de
Reactiva Calculada por 114 * -0.0032248 170 * -0.00915085 programar.
Barra * 115 * 0 171 * 0.586028
61 * 0 116 * 0 172 * -1.06246 REFERENCIAS
62 * -0.00915085 117 * 1 173 * -4.81627e-006
63 * 0.211369 118 * 0 174 * -2.35045 [1] Gilberto Enrquez
64 * -0.363 119 * 0 175 * 7.1822 Harper , Anlisis
* Jacobiano * 120 * 0 176 * -3.3 Moderno de
65 * 4.87256 121 * 0.134514 177 * 0.211369 Sistemas elctricos
66 * -2.35045 122 * 0 178 * 0 de Potencia, ED
67 * 0 123 * 0 179 * -4.81627e-006 Limusa., Mxico.
68 * 1.04822 124 * 0 180 * 4.81627e-006
69 * -0.586028 125 * 1 181 * 0 [2] Luis Joyanes
70 * 0 126 * 0 182 * -3.63 Aguilar C++ A su
71 * -2.35045 127 * 0 183 * 3.96 Alcance McGraw
72 * 7.96494 128 * -0.0424814 184 * -0.363 Hill J.,Espaa,
73 * -3.63 129 * 0 185 * 1.05 1991.
74 * -0.586028 130 * 0 186 * 1
75 * 1.01246 131 * 0 187 * 1 [3] W. D Stevenson, Jr
76 * 4.37842e-006 132 * 0 188 * 1.1 Sistemas
77 * 0 133 * 1 189 * 0 Elctricos de
78 * -3.63 134 * 0 190 * 0 Potencia
79 * 3.63 135 * -0.0319831 191 * 0 .,Mxico.
80 * 0 136 * 0 192 * 0
81 * 4.81627e-006 137 * 0
82 * 1.4011e-005 138 * 0 APENDICE
83 * -1.08999 139 * 0 A continuacin se
84 * 0.586028 140 * 0 5. CONCLUSIONES proporciona el cdigo
85 * 0 141 * 1 fuente en C++ desarrollo
86 * 4.63086 142 * -0.120985 Se ha realizado el por autor
87 * -2.35045 143 Jacobiano programa de flujo de
88 * 0 Ordenado1 * carga utilizando una FLUJONET1.CPP
89 * 0.586028 143 * 4.87256 sola matriz
90 * -1.06246 144 * -2.35045 unidimensional, al // flujo.cpp : Defines the entry
91 * -4.81627e-006 145 * 0 agrupar todas las point for the console
92 * -2.35045 146 * 1.04822 matrices en al matriz application.
93 * 7.1822 147 * -0.586028 unidimensional se ha // Programa Elaborado Por
94 * -3.3 148 * 0 establecido el orden de Ing. Jess Solrzano M CIP
95 * 0 149 * -0.529115 la matriz conociendo 61996
96 * -4.81627e-006 150 * -2.35045 el nmero de barras y // solo utiliza la matriz
97 * 4.81627e-006 151 * 7.96494 permitiendo optimizar unidimencioanl Z[] para toda el
98 * 0 152 * -3.63 el nmero de Programa
99 * -3.63 153 * -0.586028 variables. // archivo de Datos "datos.txt"
100 * 3.96 154 * 1.01246 Se ha mejora la // archivo de salida ""
101 Resultados de la 155 * 4.37842e-006 reserva dinmica de salidasJES.txt"
Iteracin 1 * 156 * -0.275004 memoria se hace en
101 * 1 157 * 0 tiempo de ejecucin, #include <iostream.h>
6/8
#include <math.h> //---------------------- //--------------------------------------- Z[F+U*MM-MM+W+E]= B;
#include <wtypes.h> I=0; -------- Z[F+(U+W)* MM-MM+E]= C;
#include <stdio.h> while ( I < FFF-2*N*N - while (J<N) Z[F+(U+W)*MM-MM+W+E]=
#define PI 3.14159 8*N) { J++; D;
#include <fstream.h> // { I++; //------------------------------bucle if }
Biblioteca para el manejo de if (I==J ) // Calculo de los }
ficheros Z[FF+I]=0; elementos Diagonales H, N, J, }
} L // Ordenamiento de la Matriz
int main(int argc, char* argv[], //--------------------------------------- { X =0; Y=0; L=0; para la solucin de Gauss
double Z[200]) -------------- //--------------------------------------- // MM=2*(N-1)
// Calculo de las Potencias en -------- I=0;
{ cada Barra // calcula Vq sumatoria Ypq while (I<MM)
double A, B, C, D, X, Y, P, Q, I= 0; while (L < N) {I++;
T, R, S, DD ; while ( I<N) { L++; J=0;
int N, I, J, L, M, MM, F, W, U, { I++; if (L !=I ) while (J<MM)
E, M1,FF,LL, L1, FFF, H, K, X = 0; Y=0; { T = - Z[N*N + N*I-N + L] + Z[ { J++; Z[FF+J+I*L1-L1]=
ITER ; J=0; 2*N*N +N +J] - Z[ 2*N*N +N Z[F+J+I*MM-MM];}
// Lee fichero de ingreso de // Calculo de las potencias por +L]; Z[FF+L1*I]= 0;
datos Barra R = Z[2*N*N+L]*Z[N*J-N+L]; }
//--------------------------------------- while ( J<N) X= X + R*sin(T*PI/180); // Asignado los valores del
---------- { J++; Y= Y + R*cos(T*PI/180); Delta de Potencia
ifstream T = - Z[N*N + N*I-N + J] + Z[ }} I=0;
fichinput("datos.txt",ios::in); 2*N*N +N +I] - Z[ 2*N*N +N while (I<N-1) // Asignacin
if (!fichinput) +J]; //--------------------------------------- de los deltas
cout << "\n Incapaz de crear R = Z[ 2*N*N+J]*Z[N*I-N+J]; ------------ { I++ ; Z[FF+L1*(I)]=
este fichero \n"; X= X + R* cos(T*PI/180); A= - Z[2*N*N+I]*X; B=Y; Z[2*N*N+6*N+I+1] ;
else { Y= Y+ R* sin(T*PI/180); C= Z[2*N*N+I]*Y; D=X; Z[FF+L1*(N+I-1)]=
I=0; P= Z[2*N*N +I]*X; B= B+ 2*Z[2*N*N+I]*Z[N*I- Z[2*N*N+7*N+I+1];}
// Lectura del Numero de Q= Z[2*N*N +I]*Y; N+I]*(cos((Z[N*N+I*N- // Guardando los valores del
Barras Z[2*N*N+4*N+I]=P; N+I]*PI)/180)); Jacobiano
fichinput >> I >> N; Z[2*N*N+5*N+I]=Q; D= D+ 2*Z[2*N*N+I]*Z[N*I- Ordenado----------------------------
while ( I < 2*N*N+4*N ) } N+I]*(sin(-(Z[N*N+I*N- ---------------------------------
{ I++; // Calculo del deltas de N+I]*PI)/180)); I=0;
fichinput >> I >> Z[I] ; Potencia Activa y Reactiva U= I-1; while (I<LL)
} I=1; E= J-1; {I++;
fichinput.close();} while (I<N) Z[F+U*MM-MM+E]= A; Z[FFF+I]=Z[FF+I];
/////////////////////////////////////77 { I++; Z[F+U*MM-MM+W+E]= B; }
// iniciar a Cero las Variables Z[2*N*N+6*N+I]=Z[2*N*N+2*N Z[F+(U+W)* MM-MM+E]= C; // gauss sidell
I=2*N*N+4*N; +I]-Z[2*N*N+4*N+I]; Z[F+(U+W)*MM-MM+W+E]= K=0;
while (I < 2*N*N+8*N) D; while ( K< MM)
{I++; Z[2*N*N+7*N+I]=Z[2*N*N+3*N } { K++;
Z[I]=0; +I]-Z[2*N*N+5*N+I];} //------------------------------------- DD= Z[FF+K*L1-L1+K];
} //--------------------------------------- cierra bucle if J=0;
I=0; ------------------------------------ else while ( J<L1)
// Inicio de la Iteracin // Calculo del Jacobiano {T = - Z[N*N + N*I-N + J] + Z[ { J++;
ITER=0; MM= 2*(N-1); // Orden del 2*N*N +N +I] - Z[ 2*N*N +N Z[FF+K*L1-L1+J] =
while (ITER<10) Jacobiano +J]; Z[FF+K*L1-L1+J]/DD; }
{ R= I=0;
ITER++; F= 2*N*N+8*N; // Ubicacin Z[2*N*N+I]*Z[2*N*N+J]*Z[N*I- while ( I<MM)
// Jacobiano (solo barras pq) del inicio del Jacobiano N+J]; { I++;
4*(N-1)*(N-1) W= N-1; // Orden de las S= Z[2*N*N+I]*Z[N*I-N+J]; H=I-K;
FF = 2*N*N+8*N+4*(N-1)*(N- Submatrices H, N, J, L A= R* sin(T*PI/180); //---------------------------------------
1); A=0; B=0; C=0; D= 0; B= S* cos(T*PI/180); -----
LL = 2*(N-1)*(2*(N-1)+1); I=1; // la Barra de Carga es la C= -R*cos(T*PI/180); if ( I != K)
L1= 2*(N-1)+1; Barra 1 D= S* sin(T*PI/180); { DD=Z[FF+I*L1-L1+K];
FFF= FF+LL; while (I<N) U= I-1; J=0;
// Iniciar a cero las variables { I++; E= J-1; while ( J<L1)
del Jacobiano J=1; Z[F+U*MM-MM+E]= A; { J++;
7/8
 Z[FF+I*L1-L1+J]=Z[FF+I*L1- if (I==2*N*N+2*N+1) { fichout
L1+J]-Z[FF+K*L1-L1+J]*DD; << "*" << " Potencia Activa por
} Barra " << "*" << " " << endl;}
} if (I==2*N*N+3*N+1) { fichout
} << "*" << " Potencia Reactiva
//--------------------------------------- por Barra " << "*" << " " <<
---- endl;}
} if (I==2*N*N+4*N+1) { fichout
// Correccin de Voltajes y << "*" << " Potencia Activa
Angulos Calculada por Barra " << "*" <<
if (ITER < 2) " " << endl;}
{I=0; if (I==2*N*N+5*N+1) { fichout
while (I<N) << "*" << " Potencia Reactiva
{I++; Z[FFF+LL+I]= Calculada por Barra " << "*" <<
Z[2*N*N+I]; " " << endl;}
Z[FFF+LL+I+N]= if (I==2*N*N+6*N+1) { fichout
Z[2*N*N+N+I];} << "*" << " Delta de Potencia
} Activa Calculada por Barra "
I=0; << "*" << " " << endl;}
while (I< N-1) if (I==2*N*N+7*N+1) { fichout
{I++; << "*" << " Delta de Potencia
Z[2*N*N+I+1]=Z[2*N*N+I+1]+Z Reactiva Calculada por Barra "
[FF+L1*(N+I-1)]; << "*" << " " << endl;}
Z[2*N*N+N+I+1]=Z[2*N*N+N+I if (I==2*N*N+8*N+1)
+1]+(Z[FF+L1*I])*180/PI;} { fichout << "*" << " Jacobiano
} " << "*" << " " << endl;}
// crea fichero de salida de if (I==FF+1) { fichout << I << "
datos Resultados de la Iteracin 1 "
//--------------------------------------- << "*" << " " << endl;}
---------- if (I==FFF+1) { fichout << I <<
ofstream " Jacobiano Ordenado1 " <<
fichout("SalidaJES.TXT",ios::o "*" << " " << endl;}
ut); fichout << I << " * " << Z[I] <<
if (!fichout) " " << endl;
cout << "\n Incapaz de crear }
este o abrir el fichero \n"; fichout.close();}
else { //---------------------------------------
I=0; ---------------------------
fichout << I << " Nmero de return 0;
Barras " << N << " " << endl; }
while ( I< FFF+LL+2*N)
{ I++;
if (I==1) { fichout << "*" << "
Matriz de Admitancia Modulos
" << "*" << " " << endl;}

if (I==N*N+1) { fichout << "*"

<< " Matriz de Admitancia
Angulos " << "*" << " " <<
endl;}
if (I==2*N*N+1) { fichout <<
"*" << " Voltaje de Barras
Modulos " << "*" << " " <<
endl;}
if (I==2*N*N+N+1) { fichout
<< "*" << " Voltaje de Barras
Angulos " << "*" << " " <<
endl;}
8/8