def gera_arvore_nos_de_carga(self):
# define os nós de carga do setor raiz da subestação como os primeiros
# nós de carga a povoarem a arvore nós de carga e a rnp nós de carga
setor_raiz = self.setores[self.rnp[1][0]]
self.arvore_nos_de_carga = Arvore(
arvore=setor_raiz._gera_arvore_do_setor(), dtype=str)
self.arvore_nos_de_carga.ordena(raiz=setor_raiz.rnp[1][0])
# define as listas visitados e pilha, necessárias ao processo recursivo de visita
# dos setores da subestação
visitados = []
pilha = []
# inicia o processo iterativo de visita dos setores
# em busca de seus respectivos nós de carga
self._gera_arvore_nos_de_carga(setor_raiz, visitados, pilha)
def gera_arvore_nos_de_carga(self):
# define os nós de carga do setor raiz da subestação como os primeiros
# nós de carga a povoarem a arvore nós de carga e a rnp nós de carga
setor_raiz = self.setores[self.rnp[1][0]]
self.arvore_nos_de_carga = Arvore(arvore=setor_raiz._gera_arvore_do_setor(), dtype=str)
self.arvore_nos_de_carga.ordena(raiz=setor_raiz.rnp[1][0])
# define as listas visitados e pilha, necessárias ao processo recursivo de visita
# dos setores da subestação
visitados = []
pilha = []
# inicia o processo iterativo de visita dos setores
# em busca de seus respectivos nós de carga
self._gera_arvore_nos_de_carga(setor_raiz, visitados, pilha)
class Alimentador(Arvore):
def __init__(self, nome, setores, trechos, chaves):
assert isinstance(nome, str), 'O parâmetro nome da classe Alimentador' \
'deve ser do tipo string'
assert isinstance(setores, list), 'O parâmetro setores da classe' \
'Alimentador deve ser do tipo list'
assert isinstance(chaves, list), 'O parâmetro chaves da classe' \
'Alimentador deve ser do tipo list'
self.nome = nome
self.setores = dict()
for setor in setores:
self.setores[setor.nome] = setor
self.chaves = dict()
for chave in chaves:
self.chaves[chave.nome] = chave
self.nos_de_carga = dict()
for setor in setores:
for no in setor.nos_de_carga.values():
self.nos_de_carga[no.nome] = no
self.trechos = dict()
for trecho in trechos:
self.trechos[trecho.nome] = trecho
for setor in self.setores.values():
print 'Setor: ', setor.nome
setores_vizinhos = list()
for chave in self.chaves.values():
if chave.n1 is setor:
setores_vizinhos.append(chave.n2)
elif chave.n2 is setor:
setores_vizinhos.append(chave.n1)
for setor_vizinho in setores_vizinhos:
print 'Setor Vizinho: ', setor_vizinho.nome
nos_de_ligacao = list()
for i in setor.nos_de_carga.values():
for j in setor_vizinho.nos_de_carga.values():
if i.nome in j.vizinhos:
nos_de_ligacao.append((j, i))
for no in nos_de_ligacao:
setor.ordenar(no[1].nome)
setor.rnp_associadas[setor_vizinho.nome] = (no[0],
setor.rnp)
print 'RNP: ', setor.rnp
_arvore_da_rede = self._gera_arvore_da_rede()
super(Alimentador, self).__init__(_arvore_da_rede, str)
def ordenar(self, raiz):
super(Alimentador, self).ordenar(raiz)
for setor in self.setores.values():
caminho = self.caminho_no_para_raiz(setor.nome)
if setor.nome != raiz:
setor_jusante = caminho[1, 1]
setor.rnp = setor.rnp_associadas[setor_jusante][1]
def _gera_arvore_da_rede(self):
arvore_da_rede = {i: list() for i in self.setores.keys()}
for chave in self.chaves.values():
if chave.n1.nome in self.setores.keys() and chave.estado == 1:
arvore_da_rede[chave.n1.nome].append(chave.n2.nome)
if chave.n2.nome in self.setores.keys() and chave.estado == 1:
arvore_da_rede[chave.n2.nome].append(chave.n1.nome)
return arvore_da_rede
def gerar_arvore_nos_de_carga(self):
# define os nós de carga do setor raiz da subestação como os primeiros
# nós de carga a povoarem a arvore nós de carga e a rnp nós de carga
setor_raiz = self.setores[self.rnp[1][0]]
self.arvore_nos_de_carga = Arvore(
arvore=setor_raiz._gera_arvore_do_setor(), dtype=str)
self.arvore_nos_de_carga.ordenar(raiz=setor_raiz.rnp[1][0])
# define as listas visitados e pilha, necessárias ao
# processo recursivo de visita
# dos setores da subestação
visitados = []
pilha = []
# inicia o processo iterativo de visita dos setores
# em busca de seus respectivos nós de carga
self._gerar_arvore_nos_de_carga(setor_raiz, visitados, pilha)
def _gerar_arvore_nos_de_carga(self, setor, visitados, pilha):
# atualiza as listas de recursão
visitados.append(setor.nome)
pilha.append(setor.nome)
# for percorre os setores vizinhos ao setor atual
# que ainda não tenham sido visitados
vizinhos = setor.vizinhos
for i in vizinhos:
# esta condição testa se existe uma ligação
# entre os setores de uma mesma subestação, mas
# que possuem uma chave normalmente aberta entre eles.
# caso isto seja constatado o laço for é interrompido.
if i not in visitados and i in self.setores.keys():
for c in self.chaves.values():
if c.n1.nome == setor.nome and c.n2.nome == i:
if c.estado == 1:
break
else:
pass
elif c.n2.nome == setor.nome and c.n1.nome == i:
if c.estado == 1:
break
else:
pass
else:
continue
prox = i
setor_vizinho = self.setores[i]
no_insersao, rnp_insersao = setor_vizinho.rnp_associadas[
setor.nome]
arvore_insersao = setor_vizinho._gera_arvore_do_setor()
setor_vizinho.no_de_ligacao = no_insersao
setor_vizinho.rnp = rnp_insersao
self.arvore_nos_de_carga.inserir_ramo(
no_insersao.nome, (rnp_insersao, arvore_insersao),
no_raiz=rnp_insersao[1, 0])
break
else:
continue
else:
pilha.pop()
if pilha:
anter = pilha.pop()
return self._gerar_arvore_nos_de_carga(self.setores[anter],
visitados, pilha)
else:
return
return self._gerar_arvore_nos_de_carga(self.setores[prox], visitados,
pilha)
def atualizar_arvore_da_rede(self):
_arvore_da_rede = self._gera_arvore_da_rede()
self.arvore = _arvore_da_rede
def gerar_trechos_da_rede(self):
self.trechos = dict()
j = 0
for i in range(1, np.size(self.arvore_nos_de_carga.rnp, axis=1)):
prof_1 = int(self.arvore_nos_de_carga.rnp[0, i])
prof_2 = int(self.arvore_nos_de_carga.rnp[0, j])
while abs(prof_1 - prof_2) is not 1:
if abs(prof_1 - prof_2) == 0:
j -= 1
elif abs(prof_1 - prof_2) == 2:
j = i - 1
prof_2 = int(self.arvore_nos_de_carga.rnp[0, j])
else:
n_1 = str(self.arvore_nos_de_carga.rnp[1, j])
n_2 = str(self.arvore_nos_de_carga.rnp[1, i])
setor_1 = None
setor_2 = None
print 'Trecho: ' + n_1 + '-' + n_2
# verifica quais os nós de carga existentes nas extremidades do trecho
# e se existe uma chave no trecho
for setor in self.setores.values():
if n_1 in setor.nos_de_carga.keys():
setor_1 = setor
if n_2 in setor.nos_de_carga.keys():
setor_2 = setor
if setor_1 is not None and setor_2 is not None:
break
else:
if setor_1 is None:
n = n_1
else:
n = n_2
for setor in self.setores.values():
if n in setor.nos_de_carga.keys() and np.size(
setor.rnp, axis=1) == 1:
if setor_1 is None:
setor_1 = setor
else:
setor_2 = setor
break
if setor_1 != setor_2:
for chave in self.chaves.values():
if chave.n1 in (setor_1,
setor_2) and chave.n2 in (setor_1,
setor_2):
self.trechos[n_1 + n_2] = Trecho(
nome=n_1 + n_2,
n1=self.nos_de_carga[n_1],
n2=self.nos_de_carga[n_2],
chave=chave)
else:
self.trechos[n_1 + n_2] = Trecho(nome=n_1 + n_2,
n1=self.nos_de_carga[n_1],
n2=self.nos_de_carga[n_2])
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 podar(self, no, alterar_rnp=False):
poda = super(Alimentador, self).podar(no, alterar_rnp)
rnp_setores = poda[0]
arvore_setores = poda[1]
if alterar_rnp:
# for povoa dicionario com setores podados
setores = dict()
for i in rnp_setores[1, :]:
setor = self.setores.pop(i)
setores[setor.nome] = setor
# for povoa dicionario com nos de carga podados
nos_de_carga = dict()
for setor in setores.values():
for j in setor.nos_de_carga.values():
if j.nome in self.nos_de_carga.keys():
no_de_carga = self.nos_de_carga.pop(j.nome)
nos_de_carga[no_de_carga.nome] = no_de_carga
# for atualiza a lista de nós de carga da subestação
# excluindo os nós de carga podados
for setor in self.setores.values():
for no_de_carga in setor.nos_de_carga.values():
self.nos_de_carga[no_de_carga.nome] = no_de_carga
if no_de_carga.nome in nos_de_carga.keys():
nos_de_carga.pop(no_de_carga.nome)
# poda o ramo na arvore da subetação
poda = self.arvore_nos_de_carga.podar(setores[no].rnp[1, 0],
alterar_rnp=alterar_rnp)
rnp_nos_de_carga = poda[0]
arvore_nos_de_carga = poda[1]
# for povoa dicionario de chaves que estao nos trechos podados
# e retira do dicionario de chaves da arvore que esta sofrendo a poda
# as chaves que não fazem fronteira com os trechos remanescentes
chaves = dict()
for chave in self.chaves.values():
if chave.n1.nome in setores.keys():
if not chave.n2.nome in self.setores.keys():
chaves[chave.nome] = self.chaves.pop(chave.nome)
else:
chave.estado = 0
chaves[chave.nome] = chave
elif chave.n2.nome in setores.keys():
if not chave.n1.nome in self.setores.keys():
chaves[chave.nome] = self.chaves.pop(chave.nome)
else:
chave.estado = 0
chaves[chave.nome] = chave
# for poda os trechos dos setores podados e povoa o dicionario trechos
# para que possa ser repassado juntamente com os outros dados da poda
trechos = dict()
for no in rnp_nos_de_carga[1, :]:
for trecho in self.trechos.values():
if trecho.n1.nome == no or trecho.n2.nome == no:
trechos[trecho.nome] = self.trechos.pop(trecho.nome)
return (setores, arvore_setores, rnp_setores, nos_de_carga,
arvore_nos_de_carga, rnp_nos_de_carga, chaves, trechos)
else:
return rnp_setores
def inserir_ramo(self, no, poda, no_raiz=None):
(setores, arvore_setores, rnp_setores, nos_de_carga,
arvore_nos_de_carga, rnp_nos_de_carga, chaves, trechos) = poda
# atualiza setores do alimentador
self.setores.update(setores)
# atualiza os nos de carga do alimentador
self.nos_de_carga.update(nos_de_carga)
# atualiza as chaves do alimentador
self.chaves.update(chaves)
# atualiza os trechos do alimentador
self.trechos.update(trechos)
if no_raiz is None:
setor_inserir = setores[rnp_setores[1, 0]]
else:
setor_inserir = setores[no_raiz]
setor_insersao = self.setores[no]
# for identifica se existe alguma chave que permita a inserção do ramo na arvore
# da subestação que ira receber a inserção.
chaves_de_lig = dict()
# for percorre os nos de carga do setor de insersão
for i in self.setores[setor_insersao.nome].nos_de_carga.values():
# for percorre as chaves associadas ao no de carga
for j in i.chaves:
# for percorre os nos de carga do setor raiz do ramo a ser inserido
for w in setores[setor_inserir.nome].nos_de_carga.values():
# se a chave pertence aos nos de carga i e w então é uma chave de ligação
if j in w.chaves:
chaves_de_lig[j] = (i, w)
if not chaves_de_lig:
print 'A insersao não foi possível pois nenhuma chave de fronteira foi encontrada!'
return
i = randint(0, len(chaves_de_lig) - 1)
n1, n2 = chaves_de_lig[chaves_de_lig.keys()[i]]
self.chaves[chaves_de_lig.keys()[i]].estado = 1
if setor_inserir.nome == setores[rnp_setores[1, 0]].nome:
super(Alimentador,
self).inserir_ramo(no, (rnp_setores, arvore_setores))
else:
super(Alimentador,
self).inserir_ramo(no, (rnp_setores, arvore_setores),
no_raiz)
# atualiza a arvore de setores do alimentador
self.atualizar_arvore_da_rede()
# atualiza a arvore de nos de carga do alimentador
self.gerar_arvore_nos_de_carga()
def verifica_chave(self, n1, n2):
c = self.arvore_nos_de_carga.caminho_no_para_no(n1, n2)
if np.shape(c)[1] != 2:
raise AttributeError('Os nos n1 e n2 nao sao consecutivos!')
else:
trs = list()
# seleciona os trechos que tem algum dos nos nos extremos
for trecho in self.trechos.values():
if trecho.n1.nome == n1 or trecho.n2.nome == n1:
trs.append(trecho)
elif trecho.n1.nome == n2 or trecho.n2.nome == n2:
trs.append(trecho)
# percorre os trechos selecionados
for trecho in trs:
chaves = list()
# se for uma chave nos extremos seleciona
if type(trecho.n1) == Chave:
# verifica se existe outro trecho
# com a mesma chave nos extremos
for tr in trs:
if (tr.n1 == trecho.n1 or tr.n2 == trecho.n1)\
and tr is not trecho:
return trecho.n1
# se for uma chave nos extremos seleciona
elif type(trecho.n2) == Chave:
# verifica se existe outro trecho
# com a mesma chave nos extremos
for tr in trs:
if (tr.n1 == trecho.n2 or tr.n2 == trecho.n2)\
and tr is not trecho:
return trecho.n2
# se nao encontrar chave, retorna None
return None
def retorna_trecho(self, n1, n2):
trs = list()
for trecho in self.trechos.values():
if trecho.n1.nome == n1 or trecho.n2.nome == n1:
trs.append(trecho)
for tr in trs:
if tr.n1.nome == n2 or tr.n2.nome == n2:
return tr
return None
def inserir_ramos_recursivo(agent, alimentador, subestacao, ramos):
# Escolha da ordem de inserção dos ramos de acordo com as
# prioridades
# calculo dos indices de prioridade de cada ramo
# de acordo com a seguinte equação:
# soma_das_prioridades
# prioridade_media = -------------------------
# numero de setores do ramo
indice_prioridades_dict = {}
for ramo in ramos:
soma_prioridades = 0
for setor in ramo[0].values():
soma_prioridades += setor.prioridade
# indice_prioridades_dict é um dicionario contendo pares
# chave/valor, as chaves são o identificador do objeto
# ramo e os valores são tuplas com o primeiro elemento
# o indice de prioridade e o segundo o proprio obejto
# ramo
indice_prioridades_dict[id(ramo)] = (
float(soma_prioridades)/float(len(ramo[0].keys())),
ramo
)
# reorganização da lista ramos de acordo com a prioridade
# de cada ramo
ramos_2 = []
for ramo in ramos:
prioridade_max = max(
[i[0] for i in indice_prioridades_dict.values()]
)
# a variavel ramo recebe o objeto ramo de maior prioridade
# dentre os existentes no dicionario indice_prioridades_dict
ramo = [i[1] for i in indice_prioridades_dict.values()
if i[0] == prioridade_max]
indice_prioridades_dict.pop(id(ramo[0]))
ramos_2.append(ramo[0])
ramos = ramos_2
ramos_2 = []
# armazena a estrtura RNP inicial do alimentador
arvore_inicial = Arvore(agent.alimentador.arvore, dtype=str)
arvore_inicial.ordenar(agent.alimentador.raiz)
rnp_inicial = arvore_inicial.rnp
# inicializa a variável chave_de_isolacao
chave_de_isolacao = None
# for percorre os ramos afetados tentando a recomposicao de cada um deles!
for ramo in ramos:
# identifica quais setores fazem vizinhança ao alimentador
# afetado e quais setores deste alimentador fazem vizinhança
# para que possa ser realizada a inserção
pares_setores_recomp = identificar_setor_de_insercao(ramo, alimentador)
if pares_setores_recomp == []:
ramos_2.append(ramo)
else:
no, no_raiz, chave = pares_setores_recomp[0]
# inserção de todo o ramo na arvore do alimentador
alimentador.inserir_ramo(no, ramo, no_raiz)
display_message(agent.aid.name, 'Inserção de ramo no alimentador')
print alimentador.rnp
# Envia mensagem para atualizar os outros agentes
# que também têm uma representação da rede
notificar_agentes(agent,
'insercao',
alimentador.nome,
(no, no_raiz))
# verificação da potencia fornecida pelos transformadores
potencia_disponivel = calcular_potencia_disponivel(subestacao)
display_message(agent.aid.name, 'Potencia disponivel após inserção de ramo: {pot} MVA'.format(
pot=potencia_disponivel / 1e6))
setores_mais_profundos = []
setores_analisados = []
poda_de_setores = []
rnp_de_setor = ramo[2] # 2 : RNP de setor da poda
prof = int(max(rnp_de_setor[0, :]))
setores_ramo = list(rnp_de_setor[1, :])
setores_ramo.sort()
while potencia_disponivel < 0.0:
# caso haja violação nas potências dos trafos, o sistema
# irá podar os setores de maior profundidade do ramo
# inserido até que a violação deixe de existir
info_poda = podar_setor_mais_profundo(agent,
alimentador,
setores_analisados,
setores_mais_profundos,
rnp_de_setor,
prof)
if info_poda is None:
break
else:
(setores_analisados,
setores_mais_profundos,
prof,
poda,
chave_de_isolacao) = info_poda
poda_de_setores.append(poda)
# atualização da potencia fornecida pelos transformadores
potencia_disponivel = calcular_potencia_disponivel(subestacao)
display_message(agent.aid.name, 'Potencia disponivel após realizaçao de poda: {pot} MVA'.format(
pot=potencia_disponivel / 1e6))
else:
# se não houver violação na potencia
# dos trafos a restrição de carregamento
# dos condutores e nível de tensão são verificadas
subestacao.calcular_fluxo_de_carga()
trecho = verificar_carregamento_dos_condutores(agent, subestacao)
while trecho is not None:
info_poda = podar_setor_mais_profundo(agent,
alimentador,
setores_analisados,
setores_mais_profundos,
rnp_de_setor,
prof)
(setores_analisados,
setores_mais_profundos,
prof,
poda,
chave_de_isolacao) = info_poda
poda_de_setores.append(poda)
if info_poda is None:
break
else:
(setores_analisados,
setores_mais_profundos,
prof,
poda,
chave_de_isolacao) = info_poda
# calculo de fluxo de carga no alimentador
subestacao.calcular_fluxo_de_carga()
trecho = verificar_carregamento_dos_condutores(agent, subestacao)
if trecho is not None:
display_message(agent.aid.name, 'Trecho {tr} em sobrecarga'.format(tr=trecho))
else:
no = verificar_nivel_de_tensao(agent, subestacao)
while no is not None:
info_poda = podar_setor_mais_profundo(agent,
alimentador,
setores_analisados,
setores_mais_profundos,
rnp_de_setor,
prof)
(setores_analisados,
setores_mais_profundos,
prof,
poda,
chave_de_isolacao) = info_poda
poda_de_setores.append(poda)
if info_poda is None:
break
else:
(setores_analisados,
setores_mais_profundos,
prof,
poda,
chave_de_isolacao) = info_poda
poda_de_setores.append(poda)
# calculo de fluxo de carga no alimentador
subestacao.calcular_fluxo_de_carga()
no = verificar_nivel_de_tensao(agent, subestacao)
if no is not None:
display_message(agent.aid.name, 'No de carga {no} com' \
'violacao de tensao'.format(no=no))
# se a estrtura RNP do alimentador foi modificada
if not agent.alimentador.rnp.size == rnp_inicial.size:
display_message(agent.aid.name, 'Enviando comando de fechamento para AD...')
# # # # # #
# Envia mensagem para AD fechar chave de recomposicao
# TODO: e abrir chave de isolação
# # # # # #
message = ACLMessage(ACLMessage.REQUEST)
message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL)
if chave_de_isolacao is not None:
message.set_content(json.dumps({'ref': 'R_05',
'dados': {'chaves': [chave, chave_de_isolacao],
'estados': [1, 0]
}
},
indent=4)
)
else:
message.set_content(json.dumps({'ref': 'R_05',
'dados': {'chaves': [chave],
'estados': [1]
}
},
indent=4)
)
message.add_receiver(agent.agente_dispositivo_aid)
# lança comportamento
comp = CompRequest3(agent, message)
agent.behaviours.append(comp)
comp.on_start()
display_message(agent.aid.name, 'Recomposição do ramo realizada')
print alimentador.rnp
inserir_ramos_recursivo(agent, alimentador, subestacao, ramos_2)
elif trecho is not None:
return
elif no is not None:
return
return
class Alimentador(Arvore):
def __init__(self, nome, setores, chaves):
assert isinstance(nome, str), 'O parâmetro nome da classe Alimentador' \
'deve ser do tipo string'
assert isinstance(setores, list), 'O parâmetro setores da classe' \
'Alimentador deve ser do tipo list'
assert isinstance(chaves, list), 'O parâmetro chaves da classe' \
'Alimentador deve ser do tipo list'
self.nome = nome
self.setores = dict()
for setor in setores:
self.setores[setor.nome] = setor
self.chaves = dict()
for chave in chaves:
self.chaves[chave.nome] = chave
self.nos_de_carga = dict()
for setor in setores:
for no in setor.nos_de_carga.values():
self.nos_de_carga[no.nome] = no
for setor in self.setores.values():
print 'Setor: ', setor.nome
setores_vizinhos = list()
for chave in self.chaves.values():
if chave.n1 is setor:
setores_vizinhos.append(chave.n2)
elif chave.n2 is setor:
setores_vizinhos.append(chave.n1)
for setor_vizinho in setores_vizinhos:
print 'Setor Vizinho: ', setor_vizinho.nome
nos_de_ligacao = list()
for i in setor.nos_de_carga.values():
for j in setor_vizinho.nos_de_carga.values():
if i.nome in j.vizinhos:
nos_de_ligacao.append((j, i))
for no in nos_de_ligacao:
setor.ordena(no[1].nome)
setor.rnp_associadas[setor_vizinho.nome] = (no[0], setor.rnp)
print 'RNP: ', setor.rnp
self.trechos = dict()
_arvore_da_rede = self._gera_arvore_da_rede()
super(Alimentador, self).__init__(_arvore_da_rede, str)
# def _gera_arvore_da_rede(self):
# # for percorre os setores da subestação
# arvore_da_rede = dict()
# for i, j in self.setores.iteritems():
# setores_outra_subest = set()
#
# # for percorre os vizinhos do setor analisado
# for w in j.vizinhos:
# # se o setor vizinho ainda nao esta entre os vizinhos do
# # setor vizinho este setor é setado na lista da vizinhança
# # do setor analisado
# if w in self.setores.keys():
# if i not in self.setores[w].vizinhos:
# self.setores[w].vizinhos.append(i)
# else:
# # armazena os setores que pertencem a outra subestação
# setores_outra_subest.add(w)
#
# print '%-12s vizinhos %s' % (str(j), j.vizinhos)
#
# # atualiza a arvore de setores
# arvore_da_rede[i] = list(set(j.vizinhos) - setores_outra_subest)
#
# return arvore_da_rede
def ordena(self, raiz):
super(Alimentador, self).ordena(raiz)
for setor in self.setores.values():
caminho = self.caminho_no_para_raiz(setor.nome)
if setor.nome != raiz:
setor_jusante = caminho[1, 1]
setor.rnp = setor.rnp_associadas[setor_jusante][1]
def _gera_arvore_da_rede(self):
arvore_da_rede = {i: list() for i in self.setores.keys()}
for chave in self.chaves.values():
if chave.n1.nome in self.setores.keys() and chave.estado == 1:
arvore_da_rede[chave.n1.nome].append(chave.n2.nome)
if chave.n2.nome in self.setores.keys() and chave.estado == 1:
arvore_da_rede[chave.n2.nome].append(chave.n1.nome)
return arvore_da_rede
def gera_arvore_nos_de_carga(self):
# define os nós de carga do setor raiz da subestação como os primeiros
# nós de carga a povoarem a arvore nós de carga e a rnp nós de carga
setor_raiz = self.setores[self.rnp[1][0]]
self.arvore_nos_de_carga = Arvore(arvore=setor_raiz._gera_arvore_do_setor(), dtype=str)
self.arvore_nos_de_carga.ordena(raiz=setor_raiz.rnp[1][0])
# define as listas visitados e pilha, necessárias ao processo recursivo de visita
# dos setores da subestação
visitados = []
pilha = []
# inicia o processo iterativo de visita dos setores
# em busca de seus respectivos nós de carga
self._gera_arvore_nos_de_carga(setor_raiz, visitados, pilha)
def _gera_arvore_nos_de_carga(self, setor, visitados, pilha):
# atualiza as listas de recursão
visitados.append(setor.nome)
pilha.append(setor.nome)
# for percorre os setores vizinhos ao setor atual
# que ainda não tenham sido visitados
vizinhos = setor.vizinhos
for i in vizinhos:
# esta condição testa se existe uma ligação entre os setores de uma mesma
# subestação, mas que possuem uma chave normalmente aberta entre eles.
# caso isto seja constatado o laço for é interrompido.
if i not in visitados and i in self.setores.keys():
for c in self.chaves.values():
if c.n1.nome == setor.nome and c.n2.nome == i:
if c.estado == 1:
break
else:
pass
elif c.n2.nome == setor.nome and c.n1.nome == i:
if c.estado == 1:
break
else:
pass
else:
continue
prox = i
setor_vizinho = self.setores[i]
no_insersao, rnp_insersao = setor_vizinho.rnp_associadas[setor.nome]
arvore_insersao = setor_vizinho._gera_arvore_do_setor()
setor_vizinho.no_de_ligacao = no_insersao
setor_vizinho.rnp = rnp_insersao
self.arvore_nos_de_carga.inserir_ramo(no_insersao.nome, (rnp_insersao, arvore_insersao),
no_raiz=rnp_insersao[1, 0])
break
else:
continue
else:
pilha.pop()
if pilha:
anter = pilha.pop()
return self._gera_arvore_nos_de_carga(self.setores[anter], visitados, pilha)
else:
return
return self._gera_arvore_nos_de_carga(self.setores[prox], visitados, pilha)
def atualiza_arvore_da_rede(self):
_arvore_da_rede = self._gera_arvore_da_rede()
self.arvore = _arvore_da_rede
def gera_trechos_da_rede(self):
self.trechos = dict()
j = 0
for i in range(1, size(self.arvore_nos_de_carga.rnp, axis=1)):
prof_1 = int(self.arvore_nos_de_carga.rnp[0, i])
prof_2 = int(self.arvore_nos_de_carga.rnp[0, j])
while abs(prof_1 - prof_2) is not 1:
if abs(prof_1 - prof_2) == 0:
j -= 1
elif abs(prof_1 - prof_2) == 2:
j = i - 1
prof_2 = int(self.arvore_nos_de_carga.rnp[0, j])
else:
n_1 = str(self.arvore_nos_de_carga.rnp[1, j])
n_2 = str(self.arvore_nos_de_carga.rnp[1, i])
setor_1 = None
setor_2 = None
print 'Trecho: ' + n_1 + '-' + n_2
# verifica quais os nós de carga existentes nas extremidades do trecho
# e se existe uma chave no trecho
for setor in self.setores.values():
if n_1 in setor.nos_de_carga.keys():
setor_1 = setor
if n_2 in setor.nos_de_carga.keys():
setor_2 = setor
if setor_1 is not None and setor_2 is not None:
break
else:
if setor_1 is None:
n = n_1
else:
n = n_2
for setor in self.setores.values():
if n in setor.nos_de_carga.keys() and size(setor.rnp, axis=1) == 1:
if setor_1 is None:
setor_1 = setor
else:
setor_2 = setor
break
if setor_1 != setor_2:
for chave in self.chaves.values():
if chave.n1 in (setor_1, setor_2) and chave.n2 in (setor_1, setor_2):
self.trechos[n_1 + n_2] = Trecho(nome=n_1 + n_2,
n1=self.nos_de_carga[n_1],
n2=self.nos_de_carga[n_2],
chave=chave)
else:
self.trechos[n_1 + n_2] = Trecho(nome=n_1 + n_2,
n1=self.nos_de_carga[n_1],
n2=self.nos_de_carga[n_2])
def podar(self, no, alterar_rnp=False):
poda = super(Alimentador, self).podar(no, alterar_rnp)
rnp_setores = poda[0]
arvore_setores = poda[1]
if alterar_rnp:
# for povoa dicionario com setores podados
setores = dict()
for i in rnp_setores[1, :]:
setor = self.setores.pop(i)
setores[setor.nome] = setor
# for povoa dicionario com nos de carga podados
nos_de_carga = dict()
for setor in setores.values():
for j in setor.nos_de_carga.values():
if j.nome in self.nos_de_carga.keys():
no_de_carga = self.nos_de_carga.pop(j.nome)
nos_de_carga[no_de_carga.nome] = no_de_carga
# for atualiza a lista de nós de carga da subestação
# excluindo os nós de carga podados
for setor in self.setores.values():
for no_de_carga in setor.nos_de_carga.values():
self.nos_de_carga[no_de_carga.nome] = no_de_carga
if no_de_carga.nome in nos_de_carga.keys():
nos_de_carga.pop(no_de_carga.nome)
# poda o ramo na arvore da subetação
poda = self.arvore_nos_de_carga.podar(setores[no].rnp[1, 0], alterar_rnp=alterar_rnp)
rnp_nos_de_carga = poda[0]
arvore_nos_de_carga = poda[1]
# for povoa dicionario de chaves que estao nos trechos podados
# e retira do dicionario de chaves da arvore que esta sofrendo a poda
# as chaves que não fazem fronteira com os trechos remanescentes
chaves = dict()
for chave in self.chaves.values():
if chave.n1.nome in setores.keys():
if not chave.n2.nome in self.setores.keys():
chaves[chave.nome] = self.chaves.pop(chave.nome)
else:
chave.estado = 0
chaves[chave.nome] = chave
elif chave.n2.nome in setores.keys():
if not chave.n1.nome in self.setores.keys():
chaves[chave.nome] = self.chaves.pop(chave.nome)
else:
chave.estado = 0
chaves[chave.nome] = chave
# atualiza os trechos da rede
self.gera_trechos_da_rede()
return (setores, arvore_setores, rnp_setores,
nos_de_carga, arvore_nos_de_carga, rnp_nos_de_carga,
chaves)
else:
return rnp_setores
def inserir_ramo(self, no, poda, no_raiz=None):
(setores, arvore_setores, rnp_setores,
nos_de_carga, arvore_nos_de_carga, rnp_nos_de_carga,
chaves) = poda
if no_raiz is None:
setor_inserir = setores[rnp_setores[1, 0]]
else:
setor_inserir = setores[no_raiz]
setor_insersao = self.setores[no]
# for identifica se existe alguma chave que permita a inserção do ramo na arvore
# da subestação que ira receber a inserção.
chaves_de_lig = dict()
# for percorre os nos de carga do setor de insersão
for i in self.setores[setor_insersao.nome].nos_de_carga.values():
# for percorre as chaves associadas ao no de carga
for j in i.chaves:
# for percorre os nos de carga do setor raiz do ramo a ser inserido
for w in setores[setor_inserir.nome].nos_de_carga.values():
# se a chave pertence aos nos de carga i e w então é uma chave de ligação
if j in w.chaves:
chaves_de_lig[j] = (i, w)
if not chaves_de_lig:
print 'A insersao não foi possível pois nenhuma chave de fronteira foi encontrada!'
return
i = randint(0, len(chaves_de_lig) - 1)
n1, n2 = chaves_de_lig[chaves_de_lig.keys()[i]]
self.chaves[chaves_de_lig.keys()[i]].estado = 1
if setor_inserir.nome == setores[rnp_setores[1, 0]].nome:
super(Alimentador, self).inserir_ramo(no, (rnp_setores, arvore_setores))
else:
super(Alimentador, self).inserir_ramo(no, (rnp_setores, arvore_setores), no_raiz)
# atualiza setores da arvore da subestação atual
self.setores.update(setores)
self.nos_de_carga.update(nos_de_carga)
self.chaves.update(chaves)
self.atualiza_arvore_da_rede()
#self.arvore_nos_de_carga.inserir_ramo_1()
self.gera_arvore_nos_de_carga()
14: [15],
8: [9, 7, 13],
13: [8],
7: [8]}
nos_arvore_3 = {3: [27],
27: [3, 21, 26],
21: [27, 20],
20: [21],
26: [27, 25, 19],
25: [26, 24],
24: [25],
19: [26, 18],
18: [19, 17],
17: [18]}
nos_arvore_4 = {28:[29,30],
29:[28],
30:[28]}
arvore_1 = Arvore(nos_arvore_1)
arvore_1.ordena(raiz=1)
arvore_2 = Arvore(nos_arvore_2)
arvore_2.ordena(raiz=2)
arvore_3 = Arvore(nos_arvore_3)
arvore_3.ordena(raiz=3)
arvore_4 = Arvore(nos_arvore_4)
arvore_4.ordena(raiz=28)
14: [15],
8: [9, 7, 13],
13: [8],
7: [8]
}
nos_arvore_3 = {
3: [27],
27: [3, 21, 26],
21: [27, 20],
20: [21],
26: [27, 25, 19],
25: [26, 24],
24: [25],
19: [26, 18],
18: [19, 17],
17: [18]
}
nos_arvore_4 = {28: [29, 30], 29: [28], 30: [28]}
arvore_1 = Arvore(nos_arvore_1)
arvore_1.ordena(raiz=1)
arvore_2 = Arvore(nos_arvore_2)
arvore_2.ordena(raiz=2)
arvore_3 = Arvore(nos_arvore_3)
arvore_3.ordena(raiz=3)
arvore_4 = Arvore(nos_arvore_4)
arvore_4.ordena(raiz=28)
class Alimentador(Arvore):
def __init__(self, nome, setores, chaves):
assert isinstance(nome, str), 'O parâmetro nome da classe Alimentador' \
'deve ser do tipo string'
assert isinstance(setores, list), 'O parâmetro setores da classe' \
'Alimentador deve ser do tipo list'
assert isinstance(chaves, list), 'O parâmetro chaves da classe' \
'Alimentador deve ser do tipo list'
self.nome = nome
self.setores = dict()
for setor in setores:
self.setores[setor.nome] = setor
self.chaves = dict()
for chave in chaves:
self.chaves[chave.nome] = chave
self.nos_de_carga = dict()
for setor in setores:
for no in setor.nos_de_carga.values():
self.nos_de_carga[no.nome] = no
for setor in self.setores.values():
print 'Setor: ', setor.nome
setores_vizinhos = list()
for chave in self.chaves.values():
if chave.n1 is setor:
setores_vizinhos.append(chave.n2)
elif chave.n2 is setor:
setores_vizinhos.append(chave.n1)
for setor_vizinho in setores_vizinhos:
print 'Setor Vizinho: ', setor_vizinho.nome
nos_de_ligacao = list()
for i in setor.nos_de_carga.values():
for j in setor_vizinho.nos_de_carga.values():
if i.nome in j.vizinhos:
nos_de_ligacao.append((j, i))
for no in nos_de_ligacao:
setor.ordena(no[1].nome)
setor.rnp_associadas[setor_vizinho.nome] = (no[0],
setor.rnp)
print 'RNP: ', setor.rnp
self.trechos = dict()
_arvore_da_rede = self._gera_arvore_da_rede()
super(Alimentador, self).__init__(_arvore_da_rede, str)
# def _gera_arvore_da_rede(self):
# # for percorre os setores da subestação
# arvore_da_rede = dict()
# for i, j in self.setores.iteritems():
# setores_outra_subest = set()
#
# # for percorre os vizinhos do setor analisado
# for w in j.vizinhos:
# # se o setor vizinho ainda nao esta entre os vizinhos do
# # setor vizinho este setor é setado na lista da vizinhança
# # do setor analisado
# if w in self.setores.keys():
# if i not in self.setores[w].vizinhos:
# self.setores[w].vizinhos.append(i)
# else:
# # armazena os setores que pertencem a outra subestação
# setores_outra_subest.add(w)
#
# print '%-12s vizinhos %s' % (str(j), j.vizinhos)
#
# # atualiza a arvore de setores
# arvore_da_rede[i] = list(set(j.vizinhos) - setores_outra_subest)
#
# return arvore_da_rede
def ordena(self, raiz):
super(Alimentador, self).ordena(raiz)
for setor in self.setores.values():
caminho = self.caminho_no_para_raiz(setor.nome)
if setor.nome is not raiz:
setor_jusante = caminho[1, 1]
setor.rnp = setor.rnp_associadas[setor_jusante][1]
def _gera_arvore_da_rede(self):
arvore_da_rede = {i: list() for i in self.setores.keys()}
for chave in self.chaves.values():
if chave.n1.nome in self.setores.keys() and chave.estado == 1:
arvore_da_rede[chave.n1.nome].append(chave.n2.nome)
if chave.n2.nome in self.setores.keys() and chave.estado == 1:
arvore_da_rede[chave.n2.nome].append(chave.n1.nome)
return arvore_da_rede
def gera_arvore_nos_de_carga(self):
# define os nós de carga do setor raiz da subestação como os primeiros
# nós de carga a povoarem a arvore nós de carga e a rnp nós de carga
setor_raiz = self.setores[self.rnp[1][0]]
self.arvore_nos_de_carga = Arvore(
arvore=setor_raiz._gera_arvore_do_setor(), dtype=str)
self.arvore_nos_de_carga.ordena(raiz=setor_raiz.rnp[1][0])
# define as listas visitados e pilha, necessárias ao processo recursivo de visita
# dos setores da subestação
visitados = []
pilha = []
# inicia o processo iterativo de visita dos setores
# em busca de seus respectivos nós de carga
self._gera_arvore_nos_de_carga(setor_raiz, visitados, pilha)
def _gera_arvore_nos_de_carga(self, setor, visitados, pilha):
# atualiza as listas de recursão
visitados.append(setor.nome)
pilha.append(setor.nome)
# for percorre os setores vizinhos ao setor atual
# que ainda não tenham sido visitados
vizinhos = setor.vizinhos
for i in vizinhos:
# esta condição testa se existe uma ligação entre os setores de uma mesma
# subestação, mas que possuem uma chave normalmente aberta entre eles.
# caso isto seja constatado o laço for é interrompido.
if i not in visitados and i in self.setores.keys():
for c in self.chaves.values():
if c.n1.nome == setor.nome and c.n2.nome == i:
if c.estado == 1:
break
else:
pass
elif c.n2.nome == setor.nome and c.n1.nome == i:
if c.estado == 1:
break
else:
pass
else:
continue
prox = i
setor_vizinho = self.setores[i]
no_insersao, rnp_insersao = setor_vizinho.rnp_associadas[
setor.nome]
arvore_insersao = setor_vizinho._gera_arvore_do_setor()
setor_vizinho.no_de_ligacao = no_insersao
setor_vizinho.rnp = rnp_insersao
self.arvore_nos_de_carga.inserir_ramo(
no_insersao.nome, (rnp_insersao, arvore_insersao),
no_raiz=rnp_insersao[1, 0])
break
else:
continue
else:
pilha.pop()
if pilha:
anter = pilha.pop()
return self._gera_arvore_nos_de_carga(self.setores[anter],
visitados, pilha)
else:
return
return self._gera_arvore_nos_de_carga(self.setores[prox], visitados,
pilha)
def atualiza_arvore_da_rede(self):
_arvore_da_rede = self._gera_arvore_da_rede()
self.arvore = _arvore_da_rede
def gera_trechos_da_rede(self):
print self.arvore_nos_de_carga.rnp
j = 0
for i in range(1, size(self.arvore_nos_de_carga.rnp, axis=1)):
prof_1 = int(self.arvore_nos_de_carga.rnp[0, i])
prof_2 = int(self.arvore_nos_de_carga.rnp[0, j])
while abs(prof_1 - prof_2) is not 1:
if abs(prof_1 - prof_2) == 0:
j -= 1
elif abs(prof_1 - prof_2) == 2:
j = i - 1
prof_2 = int(self.arvore_nos_de_carga.rnp[0, j])
else:
n_1 = str(self.arvore_nos_de_carga.rnp[1, j])
n_2 = str(self.arvore_nos_de_carga.rnp[1, i])
setor_1 = None
setor_2 = None
for setor in self.setores.values():
if n_1 in setor.nos_de_carga.keys() and n_1 != str(
setor.rnp[1, 0]):
setor_1 = setor
if n_2 in setor.nos_de_carga.keys() and n_2 != str(
setor.rnp[1, 0]):
setor_2 = setor
if setor_1 is not None and setor_2 is not None:
break
else:
if setor_1 is None:
n = n_1
else:
n = n_2
for setor in self.setores.values():
if n in setor.nos_de_carga.keys() and size(
setor.rnp, axis=1) == 1:
if setor_1 is None:
setor_1 = setor
else:
setor_2 = setor
break
if setor_1 != setor_2:
for chave in self.chaves.values():
if chave.n1 in (setor_1,
setor_2) and chave.n2 in (setor_1,
setor_2):
self.trechos[n_1 + n_2] = Trecho(
nome=n_1 + n_2,
n1=self.nos_de_carga[n_1],
n2=self.nos_de_carga[n_2],
chave=chave)
else:
self.trechos[n_1 + n_2] = Trecho(nome=n_1 + n_2,
n1=self.nos_de_carga[n_1],
n2=self.nos_de_carga[n_2])
def podar(self, no, alterar_rnp=False):
poda = super(Alimentador, self).podar(no, alterar_rnp)
rnp_setores = poda[0]
arvore_setores = poda[1]
if alterar_rnp:
# for povoa dicionario com setores podados
setores = dict()
for i in rnp_setores[1, :]:
setor = self.setores.pop(i)
setores[setor.nome] = setor
# for povoa dicionario com nos de carga podados
nos_de_carga = dict()
for setor in setores.values():
for j in setor.nos_de_carga.values():
if j.nome in self.nos_de_carga.keys():
no_de_carga = self.nos_de_carga.pop(j.nome)
nos_de_carga[no_de_carga.nome] = no_de_carga
# for atualiza a lista de nós de carga da subestação
# excluindo os nós de carga podados
for setor in self.setores.values():
for no_de_carga in setor.nos_de_carga.values():
self.nos_de_carga[no_de_carga.nome] = no_de_carga
if no_de_carga.nome in nos_de_carga.keys():
nos_de_carga.pop(no_de_carga.nome)
# poda o ramo na arvore da subetação
poda = self.arvore_nos_de_carga.podar(setores[no].rnp[1, 0],
alterar_rnp=True)
rnp_nos_de_carga = poda[0]
arvore_nos_de_carga = poda[1]
# for povoa dicionario de chaves que estao nos trechos podados
# e retira do dicionario de chaves da arvore que esta sofrendo a poda
# as chaves que não fazem fronteira com os trechos remanescentes
chaves = dict()
for chave in self.chaves.values():
if chave.n1.nome in setores.keys():
if not chave.n2.nome in self.setores.keys():
chaves[chave.nome] = self.chaves.pop(chave.nome)
else:
chave.estado = 0
chaves[chave.nome] = chave
elif chave.n2.nome in setores.keys():
if not chave.n1.nome in self.setores.keys():
chaves[chave.nome] = self.chaves.pop(chave.nome)
else:
chave.estado = 0
chaves[chave.nome] = chave
return (setores, arvore_setores, rnp_setores, nos_de_carga,
arvore_nos_de_carga, rnp_nos_de_carga, chaves)
else:
return rnp_setores
def inserir_ramo(self, no, poda, no_raiz=None):
(setores, arvore_setores, rnp_setores, nos_de_carga,
arvore_nos_de_carga, rnp_nos_de_carga, chaves) = poda
if no_raiz is None:
setor_inserir = setores[rnp_setores[1, 0]]
else:
setor_inserir = setores[no_raiz]
setor_insersao = self.setores[no]
# for identifica se existe alguma chave que permita a inserção do ramo na arvore
# da subestação que ira receber a inserção.
chaves_de_lig = dict()
# for percorre os nos de carga do setor de insersão
for i in self.setores[setor_insersao.nome].nos_de_carga.values():
# for percorre as chaves associadas ao no de carga
for j in i.chaves:
# for percorre os nos de carga do setor raiz do ramo a ser inserido
for w in setores[setor_inserir.nome].nos_de_carga.values():
# se a chave pertence aos nos de carga i e w então é uma chave de ligação
if j in w.chaves:
chaves_de_lig[j] = (i, w)
if not chaves_de_lig:
print 'A insersao não foi possível pois nenhuma chave de fronteira foi encontrada!'
return
i = randint(0, len(chaves_de_lig) - 1)
n1, n2 = chaves_de_lig[chaves_de_lig.keys()[i]]
self.chaves[chaves_de_lig.keys()[i]].estado = 1
if setor_inserir.nome == setores[rnp_setores[1, 0]].nome:
super(Alimentador,
self).inserir_ramo(no, (rnp_setores, arvore_setores))
else:
super(Alimentador,
self).inserir_ramo(no, (rnp_setores, arvore_setores),
no_raiz)
# atualiza setores da arvore da subestação atual
self.setores.update(setores)
self.nos_de_carga.update(nos_de_carga)
self.chaves.update(chaves)
self.atualiza_arvore_da_rede()
#self.arvore_nos_de_carga.inserir_ramo_1()
self.gera_arvore_nos_de_carga()
