INSTITUTO FEDERAL DE EDUCAÇÃO, CIÊNCIA E TECNOLOGIA DO

TOCANTINS - IFTO
CAMPUS PALMAS

Silas Bispo de Sousa

FLUXO DE POTÊNCIA
Modelagem computacional através dos métodos de Gauss e Gauss-Seidel

Palmas - TO
2019
 Silas Bispo de Sousa

FLUXO DE POTÊNCIA
Modelagem computacional através dos métodos de Gauss e Gauss-Seidel

Trabalho submetido à disciplina de

Sinais e Sistemas, 7º período, do
curso de Engenharia Elétrica do
Instituto Federal do Tocantins, como
requisito parcial para aprovação.
Prof. Dr. Augusto Cesar dos Santos
C. F. Vieira.

Palmas - TO
2019
 2

SUMÁRIO

1 INTRODUÇÃO...........................................................................................................................3
2 MÉTODOS..................................................................................................................................4
2.1 Método de Gauss.......................................................................................................................5
2.1.1 Primeira Parte: Coleta de dados..............................................................................................6
2.1.2 Segunda Parte: aplicando o método de Gauss.......................................................................10
2.2 Método de Gauss-Seidel.........................................................................................................13
2.2.1 Segunda Parte: aplicando o método de Gauss-Seidel............................................................13
3 RESULTADOS E DISCUSSÕES.............................................................................................15
CONCLUSÃO..............................................................................................................................17
REFERÊNCIAS BIBLIOGRÁFICAS.......................................................................................18
 3

Resumo
Este relatório descreve o procedimento utilizado para a modelagem de um programa para
solução de problemas de fluxo de carga utilizando os métodos de Gauss e Gauss-Seidel através
da interface do software Octave.

1 INTRODUÇÃO

Com o desenvolvimento crescente do setor elétrico e o aumento de sua complexidade junto à ânsia
por inovações e aperfeiçoamentos das tecnologias ligadas às atividades de operação e
planejamento dos sistemas de energia elétrica (MANZONI, 2005, p. 1), torna-se mais do que
necessário o estudo de técnicas que possam otimizar tais processos. No cenário atual, novas
tecnologias computacionais estão permitindo o desenvolvimento exponencial dessas técnicas
através do aproveitamento da grande capacidade e velocidade com que os computadores atuais
efetuam rotinas de cálculos complexos. Desta maneira, é de grande importância que o profissional
ligado a área de análise de sistemas elétricos se habituem com o desenvolvimento dessas
tecnologias.
Dentre os diversos campos de estudo na análise de sistema de potência, está o estudo de fluxo de
potência, ou fluxo de carga, que leva em consideração o sistema elétrico em regime permanente e
simétrico. Tal estudo permite analisar as características de funcionamento global do sistema. “O
objetivo é determinar as tensões e potências em todos os barramentos de um sistema elétrico”
(ALMEIDA, 2017, p. 111).
Na modelagem de sistemas do mundo real, os problemas não são lineares e, devido às suas
complexidades, suas soluções são obtidas através de métodos numéricos como o de Gauss ou
Newton-Raphson. A aplicação desses métodos, permite que a solução seja obtida através de uma
rotina de cálculos iterativos simples utilizando valores de iterações anteriores que se repetem até
que o erro entre os valores obtidos entre as iterações seja menor que um erro previamente
especificado.
Dentre os diversos métodos disponíveis, embora não seja o mais utilizado devido ao consumo de
tempo, o método de Gauss é um dos mais didáticos e simples. Através dele é possível entender de
maneira simples como os métodos interativos funcionam. Ainda, de maneira semelhante, existe o
método de Gauss-Seidel, que explora a simplicidade do método de Gauss, mas tem uma
convergência mais rápida.
Neste relatório, são apresentadas duas modelagens para a solução de fluxo de carga, onde, um
algoritmo é baseado no método de Gauss e o outro no de Gauss-Seidel. Os dois programas foram
escritos utilizando o software Octave como interface e serão apresentados juntamente aos seus
códigos-fonte. Ao final, os dois métodos serão comparados utilizando, ainda, os resultados obtidos
através do software power world.
 4

2 MÉTODOS

Antes de partir para a solução do sistema, é necessário conhecer alguns dados chave como as
impedâncias das linhas de transmissão e características dos nós. Os sistemas elétricos de potência
são, geralmente, apresentados num diagrama unifilar com diversas barras (nós). Tais barras são
onde acontecem ligações importantes no mundo real (Geradores, transformadores, motores etc.).
Essas barras são classificadas em três tipos baseado nas informações que, inicialmente, se conhece
delas, sendo esses (ALMEIDA, 2017, p. 111):
• Barras de Carga (PQ): são conhecidas as potências ativa (P) e reativa (Q), mas o módulo
da tensão (V) e seu ângulo (θ) são desconhecidos;
• Barras de Geração (PV): a potências ativa (P) e o módulo da tensão (V) são conhecidos,
mas a potência reativa (Q) e o ângulo da tensão (θ) são desconhecidos;
• Barra de referência (Vθ): o módulo da tensão (V) e ângulo da tensão (θ) são conhecidos,
mas as potências ativa (P) e reativa (Q) são desconhecidas. Também denominada barra
“oscilante”, “flutuante” ou “swing”.
Existe apenas uma barra de referência num sistema podendo haver várias barras de carga ou de
geração.
Em barras de geração, as potências são consideradas positivas para efeito de cálculos, essas barras
“injetam” potência no sistema. Em barras de cargas, as potências são consideradas negativas, as
barras “consomem” potência do sistema. Barras intermediárias onde não estão conectadas
geradores ou cargas no mundo real, são consideradas barras PQ com P=0 e Q=0.
O sistema a ser analisado é dado abaixo na Figura 1:

Nesse sistema, pode-se observar que a barra 1 é Vθ, a barra 2 é PQ e a barra 3 é PV. A Tabela 1
apresenta um resumo dos dados de barra:
 5

Os valores dos módulos das tensões e ângulos das tensões nas barras PQ, das potências ativas e
reativas na barra de referência e do ângulo da tensão e potência reativa nas barras PV mostrados
na tabela são desconhecidos e são os focos da análise. Esses valores como apresentados na tabela
são apenas “chutes” que servirão como valores iniciais da análise.
A Tabela 2 apresenta os dados das linhas do sistema:

2.1 Método de Gauss

O primeiro passo para a solução pelo método de Gauss é obter a matriz admitância nodal do
sistema. Uma vez conhecida a matriz admitância, utiliza-se a seguinte equação:

(Equação 1)

Deste modo, numa iteração k+1 a tensão Vk+1p da barra p é calculada utilizando os valores da
potência aparente Skp e tensão Vkp da iteração k, ou seja, da iteração anterior. Os valores de
admitâcias Y da equação são retirados da matriz admitância nas posições indicadas pelo
subíndices.
O método consiste em repetir os cálculos a cada iteração utilizando os dados obtidos na iteração
anterior onde, os valores iniciais e os “chutes”, são os valores da iteração zero. A cada iteração o
valor do erro em relação a iteração anterior é calculado, onde:
𝑒𝑟𝑟𝑜 = 𝑚á𝑥|𝑉𝑝𝑘+1 − 𝑉𝑝𝑘 | (Equação 2)
 6

Uma vez que o erro calculado seja menor do que o erro máximo especificado, interrompe-se as
iterações e o sistema está resolvido.
Baseando-se nessas considerações, o programa abaixo foi escrito para resolver o sistema
apresentado através do método de Gauss usando como entrada as tabelas 1 e 2. A interface utilizada
foi o software Octave. O programa foi dividido em duas partes: a primeira faz a leitura de dados
através de tabelas em arquivo de texto (.txt) e produz a matriz admitância (Ybus), e a segunda
parte soluciona o sistema através do método de Gauss considerando um erro máximo de 10-5.

2.1.1 Primeria Parte: Coleta de dados

1. clear
2. clc
3. ###### FAZER LEITURA DE DADOS ######
4. dadosbar = load("dados_barra.txt","r"); % Leitura dos dados de barra
5. dadoslin = load("dados_linha.txt","r"); % Leitura dos dados de linha
6. bar = max(dadosbar(:,1)); % Define o número de barras
7. clc
8. Sbase = 100; % Potência Base
9. ###### ORGANIZANDO OS DADOS DE BARRA ######
10. # 1 Definir dimensões dos parâmetros inicias
11. Num(bar,1) = 0; % Matriz para salvar número das barras
12. bartipo(bar,1) = 0; % Matriz para tipo das barras
13. V(bar,1) = 0; % Matriz para módulos das tensões
14. theta(bar,1) = 0; % Matriz para ângulo das tensões
15. Pc(bar,1) = 0; % Matriz para potências ativas de carga
16. Qc(bar,1) = 0; % Matriz para potências reativas de carga
17. Pg(bar,1) = 0; % Matriz para potências ativas geradas
18. Qg(bar,1) = 0; % Matriz para potências reativas geradas
19. Qi(bar,1) = 0; % Matriz para potências reativas injetadas
20. # 2 Atribuir valores aos parâmetros iniciais
21. Num = dadosbar(:,1); % Preenche matriz de números
22. % Através da Matriz N, é possível preencher as matrizes na ordem
independentemente da ordem da entrada dos dados
23. %ajustando-se a posição na matriz ao valor de N na posição. Deste modo, os
valores de entrada não precisam estar
24. %em ordem.
25. %Laço para preencher a matriz bartipo
26. for (m = 1:bar)
27. bartipo(Num(m,1),1) = dadosbar(m,2);
28. m++;
29. endfor
30. %Laço para preencher a matriz V
31. for (m = 1:bar)
32. V(Num(m,1),1) = dadosbar(m,3);
33. m++;
34. endfor
35. %Laço para preencher a matriz theta
36. for (m = 1:bar)
37. theta(Num(m,1),1) = dadosbar(m,4);
38. m++;
39. endfor
40. %Laço para preencher a matriz Pc
41. for (m = 1:bar)
42. Pc(Num(m,1),1) = dadosbar(m,5);
43. m++;
 7

44. endfor
45. Pc = Pc/Sbase; %converter para PU
46. %Laço para preencher a matriz Qc
47. for (m = 1:bar)
48. Qc(Num(m,1),1) = dadosbar(m,6);
49. m++;
50. endfor
51. Qc = Qc/Sbase; %converter para PU
52. %Laço para preencher a matriz Pg
53. for (m = 1:bar)
54. Pg(Num(m,1),1) = dadosbar(m,7);
55. m++;
56. endfor
57. Pg = Pg/Sbase; %converter para PU
58. %Laço para preencher a matriz Qg
59. for (m = 1:bar)
60. Qg(Num(m,1),1) = dadosbar(m,8);
61. m++;
62. endfor
63. Qg = Qg/Sbase; %converter para PU
64. %Laço para preencher a matriz Qi
65. for (m = 1:bar)
66. Qi(Num(m,1),1) = dadosbar(m,9);
67. m++;
68. endfor
69. Qi = Qi/Sbase; %converter para PU
70. # 3 Calcular valores adicionais
71. %Calcular tensões complexas
72. for (m = 1:bar)
73. V(m,1) = V(m,1)*cos(theta(m,1)*(pi/180)) + (V(m,1)*sin(theta(m,1)*(pi/180)))*j;
74. endfor
75. %Determinar Matriz Potencia Aparente
76. S(bar,1) = 0;
77. for (m = 1:bar)
78. S(m,1) = (-Pc(m,1) + Pg(m,1)) + (-Qc(m,1) + Qg(m,1) + Qi(m,1))*j;
79. endfor
80. ###### ORGANIZANDO OS DADOS DE LINHA ######
81. # 1 Definir dimensões dos parâmetros inicias
82. barI(bar,1) = 0; % Matriz para barra inicial
83. barF(bar,1) = 0; % Matriz para barra final
84. R(bar,1) = 0; % Matriz para resistência das linhas
85. X(bar,1) = 0; % Matriz para reatância das linhas
86. B(bar,1) = 0; % Matriz para susceptância das linhas
87. Tap(bar,1) = 0; % Matriz para tap dos transformadores
88. # 2 Atribuir valores aos parâmetros iniciais
89. %Laço para preencher a matriz barI
90. for (m = 1:bar)
91. barI(m,1) = dadoslin(m,1);
92. m++;
93. endfor
94. %Laço para preencher a matriz barF
95. for (m = 1:bar)
96. barF(m,1) = dadoslin(m,2);
97. if (barF(m,1) == 0)
98. barF(m,1) = barI(m,1);
99. endif
100. m++;
101. endfor
102. %Laço para preencher matriz R
103. for (m = 1:bar)
104. R(m,1) = dadoslin(m,3);
105. m++;
106. endfor
 8

107. %Laço para preencher matriz X

108. for (m = 1:bar)
109. X(m,1) = dadoslin(m,4);
110. m++;
111. endfor
112. %Laço para preencher matriz B
113. for (m = 1:bar)
114. B(m,1) = dadoslin(m,5);
115. m++;
116. endfor
117. %Laço para preencher matriz Tap
118. for (m = 1:bar)
119. Tap(m,1) = dadoslin(m,6);
120. m++;
121. endfor
122. ###### MONTAR MATRIZ Ybus ######
123. % Zprim
124. Zprim(bar,bar) = 0;
125. for (m = 1:bar)
126. Zprim(barI(m,1),barF(m,1)) = R(m,1) + (X(m,1))*i;
127. if (barI(m,1) != barF(m,1))
128. Zprim(barF(m,1),barI(m,1)) = Zprim(barI(m,1),barF(m,1));
129. endif
130. m++;
131. endfor
132. % Yprim
133. Yprim(bar,bar) = 0;
134. for (m = 1:bar)
135. for (n = 1:bar)
136. if (Zprim(m,n) != 0)
137. Yprim(m,n) = inv(Zprim(m,n));
138. else
139. Yprim(m,n) = 0;
140. endif
141. n++;
142. endfor
143. m++;
144. endfor
145. % Ybus
146. Ybus(bar,bar) = 0;
147. for (m = 1:bar)
148. for (n = 1:bar)
149. if (m != n)
150. Ybus(m,n) = -Yprim(m,n);
151. else
152. soma = 0;
153. for (c = 1:bar)
154. soma += Yprim(m,c);
155. c++;
156. endfor
157. Ybus(m,n) = soma;
158. endif
159. n++;
160. endfor
161. m++;
162. endfor
163. # Informar sucesso na coleta e processamento de dados
164. printf('Dados coletados com sucesso! \n\n Ybus: \n');
165. disp(Ybus);
 9

Os caracteres e símbolos escritos após ‘#’ e ‘%’ são comentários e não são lidos na execução do
programa.
A linha 1 utiliza o comando clear para limpar a área de trabalho do Octave e a linha 2 limpa a
janela de comando através do comando clc.

As linhas 4 e 5 limpam a memória do programa e coletam os dados das tabelas nos arquivos
“dados_barra.txt” e dados_linha.txt” conforme a Tabela 1 e a Tabela 2, respectivamente. Esses
valores são guardados nas matrizes ‘dadosbar’ e ‘dadoslin’.
A linha 6 cria uma variável chamada ‘bar’ para salvar o número de barras do sistema. Esse
comando vai levar em consideração o maior número da coluna onde estão o número das barras na
tabela de dados de barra. Por exemplo, se o maior número for o da barra nº 18, então a variável
bar recebe o número 18.
A linha 8 define a potência base como 100 MVA.
As linhas 11-19 criam as matrizes de dados de dimensão nx1 onde n é o número de barras. Cada
uma dessas matrizes receberá os valores de uma das colunas da tabela de dados de barra.
Na linha 21 a matriz ‘Num’ é preenchida com a coluna onde estão os números das barras na ordem
da tabela de dados de barra. Os valores dos números das barras serão usados para organizar o
preenchimento das outras matrizes em ordem crescente.
Nas linhas 26-69, laços for são utilizados para preencher as matrizes de dados. O laço permite
que todas as linhas da matriz ‘dadosbar’ da coluna referente ao dado preenchido, de acordo com a
Tabela 1, sejam lidos e preenchidos na ordem crescente relacionando ao número da barra salvo na
mesma linha da matriz ‘Num’. Desta maneira, mesmo que os dados da barra 2 estejam salvos na
linha 3 da matriz de entrada, seus dados serão colocados na linha 2 das matrizes de dados pois sua
posição nessas matrizes será o número do valor da matriz ‘Num’ na mesma posição.
As linhas 45, 51, 57, 63 e 69 converte os valores de potência da entrada para p.u. utilizando o valor
da potência base.
As linhas 72-79 utiliza laços for para converter os valores dos módulos da tensão e da potência
aparente para valores complexos utilizando a relação de números complexos. A tensão é
convertida a partir do módulo e ângulo dados na tabela de entrada. A potência aparente é calculada
utilizando a soma dos valores das potências ativas e reativas dadas na entrada, considerando
potências geradas como positivas e potências de carga como negativas.
As linhas 82-87 cria matrizes de dados de linha de maneira semelhante a feita com os dados de
barra.
Da mesma maneira, as linhas 90-121 preenchem as matrizes com os dados de linha de maneira
semelhante às matrizes com os dados de barra. Há uma matriz para cada coluna e um laço for é
utilizado para executar uma rotina que leia todas as linhas.
A partir da linha 122, a montagem da matriz admitância (Ybus) é feita.
 10

Primeiramente, criamos uma matriz de impedâncias, onde seus valores são preenchidos conforme
os números das barras, onde, a linha é o número da barra de origem e a coluna é o número da barra
destino. Essa matriz é chamada de ‘Zprim’.
Após a criação da matriz de impedâncias, uma matriz contendo os valores inversos dos elementos
dessa matriz é criada. Essa matriz se chama ‘Yprim’.
Finalmente, a matriz ‘Ybus’ é criada a partir de ‘Yprim’ onde os elementos de ‘Ybus’ fora da
diagonal principal recebem os valores dos elementos de ‘Yprim’ negativos e os elementos da
diagonal principal de ‘Ybus’ recebem a soma de todos os elementos da linha relacionada da matriz
‘Yprim’.
As linhas 125-131 criam a matriz ‘Zprim’ utilizando dois laços for, um para as linhas e outro,
dentro para as colunas. Para cada ciclo do laço das linhas, o laço da coluna vai varrer os valores
das colunas da tabela de dados de linha. Os valores serão a soma das resistências somadas as
reatâncias e suas posições serão associadas à barra de origem na linha e à barra de destino na
coluna. Um laço if garante que os valores de posições simétricas sejam preenchidos considerando
um valor de linha diferente de um valor de coluna.
As linhas 133-143 criam a matriz ‘Yprim’ simplesmente preenchendo com o elemento na mesma
posição da matriz ‘Zprim’ invertido através da função inv. Para isso é utilizado um laço for dentro
de um laço if para impedir que haja divisão por zero. Se o valor na matriz ‘Zprim’ for zero, então
o elemento na mesma posição da matriz ‘Yprim’ recebe zero.
As linhas 147-162 criam a matriz ‘Ybus’ utilizando dois laços for, o primeiro para a linha e o
segundo, dentro, para a coluna. Dentro dos laços for, um laço if vai atribuir a soma dos valores
da linha da matriz ‘Yprim’ relacionada se o valor da linha for igual ao valor da coluna ou o valor
negativo do elemento da matriz ‘Yprim’ relacionado se forem diferentes. Para efetuar a soma, um
laço for auxiliado da função += foi utilizado.
As linhas 164 e 165 informam o sucesso da coleta de dados, caso o programa tenha sido executado
corretamente.

2.1.2 Segunda parte: aplicando o método de Gauss

1. printf ('\t\t## MÉTODO DE GAUSS ##\n\n');

2. # Determiar erro mínimo
3. erromin = 1e-10;
4. # Fórmula de Gauss
5. u = 0;
6. e = 0;
7. erro = 1;
8. while (erro > erromin)
9. u++;
10. Vn(bar,1) = 0;
 11

11. for (p = 1:bar)

12. % Atualizar V na barra
13. if (bartipo(p,1) != 1)
14. soma = 0;
15. for (q = 1:bar)
16. if (p != q)
17. soma += Ybus(p,q)*V(q,1);
18. endif
19. q++;
20. endfor
21. Vn(p,1) = inv(Ybus(p,p))*(conj(S(p,1)/V(p,1)) - soma);
22. else
23. Vn(p,1) = V(p,1);
24. endif
25. % Cálculo para manter módulo da tensão na barra PV
26. if (bartipo(p,1) == 3)
27. phi = arg(Vn(p,1));
28. Vn(p,1) = abs(V(p,1))*cos(phi)+(abs(V(p,1))*sin(phi))*j;
29. endif
30. p++;
31. endfor
32. e = abs(V) - abs(Vn);
33. erro = max(abs(e));
34. V = Vn;
35. % Atualizar S das barras PV mantendo P fixo
36. for (p = 1:bar)
37. if (bartipo(p,1) == 3)
38. I3 = 0;
39. for (d = 1:bar)
40. I3 += V(d,1)*Ybus(p,d);
41. d++;
42. endfor
43. Sabs = abs(V(p,1)*conj(I3));
44. phi = acos((Pg(p,1)-Pc(p,1))/Sabs);
45. S(p,1) = Sabs*cos(phi)+(Sabs*sin(phi))*j;
46. endif
47. p++;
48. endfor
49. endwhile
50. clc
51. % Atualizar S barra Slack
52. for (p = 1:bar)
53. if (bartipo(p,1) == 1)
54. I1 = 0;
55. for (d = 1:bar)
56. I1 += V(d,1)*Ybus(p,d);
57. d++;
58. endfor
59. S(p,1) = V(p,1)*conj(I1);
60. endif
61. p++;
62. endfor

63. % Atualizar matrizes P e Q

64. for (m = 1:bar)
65. P(m,1) = real(S(m,1));
66. Q(m,1) = imag(S(m,1));
67. m++;
68. endfor

69. printf("\nTolerância: %d\n", erromin);

70. printf("\n [V] [ang]\n", u);
71. disp([abs(V) arg(V)*180/pi])
 12

72. printf("\n [P] [Q]\n", u);

73. disp([P Q])
74. printf("\n\nNúmero de interações: %d\n", u);
75. printf("erro: %d\n", erro);

A linha 3 determina o erro máximo admissível para se interromper as iterações. A linha 5 cria uma
variável ‘u’ para contar o número de iterações e as linhas 6 e 7 criam as variáveis ‘e’ e ‘erro’ que
guardaram os erros calculados antes de serem comparados.
A linha 8 dá início à função while que decidirá quando interromper as iterações. A condição é
que o erro calculado seja menor que o erro estabelecido. Para que o programa entre no laço o valor
do erro calculado é admitido como sendo igual a 1 inicialmente.
Na linha 9, a variável ‘u’ recebe um incremento indicando a primeira iteração.
As linhas 11-31 são utilizadas para calcular os valores das tensões a cada iteração. Para essa tarefa,
utiliza-se primeiramente um laço for (linha 11) que vai repetir o processo para cada barra p.
dentro desse laço, primeiramente encontra-se um condicional if (linha 13), o qual impedirá que
o cálculo seja feito se a barra for do tipo 1 (barra Vθ). Na linha 14, uma variável ‘soma’ com valor
inicial zero é criada para salvar o valor da soma que será calculada conforme a Equação 1. Para
isso, na linha 15 um laço for será utilizado para “varrer” os valores na matriz ‘Ybus’ e ‘V’ que
possuam o índice q a cada ciclo. Esses valores são somados aos anteriores a cada novo ciclo até
que se satisfaça a condição do laço for. Então, o valos ‘soma’ é utilizado na fórmula utilizada na
linha 21 em conformidade com a Equação 1 atribuindo a mesma posição relacinada da matriz ‘Vn’.
A linha 22 determina que se a condição do condicional if (linha 13) não for satisfeito, então a
linha 23 é executada, ou seja, se a barra for do tipo 1, o valor de ‘Vn’ na posição atual será o
mesmo da iteração anterior.
As linhas 26-29, através do condicional if, faz com que se a barra for do tipo 3 (PV), o valor atual
seja recalculado para que o módulo de tensão especificado anteriormente seja mantido e se
mantenha apenas o ângulo calculado. Para isso, cria-se uma variável ‘phi’ para guardar o valor do
ângulo através da função arg e, assim, o valor da tensão para essa barra é recalculada utilizando
a relação de números complexos utilizando o valor do módulo da tensão especificado e o ângulo
calculado na iteração atual.
Na linha 32 a variável ‘e’ recebe a matriz diferença entre a matriz V (possuindo os valores da
iteração anterior) e a matriz Vn (possuído os valores da iteração atual).
Na linha 33, a variável ‘erro’ recebe o maior elemento da matriz ‘e’.
O laço for nas linhas 36-48, atualiza o valor da potência aparente das barras tipo 3 (PV),
calculando-se a corrente na barra com os valores de tensão atuais. Calcula-se o módulo da potência
aparente e o ângulo a partir do valor da potência ativa da barra. Então, se calcula o valor complexo
da potência aparente utilizando o módulo e o novo ângulo calculados.
O laço while termina na linha 49 e compara o valor da variável erro, calculada na iteração atual,
com o valor do erro estabelecido no inicio do programa. Se ‘erro’ for menor, o laço termina.
 13

O laço for nas linhas 64-68 atualiza os valores das matrizes ‘P’ e ‘Q’ a partir dos valores finais
da matriz ‘S’, onde, ‘P’ é a parte real de ‘S’ e ‘Q’ é a parte imaginária de ‘S’.
As linhas 69-75 exibem o resultado.

2.2 Método de Gauss-Seidel

O método de Gauss-Seidel é muito semelhante ao método de Gauss. A ideia nesse método é utilizar
os valores das barras já calculados para calcular os valores das barras a calcular a cada iteração.
Isso agiliza o processo de convergência. A equação para este método é apresentada abaixo:

(Equação 3)

A equação é, praticamente, a mesma que no método de Gauss. A diferença é que a soma foi
dividida em duas partes. A primeira soma considera os valores da iteração atual, valores das barras
já calculados. A segunda considera os valores da iteração anterior, as barras que ainda não foram
calculados. Isso acontece a cada iteração. Assim, quando se calcular a tensão na barra 3, utiliza-se
os valores da iteração atual das barras 1 e 2 e os valores anteriores para as barras 3 ou posteriores.
A modelagem feita para o método de Gauss-Seidel foi a mesma anterior com a adição desse detalhe
na linhas de soma.
Assim, não é necessário a apresentação da primeira parte que contem apenas a coleta dos dados.
E, na segunda parte, apenas as modificações serão comentadadas.

2.2.1 Segunda parte: aplicando as modificações de Gauss-Seidel

1. printf ('\t\t## MÉTODO DE GAUSS-SEIDEL ##\n\n');

2. # Determiar erro mínimo
3. erromin = 1e-10;
4. # Método Gauss-Seidel
5. u = 0;
6. h = 0;
7. e = 0;
8. erro = 1;
9. Vn(bar,1) = 0;
10. while (erro > erromin)
11. u++;
12. for (k = 1:bar)
 14

13. if (h == bar)
14. h = 0;
15. endif
16. soma1 = 0;
17. if (bartipo(k,1) != 1)
18. if (h > 0)
19. for (d = 1:h)
20. if (d != k)
21. soma1 += Ybus(k,d)*Vn(d,1);
22. endif
23. d++;
24. endfor
25. soma2 = 0;
26. endif
27. if (h <= bar)
28. soma2 = 0;
29. for (d = (h+1):bar)
30. if (d != k)
31. soma2 += Ybus(k,d)*V(d,1);
32. endif
33. d++;
34. endfor
35. endif
36. Vn(k,1) = inv(Ybus(k,k))*(conj(S(k,1)/V(k,1)) - soma1 - soma2);
37. else
38. Vn(k,1) = V(k,1);
39. endif
40. % Cálculo para manter módulo da tensão na barra PV
41. if (bartipo(k,1) == 3)
42. phi = arg(Vn(k,1));
43. Vn(k,1) = abs(V(k,1))*cos(phi)+(abs(V(k,1))*sin(phi))*j;
44. endif
45. h++;
46. k++;
47. endfor
48. e = abs(V) - abs(Vn);
49. erro = max(abs(e));
50. V = Vn;
51. % Atualizar S das barras PV mantendo P fixo
52. for (p = 1:bar)
53. if (bartipo(p,1) == 3)
54. I3 = 0;
55. for (d = 1:bar)
56. I3 += V(d,1)*Ybus(p,d);
57. d++;
58. endfor
59. Sabs = abs(V(p,1)*conj(I3));
60. phi = acos((Pg(p,1)-Pc(p,1))/Sabs);
61. S(p,1) = Sabs*cos(phi)+(Sabs*sin(phi))*j;
62. endif
63. p++;
64. endfor
65. endwhile
66. % Atualizar S barra Slack
67. for (p = 1:bar)
68. if (bartipo(p,1) == 1)
69. I1 = 0;
70. for (d = 1:bar)
71. I1 += V(d,1)*Ybus(p,d);
72. d++;
73. endfor
74. S(p,1) = V(p,1)*conj(I1);
75. endif
 15

76. p++;
77. endfor
78. % Atualizar matrizes P e Q
79. for (m = 1:bar)
80. P(m,1) = real(S(m,1));
81. Q(m,1) = imag(S(m,1));
82. m++;
83. endfor
84. printf("\nTolerância: %d\n", erromin);
85. printf("\n [V] [ang]\n", u);
86. disp([abs(V) arg(V)*180/pi])
87. printf("\n [P] [Q]\n", u);
88. disp([P Q])
89. printf("\n\nNúmero de interações: %d\n", u);
90. printf("erro: %d\n", erro);

A diferença da sintax anterior está na criação de uma variável ‘h’ que receberá o número da barra
anterior à que se está calculando e na adição dos laços para a ‘soma1’ nas linhas 17-26 e para a
‘soma2’ nas linhas 27-35.
O primeiro laço começa com uma condicional que determina que só deve ser calculado a ‘soma1’
se ‘h’ for maior que zero. Isso quer dizer que a ‘soma1’ só deve ser calculada a partir da barra 2, a
cada iteração. Cumprida a condição, faz-se a soma através de um laço for semelhante aos utilizados
no método anterior, porém apenas da barra 1 até a barra com o mesmo número da variável ‘h’ da
matriz com os novos valores de tensão. Logo, apenas as barras anteriores as barras atuais serão
utilizadas no cálculo da ‘soma1’.
A variável ‘soma2’, então, será calculada considerando os valores da barra atual (h+1) e os valores
das próximas barras.
Terminadas as somas, seus valores são utilizados na atribuição da linha 36 e o programa segue
exatamente igual à modelagem pelo método de Gauss.

3 RESULTADOS E DISCUSSÕES

Para o sistema apresentado, o resultados das duas modelagens são:

 16

Figura 2: Resultados para o método de Gauss.

Figura 3: Resultados para o método de Gauss-Seidel.

Observando-se os resultados obtidos através dos dois métodos, nota-se a grande diferença quanto
ao número de iterações. Enquanto que no método de Gauss-Seidel só foram necessárias cinco
iterações, no método de Gauss foram necessárias 34 iterações (7 vezes mais iterações!), atestando-
se, dessa maneira, que o método de Gauss é muito mais lento.
Ainda assim, os dois métodos convergiram para os mesmos valores com erros substancialmente
pequenos, ainda que no método de Gauss-Seidel o erro foi 10 vezes menor, na ordem de 10-7.
 17

Utilizando o software Power World, o mesmo sistema foi simulado e os resultados são
apresentados na Figura 4:

Figura 4: Resultados da Simulação no Power World.

O Power World é um software avançado utilizado na análise de sistemas de potências. Observando

seus resultados, nota-se que os mesmo estão de acordo com os métodos obtidos na modelagem de
Gauss e Gauss-Seidel descritas neste relatório.

CONCLUSÃO

Ao final dos procedimentos descritos, pode-se perceber que a modelagem de rotinas

computacionais para solução de problemas relacionados a fluxo de carga é um desafio alcançável
através de recursos simples, bastando-se a aplicação de estudos certos. Os resultados finais
apresentaram-se satisfatórios, não apenas por convergirem para resultados esperados, mas também
comprovando anos de estudos de ferramentas matemáticas teóricas por estudiosos como Gauss e
Seidel que hoje podem ser aplicadas através das novas tecnologias computacionais.
Além disso, assim como esperado teoricamente, o método de Gauss-Seidel foi mais efetivo do que
o método de Gauss, convergindo de maneira mais rápida para os resultados finais.
Desta maneira, este trabalho é mais uma evidência do poder da atual capacidade computacional
em resolver problemas reais, através da análise e da modelagem certa.
 18

REFERÊNCIAS BIBLIOGRÁFICAS

FLUXO DE POTÊNCIA. In: ALMEIDA, Alvaro A. W. NOTAS DE AULA EM SISTEMAS

ELÉTRICOS DE POTÊNCIA. Paraná: UTFPR, 2017. cap. 7, p. 111-136.
MANZONI, Alessandro. Desenvolvimento de dm Sistema Computacional Orientado a
Objetos para Sistemas Elétricos de Potência: Aplicação a Simulação Rápida e Análise da
Estabilidade de Tensão. Orientador: Djalma M. Falcão. 2005. 190 p. Tese (Doutorado) - Curso de
Pós-Graduação em Engenharia Elétrica, UFRJ, Rio de Janeiro, 2005. Disponível em:
http://pee.ufrj.br/teses/textocompleto/2005033151.pdf. Acesso em: 31 out. 2019.