def _gerar_solucoes_avalia(self):
self._iteracao += 1
self.log(texto="Calculando nova populacao.")
for ii in range(self._tamanho_populacao):
self._id += 1
solucao = Solucao(id=self._id,
iteracao=self._iteracao,
solucao=self._solucao_base)
for jj in range(len(self._populacao[ii]['posicao'])):
nome = self._populacao[ii]['variavel'][jj]['nome']
posicao = self._populacao[ii]['variavel'][jj]['posicao']
try:
solucao.variaveis.set_variavel_posicao_by_nome(
nome, posicao)
except Exception as ex:
self.log(tipo=EnumLogStatus.ERRO,
texto="Erro ao setar variavel",
info_ex=str(ex))
solucao.variaveis.set_variavel_posicao_by_nome(nome, 0)
solucao.geral = "[PSO] "
self._solucoes.add_in_solucoes(solucao)
self._populacao[ii]['id'] = solucao.id
self._populacao[ii]['of'] = Solucao.of_padrao(
direcao=self._direcao_of)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, self._solucoes,
True)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR,
[self._iteracao], True)
def _evaluate(self, x, out, *args, **kwargs):
if len(kwargs) == 0:
return
iteracao_max = max(list(self._solucoes.solucoes))
iteracao_atual = iteracao_max + 1
id = max(list(self._solucoes.solucoes[iteracao_max])) + 1
Loggin().log(arquivo=__name__, tipo=EnumLogStatus.INFO, texto=f"Inicializando o Calculo para geração [{iteracao_atual}]")
solucao_base: Solucao = self._contexto.get_atributo(EnumAtributo.SOLUCAO_BASE)
for ii in range(x.shape[0]):
solucao_nova = Solucao(id, iteracao_atual, solucao_base)
id += 1
variavies = solucao_base.get_variavies_by_tipo()
jj = 0
for variavel in variavies:
try:
solucao_nova.variaveis.get_variavel_by_nome(variavel).posicao = int(x[ii][jj])
except ValueError as ex:
Loggin().log(arquivo=__name__, texto="Valor for do limite", info_ex=str(ex))
jj += 1
solucao_nova.geral = f'[{self._otimizador}]'
self._solucoes.add_in_solucoes(solucao_nova)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, self._solucoes, True)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR, [iteracao_atual], True)
Loggin().log(arquivo=__name__, tipo=EnumLogStatus.INFO, texto=f"Iniciando avaliação.")
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
self._contexto = avaliacao.run(self._contexto)
self._solucoes = self._contexto.get_atributo(EnumAtributo.SOLUCOES)
f1 = np.zeros((len(self._solucoes.solucoes[iteracao_atual]), self._n_obj))
g1 = np.zeros((len(self._solucoes.solucoes[iteracao_atual]), self._n_obj))
for ii in self._solucoes.solucoes[iteracao_atual]:
try:
posicao = ii - list(self._solucoes.solucoes[iteracao_atual])[0]
n_of = 0
for nome_of in sorted(self._nomes_direcoes_of):
# para minimizar precisa ser -1 o valor padrão.
direcao_of_valor = 1
if EnumValues.MIN.name in self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name]:
direcao_of_valor = -1
if self._solucoes.solucoes[iteracao_atual][ii].has_erro is None:
f1[posicao][n_of] = -1 * self._solucoes.solucoes[iteracao_atual][ii].of[nome_of].valor * direcao_of_valor
g1[posicao][n_of] = -1 * self._solucoes.solucoes[iteracao_atual][ii].of[nome_of].valor * direcao_of_valor
else:
f1[posicao][n_of] = -1 * Solucao.of_padrao(self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name])
g1[posicao][n_of] = -1 * Solucao.of_padrao(self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name])
n_of += 1
except Exception as ex:
Loggin().log(arquivo=__name__, tipo=EnumLogStatus.ERRO, texto=f"Não foi possivel ler of da solucao [{ii}] geracao [{iteracao_atual}].")
out["F"] = f1
out["G"] = g1
self._salvar()
def existe_solucao(self, solucao: Solucao, retorna_solucao=False):
try:
tamanho = len(self._solucoes_serializado)
except Exception:
if str(type(self._solucoes_serializado)) is not str(type({})):
self._solucoes_serializado = {}
self._add_serializado(solucao)
if solucao.serializacao() in self._solucoes_serializado:
# A solucao encontrada é a mesma da solução busca
if solucao.id == self._solucoes_serializado[solucao.serializacao(
)]['id'] and solucao.iteracao == self._solucoes_serializado[
solucao.serializacao()]['iteracao']:
pass
else:
if retorna_solucao:
iteracao = self._solucoes_serializado[
solucao.serializacao()]['iteracao']
id = self._solucoes_serializado[
solucao.serializacao()]['id']
return True, self._solucoes[iteracao][id]
else:
return True
if retorna_solucao:
return False, None
else:
return False
def solucoes_it_para_menos1(self, it):
solucoes = self.get_solucoes_by_iteracao(it)
if solucoes:
if self.get_solucoes_by_iteracao(-1):
self.remove_iteracao(-1)
for id, solucao in solucoes[it].items():
new_solucao = Solucao(solucao=solucao, iteracao=-1, id=id)
new_solucao.of = solucao.of
new_solucao.economico = solucao.economico
self.add_in_solucoes(new_solucao)
self.remove_iteracao(it)
def run(self, contexto: Contexto):
"""
Metodo responsavel por simular de forma total as melhores simulacoes ao ser utilizado
redutor com simulacao parcial
:param Contexto contexto: contexto com todas as informações necessárias
"""
super(SimulacaoTotal, self).run(contexto)
n_melhores = 10
solucoes = self._contexto.get_atributo(EnumAtributo.SOLUCOES)
iteracao_sim_total = max(map(int, solucoes.solucoes)) + 1
melhores_solucoes = solucoes.conjunto_melhores_solucoes(
n_melhores).solucoes
for it in melhores_solucoes:
for id in melhores_solucoes[it]:
solucao_sim_total = melhores_solucoes[it][id]
solucao = Solucao(id=id,
iteracao=iteracao_sim_total,
solucao=solucao_sim_total)
self.log(
arquivo=__name__,
texto=
f'Solucao de it={it}, id={id} sera simulado de forma total'
)
solucao.geral = f'SIMULACAO TOTAL do it = {it} id = {id}'
solucoes.add_in_solucoes(solucao)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, solucoes, True)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR,
[iteracao_sim_total], True)
gevts_templates = self._contexto.get_gevts_templates(
self._contexto.get_atributo(
EnumAtributo.AVALIACAO_MERO_GEVT_TEMPLATE))
self._contexto.set_atributo(
EnumAtributo.AVALIACAO_MERO_GEVTS_TEMPLATES_EXECUTAR,
gevts_templates, True)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_QUALIFICADOR,
EnumValues.TOTAL.name, True)
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
self._contexto = avaliacao.run(self._contexto)
Exportacao().csv(self._contexto)
Exportacao().obejto(self._contexto)
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 _set_melhores(self):
direcao_of_valor = 1
if self._direcao_of in EnumValues.MIN.name:
direcao_of_valor = -1
for ii in range(self._tamanho_populacao):
id = self._populacao[ii]['id']
solucao: Solucao = self._solucoes.get_solucao_by_iteracao_id(
self._iteracao, id)
self._populacao[ii]['of'] = solucao.of[self._nome_of_mono].valor
if not solucao.of_valida():
for of_nome in solucao.of:
self._populacao[ii]['of'] = Solucao.of_padrao(
direcao=self._direcao_of)
self.log(
tipo=EnumLogStatus.WARN,
texto=
f'Solucao com itercao [{solucao.iteracao}] e id [{solucao.id}], esta com of {of_nome} nula. Será atribuido {Solucao.of_padrao(direcao=self._direcao_of)} para of'
)
if solucao.has_erro is not None:
self._populacao[ii]['of'] = Solucao.of_padrao(
direcao=self._direcao_of)
self.log(
tipo=EnumLogStatus.WARN,
texto=
f'Solucao com itercao [{solucao.iteracao}] e id [{solucao.id}], esta com erro [{solucao.has_erro}]. Será atribuido -inf para of'
)
if (direcao_of_valor * self._populacao[ii]['of']) > (
direcao_of_valor * self._populacao[ii]['best_of']):
self.log(
texto=
f"[Melhor LOCAL] [pop:{ii}][it:{self._iteracao}][id:{id}]: of -> [{self._populacao[ii]['best_of']}]>[{self._populacao[ii]['of']}]"
)
self._populacao[ii]['best_posicao'] = deepcopy(
self._populacao[ii]['posicao'])
self._populacao[ii]['best_of'] = deepcopy(
self._populacao[ii]['of'])
if (direcao_of_valor * self._populacao[ii]['of']) > (
direcao_of_valor * self._gbest['of']):
self.log(
texto=
f"[Melhor GLOBAL] [it:{self._iteracao}][id:{id}]: of -> [{self._gbest['of']}]>[{self._populacao[ii]['of']}]"
)
self._gbest['posicao'] = deepcopy(
self._populacao[ii]['posicao'])
self._gbest['variavel'] = deepcopy(
self._populacao[ii]['variavel'])
self._gbest['of'] = deepcopy(self._populacao[ii]['of'])
def _criar_solucoes_em_contexto(self):
conteudo_sorteio_txt = self._carregar_saida_HLDG()
nomes_variaveis = conteudo_sorteio_txt[0].split('\t')[1:-1]
lista_serializado = self._solucoes.serializacao()
for solucao_txt in conteudo_sorteio_txt[1:]:
nome_solucao_val_vars = solucao_txt.split('\t')
[iteracao_solucao,
id_solucao] = nome_solucao_val_vars[0].split('_')
solucao = Solucao(id=int(id_solucao) + self._ultimo_id,
iteracao=int(iteracao_solucao),
solucao=self._solucao_pdf_atualizada)
val_vars = [
InOut().ajusta_entrada(val_var)
for val_var in nome_solucao_val_vars[1:-1]
]
for variavel, valor in zip(nomes_variaveis, val_vars):
solucao.variaveis.get_variavel_by_nome(variavel).valor = valor
if solucao.variaveis.serializacao() not in lista_serializado:
self._solucoes.add_in_solucoes(solucao)
self._contexto.set_atributo(EnumAtributo.SOLUCOES, self._solucoes,
True)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR,
[int(iteracao_solucao)], True)
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 _selecionar_melhor(self):
"""
Obtem a melhor solucao, de modo geral e se precisar de um novo caminho
:param solucoes: Lista de todas as estratégias
:type solucoes: Solucao
:param nova: Informa se quer uma solucao para um novo caminho
:type nova: bool
:return:
:rtype:
"""
solucoes_aux = self._contexto.get_atributo(
EnumAtributo.SOLUCOES).solucoes
#melhor_aux = self._solucao_base
melhor_aux = None
melhor_aux_of = float('-inf')
quantidade_de_vezes_usar_solucao_com_melhor = 1
for k_iteracao in solucoes_aux:
for k_id in solucoes_aux[k_iteracao]:
if Solucao.validar_of(solucoes_aux[k_iteracao][k_id].of[
self._nome_of_mono].valor):
direcao_of_valor = 1
if self._nomes_direcoes_of[self._nome_of_mono][
EnumValues.DIRECAO.name] in EnumValues.MIN.name:
direcao_of_valor = -1
#if (direcao_of_valor * solucoes_aux[k_iteracao][k_id].of[self._nome_of_mono].valor) > (direcao_of_valor * melhor_aux.of[self._nome_of_mono].valor):
if (direcao_of_valor * solucoes_aux[k_iteracao][k_id].of[
self._nome_of_mono].valor) > (direcao_of_valor *
melhor_aux_of):
eh_nova = True
if k_iteracao in self._solucoes_usadas:
if k_id in self._solucoes_usadas[k_iteracao]:
if self._solucoes_usadas[k_iteracao][
k_id] > quantidade_de_vezes_usar_solucao_com_melhor:
eh_nova = False
if eh_nova:
melhor_aux = solucoes_aux[k_iteracao][k_id]
melhor_aux_of = solucoes_aux[k_iteracao][k_id].of[
self._nome_of_mono].valor
if melhor_aux is None:
melhor_aux = self._solucao_base
self._solucao_melhor = melhor_aux
if '[Melhor]' not in self._solucao_melhor.geral:
self._solucao_melhor.geral += '[Melhor]'
if melhor_aux.iteracao in self._solucoes_usadas:
if melhor_aux.id in self._solucoes_usadas[melhor_aux.iteracao]:
self._solucoes_usadas[melhor_aux.iteracao][melhor_aux.id] += 1
else:
self._solucoes_usadas[melhor_aux.iteracao][melhor_aux.id] = 1
else:
self._solucoes_usadas[melhor_aux.iteracao] = {melhor_aux.id: 1}
self._contexto.set_atributo(
EnumAtributo.OTIMIZACAO_MCC_SOLUCOES_USADAS, self._solucoes_usadas,
True)
def _nova_solucao_aleatoria(self, index_fc, iteracao, id, prefixo):
solucao = copy.deepcopy(
self._solucoes.get_solucao_by_iteracao_id(
self._fontes_alimento[index_fc].iteracao,
self._fontes_alimento[index_fc].id))
variaveis = copy.deepcopy(solucao.get_variavies_by_tipo())
for nome_var in variaveis:
lim_inferior = 0
lim_superior = len(variaveis[nome_var].dominio.niveis) - 1
posicao = random.randint(
lim_inferior,
lim_superior) # ajuste para inteiro, equação [ref:2].5
variaveis[nome_var].posicao = posicao
solucao.variaveis.set_variavel_posicao_by_nome(
variaveis[nome_var].nome, variaveis[nome_var].posicao)
solucao_nova = Solucao(iteracao=iteracao, id=id, solucao=solucao)
solucao_nova.geral = f'[ABC][Aleatoria][{prefixo}]'
return solucao_nova
def _evoluindo_variavel(self, passo: int,
variavel_in: Variavel) -> Solucao:
solucao_aux = None
variavel = None
while True:
variavel = copy.deepcopy(variavel_in)
if abs(passo) > len(variavel.dominio.niveis):
solucao_aux = None
self.log(
texto=
f'Não existe niveis para mais um na variavel [{variavel.nome}], com posicao [{abs(passo)}].'
)
break
elif variavel.posicao + passo < 0:
solucao_aux = None
self.log(
texto=
f'Não existe niveis para mais um na variavel [{variavel.nome}], com posicao [{variavel.posicao + passo}].'
)
break
elif variavel.posicao + passo >= len(variavel.dominio.niveis):
solucao_aux = None
self.log(
texto=
f'Não existe niveis para mais um na variavel [{variavel.nome}], com posicao [{variavel.posicao + passo}].'
)
break
valor_antigo = variavel.valor
try:
variavel.posicao += passo
except ValueError as ex:
self.log(texto="Valor for do limite", info_ex=str(ex))
return None
#self.log(texto=f'Passo igual [{passo}] para evolução da variavel [{variavel.nome}], valor antigo [{valor_antigo}], valor novo [{variavel.valor}]')
solucao_aux = Solucao(iteracao=self._iteracao,
id=self._id + 1,
solucao=self._solucao_melhor)
solucao_aux.variaveis.set_variavel_posicao_by_nome(
variavel.nome, variavel.posicao)
solucao_aux.geral += f'[MCC][{variavel.nome}|{valor_antigo}>{variavel.valor}]'
if self._solucoes.existe_solucao(solucao_aux):
passo += int(passo / abs(passo))
#self.log(texto=f'Já existe solucao com esses valores nas variaveis. Passo será [{passo}].')
else:
self._id += 1
break
del variavel
variavel = None
return solucao_aux
def _iteracao_um(self, avaliacao, exportacao):
empty_particle = {
'posicao': None,
'velocidade': None,
'of': None,
'best_posicao': None,
'best_of': -1 * float('inf'),
'variavel': None,
'id': None,
}
if len(self._populacao) == 0:
self._populacao = []
for ii in range(self._tamanho_populacao):
self._populacao.append(empty_particle.copy())
self._populacao[ii]['of'] = Solucao.of_padrao(
direcao=self._direcao_of
) # ofFunction(self._populacao[ii]['posicao'])
self._populacao[ii]['velocidade'] = np.full(
len(self._variaveis), self._w)
self._populacao[ii]['posicao'] = np.zeros(len(self._variaveis))
self._populacao[ii]['variavel'] = [None] * (len(
self._variaveis))
self._populacao[ii]['best_posicao'] = deepcopy(
self._populacao[ii]['posicao'])
self._populacao[ii]['best_of'] = deepcopy(
self._populacao[ii]['of'])
if len(self._solucoes_historico) > 0:
self._obtem_variaveis_solucao_historico()
else:
self._obtem_variavies_aleatoriamente()
self._gerar_solucoes_avalia()
self._avaliar_solucoes(avaliacao)
self._set_melhores()
self._para_resume()
exportacao.csv(self._contexto)
exportacao.obejto(self._contexto)
LogarMemoria(self._contexto)
else:
self._gbest['posicao'] = deepcopy(self._populacao[0]['posicao'])
self._gbest['variavel'] = deepcopy(self._populacao[0]['variavel'])
self._gbest['of'] = deepcopy(self._populacao[0]['of'])
for ii in range(1, len(self._populacao)):
if self._populacao[ii]['of'] > self._gbest['of']:
self._gbest['posicao'] = deepcopy(
self._populacao[ii]['posicao'])
self._gbest['variavel'] = deepcopy(
self._populacao[ii]['variavel'])
self._gbest['of'] = deepcopy(self._populacao[ii]['of'])
self._set_melhores()
def __init__(self):
"""
Construtor da solucoes
"""
super().__init__()
self._name = __name__
"""
Variavel com o nome do arquivo
"""
self._solucoes = {}
"""
Variavel que armazena a coleção de solucoes
"""
self._melhor_solucao = Solucao(0, 0)
self._solucoes_serializado = {}
def _run_neighbors(self, neighbors: list):
"""
Metodo responsavel por simular as estratégias vizinhas
:param neighbors:
"""
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
for candidatestrategy in neighbors:
self._id += 1
solucao = Solucao(id=int(self._id),
iteracao=int(self._iteracao),
solucao=candidatestrategy)
solucao.geral += "[TS]"
self._solucoes.add_in_solucoes(solucao)
self._contexto.set_atributo(EnumAtributo.AVALIACAO_ITERACAO_AVALIAR,
[self._iteracao],
sobrescreve=True)
self._contexto = avaliacao.run(self._contexto)
def _gera_solucoes(self):
"""
Gera as solucoes e salva na variavel de classe
"""
self.log(texto="Gerando Soluções")
self._solucoes = Solucoes()
nome_variaveis = self._solucao_referencia.variaveis.get_variaveis_by_tipo(
EnumTipoVariaveis.VARIAVEL)
amostras = []
for nome_variavel in nome_variaveis:
probabilidade = self._solucao_referencia.variaveis.get_variavel_by_nome(
nome_variavel).dominio.probabilidade
niveis = self._solucao_referencia.variaveis.get_variavel_by_nome(
nome_variavel).dominio.niveis
if round(sum(probabilidade), 3) != round(1, 3):
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto='Somatorio das probabilidades diferente de 1')
amostra = self._gera_amostragem_variaveis(probabilidade, niveis,
self._tamanho_populacao)
amostras.append(amostra)
amostras = np.array(amostras).T
amostras = self._checa_duplicidade(amostras)
solucoes_df = pd.DataFrame(amostras, columns=nome_variaveis.keys())
for i in range(solucoes_df.shape[0]):
self._ultimo_id += 1
solucao = Solucao(id=int(self._ultimo_id),
iteracao=int(self._iteracao),
solucao=self._solucao_referencia)
for variavel, valor in zip(solucoes_df.columns,
solucoes_df.iloc[i, :]):
solucao.variaveis.get_variavel_by_nome(
variavel).valor = InOut.ajusta_entrada(str(valor))
#Caso a simulacao ja tenha sido simulada, o avaliador sera responsavel por reutilizar o valor ja simulado
#Caso nao queira solucoes repetidas, deve ser tratado fora da classe de sorteio
self._solucoes.add_in_solucoes(solucao)
def run(self):
"""
Metodo responsavel por utilizar avaliadores em arquivos externos python.
O arquivo deve possuir o metodo getResult(dict_variaveis)
"""
if self._nome_of_mono is None:
return
super(MultiObjetivo, self).run()
if EnumValues.MULTIOBJETIVO.name in self._nome_of_mono:
iteracoes = self._contexto.get_atributo(
EnumAtributo.AVALIACAO_ITERACAO_AVALIAR)
self._solucoes: Solucoes = self._contexto.get_atributo(
EnumAtributo.SOLUCOES).get_solucoes_by_iteracao(iteracoes)
for it in self._solucoes:
for id in self._solucoes[it]:
try:
for of_nome in self._nomes_direcoes_of:
if EnumValues.MULTIOBJETIVO.name not in of_nome:
exec(
f'{of_nome} = {self._solucoes[it][id].of[of_nome].valor}'
)
funcao_of = self._nome_of_mono.replace(
EnumValues.MULTIOBJETIVO.name,
"").replace('[', '').replace(']', '').replace(
EnumValues.MAX.name,
"").replace(EnumValues.MIN.name,
"").replace("_", "")
valor_funcao_of = eval(f'{funcao_of}')
self._solucoes[it][id].of[
self._nome_of_mono].valor = valor_funcao_of
except Exception as ex:
self.log(f"Erro ao calcular função.")
self._solucoes[it][id].of[
self._nome_of_mono].valor = Solucao.of_padrao(
self._solucoes[it][id].of[
self._nome_of_mono].direcao)
def _set_of(self, iteracao, id, file_unipro, nome_of):
try:
tempo, valor_of = self._ler_serie_field_unipro(
file_unipro, nome_of)
self.log(
texto=
f'Solucao iteracao [{iteracao}], e id [{id}] tem OF [{nome_of}] no valor de [{valor_of}] e tempo [{tempo}]'
)
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).of[nome_of].valor = valor_of
self._solucoes.get_solucao_by_iteracao_id(iteracao=iteracao,
id=id).set_avaliada()
except Exception as ex:
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao obter dados de {nome_of} 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_{nome_of}'
self._solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = Solucao.of_padrao(
self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name])
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])
class Default(InicializadorPadrao):
"""
Classe para inicializacao dos dados.
"""
def __init__(self):
super(Default, self).__init__()
self._name = __name__
"""
Variavel com o nome do arquivo
"""
self._necessidade = [EnumAtributo.INICIALIZACAO_DOMINIO] + super(
Default, self).necessidade
"""
Contem a lista de todos os atributos necessários para o módulo ser executado.
"""
self._solucao = None
"""
Objeto com todos os dominios
"""
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 _linha_2_dominio(self, linha):
"""
Converte a linha do arquivo de donimio.csv em um objto do tipo dominio
:param linha: Linha do arquivo de problema nome, problema, default, probabilidade
:type linha: str
:return: retorna o objeto do dominio
:rtype: Dominio
"""
tipo = EnumTipoVariaveis.VARIAVEL
linha = linha.strip()
if len(linha.split(";")) < 2:
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto=f"Dominio {linha} esta com erro.")
if linha[0] == "#":
tipo = EnumTipoVariaveis.CONSTANTE
linha = linha.replace("#", "")
args = linha.split(";")
nome = args[0].strip()
default = None
niveis = None
probabilidade = None
equacao = None
if '=' in linha:
tipo = EnumTipoVariaveis.CONDICIONAL
if len(args) > 2:
self.log(
tipo=EnumLogStatus.WARN,
texto=
f"Para variavel tipo condicional, são usados somentes dois parametros, nome [{args[0]}] e equacao [{args[1]}]."
)
equacao = args[1].strip()
equacao = equacao.replace("=", "").strip()
else:
niveis, probabilidade = self._str_2_niveis(args[1].strip())
if len(args) > 2:
default = InOut.ajusta_entrada(args[2].strip().replace(
"'", "").replace('"', ''))
if default == "":
self.log(
tipo=EnumLogStatus.WARN,
texto=
f'O valor default, não existe, com isso o default será [{niveis[0]}]'
)
default = niveis[0]
else:
if default in niveis:
pass
else:
self.log(
tipo=EnumLogStatus.WARN,
texto=
f'O valor default [{default}], não existe no domínio, com isso o default será [{niveis[0]}]'
)
default = niveis[0]
if len(args) > 3:
probabilidade = args[3].strip()
if probabilidade == "":
probabilidade = None
else:
probabilidade = probabilidade.replace("[", "").replace(
"]", "").replace(" ", "").split(",")
for ii in range(len(probabilidade)):
probabilidade[ii] = InOut.ajusta_entrada(
probabilidade[ii])
if len(niveis) != len(probabilidade):
self.log(
tipo=EnumLogStatus.ERRO_FATAL,
texto=
f"Quantidade de níveis [{len(niveis)}] é diferente da quantidade de probabilidades [{len(probabilidade)}]."
)
return Dominio(nome, niveis, probabilidade, default, equacao, tipo)
def _monta_niveis(self, linha, replace):
linha = linha.strip()
linha = linha.replace(replace, "")
args = linha.split(";")
if len(args) < 2:
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto=f"Dominio {linha} esta com erro.")
nome = args[0].strip()
default = None
niveis, probabilidade = self._str_2_niveis(args[1].strip())
return nome, niveis, probabilidade, default
def _str_2_niveis(self, str_niveis: str) -> tuple:
"""
Converte as string [ | ] ou { } exemplo [1 | 3] ou {1 2 3} em list [1, 2, 3]
:param str_niveis: string nos formatos [ | ] ou { } exemplo [1 | 3] ou {1 2 3}
:type str_niveis: str
:return: list do problema
:rtype: list
"""
niveis = []
probabilidade = []
discretizacao = str_niveis
try:
if str_niveis.find("[") >= 0:
str_niveis = str_niveis.replace(",", "|")
if str_niveis.find("{") >= 0:
str_niveis = str_niveis.replace(",", " ")
if str_niveis.find("[") >= 0 and str_niveis.find(
"]") > 0 and str_niveis.find("|") > 0:
discretizacao = discretizacao.replace("[", "")
discretizacao = discretizacao.replace("]", "")
discretizacao = discretizacao.strip()
limite = discretizacao.split("|")
for rr in range(
int(InOut.ajusta_entrada(limite[0].strip())),
int(InOut.ajusta_entrada(limite[1].strip())) + 1):
niveis.append(InOut.ajusta_entrada(str(rr)))
probabilidade.append(0)
elif str_niveis.find("{") >= 0 and str_niveis.find("}") > 0:
discretizacao = discretizacao.replace("{", "")
discretizacao = discretizacao.replace("}", "")
discretizacao = discretizacao.strip()
possiveis = discretizacao.split(" ")
for rr in range(len(possiveis)):
niveis.append(
InOut.ajusta_entrada(possiveis[rr].strip().replace(
"'", "").replace('"', '')))
probabilidade.append(0)
if len(niveis) > 0:
for ii in range(len(probabilidade)):
probabilidade[ii] = 1 / len(probabilidade)
except Exception as ex:
niveis = []
probabilidade = []
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto=f"Erro para criar problema [{str_niveis}].",
info_ex=str(ex))
return niveis, probabilidade
def _nova_solucao(self, index_fc_selecionada, iteracao, id,
prefixo) -> Solucao:
solucao_fonte = copy.deepcopy(
self._solucoes.get_solucao_by_iteracao_id(
self._fontes_alimento[index_fc_selecionada].iteracao,
self._fontes_alimento[index_fc_selecionada].id))
solucao_nova = Solucao(iteracao=iteracao, id=id, solucao=solucao_fonte)
solucao_nova.geral = f'[ABC][Vizinhanca][{prefixo}]'
try:
from random import sample
index_variaveis_sorteio = sample(
range(0, len(self._lista_variaveis)),
len(self._lista_variaveis))
index_fonte_alimento_sorteio = sample(
range(0, len(self._fontes_alimento)),
len(self._fontes_alimento))
fonte_vizinha_index = index_fonte_alimento_sorteio.pop(0)
while fonte_vizinha_index == index_fc_selecionada:
fonte_vizinha_index = index_fonte_alimento_sorteio.pop(0)
fonte_vizinha = self._fontes_alimento[fonte_vizinha_index]
contador_existem = 0
limites_random = 1
while self._solucoes.existe_solucao(solucao_nova):
contador_existem += 1
variavel_modificar = self._lista_variaveis[
index_variaveis_sorteio.pop(0)]
dominio_niveis = len(solucao_nova.get_variavies_by_tipo()
[variavel_modificar].dominio.niveis)
posicao_fonte = solucao_nova.get_variavies_by_tipo(
)[variavel_modificar].posicao
posicao_vizinha = self._solucoes.get_solucao_by_iteracao_id(
fonte_vizinha.iteracao, fonte_vizinha.id
).get_variavies_by_tipo()[variavel_modificar].posicao
r = random.uniform(-1 * limites_random, limites_random)
# gera valores entre -1 e 1, equacao [ref:2].6 | estamos gerando entre -2 e 2 para aumentar variabilidade visto que são inteiros
posicao_nova = max(
min(
dominio_niveis - 1,
math.ceil(posicao_fonte +
(posicao_fonte - posicao_vizinha) * r)), 0)
posicao_antiga = solucao_nova.get_variavies_by_tipo(
)[variavel_modificar].posicao
if posicao_antiga == posicao_nova:
if posicao_nova == dominio_niveis - 1:
posicao_nova += -1
elif posicao_nova == 0:
posicao_nova += 1
else:
posicao_nova += random.sample([-1, 1], 1)[0]
self.log(
texto=
f'[{variavel_modificar} | {posicao_antiga} > {posicao_nova}]'
)
solucao_nova.get_variavies_by_tipo(
)[variavel_modificar].posicao = posicao_nova
if limites_random >= 10:
break
if len(index_variaveis_sorteio) <= 0:
limites_random += 0.1
index_variaveis_sorteio = sample(
range(0, len(self._lista_variaveis)),
len(self._lista_variaveis))
if len(index_fonte_alimento_sorteio) <= 0:
index_fonte_alimento_sorteio = sample(
range(0, len(self._fontes_alimento)),
len(self._fontes_alimento))
fonte_vizinha_index = index_fonte_alimento_sorteio.pop(0)
while fonte_vizinha_index == index_fc_selecionada:
if len(index_fonte_alimento_sorteio) <= 0:
index_fonte_alimento_sorteio = sample(
range(0, len(self._fontes_alimento)),
len(self._fontes_alimento))
fonte_vizinha_index = index_fonte_alimento_sorteio.pop(
0)
fonte_vizinha = self._fontes_alimento[fonte_vizinha_index]
self.log(
texto=
f'Tentativas para nova solucao [{contador_existem}] e Limite em [{limites_random:.2f}].'
)
except Exception as ex:
self.log(tipo=EnumLogStatus.ERRO_FATAL,
texto="Erro para obter nova solucao.",
info_ex=str(ex))
return solucao_nova
def _ler_dados_economicos(self, solucoes, path, ler_resultados, nome_of):
keys = deepcopy(list(ler_resultados.keys()))
direcao_of = self._nomes_direcoes_of[nome_of][EnumValues.DIRECAO.name]
if len(keys) == 0:
return solucoes
self.log(texto=f'Ler dados economicos de {path}')
try:
df_lido_correto = True
df = CSV().ler(f'{path}', lines_ignore=3, sep=";", index_col=False)
if df is None or df.shape[1] <= 1:
df = CSV().ler(f'{path}',
lines_ignore=3,
sep=",",
index_col=False)
if df is None or df.shape[1] <= 1:
df_lido_correto = False
if df_lido_correto:
df.sort_values(by='MODEL', inplace=True)
df.index = df.MODEL
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = ler_resultados[prefixo]['iteracao']
id = ler_resultados[prefixo]['id']
df_aux = {'dataframe': df[df.index == prefixo]}
if len(df_aux) > 0:
try:
valor_of = Solucao.of_padrao(direcao_of)
if nome_of == EnumValues.VPL.name:
if 'OF' in list(df_aux['dataframe'].columns):
df_npvf = df_aux['dataframe'][
df_aux['dataframe'].OF == 'NPVF']
valor_of = df_npvf.VALUE.iloc[0]
if nome_of == EnumValues.VME.name:
if 'EMV' in list(df_aux['dataframe'].columns):
valor_of = df_aux["dataframe"].EMV.iloc[0]
self.log(
texto=
f'Solucao iteracao [{iteracao}], e id [{id}] tem OF no valor de [{valor_of}]'
)
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = valor_of
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).set_avaliada()
except Exception as ex:
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao ler dados economicos da solucao iteracao [{iteracao}], e id [{id}]',
info_ex=str(ex))
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = f'LER_CVS_{nome_of}'
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = Solucao.of_padrao(
direcao_of)
else:
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao ler dados economicos da solucao iteracao [{iteracao}], e id [{id}]'
)
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = f'LER_CVS_{nome_of}'
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = Solucao.of_padrao(
direcao_of)
else:
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = ler_resultados[prefixo]['iteracao']
id = ler_resultados[prefixo]['id']
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao abrir dados economicos da solucao iteracao [{iteracao}], e id [{id}]'
)
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).has_erro = f'ABRIR_CVS_{nome_of}'
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = Solucao.of_padrao(
direcao_of)
except Exception as ex:
for ii in range(len(keys)):
prefixo = keys[ii]
iteracao = ler_resultados[prefixo]['iteracao']
id = ler_resultados[prefixo]['id']
self.log(
tipo=EnumLogStatus.ERRO,
texto=
f'Erro ao obter dados economicos da solucao iteracao [{iteracao}], e id [{id}]',
info_ex=str(ex))
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao, id=id).has_erro = f'OBTER_{nome_of}'
solucoes.get_solucao_by_iteracao_id(
iteracao=iteracao,
id=id).of[nome_of].valor = Solucao.of_padrao(direcao_of)
return solucoes
def run(self):
"""
Executa o PSO
:param Contexto contexto: contexto com todas as informações necessárias
:return: Devolve o contexto atualizado
:rtype: Contexto
"""
super(PSO, self).run()
exportacao = Exportacao()
avaliacao = self._contexto.get_modulo(EnumModulo.AVALIACAO)
criterio = self._contexto.get_modulo(EnumModulo.CRITERIOPARADA)
self._iteracao_um(avaliacao, exportacao)
while not criterio.run(self._contexto):
self.log(texto=f"Nova iteracao do método")
for ii in range(self._tamanho_populacao):
rp = np.random.rand(1)
rg = np.random.rand(1)
ld = np.zeros(len(self._variaveis))
lu = np.zeros(len(self._variaveis))
for jj in range(len(self._variaveis)):
ld[jj] = 0
lu[jj] = self._populacao[ii]['variavel'][jj]['lu'] - 1
termo_inercia = self._w * self._populacao[ii]['velocidade']
termo_cognitivo = self._cp * rp * (
self._populacao[ii]['best_posicao'] -
self._populacao[ii]['posicao'])
termo_social = self._cg * rg * (self._gbest['posicao'] -
self._populacao[ii]['posicao'])
self._populacao[ii][
'velocidade'] = termo_inercia + termo_cognitivo + termo_social
posicao_atualizada = self._populacao[ii][
'posicao'] + self._populacao[ii]['velocidade']
posicao_atualizada = np.round(posicao_atualizada,
0).astype(int)
posicao_atualizada = np.maximum(posicao_atualizada, ld)
posicao_atualizada = np.minimum(posicao_atualizada, lu)
self._populacao[ii]['posicao'] = np.round(
posicao_atualizada, 0).astype(int)
for vv in range(len(self._populacao[ii]['variavel'])):
self._populacao[ii]['variavel'][vv][
'posicao'] = self._populacao[ii]['posicao'][vv]
self._populacao[ii]['of'] = Solucao.of_padrao(
direcao=self._direcao_of)
self._populacao[ii]['id'] = None
self._w *= self._wdamp
self._gerar_solucoes_avalia()
self._avaliar_solucoes(avaliacao)
self._set_melhores()
self._para_resume()
exportacao.csv(self._contexto)
exportacao.obejto(self._contexto)
LogarMemoria(self._contexto)
self.log(texto=f'Fim da execução do {self._name}')
def _iniciar_fonte_alimento(self):
self.log(tipo=EnumLogStatus.INFO,
texto='Iniciando as fonte de alimento.')
self._existe_solucao_avaliar = False
# resume de um otimizador diferente
if self._iteracao > 1 and self._iteracao != self._ultima_iteracao:
self._fontes_alimento = []
solucoes_melhores = self._solucoes.conjunto_melhores_solucoes(
quantidade=self._qtd_fonte_alimento,
nome_of_mono=self._nome_of_mono).solucoes
for iteracao in solucoes_melhores:
for id in solucoes_melhores[iteracao]:
fonte_alimento = FonteAlimento(
iteracao, id, solucoes_melhores[iteracao][id].of[
self._nome_of_mono].direcao)
fonte_alimento.of = solucoes_melhores[iteracao][id].of[
self._nome_of_mono].valor
self._fontes_alimento.append(fonte_alimento)
# resume do ABC
if self._iteracao > 1 and self._iteracao == self._ultima_iteracao:
qtd_solucoes_melhores = self._qtd_fonte_alimento - len(
self._fontes_alimento)
solucoes_melhores = self._solucoes.conjunto_melhores_solucoes(
quantidade=qtd_solucoes_melhores,
nome_of_mono=self._nome_of_mono).solucoes
for iteracao in solucoes_melhores:
for id in solucoes_melhores[iteracao]:
fonte_alimento = FonteAlimento(
iteracao, id, solucoes_melhores[iteracao][id].of[
self._nome_of_mono].direcao)
fonte_alimento.of = solucoes_melhores[iteracao][id].of[
self._nome_of_mono].valor
self._fontes_alimento.append(fonte_alimento)
# default
if self._qtd_fonte_alimento != len(self._fontes_alimento):
self._iteracao += 1
while self._qtd_fonte_alimento > len(self._fontes_alimento):
self._id += 1
solucao = Solucao(iteracao=self._iteracao,
id=self._id,
solucao=self._solucao_base)
solucao.geral = '[ABC][Aleatorio][Inicio]'
variaveis = copy.deepcopy(solucao.get_variavies_by_tipo())
for nome_var in variaveis:
lim_inferior = 0
lim_superior = len(variaveis[nome_var].dominio.niveis) - 1
posicao = random.randint(
lim_inferior,
lim_superior) # ajuste para inteiro, equação [ref:2].5
variaveis[nome_var].posicao = posicao
solucao.variaveis.set_variavel_posicao_by_nome(
variaveis[nome_var].nome, variaveis[nome_var].posicao)
if self._solucoes.existe_solucao(solucao):
self._id -= 1
else:
self._solucoes.add_in_solucoes(solucao)
self._fontes_alimento.append(
FonteAlimento(solucao.iteracao, solucao.id,
solucao.of[self._nome_of_mono].direcao))
self._existe_solucao_avaliar = True
# self.log(tipo=EnumLogStatus.INFO, texto=solucao.to_string())
self._avaliar()