def calcular_potencia(self):
potencia_fase_a = Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia)
potencia_fase_b = Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia)
potencia_fase_c = Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia)
for no in self.nos_de_carga.values():
potencia_fase_a = potencia_fase_a + no.potencia_fase_a
potencia_fase_b = potencia_fase_b + no.potencia_fase_b
potencia_fase_c = potencia_fase_c + no.potencia_fase_c
return potencia_fase_a, potencia_fase_b, potencia_fase_c
def __init__(
self,
nome,
n1,
n2,
#local,
#config_tr,
fluxo_fase_a=None,
fluxo_fase_b=None,
fluxo_fase_c=None,
condutor=None,
comprimento=None,
resistenciacontato=100):
assert isinstance(nome, str), 'O parâmetro nome da classe Trecho ' \
'deve ser do tipo str'
assert isinstance(n1, NoDeCarga) or isinstance(n1, Chave) or isinstance(n1, Gerador), 'O parâmetro n1 da classe Trecho ' \
'deve ser do tipo No de carga ' \
'ou do tipo Chave'
assert isinstance(n2, NoDeCarga) or isinstance(n2, Chave) or isinstance(n2, Gerador), 'O parâmetro n2 da classe Trecho ' \
'deve ser do tipo No de carga ' \
'ou do tipo Chave'
super(Trecho, self).__init__(nome)
self.n1 = n1
self.n2 = n2
self.no_montante = None
self.no_jusante = None
#self.config_tr = config_tr
#self.local = local
self.condutor = condutor
self.comprimento = comprimento
self.impedancia_positiva = (self.condutor.rp +
self.condutor.xp * 1j) * self.comprimento
self.impedancia_zero = (self.condutor.rz +
self.condutor.xz * 1j) * self.comprimento
#self.resistencia_contato = resistenciacontato
if fluxo_fase_a is None:
self.fluxo_fase_a = Fasor(real=0.0, imag=0.0, tipo=Fasor.Corrente)
else:
self.fluxo_fase_a = fluxo_fase_a
if fluxo_fase_a is None:
self.fluxo_fase_b = Fasor(real=0.0, imag=0.0, tipo=Fasor.Corrente)
else:
self.fluxo_fase_b = fluxo_fase_b
if fluxo_fase_a is None:
self.fluxo_fase_c = Fasor(real=0.0, imag=0.0, tipo=Fasor.Corrente)
else:
self.fluxo_fase_c = fluxo_fase_c
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 desativaGD(self): # adicionado por felipe
if self.ativo:
self.ativo = False
self.potencia_fase_a = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.potencia_fase_a = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.potencia_fase_a = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
else:
pass
def ativaGD(self): # adicionado por felipe
if self.ativo:
pass
else:
self.ativo = True
self.potencia_fase_a = Fasor(real=self.potencia_nominal.real,
imag=self.potencia_nominal.imag,
tipo=Fasor.Potencia)
self.potencia_fase_b = Fasor(real=self.potencia_nominal.real,
imag=self.potencia_nominal.imag,
tipo=Fasor.Potencia)
self.potencia_fase_c = Fasor(real=self.potencia_nominal.real,
imag=self.potencia_nominal.imag,
tipo=Fasor.Potencia)
def __init__(
self,
nome,
vizinhos,
#conexao,
modelo,
potencia_fase_a=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
potencia_fase_b=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
potencia_fase_c=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
tensao_fase_a=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
tensao_fase_b=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
tensao_fase_c=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.conexao = conexao
self.modelo = modelo
self.potencia_fase_a = potencia_fase_a
self.potencia_fase_b = potencia_fase_b
self.potencia_fase_c = potencia_fase_c
self.potencia_eq_fase_a = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.potencia_eq_fase_b = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.potencia_eq_fase_c = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.tensao_fase_a = tensao_fase_a
self.tensao_fase_b = tensao_fase_b
self.tensao_fase_c = tensao_fase_c
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(self):
# Busca e instanciamento dos objetos do tipo NoDeCarga
print 'Gerando Nos de Carga...'
nos_xml = self.ELEMENTOS.find_all('no')
nos = dict()
for no_tag in nos_xml:
elemento_tag = self.TOPO.find_all('elemento',
tipo='no',
nome=no_tag['nome'])[0]
#if elemento_tag is not None:
# elemento_tag.reverse()
vizinhos = [
no['nome'] for no in elemento_tag.vizinhos.findChildren('no')
]
vizinhos.reverse()
chaves_do_no = [
chave['nome']
for chave in elemento_tag.chaves.findChildren('chave')
]
potencia_ativa_tag = no_tag.find_all('potencia', tipo='ativa')[0]
potencia_reativa_tag = no_tag.find_all('potencia',
tipo='reativa')[0]
if potencia_ativa_tag['multip'] == 'k':
potencia_ativa = float(potencia_ativa_tag.text) * 1e3
elif potencia_ativa_tag['multip'] == 'M':
potencia_ativa = float(potencia_ativa_tag.text) * 1e6
else:
potencia_ativa = float(potencia_ativa_tag.text)
if potencia_reativa_tag['multip'] == 'k':
potencia_reativa = float(potencia_reativa_tag.text) * 1e3
elif potencia_reativa_tag['multip'] == 'M':
potencia_reativa = float(potencia_reativa_tag.text) * 1e6
else:
potencia_reativa = float(potencia_reativa_tag.text)
print potencia_ativa
print potencia_reativa
print chaves_do_no
nos[no_tag['nome']] = NoDeCarga(nome=no_tag['nome'],
vizinhos=vizinhos,
potencia=Fasor(
real=potencia_ativa,
imag=potencia_reativa,
tipo=Fasor.Potencia),
chaves=chaves_do_no)
print 'NoDeCarga %s criado.' % nos[no_tag['nome']].nome
return nos
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_transformadores(self):
# Busca e instanciamento dos objetos do tipo Transformador
print 'Gerando Transformadores'
transformadores_xml = self.ELEMENTOS.find_all('transformador')
transformadores = dict()
for trafo_tag in transformadores_xml:
tensao_primario_tag = trafo_tag.find_all('enrolamento',
tipo='primario')[0].tensao
if tensao_primario_tag['multip'] == 'k':
tensao_primario = float(tensao_primario_tag.text) * 1e3
elif tensao_primario_tag['multip'] == 'M':
tensao_primario = float(tensao_primario_tag.text) * 1e6
else:
tensao_primario = float(tensao_primario_tag.text)
tensao_secundario_tag = trafo_tag.find_all(
'enrolamento', tipo='secundario')[0].tensao
if tensao_secundario_tag['multip'] == 'k':
tensao_secundario = float(tensao_secundario_tag.text) * 1e3
elif tensao_secundario_tag['multip'] == 'M':
tensao_secundario = float(tensao_secundario_tag.text) * 1e6
else:
tensao_secundario = float(tensao_secundario_tag.text)
potencia_tag = trafo_tag.find_all('potencia')[0]
if potencia_tag['multip'] == 'k':
potencia = float(potencia_tag.text) * 1e3
elif potencia_tag['multip'] == 'M':
potencia = float(potencia_tag.text) * 1e6
else:
potencia = float(potencia_tag.text)
impedancia_tag = trafo_tag.find_all('impedancia',
tipo='seq_pos')[0]
resistencia_tag = impedancia_tag.resistencia
reatancia_tag = impedancia_tag.reatancia
if resistencia_tag['multip'] == 'k':
resistencia = float(resistencia_tag.text) * 1e3
elif resistencia_tag['multip'] == 'M':
resistencia = float(resistencia_tag.text) * 1e6
else:
resistencia = float(resistencia_tag.text)
if reatancia_tag['multip'] == 'k':
reatancia = float(reatancia_tag.text) * 1e3
elif resistencia_tag['multip'] == 'M':
reatancia = float(reatancia_tag.text) * 1e6
else:
reatancia = float(reatancia_tag.text)
transformadores[trafo_tag['nome']] = Transformador(
nome=trafo_tag['nome'],
tensao_primario=Fasor(mod=tensao_primario,
ang=0.0,
tipo=Fasor.Tensao),
tensao_secundario=Fasor(mod=tensao_secundario,
ang=0.0,
tipo=Fasor.Tensao),
potencia=Fasor(mod=potencia, ang=0.0, tipo=Fasor.Potencia),
impedancia=Fasor(real=resistencia,
imag=reatancia,
tipo=Fasor.Impedancia))
return transformadores
def __init__(
self,
nome,
ativo,
vizinhos,
interface_rede,
#maquina,
modelo,
conexao,
qmin,
qmax,
tensaogerador,
dvtol,
x0=0.0j,
x1=0.0j,
x2=0.0j,
xsubt=0.0j,
xsobrer=0.0,
potencia_nominal=Fasor(
real=0.0, imag=0.0,
tipo=Fasor.Potencia), # adicionado por felipe
#potencia_fase_a=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
#potencia_fase_b=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
#potencia_fase_c=Fasor(real=0.0, imag=0.0, tipo=Fasor.Potencia),
tensao_fase_a=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
tensao_fase_b=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
tensao_fase_c=Fasor(real=0.0, imag=0.0, tipo=Fasor.Tensao),
chaves=None):
self.nome = nome
self.ativo = ativo
self.vizinhos = vizinhos
#self.potencia_fase_a = potencia_fase_a
#self.potencia_fase_b = potencia_fase_b
#self.potencia_fase_c = potencia_fase_c
self.potencia_nominal = potencia_nominal
if self.ativo: # adicionado por felipe
self.potencia_fase_a = Fasor(real=self.potencia_nominal.real,
imag=self.potencia_nominal.imag,
tipo=Fasor.Potencia)
self.potencia_fase_b = Fasor(real=self.potencia_nominal.real,
imag=self.potencia_nominal.imag,
tipo=Fasor.Potencia)
self.potencia_fase_c = Fasor(real=self.potencia_nominal.real,
imag=self.potencia_nominal.imag,
tipo=Fasor.Potencia)
else:
self.potencia_fase_a = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.potencia_fase_b = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.potencia_fase_c = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.dvtol = dvtol
self.potencia_eq_fase_a = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.potencia_eq_fase_b = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.potencia_eq_fase_c = Fasor(real=0.0,
imag=0.0,
tipo=Fasor.Potencia)
self.tensao_fase_a = tensao_fase_a
self.tensao_fase_b = tensao_fase_b
self.tensao_fase_c = tensao_fase_c
self.interface_rede = interface_rede
#self.maquina = maquina
self.modelo = modelo
self.conexao = conexao
self.qmin = qmin
self.qmax = qmax
self.tensaogerador = tensaogerador
self.corrente_nominal = 1
if self.interface_rede == 'INVERSOR':
self.corrente_curto = 2 * self.corrente_nominal
self.x1 = 1
elif self.interface_rede == 'SINCRONO':
self.xsobrer = xsobrer
self.xsubt = xsubt
self.x0 = x0
self.r0 = self.x0 * (self.xsobrer)**-1
self.x1 = xsubt
self.r1 = self.x1 * (self.xsobrer)**-1
self.x2 = x2
self.r2 = self.x2 * (self.xsobrer)**-1
assert isinstance(interface_rede, str), 'O parâmetro interface_rede deve' \
'ser do tipo str'
# assert isinstance(maquina, str), 'O parâmetro maquina deve' \
# 'ser do tipo str'
assert isinstance(modelo, str), 'O parâmetro modelo deve' \
'ser do tipo str'
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
