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
SG y SC Flujos de potencia compleja que
van desde la barra 1 a la barra 2 y
viceversa.

RESUMEN
En el presente articulo se elabora el programa de flujo de
carga aplicando una matriz unidimensional, se calcula el
numero de orden de la matriz unidimensional para todas las
submatrices se necesitan para el clculo del flujo de
potencia.
Se ha desarrollado el cdigo fuente en el lenguaje C++, para
la compilacin se ha utilizado el software libre DEV C++.
Se describen la tcnicas para utiliza las matrices
unidimensionales utilizando una formula propia del autor.
Para la aplicacin se ha tomado un sistema elctrico de 4
barras del Libro de Harper Pg. 165 Anlisis Moderno de
Sistemas Elctricos de Potencia, se compara los resultados.

Figura 1

Palabras Clave: Flujo de Carga cdigo fuente matrices

unidimensionales.
INTRODUCCIN
El clculo y anlisis del flujo de potencias en la red de
un Sistema Elctrico de Potencia (SEP) es uno de los
aspectos ms importantes de su comportamiento en rgimen
permanente. Consiste en determinar los flujos de potencia
activa y reactiva en cada lnea del sistema y las tensiones en
cada una de las barras, para ciertas condiciones
preestablecidas de operacin.
El anlisis del flujo de potencias (AFP) permite:
Programar las ampliaciones necesarias del SEP y determinar
su mejor modo de operacin, teniendo en cuenta posibles
nuevos consumos, nuevas lneas o nuevas centrales
generadoras.
Estudiar los efectos sobre la distribucin de potencias,
cuando se producen prdidas temporales de generacin o
circuitos de transmisin.
Ayudar a determinar los programas de despacho de carga
para obtener un funcionamiento ptimo.

1.

2.

S1 SG1 SC1 ( PG1 PC1 ) j (QG1 QC1 ) P1 jQ1

S 2 SG 2 SC 2 ( PG 2 PC 2 ) j (QG 2 QC 2 ) P2 jQ2
En la figura 2 la lnea L12 se ha representado por
su circuito nominal y donde:
Potencias complejas netas de las barra 1 y 2
respectivamente, representadas como fuentes
de potencia activa y reactiva, que corresponden
a la Potencia Generada menos la Potencia
Consumida.
Sistema elemental

PROGRAMACIN DE FLUJO DE CARGA DE

UN SISTEMA SIMPLE DE DOS BARRAS

FLUJO DE CARGA EN UN
BARRAS

SEP DE DOS

Figura 2
En la Figura 2
*

Considrese el SEP elemental de dos barras de

la Figura 1 y su circuito equivalente por fase
que se muestra en la figura

1/11

S1
*

V1

P1 jQ1
*

V1

Yi
V 1 V2
V1
2 RL jX L
*

S2
*

V2

P2 jQ2
*

V2

Yi
V 2 V1
V2
2 RL jX L
*

Estas ecuaciones, que relacionan las tensiones

con las potencias activas y reactivas, presentan
las siguientes caractersticas.
Son algebraicas y no lineales.
La frecuencia no aparece en forma explcita
porque se la supone constante.
El sistema de cuatro ecuaciones, tiene 12
variables en total: PG1, PG2, QG1, QG2, PC1, PC2,
QC1, QC2, V1, 1, V2, 2, por lo que no es
posible obtener una solucin para ninguna
de ellas a menos que se reduzca el nmero
de incgnitas, fijando de antemano algunas
variables.
En relacin a esto ltimo, una forma posible de
resolver el problema es la siguiente:
1 A partir de los datos del consumo suponer
conocidas e independientes del voltaje, las
potencias de las cargas PCi, QCi, con i = 1,2
n..
2 Fijar a priori dos variables de generacin P G2
y QG2 por ejemplo. No se pueden fijar las
cuatro variables de generacin debido a que
las prdidas en el sistema no son conocidas
inicialmente.
3 Fijar el mdulo y ngulo de la tensin en
barra 1; es decir; suponer conocidos V 1, 1.
En particular, puede tomarse esta tensin
como referencia, o sea, 1=0
En estas condiciones, el sistema de 4
ecuaciones (3.2) queda con slo 4 variables:
PG1, QG1, V2, 2.
3.

Representacin de una Barra p en un SEP

*

S P V P I P PP jQ P
*

IP

SP
*

PP * jQP
*

VP

VP

Ecuaciones del flujo de potencias

escribir:
*

I P (V p V q ) Ypq V p
*

*
i
pq

S pq V p I pq V p (V p V q ) Ypq V p
*

se puede

S qp Vq I qp V q (Vq V p ) Yqp V q

*
i
pq

*
*

) (Y pq

*
i
qp

Y i pq * 2 *
)V p V
2
*

Y i qp * 2 *
) (Y qp
)V q V q
2
2
*

Clculo de las tensiones de barras

Las ecuaciones anteriores indican claramente
que para resolver el problema del flujo de
potencias se requiere determinar previamente
las tensiones en todas las barras que
correspondan. Empleando el mtodo nodal de
resolucin de circuitos, en forma matricial, para
la red de un SEP de n barras se puede escribir:

PLANTEAMIENTO
MATEMTICO
DEL
PROBLEMA PARA UN SEP DE N BARRAS

Considrese una barra p cualquiera de un

sistema tal como se muestra en la Figura 3.5.
La potencia compleja neta, y la corriente
inyectada en la barra p, &estn relacionadas
por las siguientes ecuaciones, que constituyen
las ecuaciones de barras

2/11

I B VB YB

 I1
I
2

S1
*

V1
*

S2
*

V2

V1
V
2

Ip =

.
Vp

Y11
Y
21
.
.
Y p1
.

Yn1

Y12
Y22
.
Yp 2
.
Yn 2

P
H
Q M

H pq

Vn

. Y1 p
. Y2 p
.
.
. Ypp
.
.
. Ynp

.
.
.
.
.
.

M pq

Vp
*

Sn
*

Vn

Pp
Vq

Q p
q

L pq Vq

Q p
Vq

Se determinan los elementos de la matriz

Jacobiana como sigue:
Para p q
H pq V p (G sin pq B pq cos pq )Vq

Y11 V1 Y12 V2 .. Y1 pV p .. Y1n Vn

N pq V p (G cos pq B pq sin pq )Vq

M pq V p (Gco pq B pq sin pq )Vq

L pq V p (G sin pq B pq cos pq )Vq

Para p = q

Y21 V1 Y22 V2 .. Y2 pV p .. Y2 n Vn

H pp B ppV p Q p

Sp

Pp
q

N pq Vq

YIn
Y2 n
.

Ypn
.

Ynn

N
. V
L
V

N pp G ppV p Pp

Yp1 V1 Yp 2 V2 .. YppV p .. Ypn Vn

M pp G ppV p Pp
2

L pp B ppV p Q p

Yn1 V1 Yn 2 V2 .. YnpV p .. Ynn Vn

Este sistema de ecuaciones es similar al

obtenido en el problema elemental de 2 barras;
es decir; las ecuaciones son algebraicas y no
lineales, por lo tanto es necesario resolverlo
mediante
tcnicas
de
aproximaciones
sucesivas.
4. METODO NEWTON RAPSHON
El mtodo mas empleado para la solucin de
los Flujos de carga es el Mtodo de Newton
Rapshon

1 P
V J . Q

Una vez clculado el Jacobiano se obtiene los voltajes y

ngulos de las barras y se recalcula hasta reducir la
diferencia de la potencia especificada y la calculada
5.

PROGRAMACIN UTILIZANDO MATRIZ

UNIDIMENCIONAL
El problema de utilizar matrices bidimensionales es debido a
que no se conoce a priori el numero de barras del sistema a
calcular, en los programas de computacin es indispensable
definir el tamao de las matrices lo que conlleva especificar
nmeros altos de matrices ocasionando a sobredimensionar
la memoria dinmica de la PC.
Matrices Unidimensional
Una matriz unidimensional es una variable del tipo array y
es la unidad elemental de tamao indica el nmero de
elementos del array (o dimensin del mismo).
Ejemplo de matriz unidimencional en C++:
ndice

3/11

componente vacio vacio vaci vaci vaci vaci vaci Z[2,3]=Z[3*2-3+3]=Z[6]

Como se muestra en este ejemplo, la matriz unidimensional
en C++ empieza con el 0 como ndice del primer elemento.
En la memoria del ordenador, el compilador reservara una
direccin para cada una de las componentes (la variables
tipo double el tamao es 8 bytes en el caso de DEV C++),
Z(6)=48 Bits
Tipos de Variables Double y Ventajas de Conocer el
orden de la Matriz
Las variables de este tipo almacenan nmeros en formato de
coma flotante, mantisa y exponente, al igual que
float, pero usan mayor precisin. Son aptos para
variables de tipo real. Se usa este tipo en nmeros
grandes y tambin de gran precisin.
En el programa utiliza se utilizado el tipo double. La
respuesta es que C siempre ha estado orientado a la
economa de recursos, tanto en cuanto al uso de
memoria como al uso de procesador
La memoria esttica es memoria que se reserva en el
momento de la compilacin, antes de comenzar a
ejecutarse el programa. Por ejemplo, para una
resolucin de un sistema de ecuaciones lineales, la
memoria esttica se puede reservar con sentencias
del tipo:
double x[100], b[100];
El inconveniente de la reserva esttica es que la cantidad de
memoria se reserva siempre antes de conocer los
datos concretos del problema a resolver. Eso lleva a
reservar siempre un mximo de memoria que en la
mayor parte de las ocasiones no se va a necesitar. La
reserva esttica tampoco se adapta bien a la memoria
real disponible en el ordenador en que se est
ejecutando el programa.

Z[2,3]=Z[6]
CLCULO DE LA ORDEN DE LA MATRIZ
UNIDEMENCIONAL
Datos del Programa
Y = Modulo de Matriz de Admitancias Polar
= ngulos de Matriz de Admitancias Polar
V= Voltajes de Barras
= ngulos de Voltajes de Barras
Pesp
=
Potencia Activa Especificada por Barra
Cesp
=
Potencia Reactiva Especificada por Barra
Salida del Programa
P
Q
P
Q
J
JJ
J Orde
V0
0 =

Z i, j NxN Z N * i N j N 2

Potencia Activa Calculada Por Barra

Potencia Reactiva Calculada Por Barra
Delta de Potencia Activa
Delta de Potencia Reactiva
Jacobiano
Arreglo Jacobiano Ecuacin Gauss Sidel
Jacobiano ITER-1
Voltajes Iniciales
ngulos Iniciales

Se muestra la Longitud de la Matriz unidimensional en

funcin del Nmero de Barras
N*N N*N N N
Y

V Pesp Qesp

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

CONVERSIN DE MATRIZ BIDIMENSIONAL A

UNIDIMENCIONAL
Como la mayora de los algoritmos propuestos de la
literatura para los programas de flujo de carga utilizan
matrices bidimensionales es necesaria realizar una
conversin de ndices se realiza la siguiente igualdad
propuesta por el autor:

=
=
=
=
=
=
=
=

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

JJ

J Orde

V0 0

Sumando las rdenes de las submatrices el orden de la

matriz unidimensional para N barras es:
Orden= 14N2-10N+8
Se verifican el numero de orden en funcin del nmero de
barras Z[14N2-10N+8]

Ejemplos

1,1 1,2 1,3

Z 2,1 2, 2 2,3 = Z[ 1, 2. 3 ,4 , 5, 6, 7 ,8 ,9 ]

3,1 3,2 3,3

Barras
4
10
100

4/11

Orden

bits

192

1.536

1.308

10.464

139.008

1.112.064

200

558.008

4.464.064

500

3.495.008

27.960.064

1000

13.990.008

111.920.064

2000

55.980.008

447.840.064

4000

223.960.008

1.791.680.064

6000

503.940.008

4.031.520.064

Cuando se reserva memoria dinmicamente, es muy

importante liberar la memoria que ya no se necesita. De otra
forma los programas van creciendo a lo largo de una
ejecucin hasta agotar la memoria disponible
DIAGRAMA DE FLUJO DEL PROGRAMA

5/11

Z13
=0.
12
+j0
.5

Utilizando Software libre DEV C++ se ha podido correr

El programa para Z=[503940008], en Pentium 4 512 RAM

6.

CASO DE ESTUDIO SISTEMA DE 4 BARRAS

(Pag 165 Anlisis Moderno de Sistema elctricos de
Potencia Gilberto Harper ED Limusa -1981)
G
1

S2=0.55+j0.1
3

V1=1.05
0
Z12=0.08+j0.4

Z23=0.1+j0.4
Z34=j0.3
3

S3=
0.3+j0.18

G
2

V=1.10
4 0

El ingreso de datos se realiza en el archivo datos.txt

Se ingresa los datos a un archivo txt
0 4 // numero de barras
1 Matriz de admitancias
2
.
10 .Voltajes prefijados
.
15 Potencia Activa especificada
20 Potencia Reactiva especificada.

15 3.3
16 3.3
17 -77.7
18 101.3
19 103.5
20 0
21 101.3
22 -77.32
23 104
24 0
25 103.5
26 104
27 -82.2
28 90
29 0
30 0
31 90
32 -90
33 1.05
34 1
35 1
36 1.1
37 0
38 0
39 0
40 0
41 0
42 -0.55
43 -0.3
44 0.5
45 0
46 -0.13
47 -0.18
48 0

Salida Archivo salidasjes.txt Para la primera

Iteracin

Archivo datos.txt

0 Nmero de Barras 4
* Matriz de Admitancia Mdulos *
1 * 4.3924
2 * 2.4495
3 * 1.9437
4*0
5 * 2.4495
6 * 4.8705
7 * 2.4224
8*0
9 * 1.9437
10 * 2.4224
11 * 7.6443
12 * 3.3
13 * 0
14 * 0
15 * 3.3

04
1 4.3924
2 2.4495
3 1.9437
40
5 2.4495
6 4.8705
7 2.4224
8 0
9 1.9437
10 2.4224
11 7.6443
12 3.3
13 0
14 0

6/11

16 * 3.3
* Matriz de Admitancia ngulos *
17 * -77.7
18 * 101.3
19 * 103.5
20 * 0
21 * 101.3
22 * -77.32
23 * 104
24 * 0
25 * 103.5
26 * 104
27 * -82.2
28 * 90
29 * 0
30 * 0
31 * 90
32 * -90
* Voltaje de Barras Mdulos *
33 * 1.05
34 * 0.957519
35 * 0.968017
36 * 0.979015
* Voltaje de Barras ngulos *
37 * 0
38 * -6.0077
39 * -0.184768
40 * 7.70709
* Potencia Activa por Barra *
41 * 0
42 * -0.55
43 * -0.3
44 * 0.5
* Potencia Reactiva por Barra *
45 * 0
46 * -0.13
47 * -0.18
48 * 0
* Potencia Activa Calculada por Barra *
49 * 0.0512339
50 * -0.0208851
51 * -0.0249956
52 * 1.01142e-005
* Potencia Reactiva Calculada por Barra *
53 * 0.224847
54 * -0.120849
55 * -0.391369
56 * 0.363
* Delta de Potencia Activa Calculada por Barra *
57 * 0
58 * -0.529115
59 * -0.275004
60 * 0.49999
* Delta de Potencia Reactiva Calculada por Barra *
61 * 0
62 * -0.00915085

63 * 0.211369
64 * -0.363
* Jacobiano *
65 * 4.87256
66 * -2.35045
67 * 0
68 * 1.04822
69 * -0.586028
70 * 0
71 * -2.35045
72 * 7.96494
73 * -3.63
74 * -0.586028
75 * 1.01246
76 * 4.37842e-006
77 * 0
78 * -3.63
79 * 3.63
80 * 0
81 * 4.81627e-006
82 * 1.4011e-005
83 * -1.08999
84 * 0.586028
85 * 0
86 * 4.63086
87 * -2.35045
88 * 0
89 * 0.586028
90 * -1.06246
91 * -4.81627e-006
92 * -2.35045
93 * 7.1822
94 * -3.3
95 * 0
96 * -4.81627e-006
97 * 4.81627e-006
98 * 0
99 * -3.63
100 * 3.96
101 Resultados de la Iteracin 1 *
101 * 1
102 * 0
103 * 0
104 * 0
105 * 0
106 * 0
107 * -0.104854
108 * 0
109 * 1
110 * 0
111 * 0
112 * 0
113 * 0
114 * -0.0032248
115 * 0
116 * 0

7/11

117 * 1
118 * 0
119 * 0
120 * 0
121 * 0.134514
122 * 0
123 * 0
124 * 0
125 * 1
126 * 0
127 * 0
128 * -0.0424814
129 * 0
130 * 0
131 * 0
132 * 0
133 * 1
134 * 0
135 * -0.0319831
136 * 0
137 * 0
138 * 0
139 * 0
140 * 0
141 * 1
142 * -0.120985
143 Jacobiano Ordenado1 *
143 * 4.87256
144 * -2.35045
145 * 0
146 * 1.04822
147 * -0.586028
148 * 0
149 * -0.529115
150 * -2.35045
151 * 7.96494
152 * -3.63
153 * -0.586028
154 * 1.01246
155 * 4.37842e-006
156 * -0.275004
157 * 0
158 * -3.63
159 * 3.63
160 * 0
161 * 4.81627e-006
162 * 1.4011e-005
163 * 0.49999
164 * -1.08999
165 * 0.586028
166 * 0
167 * 4.63086
168 * -2.35045
169 * 0
170 * -0.00915085
171 * 0.586028

172 * -1.06246
173 * -4.81627e-006
174 * -2.35045
175 * 7.1822
176 * -3.3
177 * 0.211369
178 * 0
179 * -4.81627e-006
180 * 4.81627e-006
181 * 0
182 * -3.63
183 * 3.96
184 * -0.363
185 * 1.05
186 * 1
187 * 1
188 * 1.1
189 * 0
190 * 0
191 * 0
192 * 0

5.

CONCLUSIONES
Se ha realizado el programa de flujo de carga
utilizando una sola matriz unidimensional, al agrupar
todas las matrices en al matriz unidimensional se ha
establecido el orden de la matriz conociendo el
nmero de barras y permitiendo optimizar el nmero
de variables.
Se ha mejora la reserva dinmica de memoria se hace
en tiempo de ejecucin, despus de leer los datos y de
conocer el tamao exacto del problema a resolver.
Como consecuencia, la reserva dinmica de memoria
se adapta mucho mejor a las necesidades de cada caso.
Como contrapartida, es algo ms difcil de programar.
REFERENCIAS

[1]

Gilberto Enrquez Harper , Anlisis Moderno de

Sistemas elctricos de Potencia, ED Limusa.,
Mxico.

[2]

Luis Joyanes Aguilar C++ A su Alcance McGraw

Hill J.,Espaa, 1991.

[3]

W. D Stevenson, Jr Sistemas Elctricos de

Potencia .,Mxico.

APENDICE
A continuacin se proporciona el cdigo fuente en C++
desarrollo por autor

8/11

{ I++;

FLUJONET1.CPP
// flujo.cpp : Defines the entry point for the console application.
// Programa Elaborado Por Ing. Jess Solrzano M CIP 61996
// solo utiliza la matriz unidimencioanl Z[] para toda el Programa
// archivo de Datos "datos.txt"
// archivo de salida "" salidasJES.txt"
#include <iostream.h>
#include <math.h>
#include <wtypes.h>
#include <stdio.h>
#define PI 3.14159
#include <fstream.h> // Biblioteca para el manejo de ficheros
int main(int argc, char* argv[], double Z[200])
{
double A, B, C, D, X, Y, P, Q, T, R, S, DD ;
int N, I, J, L, M, MM, F, W, U, E, M1,FF,LL, L1, FFF, H, K, ITER ;
// Lee fichero de ingreso de datos
//------------------------------------------------ifstream fichinput("datos.txt",ios::in);
if (!fichinput)
cout << "\n Incapaz de crear este fichero \n";
else {
I=0;
// Lectura del Numero de Barras
fichinput >> I >> N;
while ( I < 2*N*N+4*N )
{ I++;
fichinput >> I >> Z[I] ;
}
fichinput.close();}
/////////////////////////////////////77
// iniciar a Cero las Variables
I=2*N*N+4*N;
while (I < 2*N*N+8*N)
{I++;
Z[I]=0;
}
I=0;
// Inicio de la Iteracin
ITER=0;
while (ITER<10)
{
ITER++;
// Jacobiano (solo barras pq) 4*(N-1)*(N-1)
FF = 2*N*N+8*N+4*(N-1)*(N-1);
LL = 2*(N-1)*(2*(N-1)+1);
L1= 2*(N-1)+1;
FFF= FF+LL;
// Iniciar a cero las variables del Jacobiano
//---------------------I=0;
while ( I < FFF-2*N*N - 8*N)

Z[FF+I]=0;
}
//----------------------------------------------------// Calculo de las Potencias en cada Barra
I= 0;
while ( I<N)
{ I++;
X = 0; Y=0;
J=0;
// Calculo de las potencias por Barra
while ( J<N)
{ J++;
T = - Z[N*N + N*I-N + J] + Z[ 2*N*N +N +I] - Z[ 2*N*N +N +J];
R = Z[ 2*N*N+J]*Z[N*I-N+J];
X= X + R* cos(T*PI/180);
Y= Y+ R* sin(T*PI/180);
P= Z[2*N*N +I]*X;
Q= Z[2*N*N +I]*Y;
Z[2*N*N+4*N+I]=P;
Z[2*N*N+5*N+I]=Q;
}
// Calculo del deltas de Potencia Activa y Reactiva
I=1;
while (I<N)
{ I++; Z[2*N*N+6*N+I]=Z[2*N*N+2*N+I]-Z[2*N*N+4*N+I];
Z[2*N*N+7*N+I]=Z[2*N*N+3*N+I]-Z[2*N*N+5*N+I];}
//--------------------------------------------------------------------------// Calculo del Jacobiano
MM= 2*(N-1); // Orden del Jacobiano
F= 2*N*N+8*N; // Ubicacin del inicio del Jacobiano
W= N-1; // Orden de las Submatrices H, N, J, L
A=0; B=0; C=0; D= 0;
I=1; // la Barra de Carga es la Barra 1
while (I<N)
{ I++;
J=1;
//----------------------------------------------while (J<N)
{ J++;
//------------------------------bucle if
if (I==J ) // Calculo de los elementos Diagonales H, N, J, L
{
X =0; Y=0; L=0;
//----------------------------------------------// calcula Vq sumatoria Ypq
while (L < N)
{ L++;
if (L !=I )
{ T = - Z[N*N + N*I-N + L] + Z[ 2*N*N +N +J] - Z[ 2*N*N +N +L];
R = Z[2*N*N+L]*Z[N*J-N+L];
X= X + R*sin(T*PI/180);
Y= Y + R*cos(T*PI/180);
}}
//---------------------------------------------------

9/11

A= - Z[2*N*N+I]*X; B=Y;
C= Z[2*N*N+I]*Y; D=X;
B= B+ 2*Z[2*N*N+I]*Z[N*I-N+I]*(cos((Z[N*N+I*N-N+I]*PI)/180));
D= D+ 2*Z[2*N*N+I]*Z[N*I-N+I]*(sin(-(Z[N*N+I*N-N+I]*PI)/180));
U= I-1;
E= J-1;
Z[F+U*MM-MM+E]= A;
Z[F+U*MM-MM+W+E]= B;
Z[F+(U+W)* MM-MM+E]= C;
Z[F+(U+W)*MM-MM+W+E]= D;
}
//------------------------------------- cierra bucle if
else
{T = - Z[N*N + N*I-N + J] + Z[ 2*N*N +N +I] - Z[ 2*N*N +N +J];
R = Z[2*N*N+I]*Z[2*N*N+J]*Z[N*I-N+J];
S= Z[2*N*N+I]*Z[N*I-N+J];
A= R* sin(T*PI/180);
B= S* cos(T*PI/180);
C= -R*cos(T*PI/180);
D= S* sin(T*PI/180);
U= I-1;
E= J-1;
Z[F+U*MM-MM+E]= A;
Z[F+U*MM-MM+W+E]= B;
Z[F+(U+W)* MM-MM+E]= C;
Z[F+(U+W)*MM-MM+W+E]= D;
}
}
}
// Ordenamiento de la Matriz para la solucin de Gauss
// MM=2*(N-1)
I=0;
while (I<MM)
{I++;
J=0;
while (J<MM)
{ J++; Z[FF+J+I*L1-L1]= Z[F+J+I*MM-MM];}
Z[FF+L1*I]= 0;
}
// Asignado los valores del Delta de Potencia
I=0;
while (I<N-1) // Asignacin de los deltas
{ I++ ; Z[FF+L1*(I)]= Z[2*N*N+6*N+I+1] ;
Z[FF+L1*(N+I-1)]= Z[2*N*N+7*N+I+1];}
// Guardando los valores del Jacobiano
Ordenado------------------------------------------------------------I=0;
while (I<LL)
{I++;
Z[FFF+I]=Z[FF+I];
}
// gauss sidell
K=0;
while ( K< MM)
{ K++;
DD= Z[FF+K*L1-L1+K];

J=0;
while ( J<L1)
{ J++;
Z[FF+K*L1-L1+J] = Z[FF+K*L1-L1+J]/DD; }
I=0;
while ( I<MM)
{ I++;
H=I-K;
//-------------------------------------------if ( I != K)
{ DD=Z[FF+I*L1-L1+K];
J=0;
while ( J<L1)
{ J++;
Z[FF+I*L1-L1+J]=Z[FF+I*L1-L1+J]-Z[FF+K*L1-L1+J]*DD;
}
}
}
//------------------------------------------}
// Correccin de Voltajes y Angulos
if (ITER < 2)
{I=0;
while (I<N)
{I++; Z[FFF+LL+I]= Z[2*N*N+I];
Z[FFF+LL+I+N]= Z[2*N*N+N+I];}
}
I=0;
while (I< N-1)
{I++;
Z[2*N*N+I+1]=Z[2*N*N+I+1]+Z[FF+L1*(N+I-1)];
Z[2*N*N+N+I+1]=Z[2*N*N+N+I+1]+(Z[FF+L1*I])*180/PI;}
}
// crea fichero de salida de datos
//------------------------------------------------ofstream fichout("SalidaJES.TXT",ios::out);
if (!fichout)
cout << "\n Incapaz de crear este o abrir el fichero \n";
else {
I=0;
fichout << I << " Nmero de 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;}
if (I==2*N*N+2*N+1) { fichout << "*" << " Potencia Activa por Barra
" << "*" << " " << endl;}
if (I==2*N*N+3*N+1) { fichout << "*" << " Potencia Reactiva por
Barra " << "*" << " " << endl;}

10/11

if (I==2*N*N+4*N+1) { fichout << "*" << " Potencia Activa

Calculada por Barra " << "*" << " " << endl;}
if (I==2*N*N+5*N+1) { fichout << "*" << " Potencia Reactiva
Calculada por Barra " << "*" << " " << endl;}
if (I==2*N*N+6*N+1) { fichout << "*" << " Delta de Potencia Activa
Calculada por Barra " << "*" << " " << endl;}
if (I==2*N*N+7*N+1) { fichout << "*" << " Delta de Potencia
Reactiva Calculada por Barra " << "*" << " " << endl;}
if (I==2*N*N+8*N+1) { fichout << "*" << " Jacobiano " << "*" << "
" << endl;}
if (I==FF+1) { fichout << I << " Resultados de la Iteracin 1 " <<
"*" << " " << endl;}
if (I==FFF+1) { fichout << I << " Jacobiano Ordenado1 " << "*" <<
" " << endl;}
fichout << I << " * " << Z[I] << " " << endl;
}
fichout.close();}
//-----------------------------------------------------------------return 0;
}

11/11