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):
"""
Executa a inicizalicao default
:param Contexto contexto: contexto com todas as informações necessárias
:return: Devolve o contexto atualizado
:rtype: Contexto
"""
super(Default, self).run(contexto)
caminho_dominio = TXT().ajuste_path(
f'{self._contexto.get_atributo(EnumAtributo.PATH_PROJETO)}/{self._contexto.get_atributo(EnumAtributo.INICIALIZACAO_DOMINIO)}'
)
iteracao = 0
identificador = 0
self._solucao = Solucao(id=identificador, iteracao=iteracao)
for nome_of in self._nomes_direcoes_of:
direcao = self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name]
self._solucao.of = Of(nome_of, direcao=direcao)
dominio = TXT().ler(caminho_dominio)
for ii in range(1, len(dominio)):
try:
if str(dominio[ii]).strip() == "":
continue
dom = self._linha_2_dominio(dominio[ii])
self.log(texto=f'Criando variavel {dom.to_string()}')
variavel = Variavel(dom)
self._solucao.add_in_variaveis(variavel)
except Exception as ex:
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro para adicionar variavel',
info_ex=str(ex))
self._contexto.set_atributo(EnumAtributo.SOLUCAO_BASE, self._solucao)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR,
[0], True)
solucoes = Solucoes()
solucoes.add_in_solucoes(self._solucao)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, solucoes, True)
if self._contexto.get_atributo(EnumAtributo.INICIALIZACAO_SIMULA_BASE):
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
self._contexto = avaliacao.run(self._contexto)
Exportacao().csv(self._contexto)
Exportacao().obejto(self._contexto)
def _carregar_informacao(self, modules: list):
"""
Ler o arquivo carrega toda informação e adiciona na variavel _configuracao
"""
linha = ''
try:
contexto = TXT().ler(
str(self._contexto.get_atributo(
EnumAtributo.PATH_CONFIGURACAO)))
for module in modules:
self._contexto.set_atributo('module',
[InOut.ajusta_entrada(module)])
for linha in contexto:
linha = linha.replace("\n", "").strip()
if (len(linha) > 0) and (not linha[0] == "*"):
sp = linha.split()
chave = sp[0].strip()
valor = sp[1].strip()
if len(sp) > 2:
for ii in range(2, len(sp)):
sp[ii] = sp[ii].strip()
if len(sp[ii]) > 0:
valor = f'{valor} {sp[ii]}'
self._contexto.set_atributo(chave,
[InOut.ajusta_entrada(valor)])
except Exception as ex:
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto=f"Erro ao carregar arquivos. Linha [{linha}]",
info_ex=f'ex[{str(ex)}]')
def _generate_copy_config(self):
run_key = datetime.now().strftime("%Y%m%d-%H%M%S")
[config_name, extension] = os.path.basename(self._contexto.get_atributo(EnumAtributo.PATH_CONFIGURACAO)).split(
'.')
if not Copy.copy_file(self._contexto.get_atributo(EnumAtributo.PATH_CONFIGURACAO),
os.path.join(self._contexto.get_atributo(EnumAtributo.PATH_PROJETO),
self._base_folder_name,
f'{config_name}_{run_key}.{extension}.bk')):
self.log(tipo=EnumLogStatus.ERRO_FATAL, texto='Erro geracao arquivo de backup da configuracao')
cont = ''
for [key, value] in self._contexto._configuracao.items():
for val in value:
if key not in [EnumAtributo.MODULE.name, EnumAtributo.PATH_PROJETO.name,
EnumAtributo.PATH_CONFIGURACAO.name, EnumAtributo.PATH_LOG.name]:
cont += f'{key}\t{val}\n'
if not TXT().salvar(
os.path.join(self._contexto.get_atributo(EnumAtributo.PATH_PROJETO), self._base_folder_name,
f'{config_name}.{extension}'), cont,
'w'):
self.log(tipo=EnumLogStatus.ERRO_FATAL, texto='Erro geracao arquivo de configuracao')
self.log(texto=f'Arquivo de configuracao gerado.{config_name}')
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 _escreve_params(self, solucao: Solucao, _path_params, prefixo):
try:
unievet_file_name = f'{self._qualificador}_{solucao.iteracao}_{solucao.id}_{prefixo}.unievent'
cont = 'name_unievent {}\n'.format(unievet_file_name)
if self._contexto.tem_atributo(
EnumAtributo.REDUCAO_GEVT_DATA_FINAL):
cont += f'{EnumValues.DATA_FINAL.name} {self._contexto.get_atributo(EnumAtributo.REDUCAO_GEVT_DATA_FINAL)}\n'
if self._contexto.tem_atributo(
EnumAtributo.REDUCAO_GEVT_DIA_FINAL):
cont += f'{EnumValues.DIA_FINAL.name} {self._contexto.get_atributo(EnumAtributo.REDUCAO_GEVT_DIA_FINAL)}\n'
# cont += f'***{EnumTipoVariaveis.VARIAVEL.name}***\n'
# for key, variavel in solucao.get_variavies_by_tipo().items():
# cont += '{} {}\n'.format(key, variavel.valor)
#
# cont += f'***{EnumTipoVariaveis.CONSTANTE.name}***\n'
# for key, variavel in solucao.get_variavies_by_tipo(EnumTipoVariaveis.CONSTANTE).items():
# cont += '{} {}\n'.format(key, variavel.valor)
cont += f'***VARIAVEIS***\n'
for nome, valor in solucao.get_variaveis_nome_valor().items():
cont += '{} {}\n'.format(nome, valor)
if TXT().salvar(_path_params, cont):
return True
except Exception as ex:
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro ao escrever arquivo de dominio.',
info_ex=str(ex))
return False
return False
def csv(self, contexto: Contexto, nome=None):
"""
Método interno para salvar CSV com dados da otimização
"""
self._contexto = contexto
conteudo_solucao_csv = self._gerar_conteudo_solucoes_csv()
try:
iteracao_max = max(
self._contexto.get_atributo(EnumAtributo.SOLUCOES).solucoes)
path_csv = InOut().ajuste_path('/'.join([
self._contexto.get_atributo(EnumAtributo.PATH_PROJETO),
f'/{self._contexto.get_atributo(EnumAtributo.PATH_RESULTADO)}.csv'
])).format(str(iteracao_max))
if nome is not None:
path_csv = InOut().ajuste_path('/'.join([
self._contexto.get_atributo(EnumAtributo.PATH_PROJETO),
f'/{self._contexto.get_atributo(EnumAtributo.PATH_RESULTADO)}.csv'
])).format(str(nome))
if not TXT().salvar(path_csv, conteudo_solucao_csv):
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro ao salvar CSV da otimização.')
except Exception as ex:
self.log(tipo=EnumLogStatus.WARN,
texto=f'Erro ao salvar CSV da otimização.',
info_ex=str(ex))
def _gera_entrada_hldg(self):
conteudo = self._gera_conteudo_hldg()
if TXT().salvar(self._path_hldg, conteudo):
self.log(texto='Arquivo de entrada do HLDG gerado com sucesso')
else:
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto='Erro na geracao do arquivo do HLDG')
def test_de_copia_de_arquivo_quando_folder_destino_eh_existente():
path_arquivo_para_copia = paths_files.path_arquivo_exemplo()
path_arquivo_copiado = '\\'.join([paths_files.path_mocks(), 'arquivo_copiado.txt'])
path_arquivo_copiado = InOut().ajuste_path(path_arquivo_copiado)
if not copy.copy_file(path_arquivo_para_copia, path_arquivo_copiado):
pytest.fail('erro ao copiar arquivo')
if not InOut().arquivo_existe(path_arquivo_copiado):
pytest.fail('arquivo copiado nao foi gerado')
if not TXT().ler(path_arquivo_copiado) == TXT().ler(path_arquivo_para_copia):
pytest.fail('conteudo arquivo copiado nao eh igual ao original')
try:
os.remove(path_arquivo_copiado)
except Exception as ex:
pytest.fail(f'Nao foi possivel remover arquivo gerado. Erro :[{ex}]')
def LogarMemoria(contexto):
"""
Método que libera memória e retorna a quantidade de memória usada.
:param contexto:
:type contexto:
:return: Quantidade de mem�ria usada
:rtype: int
"""
memoria_usada = 0
try:
LiberarMemoria()
pid = os.getpid()
p = psutil.Process(pid)
memorias = (p.memory_info())
memoria_usada = int(memorias.rss / 1000000)
n_solucoes = 0
if contexto.tem_atributo(EnumAtributo.SOLUCOES):
solucoes = contexto.get_atributo(EnumAtributo.SOLUCOES)
if solucoes is not None:
for it in solucoes.solucoes:
n_solucoes += len(solucoes.solucoes[it])
Loggin().log(texto=f'Quantilidade de solucao = {n_solucoes}')
Loggin().log(texto=f'Memoria usada [{memoria_usada}Mb]')
path_arquivo = f'{contexto.get_atributo(EnumAtributo.PATH_PROJETO)}/memoria_info.csv'
if int(n_solucoes) == 0:
try:
os.remove(path_arquivo)
Loggin().log(texto=f'Removido o arquivo {arquivo_remover}')
except Exception as ex:
pass
conteudo = f'solucoes;memoria_usada[Mb];Mb/solucao\n{n_solucoes};{memoria_usada};inf\n'
TXT().salvar(path_arquivo, conteudo, '+a')
else:
TXT().salvar(
path_arquivo,
f'{n_solucoes};{memoria_usada};{memoria_usada/(n_solucoes)}\n',
'+a')
except Exception as ex:
Loggin().log(tipo=EnumLogStatus.WARN,
texto='Erro ao logar memoria',
info_ex=str(ex))
finally:
return memoria_usada
def __init__(self, path_projeto: str, path_config: str, modules: list):
"""
Chama a função de leitura das informações nor arquivo de configura no caminho path_configuracao
:param str path_projeto: O caminho referente a raiz do projeto
:param str arquivo_config: Caminho para o arquivo de configuracao
"""
super().__init__()
self._name = __name__ # variável com nome do arquivo
path_projeto = TXT().ajuste_path(path_projeto)
path_config = TXT().ajuste_path(path_projeto + '/' + path_config)
if not TXT().diretorio_existe(path_projeto):
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto=f"Diretorio [{path_projeto}] não existe.")
if not TXT().arquivo_existe(path_config):
self.log(
tipo=EnumLogStatus.ERRO_FATAL,
texto=f"O arquivo de configuracao [{path_config}] não existe.")
path_log = TXT().ajuste_path(f'{path_projeto}/log.out')
Loggin.set_arquivo_log(path_log)
self.log(texto="[INICIO_TARDIS] - Iniciando Carregamento.")
self._contexto = Contexto()
self._contexto.set_atributo(EnumAtributo.PATH_PROJETO, [path_projeto])
self._contexto.set_atributo(EnumAtributo.PATH_CONFIGURACAO,
[path_config])
self._contexto.set_atributo(EnumAtributo.PATH_LOG, [path_log])
try:
self._carregar_informacao(modules)
self._contexto.set_defaults()
self._valida_contexto()
except Exception as ex:
self.log(texto="Erro para configurar valores defaults",
info_ex=str(ex),
tipo=EnumLogStatus.ERRO_FATAL)
def _resecreve_time_list(self, gevt_path):
if self._contexto.tem_atributo(EnumAtributo.REDUCAO_GEVT_TIME_LIST):
linhas_gevt = TXT().ler(gevt_path)
for i in range(len(linhas_gevt) - 1, 0, -1):
if (linhas_gevt[i] != '') and (not '**'
in linhas_gevt[i][0:2]):
if not linhas_gevt[i].strip(
)[-9:] in EnumValues.TIME_LIST.name:
self.log(tipo=EnumLogStatus.WARN,
texto='Ultima linha não contem TIME LIST')
return False
else:
conteudo = "\n"
conteudo += '\n'.join([
str(x) for x in self._contexto.get_atributo(
EnumAtributo.REDUCAO_GEVT_TIME_LIST)
])
self.log(texto=f'Reescrevendo arquivo {gevt_path}')
return TXT().salvar(gevt_path,
metodo_gravacao='a+',
conteudo=conteudo)
return True
def test_de_copia_de_arquivo_quando_folder_destino_nao_eh_existente():
nome_diretorio_auxiliar1 = 'mocks2'
nome_diretorio_auxiliar2 = 'mocks3\\'
path_arquivo_para_copia = paths_files.path_arquivo_exemplo()
path_arquivo_copiado = '\\'.join([paths_files.path_mocks(), nome_diretorio_auxiliar1,
nome_diretorio_auxiliar2, 'arquivo_copiado.txt'])
path_arquivo_copiado = InOut().ajuste_path(path_arquivo_copiado)
path_remocao_folder = '\\'.join([paths_files.path_mocks(), nome_diretorio_auxiliar1])
path_remocao_folder = InOut().ajuste_path(path_remocao_folder)
if not copy.copy_file(path_arquivo_para_copia, path_arquivo_copiado):
pytest.fail('Criacao de arquivo copiado falhou')
if not os.path.isfile(path_arquivo_copiado):
pytest.fail('Arquivo nao foi copiado')
if not TXT().ler(path_arquivo_copiado) == TXT().ler(path_arquivo_para_copia):
pytest.fail('conteudo arquivo copiado nao eh igual ao original')
try:
shutil.rmtree(path_remocao_folder)
except Exception as ex:
pytest.fail(f'Nao foi possivel remover folder criado. Erro :[{ex}]')
def run(self):
"""
Executa o modulo de painel de comparacao.
"""
super(Comparacao, self).run()
# TODO: GERAWIDGET RECEBE CAMINHOS DE RESULTADOS
# TODO: GERAWIDGET VAI TER SET DE MAXIMOS AVALIACOES, CAMINHOS, BOXPLOT(PODERIA ATE SER ENTRADA DO METODO BOXPLOT
# TODO: , ETC... TUDO QUE ESTAVA UTILIZANDO QUE ESTAVA DENTRO DO CONTEXTO
gera_widget = GeraWidget(self._contexto)
fig_scatter = gera_widget.scatter()
fig_sumario = gera_widget.sumario()
fig_max_lines = gera_widget.maxlines()
fig_max_lines_mean = gera_widget.averamaxlines()
fig_boxplot = gera_widget.boxplot()
fig_rank = gera_widget.rank()
fig_scatter = UpdateWidget.add_combobox_by_method(fig_scatter)
fig_max_lines = UpdateWidget.add_combobox_by_method(fig_max_lines)
fig_boxplot = UpdateWidget.fix_color_by_method(fig_boxplot)
fig_max_lines_mean = UpdateWidget.fix_color_by_method(
fig_max_lines_mean)
fig_rank = UpdateWidget.fix_color_by_method(fig_rank)
figs = [
UpdateWidget.style(fig, template='none') for fig in [
fig_sumario, fig_scatter, fig_max_lines, fig_max_lines_mean,
fig_boxplot, fig_rank
]
]
html = self._monta_html(figs)
path_resultado = os.path.join(
self._contexto.get_atributo(
EnumAtributo.VISUALIZACAO_COMPARACAO_PATH_SAIDA))
if not TXT().salvar(path_resultado, html):
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto=f'Erro ao gerar arquivo {path_resultado}')
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 _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 _carregar_saida_HLDG(self):
path_out_hldg = self._path_hldg.replace('.mero', '-models.txt')
conteudo_sorteio_txt = TXT().ler(path_out_hldg)
return conteudo_sorteio_txt
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 _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
import os
import shutil
import tests.utilitarios.PathsFiles as paths_files
from src.inout.InOut import InOut
from src.inout.TXT import TXT
txt = TXT()
txt.set_arquivo_log(paths_files.path_arquivo_log())
def test_de_verificacao_de_leitura_de_arquivo():
assert txt.ler(paths_files.path_arquivo_exemplo()) == [
'id;cab1;cab2\n', '1;val11;val12\n', '2;val21;val22'
]
def test_de_retorno_vazio_na_leitura_de_arquivo_inexistente():
path_arquivo_inexistente = InOut().ajuste_path('\\'.join(
[paths_files.path_mocks(), 'arquivo_inexistente.txt']))
assert txt.ler(path_arquivo_inexistente) == [None]
def test_para_salvar_arquivos():
errors = []
file_name = 'arquivo_teste.txt'
path_arquivo_salvar = InOut().ajuste_path('\\'.join(
[paths_files.path_mocks(), file_name]))
def _salvar_solucoes_avaliadas(self):
try:
caminho_solucoes_existentes = self._get_caminho_solucoes_existentes(
)
if caminho_solucoes_existentes is not None:
df_solucoes = CSV().ler(str(caminho_solucoes_existentes),
index_col=False)
tem_nova_coluna = False
for nome_of in self._nomes_direcoes_of:
if str(f'of[{nome_of.upper()}]') not in list(
df_solucoes.columns.values):
coluna_df = str(f'of[{nome_of.upper()}]')
df_solucoes[coluna_df] = None
tem_nova_coluna = True
colunas_df = list(df_solucoes.columns.values)
iteracoes = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR)
solucoes: Solucoes = self._contexto.get_atributo(
EnumAtributo.SOLUCOES).get_solucoes_by_iteracao(iteracoes)
if tem_nova_coluna:
for it in solucoes:
for id in solucoes[it]:
if solucoes[it][id].has_erro is None or solucoes[
it][id].has_erro == "":
if solucoes[it][id].avaliada:
serializacao = solucoes[it][
id].serializacao()
serie = df_solucoes[
df_solucoes['serializacao'] ==
serializacao].serializacao
if serie.shape[0] <= 0:
index = df_solucoes.shape[0]
zeros = np.zeros(
(len(df_solucoes.columns)))
df_solucoes.loc[index] = zeros
df_solucoes.loc[
index,
'serializacao'] = serializacao
for coluna_df in colunas_df[1:]:
of_nome = coluna_df.replace(
'of',
'').replace(']',
'').replace('[', '')
if of_nome in solucoes[it][id].of:
df_solucoes.loc[
df_solucoes['serializacao'] ==
serializacao,
coluna_df] = solucoes[it][
id].of[of_nome].valor
else:
if colunas_df != 'serializacao':
df_solucoes.loc[
df_solucoes['serializacao']
== serializacao,
coluna_df] = ""
str_solucoes_salvar = df_solucoes.to_csv(
sep=';', index=False).replace('\r', '')
TXT().salvar(str(caminho_solucoes_existentes),
str_solucoes_salvar, "+w")
else:
str_solucoes_salvar = ""
for it in solucoes:
for id in solucoes[it]:
if solucoes[it][id].has_erro is None or solucoes[
it][id].has_erro == "":
if solucoes[it][id].avaliada:
serializacao = solucoes[it][
id].serializacao()
serie = df_solucoes[
df_solucoes['serializacao'] ==
serializacao].serializacao
if serie.shape[0] <= 0:
str_solucoes_salvar += f'{solucoes[it][id].serializacao()};'
for coluna_df in colunas_df:
nome_of = coluna_df.replace(
'of[', '').replace(']', '')
if nome_of in solucoes[it][id].of:
str_solucoes_salvar += f"{solucoes[it][id].of[nome_of].valor};"
else:
if nome_of != 'serializacao':
str_solucoes_salvar += f";"
str_solucoes_salvar = str_solucoes_salvar[:
-1] + '\n'
if len(str_solucoes_salvar) > 0:
TXT().salvar(str(caminho_solucoes_existentes),
str_solucoes_salvar, "+a")
except Exception as ex:
self.log(tipo=EnumLogStatus.ERRO,
texto='Erro ao salvar em arquivo',
info_ex=str(ex))