public static void Simular(Modelo modelo)
        {
            pmObject.LoadModel(modelo.modelo);
            PassoAtual("Caregado " + modelo.modelo + ".");

            double SimulationTime = 0;

            pmObject.Simulate();

            while (SimulationTime < tempoSimulacao)
            {
                pmObject.GetSimTime(out SimulationTime);
                iVisual.TempoSimulacao(SimulationTime);
                //iVisual.Progresso(((SimulationTime * 100 / tempoSimulacao) / divisorProgresso) + valorInicial);

                System.Threading.Thread.Sleep(1);
            }
            pmObject.EndSimulation();
            PassoAtual("Terminada simulação.");
        }
        public static void SegundaGeracao()
        {
            try
            {
                PassoAtual("SEGUNDA GERAÇÃO.");

                Modelo[] modeloPrimeira = new Modelo[bancoModelos.Count];
                bancoModelos.CopyTo(modeloPrimeira);

                var top = from p in modeloPrimeira
                          orderby p.scoreSaidas descending
                          orderby p.scoreTotal descending
                          orderby p.scoreTempo ascending
                          select p;

                Relatorios.resultados.Add(top.First());

                foreach (Modelo item in top.Take(2))
                {
                    bancoModelos.Clear();
                    bancoModelos.RemoveRange(0, bancoModelos.Count);
                    bancoModelos = new List <Modelo>();
                    PassoAtual("Criando descendentes do filho " + item.modelo + ".");

                    AlgoritimoGenetico(item.modelo, false);
                    CriarDescendente(false);
                }

                var resultadoSegundaGeracao = from p in bancoModelos
                                              orderby p.scoreSaidas descending
                                              orderby p.scoreTotal descending
                                              orderby p.scoreTempo ascending
                                              select p;

                Relatorios.resultados.Add(resultadoSegundaGeracao.First());
                iVisual.ProximaEtapa();
            }
            catch (Exception ex)
            { Service.Error.GerarLog(ex); }
        }
Esempio n. 3
0
        public static double[] ExportarResultados(Modelo modelo)
        {
            double[] modeloLocal = new double[3];

            System.Threading.Thread.Sleep(2000);
            Manager.PassoAtual("Abrindo banco " + modelo.banco + ".");
            if (!File.Exists(modelo.banco))
            {
                return(null);
            }

            Manager.RDBObj.OpenFile(modelo.banco);

            int locaisModelo;
            int entidadesModelo;

            Manager.pmDataObject.GetRecordCount(1, out locaisModelo);
            Manager.pmDataObject.GetRecordCount(2, out entidadesModelo);

            double[,] InformLocais    = new double[10, locaisModelo];
            double[,] InformEntidades = new double[9, entidadesModelo];

            #region LeituraInformações
            for (int contadorLocais = 1; contadorLocais <= locaisModelo; contadorLocais++)
            {
                Manager.RDBObj.SelectData(1, 1, 1, 1, 5, contadorLocais);
                InformLocais[0, contadorLocais - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 1, 6, contadorLocais);
                InformLocais[1, contadorLocais - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 1, 8, contadorLocais);
                InformLocais[2, contadorLocais - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 3, 2, contadorLocais);
                InformLocais[3, contadorLocais - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 3, 5, contadorLocais);
                InformLocais[4, contadorLocais - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 3, 6, contadorLocais);
                InformLocais[5, contadorLocais - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 3, 7, contadorLocais);
                InformLocais[6, contadorLocais - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 7, 1, contadorLocais);
                InformLocais[7, contadorLocais - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 7, 3, contadorLocais);
                InformLocais[8, contadorLocais - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 7, 5, contadorLocais);
                InformLocais[9, contadorLocais - 1] = Manager.RDBObj.GetValue();
            }

            for (int contadorEntidades = 1; contadorEntidades <= entidadesModelo; contadorEntidades++)
            {
                Manager.RDBObj.SelectData(1, 1, 1, 5, 1, contadorEntidades);
                InformEntidades[0, contadorEntidades - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 5, 3, contadorEntidades);
                InformEntidades[1, contadorEntidades - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 5, 4, contadorEntidades);
                InformEntidades[2, contadorEntidades - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 7, 2, contadorEntidades);
                InformEntidades[3, contadorEntidades - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 6, 1, contadorEntidades);
                InformEntidades[4, contadorEntidades - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 6, 2, contadorEntidades);
                InformEntidades[5, contadorEntidades - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 6, 4, contadorEntidades);
                InformEntidades[6, contadorEntidades - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 8, 1, contadorEntidades);
                InformEntidades[7, contadorEntidades - 1] = Manager.RDBObj.GetValue();

                Manager.RDBObj.SelectData(1, 1, 1, 8, 2, contadorEntidades);
                InformEntidades[8, contadorEntidades - 1] = Manager.RDBObj.GetValue();
            }
            #endregion
            Manager.PassoAtual("Lida informações inicias.");

            #region RelatorioParcial
            using (StreamWriter relatorio = new StreamWriter(Path.GetFileNameWithoutExtension(modelo.modelo) + ".psr"))
            {
                relatorio.WriteLine("Relatorio parcial de simulacao v1.0");
                relatorio.WriteLine("Thiago Aguirre Lorscheiter");
                relatorio.WriteLine("");
                relatorio.WriteLine("A alteração de qualquer parametro pode afetar ou mesmo inviabilizar o funcionamento do software");
                relatorio.WriteLine("");
                relatorio.WriteLine("Parametros");
                relatorio.WriteLine(locaisModelo + ";" + entidadesModelo);
                relatorio.WriteLine(modelo.modeloPai);
                relatorio.WriteLine("");

                relatorio.WriteLine("RELATORIO LOCAIS");
                relatorio.WriteLine("ConteudoMedio;ConteudoMaximo;Utilização;Operacao;Aguardando;Bloqueado;ParadaNaoPlanejada;CustosdeOperacao;CustoRecurso;Total");
                for (int contadorLocais = 0; contadorLocais < locaisModelo; contadorLocais++)
                {
                    for (int i = 0; i < 10; i++)
                    {
                        relatorio.Write(InformLocais[i, contadorLocais] + ";");
                    }
                    relatorio.WriteLine("");
                }

                relatorio.WriteLine("RELATORIO ENTIDADES");
                relatorio.WriteLine("TotalSaidas;TempoMedioSistema;TempoMedioEmMovimentacao;TempoMedioEmBloqueado;EmLogicaMovimento;Aguardando;EmBloqueado;SaidasExplicitas;CustoTotal");
                for (int contadorEntidades = 0; contadorEntidades < entidadesModelo; contadorEntidades++)
                {
                    for (int i = 0; i < 9; i++)
                    {
                        relatorio.Write(InformEntidades[i, contadorEntidades] + ";");
                    }
                    relatorio.WriteLine("");
                }
            }
            #endregion
            Manager.PassoAtual("Criado relatorio parcial.");

            #region RelatorioTotal
            using (StreamWriter relatorio = new StreamWriter(Path.GetFileNameWithoutExtension(modelo.modeloPai) + ".csr", true))
            {
                relatorio.Write(modelo.modelo + ";");
                relatorio.Write(locaisModelo + ";" + entidadesModelo + ";");

                for (int i = 0; i < 10; i++)
                {
                    double media = 0;
                    for (int contadorLocais = 0; contadorLocais < locaisModelo; contadorLocais++)
                    {
                        media += InformLocais[i, contadorLocais];
                    }

                    relatorio.Write(media + ";");
                }

                for (int i = 0; i < 9; i++)
                {
                    double media = 0;
                    for (int contadorEntidades = 0; contadorEntidades < entidadesModelo; contadorEntidades++)
                    {
                        media += InformEntidades[i, contadorEntidades];
                    }

                    if (i == 7)
                    {
                        modeloLocal[0] = media;
                    }
                    if (i == 0)
                    {
                        modeloLocal[1] = media;
                    }
                    if (i == 1)
                    {
                        modeloLocal[2] = media;
                    }

                    relatorio.Write(media + ";");
                }

                relatorio.WriteLine("");
            }
            #endregion
            Manager.PassoAtual("Criado relatorio.");
            return(modeloLocal);
        }
 public static double[] SimularExportarCalcularResultados(Modelo modeloAtual)
 {
     Simular(modeloAtual);
     return(Relatorios.ExportarResultados(modeloAtual));
 }
        public static void CriarDescendente(bool primeiraGeracao)
        {
            try
            {
                for (int contadorDescendentes = 1; contadorDescendentes <= numeroFilhos; contadorDescendentes++)
                {
                    double[] resposta = null;
                    Modelo   modelo   = new Modelo();

                    pmObject.SetWindowPos(1, 10, 10, 700, 500, 0);
                    pmObject.SetWindowPos(2, 10, 10, 700, 500, 0);
                    System.Threading.Thread.Sleep(100);

                    PassoAtual("Carregando modelo pai.");
                    pmObject.LoadModel(bancoModelos[0].modelo);
                    System.Threading.Thread.Sleep(100);
                    pmDataObject.Populate();
                    PassoAtual("Modificando modelo.");
                    System.Threading.Thread.Sleep(100);
                    if (!ModificaDescendente(contadorDescendentes))
                    {
                        continue;
                    }

                    modelo.modeloPai = bancoModelos[0].modelo;
                    modelo.modelo    = Path.GetDirectoryName(bancoModelos[0].modelo) + "\\" + Path.GetFileNameWithoutExtension(bancoModelos[0].modelo) + "filho" + contadorDescendentes + ".mod";
                    pmObject.SaveAs(modelo.modelo);

                    System.Threading.Thread.Sleep(100);
                    pmObject.LoadModel(modelo.modelo);
                    System.Threading.Thread.Sleep(100);

                    string arquivo = pmObject.GetOutputPath();
                    modelo.banco = arquivo.Substring(0, arquivo.Length - 3) + "rdb";
                    PassoAtual("Salvando modelo filho " + modelo.modelo + ".");

                    resposta = SimularExportarCalcularResultados(modelo);

                    if (!File.Exists(modelo.modelo))
                    {
                        PassoAtual("Erro no ProModel, tentando corrigir.");
                        ErroFatal();
                    }

                    if (resposta == null)
                    {
                        PassoAtual("Erro no ProModel, tentando corrigir.");
                        System.Threading.Thread.Sleep(2000);
                        //ErroFatal();
                        RDBObj.CloseFile();
                        contadorDescendentes--;
                        continue;
                    }

                    modelo.scoreSaidas = resposta[0];
                    modelo.scoreTotal  = resposta[1];
                    modelo.scoreTempo  = resposta[2];

                    bancoModelos.Add(modelo);
                    System.Threading.Thread.Sleep(100);
                    pmObject.Save();
                    System.Threading.Thread.Sleep(100);
                    RDBObj.CloseFile();
                    System.Threading.Thread.Sleep(100);

                    iVisual.Progresso(contadorDescendentes * 100 / numeroFilhos);
                }
                if (primeiraGeracao)
                {
                    SegundaGeracao();
                }
            }
            catch (Exception ex)
            { Service.Error.GerarLog(ex); }
        }
 public static void Resultado(Modelo modelo)
 {
     Relatorios.resultados.Add(modelo);
 }