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 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
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)
