UFF- Universidade Federal Fluminense

Aplicação de Computares em Sistemas Elétricos

Professor: Carlos Henrique Costa Guimarães

FLUXO DE POTÊNCIA EM REDES

ELÉTRICAS

GRUPO: Marcelo Antonio Ramos Leite

Pedro Luiz Dias Júnior

Ricardo Bittar Peçanha Guia

1/2009
Introdução

O fluxo de cargas em redes elétricas, também conhecido como fluxo de potência ou

LoadFlow serve como base para diversos tipos de estudos. Seu objetivo é a solução da rede
elétrica trifásica equilibrada, em regime permanente, sob determinadas condições de
operação, isto é, sendo conhecidos os parâmetros da rede, as potências ativas geradas nas
usinas (despacho de potência ativa) e as cargas (consumo), determinam-se as tensões (módulo
e ângulo), os fluxos de potência ativa e reativa em cada ramo e as potências reativas geradas
nas usinas (despacho de potência reativa).

Os componentes de um sistema de energia elétrica podem ser classificados em dois

grupos:

- Componentes internos, tais como linhas de transmissão, transformadores, reatores e

capacitores, modelados por equações algébricas que representam o fluxo de potência entre
dois nós da rede elétrica;

- Componentes externos, tais como geradores e cargas, esses modelam as injeções de

potência nos nós da rede.

O problema de Fluxo de Carga em redes elétricas pode ser formulado de várias

maneiras, porém a mais utilizada pelos programas computacionais é a que utiliza a formulação
nodal na qual no equacionamento é feito através da lei de Kirchhoff dos nós, onde o somatório
das correntes em um nó é igual a zero, ou seja, a potência líquida injetada em cada nó da rede
elétrica deve ser igual à soma das potências injetadas por todos os componentes internos
ligados a este nó. Isto garante a conservação das potências ativa e reativa em cada nó da rede.

Esta formulação é a mais utilizada por ter inúmeras vantagens sobre as outras:
apresentam menor tempo de solução e menores requisitos de memória, pois utiliza a matriz
de admitância nodal que normalmente é bastante esparsa simétrica, sendo necessário o
armazenamento apenas dos elementos não-nulos acima da diagonal, além dos próprios
elementos da diagonal.

Observando o sistema elétrico, Verificamos que para cada barra da rede temos quatro
variáveis:

θi → ângulo da tensão na barra i

Vi → módulo da tensão na barra i

Pi → potência ativa injetada na barra i

Qi → potência reativa injetada na barra i

Nos problemas de fluxo de potência, mais especificamente nas barras do sistema

elétrico, duas variáveis possuem seu valor conhecido e duas outras são incógnitas.
Dependendo das variáveis que são especificadas podemos obter os seguintes tipos de barras:

Barra do tipo PQ

Nessas barras são especificadas as potências ativa Pi e a reativa Qi injetadas. Também

conhecidas como barra de carga, pois a potências ativa e reativa injetadas são conhecidas,
sendo iguais às potências ativa e reativa da carga com sinal trocado. O módulo da tensão Vi e o
ângulo da tensão θi são calculados.

Barra do tipo PV

Nessas barras são especificadas as potências ativas injetadas Pi e o módulo da tensão

Vi. Também conhecida como barra de geração, pois o despacho de potência ativa e a tensão
terminal podem ser controlados através de reguladores de velocidade que atuam no torque da
turbina para despachar mais ou menos potência elétrica e através de reguladores de tensão
que atuam na corrente de campo do gerador para aumentar ou diminuir o valor da tensão
nominal. A potência reativa injetada na barra Qi e o ângulo de tensão na barra θi são
calculados.

Barra do tipo Vθ:

Nessa barra é especificado o módulo da tensão Vi e o ângulo θi. Também conhecida

como barra slack ou swing. Normalmente se arbitra como barra slack uma das barras de
geração, sendo a candidata de maior capacidade instalada. A escolha desta barra deve atender
ao critério de proximidade do centro elétrico do sistema. O ângulo de tensão desta barra é que
serve como referência para o ângulo de tensão das outras barras.

Além desses valores devemos conhecer também os parâmetros das linhas de

transmissão sendo representados por um modelo Π equivalente:

Parâmetros longitudinais
+
+

São as resistências (R) e as reatâncias (X) conectadas entre dois nós do sistema (i e j).
Parâmetros transversais

+
+
São as admitâncias (Y) conectadas entre um nó do sistema (i) e à terra.

O objetivo deste trabalho é elaborar um programa computacional para calcular o fluxo

de potência da rede elétrica da figura abaixo, utilizando o método de Newton-Raphson.

Método de Newton-Raphson

O método de Newton-Raphson se baseia em séries de potências:

∞
f ( x) = ∑ C n .( x − x0 ) = C0 + C1.∆x1 + C2 .∆x 2 + ... + Cn .∆x n
n =0

Quando os coeficientes Cn assumem os valores da série abaixo, a série de potências se

transforma em uma Série de Taylor:
 f ' ( x0 ) f ' ' ( x0 ) f n ( x0 )
C0 = f ( x0 ); C1 = ; C2 = ;...; Cn =
1! 2! n!

Ou seja:

f ' ( x0 ) f ' ' ( x0 ) 2 f n ( x0 ) n

f ( x ) = f ( x0 ) + .∆x + .∆x + ... + .∆x
1! 2! n!

Para a aplicação em fluxo de potência, os termos de ordem superior a um podem ser

desprezados, pois possuem valores próximos a zero.

Assim, a equação pode ser reescrita da seguinte forma:

y = f ( x) = f ( x0 ) + f ' ( x0 ).∆x

A resolução deste problema é feita por um método iterativo, onde o resultado de cada
iteração será o dado de entrada para a próxima iteração. Assim, a equação pode ser reescrita
na forma matricial para a primeira iteração como:

y − f ( x) = J ( x).∆x 0

Onde J(x) é a matriz Jacobiano.

Analogamente, para a iteração ν tem-se:

y − f ( x v ) = J ( x v ).∆x v

Finalmente, a solução do problema pode ser resumida como:

 ∆x v = J x v −1 x y − f x v
[ ( )] [ ( )]
 v +1
 x = x v + ∆x v

Para o problema de fluxo de potência, tem-se que:

 ∆P   P esp − P calc 
[ v
]
y − f ( x ) =   =  esp calc 
∆Q  Q − Q 
 ∆θ 
∆x v =  
∆V 
Onde:

Pesp e Qesp → vetores das potências ativa e reativa líquidas especificadas no problema.

Pcalc e Qcalc → vetores das potências ativa e reativa líquidas calculadas por meio das equações.

θ e V → vetores dos ângulos e tensões nas barras do sistema.

Método aplicado ao sistema:

As equações obtidas são não-lineares, logo devemos atribuir um método de linearização

do sistema para facilitar os cálculos.

O método utilizado consiste então em fazer essa linearização como segue:

J ∆x = − f

Onde:

J → Jacobiano do sistema não-linear

∆x → correções a serem feitas nas variáveis de estado (vetor de desvios)

F → funções que formam o sistema

Normalmente se utiliza o método da triangularização (eliminação de Gauss) para resolver o

sistema linearizado. Com as correções encontradas, calcula-se x=x+∆x para corrigir o vetor de
variáveis de estado. A partir daí, deve-se formar novamente o sistema linearizado e corrigir
novamente o vetor de variáveis de estado, e assim sucessivamente, até que se obtenha o valor
da solução do sistema a menos de uma tolerância dada.

Matriz YP e YBUS

Matriz Yp

A matriz de admitâncias primitivas Yp, é a matriz onde os elementos da diagonal

principal são as admitâncias entre cada nó e a terra, ou seja, as admitâncias transversais e os
elementos fora da diagonal principal são as admitâncias entre os nós, ou seja, as admitâncias
longitudinais.

 y11 y12 0 y14 0 

y y 22 y23 y24 0 
 21
YP =  0 y32 y33 0 y35 
 
 y41 y 42 0 y44 y45 
 0 0 y53 y54 y55 

Por exemplo, y22 é a admitância resultante entre o nó 2 e a terra.

Matriz Ybus

Na matriz Ybus os elementos da diagonal principal são a soma de todas as admitâncias

ligadas a cada nó, ou seja, a soma dos elementos da linha equivalente em Yp e os elementos
fora da diagonal principal são os mesmos elementos fora da diagonal da matriz Yp com o sinal
invertido.

y11+ y12 + y14 − y12 0 − y14 0 

 −y y21 + y22 + y23 + y24 − y23 − y24 0 
 21 
Ybus =  0 − y32 y32 + y33 + y35 0 − y35 
 
 − y41 − y42 0 y41 + y42 + y44 + y45 − y45 
 0 0 − y53 − y54 y53 + y54 + y55

Se temos um sistema com n barras, podemos afirmar que as variáveis de estado são os
módulos das tensões das barras do tipo PQ e os ângulos das barras do tipo PV e PQ. As
equações que podemos escrever para solucionar os sistemas são os somatórios de potências
ativas das barras tipos PV e PQ e os somatórios das potências reativas das barras do tipo PQ.
Desta forma, a dimensão do sistema não-linear a ser resolvido é dada pelo número de
equações ou pelo número de variáveis de estado do sistema, pois os dois tem que ser iguais
para que o sistema seja determinado.

A matriz Jacobiano (J) possui dimensão definida pela seguinte expressão:

 N=2NBPQ+ NBPV

Onde,

NBPQ → número de barras tipo PQ

NBPV → número de barras tipo PV

O número de variáveis de estado do sistema é dado pela mesma equação, pois para as
barras do tipo PQ tem-se duas variáveis de estado (módulo da tensão e ângulo da tensão) e
para as barras do tipo PV tem-se apenas uma variável de estado (ângulo da tensão).

A matriz Jacobiano (J) fica dividida em quatro submatrizes: H, N, J e L, como

representada na figura abaixo:

 
 H M N   ∆θ   ∆P 
K M K  K  =  K 
    
 J M L   ∆V   ∆Q 
 
V 

Os elementos das submatrizes são definidos como segue:

Para i≠k

i k (Gik sin θik − Bik cos θik )

H ik = VV

i k (Gik sin θ ik − Bik cos θ ik )

Lik = VV

i k (Gik cos θ ik + Bik sin θ ik )

N ik = VV

i k (Gik cos θ ik + Bik sin θ ik )

J ik = −VV

Onde Gik e Bik , são retiradas da Ybus.

Para i=k

H ii = −Vi 2 Bii − Qi

N ii = +Vi 2 Gii + Pi
J ii = −Vi 2 Gii + Pi

Lii = +Vi 2 Bii + Qi

Onde Gii e Bii , são retiradas da Ybus.

Para isso temos:

θik → θi-θk

Pi → Pg (i)-Pl (i)

Qi → Qg (i)-Ql (i)

Pg → potência ativa de geração

Qg → potência reativa de geração

Pl → potência ativa da carga

Ql → potência reativa da carga

Cálculos:

Com o sistema convergido podemos calcular:

Fluxos nas linhas:

( )
Pik = Vi 2 . g ik + g ik -ViVk .( g ik . cos θik + bik sen θik )

( )
Qik = −Vi 2 . bik + bik -ViVk .( g ik .sen θik − bik cos θik )

Onde,

g ik → representa o efeito das perdas por condutância direta para a terra nas cadeias de

isoladores e também as perdas por efeito corona;

g ik → representa a condutância dos cabos utilizados na linha;

bik → representa o efeito capacitivo da linha;

bik → representa o efeito eletromagnético gerado pela linha.

Potências ativa e reativa geradas nas barras de geração:

Barra 2:

Potência ativa

PG 2 = P21 + P23 + P25 + PL2

Potência Reativa

QG 2 = Q21 + Q23 + Q25 + Q L2

Barra 4:

Potência ativa

PG 4 = 2 pu

Potência Reativa

QG 4 = Q42 + Q43 + Q L 4

Perdas Totais do sistema:

Perda ativa = PG 2 + PG 4 − PL1 − PL 2 − PL 3 − PL 4 − PL 5

Perda reativa = QG 2 + QG 4 − QL1 − QL 2 − QL 3 − Q L 4 − QL 5

Conclusão:

Podemos concluir através deste relatório que o método de Newton-Raphson é um método

eficiente na implantação de programas computacionais para resolver fluxo de potência em
sistemas elétricos.
Resultados:

O programa imprime a solução do problema de fluxo de potência em um arquivo de texto

chamado “resultados.txt”. Seu conteúdo pode ser visto abaixo:

Matriz Yp:
( 0.00, 0.23) ( 0.99, -9.90) ( 0.00, 0.00) ( 0.46, -5.52) ( 0.00, 0.00)
( 0.99, -9.90) ( 0.00, 0.22) ( 0.78,-12.45) ( 0.74,-11.06) ( 0.00, 0.00)
( 0.00, 0.00) ( 0.78,-12.45) ( 0.00, 0.22) ( 0.00, 0.00) ( 0.55, -8.30)
( 0.46, -5.52) ( 0.74,-11.06) ( 0.00, 0.00) ( 0.00, 0.38) ( 0.80,-19.97)
( 0.00, 0.00) ( 0.00, 0.00) ( 0.55, -8.30) ( 0.80,-19.97) ( 0.00, 0.35)

Matriz Ybus:
( 1.45, -15.19) ( -0.99, 9.90) ( -0.00, -0.00) ( -0.46, 5.52) ( -0.00, -0.00)
( -0.99, 9.90) ( 2.51, -33.19) ( -0.78, 12.45) ( -0.74, 11.06) ( -0.00, -0.00)
( -0.00, -0.00) ( -0.78, 12.45) ( 1.33, -20.52) ( -0.00, -0.00) ( -0.55, 8.30)
( -0.46, 5.52) ( -0.74, 11.06) ( -0.00, -0.00) ( 2.00, -36.17) ( -0.80, 19.97)
( -0.00, -0.00) ( -0.00, -0.00) ( -0.55, 8.30) ( -0.80, 19.97) ( 1.35, -27.91)

Matriz Jacobiano:
16.27 -10.40 0.00 0.00 0.51 -0.00 -0.00
-10.54 28.59 -12.36 0.00 -0.03 1.21 -0.00
0.00 -12.11 14.56 -7.69 -0.01 -0.27 -0.48
0.00 0.00 -7.68 23.59 -0.01 -0.69 -1.99
-2.51 0.14 0.06 0.03 15.35 -0.00 0.00
-0.00 2.74 -2.04 -0.59 0.00 17.63 -7.80
-0.00 -0.00 0.54 -3.98 -0.00 -7.79 20.88

deltaX[0] : é[1] = -2.66ø

deltaX[1] : é[2] = 1.13ø
deltaX[2] : é[3] = -8.03ø
deltaX[3] : é[5] = -8.27ø
deltaX[4] : Vi[1] = 1.019
deltaX[5] : Vi[3] = 0.957
deltaX[6] : Vi[5] = 0.968

BARRA 1:
Modulo de Tensao = 1.019
Angulo = -2.66ø
P[1][2]= -71.24 MW \nQ[1][2]= -22.45 Mvar \nS[1][2]= 74.69MVA
P[1][4]= -28.76 MW \nQ[1][4]= -27.55 Mvar \nS[1][4]= 39.83MVA

BARRA 2:
Modulo de Tensao = 1.040
Angulo = 1.13ø
P[2][1]= 71.74 MW \nQ[2][1]= 6.28 Mvar \nS[2][1]= 72.02MVA
P[2][3]= 205.13 MW \nQ[2][3]= 102.76 Mvar \nS[2][3]= 229.43MVA
P[2][4]= 23.13 MW \nQ[2][4]= -18.27 Mvar \nS[2][4]= 29.48MVA
Potencia reativa gerada = 90.77 Mvar

BARRA 3:
Modulo de Tensao = 0.957
Angulo = -8.03ø
P[3][2]= -202.61 MW \nQ[3][2]= -77.53 Mvar \nS[3][2]= 216.94MVA
P[3][5]= 2.61 MW \nQ[3][5]= -22.47 Mvar \nS[3][5]= 22.62MVA

BARRA 4:
Modulo de Tensao = 1.050
Angulo = 0.00ø
P[4][1]= 28.91 MW \nQ[4][1]= 2.60 Mvar \nS[4][1]= 29.03MVA
P[4][2]= -23.09 MW \nQ[4][2]= 7.93 Mvar \nS[4][2]= 24.42MVA
P[4][5]= 299.62 MW \nQ[4][5]= 159.70 Mvar \nS[4][5]= 339.53MVA
Potencia ativa gerada = 305.44 MW
Potencia reativa gerada = 170.23 Mvar

BARRA 5:
Modulo de Tensao = 0.968
Angulo = -8.27ø
P[5][3]= -2.61 MW \nQ[5][3]= -5.21 Mvar \nS[5][3]= 5.83MVA
P[5][4]= -297.39 MW \nQ[5][4]= -144.79 Mvar \nS[5][4]= 330.77MVA

PERDAS TOTAIS DO SISTEMA:

Perda total ativa do sistema = 5.44 MW
Perda total reativa do sistema = -39.00 MVar

DADOS FINAIS DAS BARRAS:

_______________________

BARRA 1:
Modulo da Tensao(V)=1.02
Potencia Ativa(Pi)= -1.00
Potencia Reativa(Qi)= -0.50
Angulo da Tensao=-0.05 rad
Potencia Ativa Gerada(Pg)= 0.00
Potencia Reativa Gerada(Qg)= 0.00
Potencia Ativa Consumida(Pl)= 1.00
Potencia Reativa Consumida(Ql)= 0.50

BARRA 2:
Modulo da Tensao(V)=1.04
Potencia Ativa(Pi)= 3.00
Potencia Reativa(Qi)= 0.57
Angulo da Tensao=0.02 rad
Potencia Ativa Gerada(Pg)= 3.00
Potencia Reativa Gerada(Qg)= 0.91
Potencia Ativa Consumida(Pl)= 0.00
Potencia Reativa Consumida(Ql)= 0.00

BARRA 3:
Modulo da Tensao(V)=0.96
Potencia Ativa(Pi)= -2.00
Potencia Reativa(Qi)= -1.00
Angulo da Tensao=-0.14 rad
Potencia Ativa Gerada(Pg)= 0.00
Potencia Reativa Gerada(Qg)= 0.00
Potencia Ativa Consumida(Pl)= 2.00
Potencia Reativa Consumida(Ql)= 1.00

BARRA 4:
Modulo da Tensao(V)=1.05
Potencia Ativa(Pi)= 0.00
Potencia Reativa(Qi)= 0.00
Angulo da Tensao=0.00 rad
Potencia Ativa Gerada(Pg)= 3.05
Potencia Reativa Gerada(Qg)= 1.70
Potencia Ativa Consumida(Pl)= 0.00
Potencia Reativa Consumida(Ql)= 0.00

BARRA 5:
Modulo da Tensao(V)=0.97
Potencia Ativa(Pi)= -3.00
Potencia Reativa(Qi)= -1.50
Angulo da Tensao=-0.14 rad
Potencia Ativa Gerada(Pg)= 0.00
Potencia Reativa Gerada(Qg)= 0.00
Potencia Ativa Consumida(Pl)= 3.00
Potencia Reativa Consumida(Ql)= 1.50
Código fonte do programa, em linguagem C, compilado por Dev-C++ :

#include <math.h>
#include <conio.h>
#include <stdio.h>
#include <stdlib.h>
#define num 5

int i,j,k,l;
int NBPQ=0; // numeros de barras do tipo PQ
int NBPV=0; // numero de barras do tipo PV
int cont=0;
int dimensao=0;
int ind[2*num-2];
double soma, Ps, Qs;
double Jacobiano[2*num-2][2*num-1];
double deltaX[2*num-2];
double P[num][num], Q[num][num], S[num][num];
double Yp_g[num][num],Yp_b[num][num]; //matriz das condutancias
double Ybus_g[num][num],Ybus_b[num][num]; //matriz das susceptancias
double temp_b,temp_g;
int Tipo_barra[num]={0,1,0,2,0}; //Tipo de barra 0=PQ 1=PV 2=V
char barra;
double Pi[num]={-1,0,-2,0,-3};
double Qi[num]={-0.5,0,-1,0,-1.5};
double Vi[num]={1,1.04,1,1.05,1};
double Angulo[num]={0,0,0,0,0};
double Potger[num]={0,3,0,0,0};
double Qger[num]={0,0,0,0,0};
double Pcons[num]={1,0,2,0,3};
double Qcons[num]={0.5,0,1,0,1.5};

/////Impedancia entre as barras

//Parƒmetros Longitudinais
//Resitência
double R[num][num]={
{0,0.01,0,0.015,0}, //Barra 1 com as outras
barras
{0.01,0,0.005,0.006,0}, //Barra 2 com as
outras barras
{0,0.005,0,0,0.008}, //Barra 3 com as outras
barras
{0.015,0.006,0,0,0.002}, //Barra 4 com as
outras barras
{0,0,0.008,0.002,0}}; //Barra 5 com as
outras barras

//Reatância
double X[num][num]={
{0,0.1,0,0.18,0}, //Barra 1 com as outras
barras
{0.1,0,0.08,0.09,0}, //Barra 2 com as outras
barras
{0,0.08,0,0,0.12}, //Barra 3 com as outras
barras
{0.18,0.09,0,0,0.05}, //Barra 4 com as outras
barras
{0,0,0.12,0.05,0}}; //Barra 5 com as outras
barras

//Susceptância
double B[num][num]={
{0,0.2,0,0.25,0}, //Barra 1 com as outras
barras
{0.20,0,0.15,0.1,0}, //Barra 2 com as outras
barras
{0,0.15,0,0,0.3}, //Barra 3 com as outras
barras
{0.25,0.1,0,0,0.4}, //Barra 4 com as outras
barras
{0,0,0.3,0.4,0}}; //Barra 5 com as outras barras

int NR(double a[2*num-2][2*num-1])

{
double x[2*num-2][1];
int i,j,k,l,m=1;
int n=2*NBPQ+NBPV;
float E=.00001;
long double P,s,aux=0;
for(k=0;k<=n-2;k++)
{ l=k;
for(i=k+1;i<=n-1;i++)
{ if (a[i][k]>a[l][k])
{ l=i; }
}
if (l!=k)
{ for(j=k;j<=n+m-1;j++)
{ aux=a[k][j];
a[k][j]=a[l][j];
a[l][j]=aux;
}
}
for(i=k+1;i<=n-1;i++)
{ P=-a[i][k]/a[k][k];
for(j=k+1;j<=n+m-1;j++)
{ a[i][j]=a[i][j]+P*a[k][j];
}
}
}

for (k=0; k<=m-1;k++)

{ x[n-1][k]=a[n-1][n+k]/a[n-1][n-1];
for(i=n-2;i>=0;i--)
{ s=0;
for(j=i+1;j<=n-1;j++)
{ s=s+a[i][j]*x[j][k];
}
x[i][k]=(a[i][n+k]-s)/a[i][i];
}
}
for(i=0;i<NBPQ+NBPV;i++)
{ deltaX[i]=deltaX[i]+x[i][0]; }
for(i=NBPQ+NBPV;i<2*NBPQ+NBPV;i++)
{ deltaX[i]=deltaX[i]*(1+(x[i][0])/deltaX[i]); }
for(i=0;i<2*NBPQ+NBPV;i++)
{ if(i<NBPQ+NBPV)
{ Angulo[ind[i]]=deltaX[i];
}
else
{ Vi[ind[i]]=deltaX[i];
}
 }
dimensao=0;
for(i=0;i<2*NBPQ+NBPV;i++)
{ if(deltaX[i]!=0)
{ if(fabs(x[i][0]/deltaX[i])<E )
{ dimensao++; }
}
}
}

// Criação do arquivo de texto com os resultados

int main()
{
FILE *pt;
pt=fopen("c:\\resultados.txt","w");

// Calcula a Y primitiva

for(i=0;i<num;i++)
{ for(j=0;j<num;j++)
{ if(i==j)
{ temp_b=B[i][i];
for(k=0;k<num;k++)
{ if(i!=k && R[i][k]!=0 && X[i][k]!=0)
{ temp_b=temp_b+B[i][k]/2;}
}
Yp_g[i][j]=0;
Yp_b[i][j]=temp_b;
}
else
{ Yp_g[i][j]=0; Yp_b[i][j]=0;
if(R[i][j]!=0)
{ Yp_g[i][j]=(R[i][j]/(pow(R[i][j],2)+pow(X[i][j],2))); }
if(X[i][j]!=0)
{ Yp_b[i][j]=-(X[i][j]/(pow(R[i][j],2)+pow(X[i][j],2))); }
}
}
}

// Imprime a Yp

fprintf(pt,"\n\nMatriz Yp:");
for(i=0;i<num;i++)
{ fprintf(pt,"\n");
for(j=0;j<num;j++)
{ fprintf(pt," (%6.2lf,%6.2lf) ",Yp_g[i][j],Yp_b[i][j]);
}
}

//Calcula a Y bus

for(i=0;i<num;i++)
{ for(j=0;j<num;j++)
{ if(i==j)
{ temp_g=0,temp_b=0;
for(k=0;k<num;k++)
{ temp_g=temp_g+Yp_g[i][k];
temp_b=temp_b+Yp_b[i][k];
 }
Ybus_g[i][j]=temp_g;
Ybus_b[i][j]=temp_b;
}
else
{ Ybus_g[i][j]=-Yp_g[i][j];
Ybus_b[i][j]=-Yp_b[i][j];
}
}
}

//Imprime a Ybus

fprintf(pt,"\n\nMatriz Ybus:");
for(i=0;i<num;i++)
{ fprintf(pt,"\n");
for(j=0;j<num;j++)
{ fprintf(pt,"(%6.2lf, %6.2lf) ",Ybus_g[i][j],Ybus_b[i][j]);
}
}

for(i=0;i<num;i++)
{ if(Tipo_barra[i]==1)
{ Pi[i]=Potger[i]-Pcons[i];
soma=0;
for(j=0;j<num;j++)
{ if(Ybus_g[i][j]!=0 && Ybus_b[i][j]!=0)
{ soma=soma+(Vi[j]*(Ybus_g[i][j]*sin(Angulo[i]-Angulo[j])-
Ybus_b[i][j]*cos(Angulo[i]-Angulo[j])));
}
}
Qi[i]=Vi[i]*soma;
NBPV++;
}
if(Tipo_barra[i]==0)
{ Pi[i]=Potger[i]-Pcons[i];
Qi[i]=Qger[i]-Qcons[i];
NBPQ++;
}
}
k=0; l=NBPQ+NBPV;
for(j=0;j<num;j++)
{ if(Tipo_barra[j]!=2)
{ ind[k]=j;
k++;
}
if(Tipo_barra[j]==0)
{ ind[l]=j;
l++;
}
}

//Calcula matriz delta X

for(i=0;i<2*NBPQ+NBPV;i++)
{ if(i<NBPQ+NBPV)
{ deltaX[i]=Angulo[ind[i]]; }
else
{ deltaX[i]=Vi[ind[i]];}
}
// Calcula a matriz jacobiano

while(dimensao<2*NBPQ+NBPV)
{
for(k=0;k<2*NBPQ+NBPV;k++)
{ i=ind[k];
for(l=0;l<2*NBPQ+NBPV;l++)
{ j=ind[l];
if(k<NBPQ+NBPV && l<NBPQ+NBPV)
{ if(i==j)
{ Jacobiano[k][l]=-pow(Vi[i],2)*Ybus_b[i][j]-Qi[i];
}
else
{ Jacobiano[k][l]=Vi[i]*Vi[j]*(Ybus_g[i][j]*sin(Angulo[i]-
Angulo[j])-Ybus_b[i][j]*cos(Angulo[i]-Angulo[j]));
}

else
if(k<NBPQ+NBPV && l>=NBPQ+NBPV)
{ if(i==j)
{ Jacobiano[k][l]=pow(Vi[i],2)*Ybus_g[i][j]+Pi[i];
}
else
{
Jacobiano[k][l]=Vi[i]*Vi[j]*(Ybus_g[i][j]*cos(Angulo[i]-
Angulo[j])+Ybus_b[i][j]*sin(Angulo[i]-Angulo[j]));
}
}
else
if(k>=NBPQ+NBPV && l<NBPQ+NBPV)
{ if(i==j)
{ Jacobiano[k][l]=-pow(Vi[i],2)*Ybus_g[i][j]+Pi[i];
}
else
{ Jacobiano[k][l]=-
Vi[i]*Vi[j]*(Ybus_g[i][j]*cos(Angulo[i]-
Angulo[j])+Ybus_b[i][j]*sin(Angulo[i]-Angulo[j]));
}
}
else
if(k>=NBPQ+NBPV && l>=NBPQ+NBPV)
{ if(i==j)
{ Jacobiano[k][l]=-pow(Vi[i],2)*Ybus_b[i][j]+Qi[i];
}
else
{
Jacobiano[k][l]=Vi[i]*Vi[j]*(Ybus_g[i][j]*sin(Angulo[i]-Angulo[j])-
Ybus_b[i][j]*cos(Angulo[i]-Angulo[j]));
}
}
}
}
//Calcula Matriz -f
l=2*NBPQ+NBPV;
for(k=0;k<2*NBPQ+NBPV;k++)
{ i=ind[k];
soma=0;
if(k<NBPQ+NBPV)
{ for(j=0;j<num;j++)
 { soma=soma+(Vi[j]*(Ybus_g[i][j]*cos(Angulo[i]-
Angulo[j])+Ybus_b[i][j]*sin(Angulo[i]-Angulo[j])));
}
Jacobiano[k][l]=Pi[i]-(Vi[i]*soma);
}
else
{ for(j=0;j<num;j++)
{ soma=soma+(Vi[j]*(Ybus_g[i][j]*sin(Angulo[i]-Angulo[j])-
Ybus_b[i][j]*cos(Angulo[i]-Angulo[j])));
}
Jacobiano[k][l]=Qi[i]-(Vi[i]*soma);
}
}
NR(Jacobiano);
cont++;
}
fprintf(pt,"\n\nMatriz Jacobiano:");
for(i=0;i<2*NBPQ+NBPV;i++)
{ fprintf(pt,"\n");
for(j=0;j<2*NBPQ+NBPV;j++)
{ fprintf(pt," %6.2lf ",Jacobiano[i][j]);
}
}

fprintf(pt,"\n");
for(k=0;k<2*NBPQ+NBPV;k++)
{ if(k<NBPQ+NBPV)
{ fprintf(pt,"\ndeltaX[%d] : é[%d] =
%.2lfø",k,ind[k]+1,180*deltaX[k]/M_PI); }
else
{ fprintf(pt,"\ndeltaX[%d] : Vi[%d] =
%.3lf",k,ind[k]+1,deltaX[k]);
}
}

//Calcula os fluxos nas linhas(Pij, Qij e Sij)

for(i=0;i<num;i++)
{ for(j=0;j<num;j++)
{ P[i][j]=pow(Vi[i],2)*Yp_g[i][j]-
Vi[i]*Vi[j]*(Yp_g[i][j]*cos(Angulo[i]-
Angulo[j])+Yp_b[i][j]*sin(Angulo[i]-Angulo[j]));
P[i][j]=100*P[i][j];
Q[i][j]=-pow(Vi[i],2)*((B[i][j]/2)+Yp_b[i][j])-
Vi[i]*Vi[j]*(Yp_g[i][j]*sin(Angulo[i]-Angulo[j])-
Yp_b[i][j]*cos(Angulo[i]-Angulo[j]));
Q[i][j]=100*Q[i][j];
S[i][j]=sqrt(pow(P[i][j],2)+pow(Q[i][j],2));
}
}
for(i=0;i<num;i++)
{ fprintf(pt,"\n\nBARRA %d:\
\nModulo de Tensao = %.3lf\
\nAngulo = %.2lfø",i+1,Vi[i],180*Angulo[i]/M_PI);
for(j=0;j<num;j++)
{ if(R[i][j]!=0 && X[i][j]!=0)
{ fprintf(pt,"\nP[%d][%d]= %7.2lf MW \\nQ[%d][%d]= %7.2lf Mvar
\\nS[%d][%d]=%7.2lfMVA",i+1,j+1,P[i][j],i+1,j+1,Q[i][j],i+1,j+1,S[i][j
]);
if(Tipo_barra[i]==2)
{ Potger[i]=Potger[i]+P[i][j]/100;
 Qger[i]=Qger[i]+Q[i][j]/100;
}
if(Tipo_barra[i]==1)
{ Qger[i]=Qger[i]+Q[i][j]/100;
}
}
}
if(Tipo_barra[i]==2)
{ fprintf(pt,"\nPotencia ativa gerada = %7.2lf
MW",Potger[i]*100);
fprintf(pt,"\nPotencia reativa gerada = %7.2lf
Mvar",Qger[i]*100);
}
if(Tipo_barra[i]==1)
{ Qger[i]=Qger[i]+Qcons[i];
fprintf(pt,"\nPotencia reativa gerada = %7.2lf
Mvar",Qger[i]*100);
}
}

//Calcula as perdas totais do sistema

Ps=0; Qs=0;
for(i=0;i<num;i++)
{ Ps=Ps-Pcons[i];
Qs=Qs-Qcons[i];
Ps=Ps+Potger[i];
Qs=Qs+Qger[i];
}
fprintf(pt,"\n\n\nPERDAS TOTAIS DO SISTEMA:");
fprintf(pt,"\nPerda total ativa do sistema = %7.2lf MW",Ps*100);
fprintf(pt,"\nPerda total reativa do sistema = %7.2lf MVar",Qs*100);

//Apresenta dados finais das barras

fprintf(pt,"\n\n\n\nDADOS FINAIS DAS BARRAS:");
fprintf(pt,"\n_______________________");
for(i=0;i<num;i++)
{ fprintf(pt,"\n\n\nBARRA %d:",i+1);
fprintf(pt,"\nModulo da Tensao(V)=%4.2lf",Vi[i]);
fprintf(pt,"\nPotencia Ativa(Pi)=%6.2lf \
\nPotencia Reativa(Qi)=%6.2lf",Pi[i],Qi[i]);
fprintf(pt,"\nAngulo da Tensao=%.2lf rad",Angulo[i]);
fprintf(pt,"\nPotencia Ativa Gerada(Pg)=%6.2lf",Potger[i]);
fprintf(pt,"\nPotencia Reativa Gerada(Qg)=%6.2lf",Qger[i]);
fprintf(pt,"\nPotencia Ativa Consumida(Pl)=%6.2lf",Pcons[i]);
fprintf(pt,"\nPotencia Reativa Consumida(Ql)=%6.2lf",Qcons[i]);
}
getch();
}