Classe que representa a rede de transmissão

3.1.6.1 Definição da classe

A rede de transmissão é representada no Framework através da classe TNetwork. Nesta classe serão cadastrados todos os dispositivos que fazem parte do sistema através de métodos específicos.

Os principais atributos desta classe são:

1. Potência base comum em MVA representada por Sbase; 2. Tensão base comum em kV representada por Vbase;

3. Erros de potência ativa e reativa a serem alcançados pelo método de cálculo do fluxo de carga, representados por errP e errQ respectivamente.

4. Número máximo de iterações do método de cálculo do fluxo de carga que, quando alcançado, caracteriza uma não convergência do método de solução do fluxo de carga, representado por maxIter. Para criar uma instância da rede deve-se declarar como objeto local através da seguinte sintaxe:

TNetwork rede(Sbase, Vbase, errP, errQ, maxIter);

Onde rede é o objeto criado, Sbase é potência base em MVA, Vbase é a tensão base em kV, errP é o erro de potência ativa, errQ é o erro de potência reativa e maxIter é o número máximo de iterações do método de cálculo do fluxo de carga.

3.1.6.2 Cadastrando dispositivos na rede

Para cadastrar os dispositivos na rede (no objeto da classe TNetwork) é necessário utilizar um dos métodos de cadastro apresentados na Tabela 3-7.

Método Descrição

AddArea (TArea *) Cadastra uma área na rede. O argumento é um ponteiro para a área.

AddLoadModel (TLoad *) Cadastra um modelo de carga. O argumento é um ponteiro para o modelo de carga.

AddBus (TBus *) Cadastra uma barra. O argumento é um ponteiro para uma barra.

AddBranch (TBranch *) Cadastra um ramo. O argumento é um ponteiro para um ramo.

Tabela 3-7 - Métodos da classe TNetwork de cadastro de dispositivos na rede

Cada dispositivo cadastrado recebe um identificador sequencial que deverá ser usado quando for necessária uma referência ao dispositivo cadastrado. Ao realizar o cadastro das barras é necessário que as barras sejam cadastradas seguindo a sequencia:

1. Primeiro a barra de referência; 2. Em seguida as barras PV; 3. _{Por último as barras PQ.}

Para fazer referência a um dos dispositivos cadastrados, pode-se utilizar um dos métodos apresentados na Tabela 3-8.

Método Descrição

TArea *GetArea(unsigned int indx) Retorna o ponteiro da área cadastrada que recebeu o identificador indx. TLoad *GetLoadModel(unsigned int indx) Retorna o ponteiro do modelo de carga

cadastrado que recebeu o identificador indx.

TBus *GetBus(unsigned int indx) Retorna o ponteiro da barra cadastrada que recebeu o identificador indx. TBranch *GetBranch(unsigned int indx) Retorna o ponteiro para o ramo

cadastrado que recebeu o identificador indx.

Tabela 3-8 - Métodos para referenciar os dispositivos cadastrados

O fragmento de código na Figura 3-2 ilustra o cadastramento de uma área e de um modelo de carga, forma que é recomendado para este Framework.

1 #include <bcssd/core/include/bcssd.h>

2 using namespace bcssd;

3 int main ()

4 {

5 TNetwork rede(100.0, 230, 1e-3, 1e-3, 5);

6 rede.AddArea(TArea::CreateArea("Eletronorte Pará", 4000.0, 9000.0, 2000.0));

7 rede.AddLoadModel(TLoad::CreateLoadModel("Carga pesada", 0.6, 0.9, 0.6, 0.1,8

0.05, 0.09)); ...

9 }

Figura 3-2 - Exemplo de cadastramento de uma área e de um modelo de carga

Na linha 1 da Figura 3-2 é incluído o arquivo de cabeçalho mestre que carrega todas as definições necessárias ao Framework. Na linha 5 é criada a instância nomeada como rede com potência base de 100MVA, tensão base de 230kV, erros de 1e-3 e o número máximo de iterações é cinco. Na linha 6 é criada e cadastrada uma instância da área nomeada “Eletronorte Pará”. Nas linhas 7 e 8 é criado e cadastrado um modelo de carga. Quando o objeto rede for destruído (quando sair do contexto, por exemplo) todos os dispositivos cadastrados serão destruídos e a memória usada é devolvida ao sistema operacional.

Para exemplificar o cadastro de barras e ramos para montagem da rede elétrica foi usado o exemplo de nove barras e três máquinas encontrado na referência (Anderson & Fouad, 2002):

1 2 3 4 5 6 7 8 9 Carga A Carga B Carga C

Figura 3-3 - Exemplo de rede elétrica

A primeira barra a ser cadastrada é a barra de referência que receberá o identificador um como indicado na Figura 3-3, em seguida as barras PV e por último as barras PQ, como apresentado no fragmento de código na Figura 3-4.

#include <bcssd/core/include/bcssd.h>

using namespace bcssd;

int main () {

TNetwork rede(100.0, 230, 1e-3, 1e-3, 5); rede.AddBus(TBus::CreateRefBus(

"Barra 1",0.0,1.04,0.0,0.0,0.0,0.0,0.0,

NULL,NULL,0.0,NULL,INBUS,100.0,230.0)); rede.AddBus(TBus::CreatePVBus(

"Barra 2",0.0,1.025,0.0,163.0,0.0,0.0,0.0,

NULL,NULL,0.0,NULL,INBUS,100.0,230.0)); rede.AddBus(TBus::CreatePVBus(

"Barra 3",0.0,1.025,0.0,85.0,0.0,0.0,0.0,

NULL,NULL,0.0,NULL,INBUS,100.0,230.0)); rede.AddBus(TBus::CreatePQBus(

"Barra 4",0.0,1.0,0.0,0.0,0.0,0.0,0.0, NULL,NULL,0.0,NULL,INBUS,100.0,230.0));

... }

como se deve proceder ao cadastrar o ramo que conecta as barras 4 e 5 do diagrama na Figura 3-3. rede.AddBranch(TBranch::CreateBranch(

"Linha 1",rede.GetBus(4),rede.GetBus(5), 1.0,0.0,0.01,0.085,0.088,

BRANCHNONE,0.0,NULL,100.0,230));

Figura 3-5 - Cadastro de uma linha de transmissão do sistema na Figura 3-3

Pode-se notar na Figura 3-5 que foi feito referencia às barras 4 e 5 utilizando rede.GetBus(4) e rede.GetBus(5).

Após o cadastro de todos os equipamentos, podem-se utilizar os métodos para cálculo de fluxo de carga. O método Arrange() deve ser chamado para que as estruturas de dados internas sejam inicializadas e a matriz admitância de rede seja calculada. Ao chamar o método LoadFlow() o fluxo de carga é calculado e então o resultado pode ser obtido nos objetos das barras e ramos. O fragmento de código na Figura 3-6 ilustra este procedimento.

1 rede.Arrange();

2 if (rede.LoadFlow())

3 cout<<*rede.GetBus(1)<<endl;

Figura 3-6 - Cálculo do fluxo de carga

Na Figura 3-6, na linha 1 são inicializadas as estruturas de dados necessárias ao cálculo do fluxo de carga e a matriz admitância de rede é determinada. Na linha 2 o método LoadFlow retorna verdadeiro se o fluxo de carga convergiu ou falso se não houver convergência. Caso o fluxo de carga tenha convergido (LoadFlow retornou verdadeiro), a linha 3 é executada e o estado da “barra 1” é exibida (potências geradas, consumidas e tensão). Em todas as classes que modelam a rede elétrica está sobrecarregado o operador de inserção em uma stream, como mostrado através da linha 3.

3.2

Conclusão

Neste capítulo foi apresentada a modelagem orientada a objetos implementada no Framework para representar a rede elétrica dos sistemas elétricos de potência. O resultado do fluxo de carga será usado pelas classes que representam os dispositivos dinâmicos para o estabelecimento das condições de contorno das suas equações diferenciais. A classe TNetwork também é responsável pelo cálculo da matriz admitância usada na solução das equações da rede elétrica na simulação dinâmica do sistema de potência

Ainda referente à classe TNetwork, ela é derivada da classe TBlock e, portanto, como será visto no capítulo 5, ela é modelada como um dispositivo dinâmico.

4

Modelagem e implementação orientada a objetos para