def get_uniecos(self, uniecos):
uniecos_executar = {}
if type(uniecos) is list:
for unieco in uniecos:
uni_separado = unieco.split("#")
unieco_path = InOut.ajuste_path(uni_separado[0])
unieco_prob = 1 / len(uniecos)
if len(uni_separado) > 1:
unieco_path = uni_separado[0]
unieco_prob = uni_separado[1]
unieco_file_name = (unieco_path.split(InOut().barra())[-1]).split('.')[0]
uniecos_executar[unieco_file_name] = {'unieco_path': unieco_path,
'unieco_file_name': unieco_file_name,
'unieco_prob': unieco_prob}
else:
uni_separado = uniecos.split("#")
unieco_path = InOut.ajuste_path(uni_separado[0])
unieco_prob = 1
if len(uni_separado) > 1:
unieco_path = uni_separado[0]
unieco_prob = uni_separado[1]
unieco_file_name = (unieco_path.split(InOut().barra())[-1]).split('.')[0]
uniecos_executar[unieco_file_name] = {'unieco_path': unieco_path,
'unieco_file_name': unieco_file_name,
'unieco_prob': unieco_prob}
return uniecos_executar
def run(self, param_path: str, contexto: Contexto):
if not contexto.tem_atributo(
EnumAtributo.AVALIACAO_MERO_TEMPOS_G2_PATH):
return
self.log(texto=f'Executando o {__name__}')
tempos_path = InOut.ajuste_path(
contexto.get_atributo(EnumAtributo.AVALIACAO_MERO_TEMPOS_G2_PATH))
tempos_path = InOut.ajuste_path(
f'{contexto.get_atributo(EnumAtributo.PATH_PROJETO)}/{tempos_path}'
)
self._tempos = list(((CSV()).ler(tempos_path, False)).index)
if len(self._tempos) < 1:
return
count = ""
estrutura = {}
params = TXT().ler(param_path)
for key in params:
try:
chave = key.split(" ")[0]
valor = key.split(" ")[1]
if (chave[0] != "#") and ("@" in chave):
try:
aux = chave.split("@")
local = (aux[1]).upper()
variavel = (aux[0]).upper()
evento = (aux[2]).upper()
if self._has_evento(evento) is None:
continue
else:
if not local in estrutura:
estrutura[local] = {}
if not evento in estrutura[local]:
estrutura[local][evento] = {}
estrutura[local][evento][variavel] = valor
count += f'{key}'
except Exception as ex:
count += f'{key}'
print(ex)
else:
count += f'{key}'
except Exception:
count += f'{key}'
count += f'***Variaveis de gerenciamento segundo formula {self._funcao}\n'
for local in estrutura:
for evento in estrutura[local]:
f_tempo = self._aplicando(estrutura[local][evento])
for tempo in f_tempo:
count += f'{local}@{evento}@{tempo} {f_tempo[tempo]}\n'
TXT().salvar(param_path, count)
def run(self, contexto: Contexto, solucao_pdf_atualizada: Solucao,
n_amostragem):
"""
Executa a amostragem com o IDLHCn
:param Contexto contexto: contexto com todas as informações necessárias
:param Solucao solucao_pdf_atualizada: Solucao com pdf atualizada para utilizacao na amostragem
"""
self._n_amostragem = n_amostragem
self._contexto = contexto
self._solucao_pdf_atualizada = solucao_pdf_atualizada
path_projeto = self._contexto.get_atributo(EnumAtributo.PATH_PROJETO)
self._solucoes = self._contexto.get_atributo(EnumAtributo.SOLUCOES)
ultima_iteracao = max(map(int, self._solucoes.solucoes))
self._ultimo_id = max(
map(int, self._solucoes.solucoes[ultima_iteracao]))
self._iteracao_nova_amostragem = ultima_iteracao + 1
self._path_hldg = InOut.ajuste_path('\\'.join([
path_projeto,
self._contexto.get_atributo(EnumAtributo.PATH_SIMULACAO),
f'HLDG_{self._iteracao_nova_amostragem}.mero'
]))
self._gera_entrada_hldg()
self._execucao_hldg()
self._criar_solucoes_em_contexto()
return self._contexto
def _avaliacao_gevt(self):
"""
Le gevt e seta o self._data_inicial, self._data_final e self._dia_inicio_previsao que serao utilizados
para calcular lista de dias e dia final de simulacao que
"""
# disponivel ainda somente para otimização nominal
gevts_tpls = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_GEVTS_TEMPLATES_EXECUTAR)
for key in gevts_tpls.keys():
path_gevt = gevts_tpls[key]['gevt_path']
path_projeto = self._contexto.get_atributo(EnumAtributo.PATH_PROJETO)
path_completo_gevt = InOut.ajuste_path(f'{path_projeto}/{path_gevt}')
linhas_gevt = TXT().ler(path_completo_gevt)
conteudo_gvt = ''
for linha in linhas_gevt:
conteudo_gvt += linha
matches = re.findall(r'\n\*INITIAL_DATE\s*([^\s]+)', conteudo_gvt)
data_inicial = matches[0]
matches = re.findall(r'\n\*FINAL_DATE\s*([^\s]+)', conteudo_gvt)
data_final = matches[0]
matches = re.findall(r'\n\*TIME_LIST\s*(\w*)', conteudo_gvt)
dia_inicio_previsao = matches[0]
self._data_inicial = data_inicial
self._data_final = data_final
self._dia_inicio_previsao = int(dia_inicio_previsao)
def _check_simulando(self):
simular = self._buffer['simular']
keys = deepcopy(list(simular.keys()))
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = simular[prefixo]["iteracao"]
id = simular[prefixo]["id"]
path = simular[prefixo]["path"]
file = InOut.ajuste_path(f'{path}.out')
if os.path.isfile(file):
self.log(
texto=
f'Solucao ({prefixo}) iteracao [{iteracao}] e id [{id}] simulando.'
)
self._buffer['simulando'][prefixo] = simular[prefixo]
del self._buffer['simular'][prefixo]
else:
horas_sim_max = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_TEMPO_MAX_SIM)
if simular[prefixo][
"time"] + horas_sim_max * 60 * 60 < time.time():
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'A simulação da solucao {prefixo}) iteracao [{iteracao}] e id [{id}] excedeu tempo de {horas_sim_max} hora.'
)
self._buffer['erro'][prefixo] = simular[prefixo]
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = f"Excedeu {horas_sim_max}h"
del self._buffer['simular'][prefixo]
def _preparar_arquivos(self):
path_projeto = self._contexto.get_atributo(EnumAtributo.PATH_PROJETO)
path_simulacao = self._contexto.get_atributo(
EnumAtributo.PATH_SIMULACAO)
gevts_template_executar = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_GEVTS_TEMPLATES_EXECUTAR)
for prefixo in gevts_template_executar.keys():
path_completo_origem = InOut.ajuste_path(
f'{path_projeto}/{gevts_template_executar[prefixo]["gevt_path"]}'
)
path_completo_destino = InOut.ajuste_path(
f'{path_projeto}/{path_simulacao}/{gevts_template_executar[prefixo]["gevt_file_name"]}.mero'
)
if not Copy.copy_file(path_completo_origem, path_completo_destino):
self.log(tipo=EnumLogStatus.ERRO_FATAL, texto=f'Erro no GEVT.')
def criar_arquivos(path_file: str) -> bool:
"""
Criar toda estrutura de arquivo para depois fazer a copia do arquivo.
:param str path_file: Deve ser o caminho do arquivo, com o nome do arquivo junto.
:return: Se tudo correu ok
:rtype: bool
"""
test_path = ""
try:
barra = '/'
inicio = '/'
if platform.system().upper() == "WINDOWS":
barra = '\\'
inicio = ''
path_aux = path_file.split(barra)
for pp in range(len(path_aux) - 1):
if path_aux[pp] == "":
continue
if test_path == "":
test_path = InOut.ajuste_path(f'{inicio}{path_aux[pp]}')
else:
test_path = InOut.ajuste_path(
f'{test_path}{barra}{path_aux[pp]}')
if not os.path.isdir(test_path):
Loggin().log(arquivo=__name__,
tipo=EnumLogStatus.WARN,
texto=f'Caminho {test_path} não existe.')
os.mkdir(test_path)
Loggin().log(
arquivo=__name__,
tipo=EnumLogStatus.WARN,
texto=f'Caminho {test_path} foi criado com sucesso.')
return True
except Exception as ex:
Loggin().log(arquivo=__name__,
tipo=EnumLogStatus.ERRO_FATAL,
texto=f'Não foi possível diretorios [{test_path}].',
info_ex=str(ex))
return False
def _gera_paths_origem_e_destino(self, solucoes):
solucoes = solucoes.solucoes
path_melhores_resultados = InOut().ajuste_path('\\'.join([
self._contexto.get_atributo(EnumAtributo.PATH_PROJETO),
self._contexto.get_atributo(EnumAtributo.AVALIACAO_PATH_MELHORES),
'\\'
]))
path_simulacao = InOut().ajuste_path('\\'.join([
self._contexto.get_atributo(EnumAtributo.PATH_PROJETO),
self._contexto.get_atributo(EnumAtributo.PATH_SIMULACAO)
]))
dados_copiar_origem = list()
dados_copiar_destino = list()
dados_manter = list()
paths_dados_manter = list()
nome_melhores_solucoes = list()
for it in list(map(int, solucoes)):
for id in list(map(int, solucoes[it])):
if solucoes[it][id].of_valida():
nome_melhores_solucoes.append(f'_{it}_{id}_')
for nome_melhor_solucao in nome_melhores_solucoes:
str_pesquisa_melhor_solucao = InOut.ajuste_path('\\'.join(
[path_simulacao, '*' + nome_melhor_solucao + '*']))
str_pesquisa_solucao_existentes = InOut.ajuste_path('\\'.join(
[path_melhores_resultados, '*' + nome_melhor_solucao + '*']))
dados_copiar_origem += (glob.glob(str_pesquisa_melhor_solucao))
dados_manter += (glob.glob(str_pesquisa_solucao_existentes))
dados_copiar_destino += \
[InOut.ajuste_path('\\'.join([path_melhores_resultados, os.path.basename(dado_copiar_origem)])) for
dado_copiar_origem in dados_copiar_origem]
paths_dados_manter += \
[InOut.ajuste_path('\\'.join([path_melhores_resultados, os.path.basename(dado_copiar_origem)])) for
dado_copiar_origem in dados_manter]
return dados_copiar_origem, dados_copiar_destino, paths_dados_manter
def get_gevts_templates(self, gevts_templates):
gevts_templantes_executar = {}
if type(gevts_templates) is list:
for gevt_template in gevts_templates:
separacao = gevt_template.split('#')
gevt_path = InOut.ajuste_path(separacao[0])
gevt_file_name = (gevt_path.split(InOut.barra())[-1]).split('.')[0]
if len(separacao) <= 1:
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto=f"Precisa ser informado o template para o GEVT [{gevt_template}]")
template_path = InOut.ajuste_path(separacao[1])
template_file_name = (template_path.split(InOut.barra())[-1]).split('.')[0]
template_prob = 1 / len(gevts_templates)
if len(separacao) > 2:
template_prob = separacao[2]
gevts_templantes_executar[f'{gevt_file_name}_{template_file_name}'] = {'gevt_path': gevt_path,
'gevt_file_name': gevt_file_name,
'template_path': template_path,
'template_file_name': template_file_name,
'template_prob': template_prob}
else:
separacao = gevts_templates.split('#')
gevt_path = InOut.ajuste_path(separacao[0])
gevt_file_name = (gevt_path.split(InOut.barra())[-1]).split('.')[0]
if len(separacao) <= 1:
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto=f"Precisa ser informado o TPL para o GEVT [{gevts_templates}]")
template_path = InOut.ajuste_path(separacao[1])
template_file_name = (template_path.split(InOut.barra())[-1]).split('.')[0]
template_prob = 1
if len(separacao) > 2 and int(InOut.ajusta_entrada(separacao[2])) != int(1):
self.log(tipo=EnumLogStatus.ERRO, texto=f"Não faz sentido probabilidade diferente de 1 quando há somente um template.")
gevts_templantes_executar[f'{gevt_file_name}_{template_file_name}'] = {'gevt_path': gevt_path,
'gevt_file_name': gevt_file_name,
'template_path': template_path,
'template_file_name': template_file_name,
'template_prob': template_prob}
return gevts_templantes_executar
def run(self):
"""
Metodo responsavel por utilizar avaliadores em arquivos externos python.
O arquivo deve possuir o metodo getResult(dict_variaveis)
"""
super(Python, self).run()
path_python = InOut.ajuste_path('/'.join([
self._contexto.get_atributo(EnumAtributo.PATH_PROJETO),
self._contexto.get_atributo(EnumAtributo.AVALIACAO_PYTHON_PATH)
]))
try:
getResult = load_method(path_python)
except Exception as ex:
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao carregar o metodo getResult em {path_python}: [{ex}]'
)
iteracoes = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR)
self._solucoes = self._contexto.get_atributo(EnumAtributo.SOLUCOES)
list_solucoes = self._solucoes.get_solucoes_by_iteracao_para_avaliar(
iteracoes)
for it in list_solucoes:
for id in list_solucoes[it]:
dict_variaveis = {}
solucao = self._solucoes.get_solucao_by_iteracao_id(
iteracao=it, id=id)
for nome, valor in solucao.get_variaveis_nome_valor().items():
valor_var = valor
if valor_var.__class__ is str:
valor_var = 0
dict_variaveis.update({nome: valor_var})
try:
of = getResult(dict_variaveis)
except Exception as ex:
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao calcular of com o metodo getResult em {path_python}: [{ex}]'
)
self._solucoes.get_solucao_by_iteracao_id(
iteracao=it, id=id).of[self._nome_of_mono].valor = of
self._solucoes.get_solucao_by_iteracao_id(
iteracao=it, id=id).set_avaliada()
def _avalia_rankeamento_simulacoes_parciais(self):
"""
Gera tabela de recall do ranqueamento em relacao ao tempo de simulacao dos n_melhores_estudos
"""
ultima_iteracao = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR)
solucoes_estudo = self._contexto.get_atributo(
EnumAtributo.SOLUCOES).solucoes[ultima_iteracao]
dfs_dates = []
for key, solucao in solucoes_estudo.items():
df_economico = solucao.economico['dataframe']
df_NPV = df_economico[df_economico['OF'] == 'NPV']
nome_modelo = df_NPV['MODEL'].iloc[0]
df_date = df_NPV[['DATE', 'VALUE']].T
datas_disponiveis = df_date.iloc[0, :]
df_date = df_date.iloc[1:, :]
df_date.columns = datas_disponiveis
df_date.index = [nome_modelo]
dfs_dates.append(copy.deepcopy(df_date))
df_date_all = pd.concat(dfs_dates, axis=0, sort=True)
dates = list(df_date_all.columns)
dates.sort(
key=lambda x: (x.split('/')[2], x.split('/')[1], x.split('/')[0]))
df_date_all = df_date_all[dates]
df_rank = df_date_all.rank().sort_values(by=dates[-1])
df_date_top = df_rank.iloc[0:self._contexto.get_atributo(EnumAtributo.REDUCAO_RANK_ANALISE), :] <= \
self._contexto.get_atributo(EnumAtributo.REDUCAO_RANK_ANALISE)
df_precisao_por_data = df_date_top.sum(
axis=0) / self._contexto.get_atributo(
EnumAtributo.REDUCAO_RANK_ANALISE)
df_precisao_por_data.index.name = 'DATA POR RECALL'
path_csv_estudo = InOut.ajuste_path('\\'.join([
self._contexto.get_atributo(EnumAtributo.PATH_PROJETO),
self._contexto.get_atributo(EnumAtributo.PATH_RESULTADO)
])).format('estudo_recall.csv')
CSV().salvar(path_csv_estudo, df_precisao_por_data)
def salvar(self,
path_arquivo: str,
conteudo: str,
metodo_gravacao: str = "w") -> bool:
"""
Método para salvar conteudo de arquivos
:param str path_arquivo: Caminho do arquivo
:param str conteudo: Conteudo a ser salvo
:param str metodo_gravacao: Método de gravação, padrão w
:return: Se deu erro ou não
:rtype: bool
"""
path_arquivo = InOut.ajuste_path(path_arquivo)
try:
if not Copy.criar_arquivos(path_arquivo):
return False
arq = open(path_arquivo, metodo_gravacao)
arq.write(conteudo)
arq.close()
except FileNotFoundError as ex:
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro ao salvar arquivo.',
info_ex=str(ex))
return False
except PermissionError as ex:
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro ao salvar arquivo.',
info_ex=str(ex))
return False
except TypeError as ex:
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro ao salvar arquivo.',
info_ex=str(ex))
return False
except NameError as ex:
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro ao salvar arquivo.',
info_ex=str(ex))
return False
except IOError as ex:
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro ao salvar arquivo.',
info_ex=str(ex))
return False
return True
def _check_unipro(self):
simulado = self._buffer['simulado']
keys = deepcopy(list(simulado.keys()))
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = simulado[prefixo]['iteracao']
id = simulado[prefixo]['id']
path = simulado[prefixo]['path']
path_file = InOut.ajuste_path(f'{path}.unipro')
if os.path.isfile(path_file):
# se arquivo unipro esta escrito
tamanho_unipro = 0
try:
tamanho_unipro = os.path.getsize(path_file)
except Exception as ex:
pass
if tamanho_unipro > 300:
self._buffer['unipro'][prefixo] = simulado[prefixo]
del self._buffer['simulado'][prefixo]
self.log(
texto=
f'Solucao ({prefixo}) iteracao [{iteracao}] e id [{id}] foi calculado o unipro, com sucesso. '
)
continue
horas_sim_max = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_TEMPO_MAX_SIM)
if simulado[prefixo]["time"] + horas_sim_max * 60 * 60 < time.time(
):
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'A simulação da solucao {prefixo}) iteracao [{iteracao}] e id [{id}] excedeu tempo de {horas_sim_max} hora.'
)
self._buffer['erro'][prefixo] = simulado[prefixo]
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = f"Excedeu {horas_sim_max}h"
del self._buffer['simulado'][prefixo]
def run(self, contexto: Contexto) -> Contexto:
"""
Executa a classe
:param Contexto contexto: Variavel de contexto que conte todas as informações
:return: A variavel de contexto
:rtype: Contexto
"""
self.log(texto=f'Executando o {self._name}')
self._contexto = contexto
self._gevts_templates = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_GEVTS_TEMPLATES_EXECUTAR)
mero_executavel = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_EXECUTAVEL)
iteracoes = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR, valor_unico_list=True)
iteracoes_str = ""
for ss in iteracoes:
iteracoes_str = f'{iteracoes_str}_{ss}'
self._qualificador = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_QUALIFICADOR)
prefixo_quali_itera = f'{self._qualificador}{iteracoes_str}'
path_projeto = self._contexto.get_atributo(EnumAtributo.PATH_PROJETO)
path_simulacao = self._contexto.get_atributo(
EnumAtributo.PATH_SIMULACAO)
path_unimap = InOut.ajuste_path(
f'{path_projeto}/{self._contexto.get_atributo(EnumAtributo.AVALIACAO_MERO_UNIMAP_PATH)}'
)
solucoes: Solucoes = self._contexto.get_atributo(EnumAtributo.SOLUCOES)
list_solucoes = solucoes.get_solucoes_by_iteracao_para_avaliar(
iteracoes)
if len(list_solucoes) < 1:
return self._contexto
for gevt_template in self._gevts_templates:
path_completo_destino = InOut.ajuste_path(
f'{path_projeto}/{path_simulacao}/{prefixo_quali_itera}_{gevt_template}_gep.mero'
)
cont = f"*SIMULATOR {self._contexto.get_atributo(EnumAtributo.SIMULADOR_NOME)} {self._contexto.get_atributo(EnumAtributo.SIMULADOR_VERSAO)}\n"
cont += '*MODEL_LIST\nID'
sol: Solucao = list(list(list_solucoes.values())[0].values())[0]
for nome, valor in sol.get_variaveis_nome_valor().items():
cont += ' {}'.format(nome)
cont += '\n'
for k_iteracao, v_est in list_solucoes.items():
for k_id, vv_est in v_est.items():
aux_path_simula = InOut.ajuste_path(
f'{path_projeto}/{path_simulacao}/{prefixo_quali_itera}_{vv_est.id}_{gevt_template}.unievent'
)
aux_path_template = InOut.ajuste_path(
f'{path_projeto}/{self._gevts_templates[gevt_template]["template_path"]}'
)
valor_variavel = ""
for nome, valor in vv_est.get_variaveis_nome_valor().items(
):
valor_variavel += f' {valor}'
cont += f'{prefixo_quali_itera}_{vv_est.id}_{gevt_template} {valor_variavel} {aux_path_template} {aux_path_simula} {path_unimap}\n'
try:
if self._contexto.tem_atributo(
EnumAtributo.AVALIACAO_MERO_GEP_INCLUDE_PATH):
include_gep = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_GEP_INCLUDE_PATH)
cont_gep = TXT().ler(path_arquivo=InOut.ajuste_path(
f'{path_projeto}/{include_gep}'))
for linha in cont_gep:
cont += linha
if not TXT().salvar(path_arquivo=path_completo_destino,
conteudo=cont):
solucoes = self._set_erro(list_solucoes, solucoes)
self.log(texto="CHAMANDO O MERO")
comando = f'{InOut.ajuste_path(str(mero_executavel))} gep -i {path_completo_destino} -l INFO'
if Terminal().run(comando) is False:
solucoes = self._set_erro(list_solucoes, solucoes)
except Exception as ex:
self.log(texto="Erro ao executar GEP",
tipo=EnumLogStatus.WARN,
info_ex=str(ex))
solucoes = self._set_erro(list_solucoes, solucoes)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, [solucoes], True)
return self._contexto
def run(self, contexto: Contexto) -> Contexto:
"""
Executa a classe
:param Contexto contexto: Variavel de contexto que conte todas as informações
:return: A variavel de contexto
:rtype: Contexto
"""
self.log(texto=f'Executando o {self._name}')
self._contexto = contexto
self._gevts_templates = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_GEVTS_TEMPLATES_EXECUTAR)
self._qualificador = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_QUALIFICADOR)
self._solucoes: Solucoes = self._contexto.get_atributo(
EnumAtributo.SOLUCOES)
mero_executavel = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_EXECUTAVEL)
iteracoes = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR, valor_unico_list=True)
iteracoes_str = ""
for ss in iteracoes:
iteracoes_str = f'{iteracoes_str}_{ss}'
prefixo = f'{self._qualificador}{iteracoes_str}'
path_projeto = InOut.ajuste_path(
str(self._contexto.get_atributo(EnumAtributo.PATH_PROJETO)))
path_simulacao = InOut.ajuste_path(
str(self._contexto.get_atributo(EnumAtributo.PATH_SIMULACAO)))
path_dsgu = InOut.ajuste_path(
f'{path_projeto}/{path_simulacao}/{prefixo}_dsgu.mero')
if not self._escrever(iteracoes, path_dsgu):
self._contexto.set_atributo(EnumAtributo.SOLUCOES,
[self._solucoes], True)
return self._contexto
try:
params = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_DS_PARAMS)
comando = f'{mero_executavel} dsgu -i {path_dsgu} {params}'
self.log(texto=f'Executando comando {comando}.')
self.log(texto=f'Abrindo as threads, aguarde ...')
terminal = Terminal()
self._thread = threading.Thread(target=terminal.run,
args=(comando, ))
self._thread.start()
except Exception as ex:
self.log(tipo=EnumLogStatus.ERRO,
texto=f'Erro executar o comando {comando}',
info_ex=str(ex))
list_solucoes = self._solucoes.get_solucoes_by_iteracao_para_avaliar(
iteracoes)
for k_iteracao, v_est in list_solucoes.items():
for k_id, vv_est in v_est.items():
vv_est.has_erro = 'DSGU'
self._solucoes.add_in_solucoes(vv_est, True)
self._thread.join()
self._thread = None
self._contexto.set_atributo(EnumAtributo.SOLUCOES, [self._solucoes],
True)
return self._contexto
def _executar_fop(self, buffer, solucoes):
unipro = buffer['unipro']
if len(unipro) == 0:
return solucoes
unieco_path = InOut.ajuste_path(
f"{self._path_projeto}/{self._uniecos[list(self._uniecos.keys())[0]]['unieco_path']}"
)
unieco_file = ((unieco_path.split(
InOut.barra())[-1]).split("#")[0]).split(".")[0]
cont = f'*PROJECT aux\n' \
f'*SIMULATOR {self._contexto.get_atributo(EnumAtributo.SIMULADOR_NOME)} {self._contexto.get_atributo(EnumAtributo.SIMULADOR_VERSAO)}\n' \
f'*UNIECO {unieco_path}\n' \
f'*ECO_REFERENCE_DATE {self._contexto.get_atributo(EnumAtributo.AVALIACAO_MERO_ECO_REFERENCE_DATE)}\n' \
f'*MODEL_LIST\n' \
f'ID\n'
iteracaoes = {}
ids = {}
for prefixo in unipro.keys():
cont += f'{prefixo}\n'
iteracaoes[unipro[prefixo]['iteracao']] = True
ids[unipro[prefixo]['iteracao']] = True
iteracaoes_str = ""
ids_str = ""
for iteracao in iteracaoes.keys():
iteracaoes_str = f'{iteracaoes_str}_{iteracao}'
for id in ids.keys():
ids_str = f'{ids_str}_{id}'
cont += self._adiciona_discretizacao_plat()
path = InOut.ajuste_path(
f'{self._path_projeto}/{self._path_simulacao}/{self._qualificador}_it{iteracaoes_str}_id{ids_str}_fop'
)
if not TXT().salvar(path_arquivo=f'{path}.mero', conteudo=cont):
self.log(tipo=EnumLogStatus.ERRO,
texto=f'Erro ao escrever aquivo {path}.')
keys = deepcopy(list(unipro.keys()))
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = unipro[prefixo]['iteracao']
id = unipro[prefixo]['id']
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao escrever fop.mero para a solucao {prefixo}) iteracao [{iteracao}] e id [{id}].'
)
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).has_erro = "Escrever_FOP.Mero"
return solucoes
else:
ler_resultados = {}
mero_executavel = InOut.ajuste_path(
self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_EXECUTAVEL))
thread_argument = ''
if self._contexto.tem_atributo(
EnumAtributo.AVALIACAO_MERO_FOP_MULTI_THREAD):
if self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_FOP_MULTI_THREAD):
thread_argument = ' --multi-thread'
comando = f'{mero_executavel} fop -i {path}.mero -t Local -s Local -p 1 -n 1 -q LocalQueue -f XML --no-wait -r{thread_argument}'
self.log(texto=f'Executando comando [{comando}]')
self.log(texto=f'Aguarde ...')
retorno_terminal = Terminal().run(comando)
path_fop_eof = f"{path}.eof.csv"
if not os.path.isfile(path_fop_eof):
path_fop_eof = f"{path}_{unieco_file}.eof.csv"
if (retorno_terminal is
False) or (not os.path.isfile(path_fop_eof)):
keys = deepcopy(list(unipro.keys()))
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = unipro[prefixo]['iteracao']
id = unipro[prefixo]['id']
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao executar FOP para a solucao {prefixo}) iteracao [{iteracao}] e id [{id}].'
)
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).has_erro = "Executando_FOP"
return solucoes
keys = deepcopy(list(unipro.keys()))
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = unipro[prefixo]['iteracao']
id = unipro[prefixo]['id']
self.log(
texto=
f'Fop da solucao [{prefixo}] iteracao [{iteracao}] e id [{id}] foi calculada com sucesso.'
)
ler_resultados[prefixo] = unipro[prefixo]
solucoes = self._ler_dados_economicos(solucoes, path_fop_eof,
ler_resultados,
EnumValues.VPL.name)
return solucoes
def _escrever(self, iteracoes, path_dsgu):
try:
path_projeto = InOut.ajuste_path(
self._contexto.get_atributo(EnumAtributo.PATH_PROJETO))
path_simulacao = InOut.ajuste_path(
self._contexto.get_atributo(EnumAtributo.PATH_SIMULACAO))
cont = f'*SIMULATOR {self._contexto.get_atributo(EnumAtributo.SIMULADOR_NOME)} {self._contexto.get_atributo(EnumAtributo.SIMULADOR_VERSAO)}\n' \
'*MODEL_LIST\n' \
'ID\n'
ids = ""
list_solucoes = self._solucoes.get_solucoes_by_iteracao_para_avaliar(
iteracoes)
for gevt_template in self._gevts_templates:
for k_iteracao, v_est in list_solucoes.items():
for k_id, vv_est in v_est.items():
id = f'{self._qualificador}_{vv_est.iteracao}_{vv_est.id}_{gevt_template}'
path_file_id = InOut.ajuste_path(
f'{path_projeto}/{path_simulacao}/{id}')
if os.path.isfile(f'{path_file_id}.dat'):
ids += f'{id}\n'
try:
if os.path.isfile(f'{path_file_id}.out'):
os.remove(f'{path_file_id}.out')
if os.path.isfile(f'{path_file_id}.mrf'):
os.remove(f'{path_file_id}.mrf')
if os.path.isfile(f'{path_file_id}.irf'):
os.remove(f'{path_file_id}.irf')
if os.path.isfile(f'{path_file_id}.rstr.irf'):
os.remove(f'{path_file_id}.rstr.irf')
if os.path.isfile(f'{path_file_id}.rstr.mrf'):
os.remove(f'{path_file_id}.rstr.mrf')
if os.path.isfile(f'{path_file_id}.rstr.sr3'):
os.remove(f'{path_file_id}.rstr.sr3')
if os.path.isfile(f'{path_file_id}.sr3'):
os.remove(f'{path_file_id}.sr3')
if os.path.isfile(f'{path_file_id}.log'):
os.remove(f'{path_file_id}.log')
if os.path.isfile(f'{path_file_id}.unipro'):
os.remove(f'{path_file_id}.unipro')
except Exception as ex:
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro ao remover arquivos.',
info_ex=str(ex))
else:
self.log(
tipo=EnumLogStatus.WARN,
texto=f'O arquivo {path_file_id} não existe.')
vv_est.has_erro = 'DSGU'
self._solucoes.add_in_solucoes(vv_est, True)
if ids == "":
self.log(tipo=EnumLogStatus.ERRO,
texto='Não há estudo para simular.')
return False
cont += ids
if not TXT().salvar(path_arquivo=path_dsgu, conteudo=cont):
self.log(tipo=EnumLogStatus.ERRO,
texto=f'Erro ao escrever aquivo {path_dsgu}.')
for k_iteracao, v_est in list_solucoes.items():
for k_id, vv_est in v_est.items():
vv_est.has_erro = 'DSGU'
self._solucoes.add_in_solucoes(vv_est, True)
return False
except Exception as ex:
self.log(tipo=EnumLogStatus.ERRO,
texto=f'Erro para escrever arquivo dsgu.mero',
info_ex=str(ex))
list_solucoes = self._solucoes.get_solucoes_by_iteracao_para_avaliar(
iteracoes)
for k_iteracao, v_est in list_solucoes.items():
for k_id, vv_est in v_est.items():
vv_est.has_erro = 'DSGU'
self._solucoes.add_in_solucoes(vv_est, True)
return False
return True
def run(self, contexto: Contexto) -> Contexto:
"""
Executa a classe
:param Contexto contexto: Variavel de contexto que conte todas as informações
:return: A variavel de contexto
:rtype: Contexto
"""
self.log(texto=f'Executando o {self._name}')
self._contexto = contexto
self._gevts_templates = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_GEVTS_TEMPLATES_EXECUTAR)
mero_executavel = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_EXECUTAVEL)
iteracoes = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR, valor_unico_list=True)
iteracoes_str = ""
for ss in iteracoes:
iteracoes_str = f'{iteracoes_str}_{ss}'
# TODO alterar o qualificador para redutor
self._qualificador = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_QUALIFICADOR)
solucoes: Solucoes = self._contexto.get_atributo(EnumAtributo.SOLUCOES)
list_solucoes = solucoes.get_solucoes_by_iteracao_para_avaliar(
iteracoes)
if len(list_solucoes) <= 0:
self.log(tipo=EnumLogStatus.ERRO,
texto=f'Não há estudo sem erro para avaliar')
return self._contexto
path_projeto = self._contexto.get_atributo(EnumAtributo.PATH_PROJETO)
path_simulacao = self._contexto.get_atributo(
EnumAtributo.PATH_SIMULACAO)
prefixo_quali_iteracoes = f'{self._qualificador}{iteracoes_str}'
for prefixo in self._gevts_templates.keys():
path_completo_destino = InOut.ajuste_path(
f'{path_projeto}/{path_simulacao}/{self._gevts_templates[prefixo]["gevt_file_name"]}.mero'
)
if not self._qualificador in EnumValues.TOTAL.name:
if not self._resecreve_time_list(path_completo_destino):
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao escrever arquivo [{path_completo_destino}].')
for iteracao in iteracoes:
for idd in solucoes.solucoes[iteracao]:
solucoes.solucoes[iteracao][idd].has_erro = "GEVT"
continue
for k_iteracao, v_est in list_solucoes.items():
for k_id, vv_est in v_est.items():
try:
_path_params = InOut.ajuste_path(
f'{path_projeto}/{path_simulacao}/{prefixo_quali_iteracoes}_{vv_est.id}_params.txt'
)
if self._escreve_params(vv_est, _path_params,
prefixo) is False:
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao escrever arquivo [{_path_params}].')
solucoes.get_solucao_by_iteracao_id(
k_iteracao, k_id).has_erro = "GEVT"
continue
gerenciamento = Gerenciamento()
gerenciamento.run(_path_params, self._contexto)
self.log(texto="CHAMANDO O MERO")
comando = f'{mero_executavel} gevt -i {path_completo_destino} --params {_path_params}'
if Terminal(
).run(comando,
erro_customizado="Unlicensed product.") is False:
self.log(
tipo=EnumLogStatus.ERRO,
texto=f'Erro ao executar comando [{comando}].')
solucoes.get_solucao_by_iteracao_id(
k_iteracao, k_id).has_erro = "GEVT"
continue
except Exception as ex:
self.log(tipo=EnumLogStatus.ERRO,
texto=f'Erro ao executar GEVT.',
info_ex=str(ex))
solucoes.get_solucao_by_iteracao_id(
k_iteracao, k_id).has_erro = "GEVT"
continue
self._contexto.set_atributo(EnumAtributo.SOLUCOES, [solucoes], True)
return self._contexto
def _ler_dados_producao(self, buffer):
unipro = buffer['unipro']
if len(unipro) == 0:
return
keys = deepcopy(list(unipro.keys()))
self.log(texto=f'Ler dados producao')
try:
keys = deepcopy(list(unipro.keys()))
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = unipro[prefixo]['iteracao']
id = unipro[prefixo]['id']
path = unipro[prefixo]['path']
path_file = InOut.ajuste_path(f'{path}.unipro')
file_unipro = h5py.File(path_file)
if EnumValues.WP.name in self._nomes_direcoes_of:
self._set_of(iteracao=iteracao,
id=id,
file_unipro=file_unipro,
nome_of=EnumValues.WP.name)
if EnumValues.NP.name in self._nomes_direcoes_of:
self._set_of(iteracao=iteracao,
id=id,
file_unipro=file_unipro,
nome_of=EnumValues.NP.name)
if EnumValues.WI.name in self._nomes_direcoes_of:
self._set_of(iteracao=iteracao,
id=id,
file_unipro=file_unipro,
nome_of=EnumValues.WI.name)
if EnumValues.GI.name in self._nomes_direcoes_of:
self._set_of(iteracao=iteracao,
id=id,
file_unipro=file_unipro,
nome_of=EnumValues.GI.name)
except Exception as ex:
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = unipro[prefixo]['iteracao']
id = unipro[prefixo]['id']
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao obter dados de produção da solucao iteracao [{iteracao}], e id [{id}]',
info_ex=str(ex))
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).has_erro = f'OBTER_OF_PROD'
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[EnumValues.NP.name].valor = Solucao.of_padrao(
self._nomes_direcoes_of[EnumValues.NP.name][
EnumValues.DIRECAO.name])
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[EnumValues.WP.name].valor = Solucao.of_padrao(
self._nomes_direcoes_of[EnumValues.WP.name][
EnumValues.DIRECAO.name])
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[EnumValues.WP.name].valor = Solucao.of_padrao(
self._nomes_direcoes_of[EnumValues.WI.name][
EnumValues.DIRECAO.name])
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[EnumValues.WP.name].valor = Solucao.of_padrao(
self._nomes_direcoes_of[EnumValues.GI.name][
EnumValues.DIRECAO.name])
def _executar_vme(self, buffer, solucoes):
unipros = buffer['unipro']
if len(unipros) == 0:
return solucoes
iteracoes = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR, valor_unico_list=True)
list_solucoes = solucoes.get_solucoes_by_iteracao_para_avaliar(
iteracoes)
for iteracao in list_solucoes.keys():
for id in list_solucoes[iteracao].keys():
vme_rodou = []
pode_vme = True
model_list = "*MODEL_LIST\nID\n"
for gevt_template in self._gevts_templates:
prefixo = f'{self._qualificador}_{iteracao}_{id}_{gevt_template}'
model_list += f'{prefixo} {prefixo}.unievent ({self._gevts_templates[gevt_template]["template_prob"]})\n'
if not prefixo in unipros:
pode_vme = False
vme_rodou.append(prefixo)
if not pode_vme:
continue
cont = "" \
f"*PROJECT ProjetoVME_{iteracao}_{id}\n" \
"*SIMULATOR IMEX 2016.10\n" \
f"*ECO_REFERENCE_DATE {self._contexto.get_atributo(EnumAtributo.AVALIACAO_MERO_ECO_REFERENCE_DATE)}\n" \
f"*HISTORY_END_DATE {self._contexto.get_atributo(EnumAtributo.AVALIACAO_MERO_ECO_REFERENCE_DATE)}\n" \
"*ECO_CONTRACT CONCESSION\n" \
"*NPV_TYPE FOP NPVF\n" \
"*UNIECO_PROBABILITY_LIST\n"
for unieco in self._uniecos.keys():
aux_path = InOut.ajuste_path(
f'{self._path_projeto}/{self._uniecos[unieco]["unieco_path"]}'
)
cont += f'{aux_path} {self._uniecos[unieco]["unieco_prob"]}\n'
cont += model_list
path = InOut.ajuste_path(
f'{self._path_projeto}/{self._path_simulacao}/{self._qualificador}_{iteracao}_{id}_vme'
)
if not TXT().salvar(path_arquivo=f'{path}.mero',
conteudo=cont):
self.log(tipo=EnumLogStatus.ERRO,
texto=f'Erro ao escrever aquivo {path}.')
for ii in range(len(vme_rodou)):
prefixo = vme_rodou[ii]
if prefixo in unipros:
iteracao = unipros[prefixo]['iteracao']
id = unipros[prefixo]['id']
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao escrever vme.mero para a solucao {prefixo}) iteracao [{iteracao}] e id [{id}].'
)
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = "Escrever_VME.Mero"
return solucoes
else:
ler_resultados = {}
mero_executavel = InOut.ajuste_path(
self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_EXECUTAVEL))
comando = f'{mero_executavel} vme -i {path}.mero -t Local -s Local -p 1 -n 1 -q LocalQueue -f XML --no-wait -r'
self.log(texto=f'Executando comando [{comando}]')
self.log(texto=f'Aguarde ...')
path_fop_eof = f'{path}.vme.csv'
retorno_terminal = Terminal().run(comando)
if (retorno_terminal is
False) or (not os.path.isfile(path_fop_eof)):
for ii in range(len(vme_rodou)):
prefixo = vme_rodou[ii]
if prefixo in unipros:
iteracao = unipros[prefixo]['iteracao']
id = unipros[prefixo]['id']
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Rodar ou ler arquivo .vme.csv da solucao {prefixo}) iteracao [{iteracao}] e id [{id}].'
)
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = "Executando_VME"
return solucoes
for ii in range(len(vme_rodou)):
prefixo = vme_rodou[ii]
if prefixo in unipros:
iteracao = unipros[prefixo]['iteracao']
id = unipros[prefixo]['id']
self.log(
texto=
f'VME da solucao [{prefixo}] iteracao [{iteracao}] e id [{id}] foi calculada.'
)
ler_resultados[prefixo] = unipros[prefixo]
solucoes = self._ler_dados_economicos(
solucoes, path_fop_eof, ler_resultados)
return solucoes
def _check_simulado(self):
simulando = self._buffer['simulando']
keys = deepcopy(list(simulando.keys()))
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = simulando[prefixo]['iteracao']
id = simulando[prefixo]['id']
path = simulando[prefixo]['path']
file = InOut.ajuste_path(f'{path}.out')
if os.path.isfile(file):
with open(file, 'r') as out_file:
file_read = out_file.read()
if 'Normal Termination' in file_read:
self.log(
texto=
f'Solucao ({prefixo}) iteracao [{iteracao}] e id [{id}] foi simulada com sucesso, será calculado o unipro. '
)
self._buffer['simulado'][prefixo] = simulando[prefixo]
del self._buffer['simulando'][prefixo]
continue
if 'End of Simulation:' in file_read:
time.sleep(1)
with open(file, 'r') as out_file2:
file_read_2 = out_file2.read()
if 'Normal Termination' in file_read_2:
self.log(
texto=
f'Solucao ({prefixo}) iteracao [{iteracao}] e id [{id}] foi simulada com sucesso, será calculado o unipro. '
)
self._buffer['simulado'][prefixo] = simulando[
prefixo]
del self._buffer['simulando'][prefixo]
continue
else:
self.log(
texto=
f'Erro ao simular solucao ({prefixo}) iteracao [{iteracao}] e id [{id}]',
tipo=EnumLogStatus.ERRO)
self._buffer['erro'][prefixo] = simulando[
prefixo]
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = "Calcula_OF"
del self._buffer['simulando'][prefixo]
continue
horas_sim_max = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_TEMPO_MAX_SIM)
if simulando[prefixo][
"time"] + horas_sim_max * 60 * 60 < time.time():
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'A simulação da solucao {prefixo}) iteracao [{iteracao}] e id [{id}] excedeu tempo de {horas_sim_max} hora.'
)
self._buffer['erro'][prefixo] = simulando[prefixo]
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = f"Excedeu {horas_sim_max}h"
del self._buffer['simulando'][prefixo]
else:
self.log(
texto=
f'Erro ao simular solucao {prefixo}) iteracao [{iteracao}] e id [{id}]',
tipo=EnumLogStatus.ERRO)
self._buffer['erro'][prefixo] = simulando[prefixo]
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).has_erro = "Calcula_OF"
del self._buffer['simulando'][prefixo]
return
