def curtoTrifasico(elemento):
curto3 = 1.0 * elemento.base.corrente / (
elemento.impedancia_equivalente_positiva)
correntecc = Fasor(real=curto3.real, imag=curto3.imag, tipo=Fasor.Corrente)
correntecc.base = elemento.base
return correntecc
def config_objects(subestacao):
for transformador in subestacao.transformadores.values():
subestacao.base_sub = Base(transformador.tensao_secundario.mod,
transformador.potencia.mod)
break
for alimentador in subestacao.alimentadores.values():
for trecho in alimentador.trechos.values():
trecho.impedancia_positiva = (
trecho.condutor.rp +
trecho.condutor.xp * 1j) * trecho.comprimento
trecho.impedancia_zero = (trecho.condutor.rz + trecho.condutor.xz *
1j) * trecho.comprimento
trecho.base = subestacao.base_sub
trecho.impedancia_positiva = trecho.impedancia_positiva / trecho.base.impedancia
trecho.impedancia_zero = trecho.impedancia_zero / trecho.base.impedancia
for chave in alimentador.chaves.values():
chave.resistencia_contato = 100
chave.base = subestacao.base_sub
chave.fluxo = Fasor(real=0.0, imag=0.0, tipo=Fasor.Corrente)
for noDeCarga in alimentador.nos_de_carga.values():
noDeCarga.resistencia_contato = 100
noDeCarga.base = subestacao.base_sub
noDeCarga.fluxo = Fasor(real=0.0, imag=0.0, tipo=Fasor.Corrente)
calculaimpedanciaeq(subestacao)
def curtoMonofasico(elemento):
curto1 = (3.0) * elemento.base.corrente / (
2 * elemento.impedancia_equivalente_positiva +
elemento.impedancia_equivalente_zero)
correntecc = Fasor(real=curto1.real, imag=curto1.imag, tipo=Fasor.Corrente)
correntecc.base = elemento.base
return correntecc
def curtoMonofasicoMinimo(elemento):
curto1m = 3.0 * elemento.base.corrente / (
2 * elemento.impedancia_equivalente_positiva +
elemento.impedancia_equivalente_zero +
3 * elemento.resistencia_contato / elemento.base.impedancia)
correntecc = Fasor(real=curto1m.real,
imag=curto1m.imag,
tipo=Fasor.Corrente)
correntecc.base = elemento.base
return correntecc
def _atribuir_tensao_a_subestacao(subestacao, tensao):
""" Função que atribui tensão à subestação
e a define para todos os nós de carga"""
subestacao.tensao = tensao
for alimentador in subestacao.alimentadores.values():
for no in alimentador.nos_de_carga.values():
no.tensao = Fasor(real=tensao.real,
imag=tensao.imag,
tipo=Fasor.Tensao)
for trecho in alimentador.trechos.values():
trecho.fluxo = Fasor(real=0.0, imag=0.0, tipo=Fasor.Corrente)
def calcular_fluxo_de_carga(subestacao):
trafos = subestacao.transformadores.keys()
T1 = subestacao.transformadores[trafos[0]]
# atribui a tensão de fase da barra da subestação a todos
# os nós de carga da subestação
f1 = Fasor(mod=T1.tensao_secundario.mod / np.sqrt(3),
ang=0.0,
tipo=Fasor.Tensao)
_atribuir_tensao_a_subestacao(subestacao, f1)
for alimentador in subestacao.alimentadores.values():
max_iteracaoes = 100
criterio_converg = 0.001
converg = 1e6
iter = 0
# print '============================'
# print 'Varredura no alimentador {al}'.format(al=alimentador.nome)
converg_nos = dict()
for no in alimentador.nos_de_carga.values():
converg_nos[no.nome] = 1e6
while iter <= max_iteracaoes and converg > criterio_converg:
iter += 1
# print '-------------------------'
# print 'Iteração: {iter}'.format(iter=iter)
tensao_nos = dict()
for no in alimentador.nos_de_carga.values():
tensao_nos[no.nome] = Fasor(real=no.tensao.real,
imag=no.tensao.imag,
tipo=Fasor.Tensao)
_varrer_alimentador(alimentador)
for no in alimentador.nos_de_carga.values():
converg_nos[no.nome] = abs(tensao_nos[no.nome].mod -
no.tensao.mod)
converg = max(converg_nos.values())
# print 'Max. diferença de tensões: {conv}'.format(conv=converg)
# for atualiza os valores das tensões dos nós de carga para valores
# de tensão de linha
subestacao.tensao.mod = subestacao.tensao.mod * np.sqrt(3)
nos = list()
for alimentador in subestacao.alimentadores.values():
for no in alimentador.nos_de_carga.values():
if no.nome not in nos:
no.tensao.mod = no.tensao.mod * np.sqrt(3)
nos.append(no.nome)
def __init__(self,
nome,
vizinhos,
potencia=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
tensao=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
chaves=None):
super(Barramento, self).__init__(nome,
vizinhos,
potencia=Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia),
tensao=Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Tensao),
chaves=None)
def calcular_potencia(self):
potencia = Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia)
for no in self.nos_de_carga.values():
potencia = potencia + no.potencia
return potencia
def gerar_transformadores(arquivo): # gera os objetos do tipo Transformador
wb=xl.load_workbook(arquivo)
transformadores_sheet=wb.get_sheet_by_name('transformadores')
transformadores=list()
for i in range(2,transformadores_sheet.max_column+1):
transformador=OrderedDict()
nome=str(transformadores_sheet.cell(row=10,column=i).value).upper()+'_'+str(transformadores_sheet.cell(row=1,column=i).value).upper()
#float(trechos_sheet.cell(row=i, column=6).value)
tensao_primario_mod=float(transformadores_sheet.cell(row=2,column=i).value)*1e3
tensao_primario_ang=float(transformadores_sheet.cell(row=3,column=i).value)
tensao_secundario_mod=float(transformadores_sheet.cell(row=4,column=i).value)*1e3
tensao_secundario_ang=float(transformadores_sheet.cell(row=5,column=i).value)
potencia_mod=float(transformadores_sheet.cell(row=6,column=i).value)*1e6
potencia_ang=float(transformadores_sheet.cell(row=7,column=i).value)
impedancia_real=float(transformadores_sheet.cell(row=8,column=i).value)
impedancia_imag=float(transformadores_sheet.cell(row=9,column=i).value)
transformador=Transformador(nome=nome,
tensao_primario=Fasor(mod=tensao_primario_mod,ang=tensao_primario_ang,tipo=Fasor.Tensao),
tensao_secundario=Fasor(mod=tensao_secundario_mod,ang=tensao_secundario_ang,tipo=Fasor.Tensao),
potencia=Fasor(mod=potencia_mod,ang=potencia_ang,tipo=Fasor.Potencia),
impedancia=Fasor(real=impedancia_real,imag=impedancia_imag,tipo=Fasor.Impedancia))
transformadores.append(transformador)
return transformadores
def __init__(self,
nome,
vizinhos,
potencia=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
tensao=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
chaves=None):
assert isinstance(nome, str), 'O parâmetro nome da classe NoDeCarga' \
' deve ser do tipo string'
assert isinstance(vizinhos, list), 'O parâmetro vizinhos da classe' \
' Barra deve ser do tipo string'
self.nome = nome
self.vizinhos = vizinhos
self.potencia = potencia
self.potencia_eq = Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia)
self.tensao = tensao
if chaves is not None:
assert isinstance(chaves, list), 'O parâmetro chaves da classe NoDeCarga' \
' deve ser do tipo list'
self.chaves = chaves
else:
self.chaves = list()
self.setor = None
def gerar_nos_de_carga(vizinhos,dados): #Gera os objetos NoDeCarga
potencia=dados['nos']
chaves=dados['chaves']
nos_de_cargas=list()
chaves_vizinhas=list()
for i in range(len(vizinhos)):
chave_vizinha=OrderedDict()
chave_vizinha['nome']=vizinhos[i]['no']
chave_vizinha['vizinhos']=list()
for j in range(len(vizinhos[i]['vizinhos'])):
if vizinhos[i]['vizinhos'][j] in chaves:
chave_vizinha['vizinhos'].append(vizinhos[i]['vizinhos'][j])
chaves_vizinhas.append(chave_vizinha)
for i in range(len(vizinhos)):
nos_de_carga=OrderedDict()
nome=vizinhos[i]['no'].upper()
real= potencia[i]['P']*1e3
img=potencia[i]['Q']*1e3
vizinhos_i=[]
chaves_i=chaves_vizinhas[i]['vizinhos']
for j in range(len(vizinhos[i]['vizinhos'])):
if vizinhos[i]['vizinhos'][j] not in chaves:
vizinhos_i.append(vizinhos[i]['vizinhos'][j].upper())
else:
for x in range(len(vizinhos)):
if vizinhos[i]['vizinhos'][j] in vizinhos[x]['vizinhos'] and x!=i:
vizinhos_i.append(vizinhos[x]['no'].upper())
nos_de_carga=NoDeCarga(nome=nome,vizinhos=vizinhos_i,potencia=Fasor(real=real, imag=img, tipo=Fasor.Potencia), chaves=chaves_i)
nos_de_cargas.append(nos_de_carga)
return nos_de_cargas
ch2 = Chave(nome='2', estado=1)
ch3 = Chave(nome='3', estado=1)
# chaves de Fronteira
ch4 = Chave(nome='4', estado=0)
ch5 = Chave(nome='5', estado=0)
ch8 = Chave(nome='8', estado=0)
# chaves do alimentador de S2
ch6 = Chave(nome='6', estado=1)
ch7 = Chave(nome='7', estado=1)
# Nos de carga do alimentador S1_AL1
s1 = NoDeCarga(nome='S1',
vizinhos=['A2'],
potencia=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
chaves=['1'])
a1 = NoDeCarga(nome='A1',
vizinhos=['A2'],
potencia=Fasor(real=160.0e3, imag=120.0e3, tipo=Fasor.Potencia))
a2 = NoDeCarga(nome='A2',
vizinhos=['S1', 'A1', 'A3', 'C1'],
potencia=Fasor(real=150.0e3, imag=110.0e3, tipo=Fasor.Potencia),
chaves=['1', '3'])
a3 = NoDeCarga(nome='A3',
vizinhos=['A2', 'B1'],
potencia=Fasor(real=100.0e3, imag=80.0e3, tipo=Fasor.Potencia),
chaves=['2'])
b1 = NoDeCarga(nome='B1',
vizinhos=['B2', 'A3'],
potencia=Fasor(real=200.0e3, imag=140.0e3, tipo=Fasor.Potencia),
def _varrer_alimentador(alimentador):
""" Função que varre os alimentadores pelo
método varredura direta/inversa"""
# guarda os nós de carga na variável nos_alimentador
nos_alimentador = alimentador.nos_de_carga.values()
# guarda a rnp dos nós de carga na variável rnp_alimentador
rnp_alimentador = alimentador.arvore_nos_de_carga.rnp
# guarda a árvore de cada nós de carga
arvore_nos_de_carga = alimentador.arvore_nos_de_carga.arvore
# variáveis para o auxílio na determinação do nó mais profundo
prof_max = 0
# for percorre a rnp dos nós de carga tomando valores
# em pares (profundidade, nó).
for no_prof in rnp_alimentador.transpose():
# pega os nomes dos nós de carga.
nos_alimentador_nomes = [no.nome for no in nos_alimentador]
# verifica se a profundidade do nó é maior do que a
# profundidade máxima e se ele está na lista de nós do alimentador.
if (int(no_prof[0]) > prof_max) \
and (no_prof[1] in nos_alimentador_nomes):
prof_max = int(no_prof[0])
# prof recebe a profundidae máxima determinada
prof = prof_max
# seção do cálculo das potências partindo dos
# nós com maiores profundidades até o nó raíz
while prof >= 0:
# guarda os nós com maiores profundidades.
nos = [alimentador.nos_de_carga[no_prof[1]]
for no_prof in rnp_alimentador.transpose() if
int(no_prof[0]) == prof]
# decrementodo da profundidade.
prof -= 1
# for que percorre os nós com a profundidade
# armazenada na variável prof
for no in nos:
# zera as potências para que na próxima
# iteração não ocorra acúmulo.
no.potencia_eq.real = 0.0
no.potencia_eq.imag = 0.0
# armazena a árvore do nó de carga
# armazenado na variável nó
vizinhos = arvore_nos_de_carga[no.nome]
# guarda os pares (profundidade, nó)
no_prof = [no_prof for no_prof in rnp_alimentador.transpose()
if no_prof[1] == no.nome]
vizinhos_jusante = list()
# for que percorre a árvore de cada nó de carga
for vizinho in vizinhos:
# verifica quem é vizinho do nó desejado.
vizinho_prof = [viz_prof for viz_prof in
rnp_alimentador.transpose()
if viz_prof[1] == vizinho]
# verifica se a profundidade do vizinho é maior
if int(vizinho_prof[0][0]) > int(no_prof[0][0]):
# armazena os vizinhos a jusante.
vizinhos_jusante.append(
alimentador.nos_de_carga[vizinho_prof[0][1]])
# verifica se não há vizinho a jusante,
# se não houverem o nó de carga analisado
# é o último do ramo.
if vizinhos_jusante == []:
no.potencia_eq.real += no.potencia.real / 3.0
no.potencia_eq.imag += no.potencia.imag / 3.0
else:
# soma a potencia da carga associada ao nó atual
no.potencia_eq.real += no.potencia.real / 3.0
no.potencia_eq.imag += no.potencia.imag / 3.0
# acrescenta à potência do nó atual
# as potências dos nós a jusante
for no_jus in vizinhos_jusante:
no.potencia_eq.real += no_jus.potencia_eq.real
no.potencia_eq.imag += no_jus.potencia_eq.imag
# chama a função busca_trecho para definir
# quais trechos estão entre o nó atual e o nó a jusante
trecho = _busca_trecho(alimentador,
no.nome,
no_jus.nome)
# se o trecho não for uma instancia da classe
# Trecho(quando há chave entre nós de cargas)
# a impedância é calculada
if not isinstance(trecho, Trecho):
r1, x1 = trecho[0].calcula_impedancia()
r2, x2 = trecho[1].calcula_impedancia()
r, x = r1 + r2, x1 + x2
# se o trecho atual for uma instancia da classe trecho
else:
r, x = trecho.calcula_impedancia()
# calculo das potências dos nós de carga a jusante.
no.potencia_eq.real += r * (no_jus.potencia_eq.mod ** 2) / \
no_jus.tensao.mod ** 2
no.potencia_eq.imag += x * (no_jus.potencia_eq.mod ** 2) / \
no_jus.tensao.mod ** 2
prof = 0
# seção do cálculo de atualização das tensões
while prof <= prof_max:
# salva os nós de carga a montante
nos = [alimentador.nos_de_carga[col_no_prof[1]]
for col_no_prof in rnp_alimentador.transpose()
if int(col_no_prof[0]) == prof + 1]
# percorre os nós para guardar a árvore do nó requerido
for no in nos:
vizinhos = arvore_nos_de_carga[no.nome]
# guarda os pares (profundidade,nó)
no_prof = [col_no_prof
for col_no_prof in rnp_alimentador.transpose()
if col_no_prof[1] == no.nome]
vizinhos_montante = list()
# verifica quem é vizinho do nó desejado.
for vizinho in vizinhos:
vizinho_prof = [viz_prof
for viz_prof in rnp_alimentador.transpose()
if viz_prof[1] == vizinho]
if int(vizinho_prof[0][0]) < int(no_prof[0][0]):
# armazena os vizinhos a montante.
vizinhos_montante.append(
alimentador.nos_de_carga[vizinho_prof[0][1]])
# armazena o primeiro vizinho a montante
no_mon = vizinhos_montante[0]
trecho = _busca_trecho(alimentador, no.nome, no_mon.nome)
# se existir chave, soma a resistência dos dois trechos
if not isinstance(trecho, Trecho):
r1, x1 = trecho[0].calcula_impedancia()
r2, x2 = trecho[1].calcula_impedancia()
r, x = r1 + r2, x1 + x2
# caso não exista, a resistência é a do próprio trecho
else:
r, x = trecho.calcula_impedancia()
v_mon = no_mon.tensao.mod
p = no.potencia_eq.real
q = no.potencia_eq.imag
# parcela de perdas
p += r * (no.potencia_eq.mod ** 2) / no.tensao.mod ** 2
q += x * (no.potencia_eq.mod ** 2) / no.tensao.mod ** 2
v_jus = v_mon ** 2 - 2 * (r * p + x * q) + \
(r ** 2 + x ** 2) * (p ** 2 + q ** 2) / v_mon ** 2
v_jus = np.sqrt(v_jus)
k1 = (p * x - q * r) / v_mon
k2 = v_mon - (p * r - q * x) / v_mon
ang = no_mon.tensao.ang * np.pi / 180.0 - np.arctan(k1 / k2)
no.tensao.mod = v_jus
no.tensao.ang = ang * 180.0 / np.pi
print 'Tensao do no {nome}: {tens}'.format(
nome=no.nome,
tens=no.tensao.mod * np.sqrt(3) / 1e3)
# calcula o fluxo de corrente passante no trecho
corrente = no.tensao.real - no_mon.tensao.real
corrente += (no.tensao.imag - no_mon.tensao.imag) * 1.0j
corrente /= (r + x * 1.0j)
# se houver chaves, ou seja, há dois trechos a mesma corrente
# é atribuida
if not isinstance(trecho, Trecho):
trecho[0].fluxo = Fasor(real=corrente.real,
imag=corrente.imag,
tipo=Fasor.Corrente)
trecho[1].fluxo = Fasor(real=corrente.real,
imag=corrente.imag,
tipo=Fasor.Corrente)
else:
trecho.fluxo = Fasor(real=corrente.real,
imag=corrente.imag,
tipo=Fasor.Corrente)
prof += 1
def curtoBifasico(elemento):
curto2 = (3**0.5) * elemento.base.corrente / (
2 * elemento.impedancia_equivalente_positiva)
correntecc = Fasor(real=curto2.real, imag=curto2.imag, tipo=Fasor.Corrente)
correntecc.base = elemento.base
return correntecc
def _calcula_curto_monofasico(trecho):
curto1 = (3.0) * trecho.base.corrente / (2 * trecho.impedancia_equivalente_positiva + trecho.impedancia_equivalente_zero)
correntecc = Fasor(real=curto1.real, imag=curto1.imag, tipo=Fasor.Corrente)
correntecc.base = trecho.base
return correntecc
def _calcula_curto_monofasico_minimo(trecho):
curto1m = 3.0 * trecho.base.corrente / (2 * trecho.impedancia_equivalente_positiva + trecho.impedancia_equivalente_zero+3*trecho.resistencia_contato/trecho.base.impedancia)
correntecc = Fasor(real=curto1m.real, imag=curto1m.imag, tipo=Fasor.Corrente)
correntecc.base = trecho.base
return correntecc
def _calcula_curto_trifasico(trecho):
curto3 = 1.0 * trecho.base.corrente / (trecho.impedancia_equivalente_positiva)
correntecc = Fasor(real=curto3.real, imag=curto3.imag, tipo=Fasor.Corrente)
correntecc.base = trecho.base
return correntecc
def _calcula_curto_bifasico(trecho):
curto2 = (3 ** 0.5) * trecho.base.corrente / (2 * trecho.impedancia_equivalente_positiva)
correntecc = Fasor(real=curto2.real, imag=curto2.imag, tipo=Fasor.Corrente)
correntecc.base = trecho.base
return correntecc