示例#1
0
        public void DQMOM_CSTR_Teste()
        {
            tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            Integral.Funcao funcaoInicial = FuncaoCSTREspecieAInicial;

            DQMoM.TermoFonteDQMoM termoFonteDqmoM = TermoFonteDqmoMCSTREspecieA;
            DQMoM dqmom = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicial,
                limiteMinimo, limiteMaximo,
                termoFonteDqmoM);

            var metodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;

            //dqmom.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            //dqmom.PassoMaximoDasslc = 1e-2;
            //dqmom.ToleranciaRelativaDasslc = 1e-8;
            //dqmom.ToleranciaAbsolutaDasslc = 1e-8;
            //dqmom.PassoInicialDasslc = 1e-2;

            var momentosAnaliticos = CalcularMomentosAnaliticosNumericosCSTREspecieA(metodoDeCoeficientes, numeroDePontos, numeroDePassosDeTempo, passoDeTempo);

            dqmom.MomentosIniciais = momentosAnaliticos[0];

            dqmom.MetodoDeCoeficientesInicial = metodoDeCoeficientes;
            dqmom.MetodoDeCoeficientes = metodoDeCoeficientes;

            var momentos = dqmom.CalcularMomentos();

            #region Cálculo dos pesos e abscissas "analíticos"

            pesosAnaliticosA = new List<double[]>();
            abscissasAnaliticasA = new List<double[]>();

            for (int i = 0; i < momentosAnaliticos.Count; i++)
            {
                double[] pesosAnaliticos;
                double[] abscissasAnaliticas;
                MomentosBase.CalcularPesosEAbscissas(metodoDeCoeficientes, momentosAnaliticos[i], out pesosAnaliticos, out abscissasAnaliticas);
                pesosAnaliticosA.Add(pesosAnaliticos);
                abscissasAnaliticasA.Add(abscissasAnaliticas);
            }

            #endregion Cálculo dos pesos e abscissas "analíticos"

            string caso = "CasoAlfa" + alfa + "a" + a + "b" + b;
            caso = caso.Replace('.', 'p');

            CriarScripParaMatlabMomentos(@"DQMoMCSTR\momentosEspecieA" + caso, "A", tempo, momentosAnaliticos, momentos, 10);
            CriarScripParaMatlabPesos(@"DQMoMCSTR\pesosEspecieA" + caso, "A", tempo, dqmom.Pesos, pesosAnaliticosA, 10);
            CriarScripParaMatlabAbscissas(@"DQMoMCSTR\abscissasEspecieA" + caso, "A", tempo, dqmom.Abscissas, abscissasAnaliticasA, 10);
        }
示例#2
0
        public void CalcularMcCoyPrimeiroCasoTeste()
        {
            double passoDeTempo = 0.01;
            int numeroDePassosDeTempo = 100;
            double t0 = 0.0;
            numeroDePontos = 10;
            deltaN = 2 * numeroDePontos - 1 - numeroDePontos;
            limiteMinimo = 125.0;
            limiteMaximo = 1200;

            Integral.Funcao funcaoInicial = FuncaoMcCoy;

            DQMoM.TermoFonteDQMoM termoFonteDqmoM = TermoFonteDqmoMMcCoyPrimeiroCaso;
            DQMoM dqmom = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicial, limiteMinimo,
                limiteMaximo,
                termoFonteDqmoM);

            dqmom.MetodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;
            dqmom.MetodoDeCoeficientesInicial = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;

            dqmom.MomentosIniciais = CalcularMomentosIniciaisMcCoy(numeroDePontos, funcaoInicial, MomentosBase.MetodoCoeficientesDosMomentos.Wheeler);

            //dqmom.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            dqmom.PassoInicialDasslc = passoDeTempo;
            //dqmom.ToleranciaRelativaDasslc = 1e-3;
            //dqmom.ToleranciaAbsolutaDasslc = 1e-2;
            List<double[]> momentos;

            momentos = dqmom.CalcularMomentos();

            #region Reconstrução usando Fourier

            double[] x = new double[44];
            x[0] = 125;
            for (int i = 1; i < x.Length; i++)
            {
                x[i] = x[i - 1] + 25;
            }

            var FCi = CalcularFCarbonosFourier(x, dqmom.Pesos[0], dqmom.Abscissas[0]);

            #endregion Reconstrução usando Fourier

            //Loop do cálculo da concentração a partir dos momentos

            double[] alfa = new double[numeroDePassosDeTempo];
            double[] beta = new double[numeroDePassosDeTempo];
            List<double[]> concentracao = new List<double[]>();

            //for (int t = 0; t < numeroDePassosDeTempo; t++)
            //{
            //    CalcularAlfaEBeta(momentos[t], out alfa[t], out beta[t]);
            //    concentracao.Add(CalcularConcentracao(alfa[t], beta[t]));
            //}

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            List<double[]> momentosAnaliticos = CalcularMomentosAnaliticosMcCoy(tempo, numeroDePontos, dqmom.MomentosIniciais);

            double[] alfaAnalitica = new double[numeroDePassosDeTempo];
            double[] betaAnalitica = new double[numeroDePassosDeTempo];
            List<double[]> concentracaoAnalitica = new List<double[]>();
            List<double[]> abscissasAnaliticas = new List<double[]>();
            List<double[]> pesosAnaliticos = new List<double[]>();

            List<double[]> xAnalitico = new List<double[]>();

            for (int t = 0; t < numeroDePassosDeTempo; t++)
            {
                CalcularAlfaEBeta(momentosAnaliticos[t], out alfaAnalitica[t], out betaAnalitica[t]);
                concentracaoAnalitica.Add(CalcularConcentracao(alfaAnalitica[t], betaAnalitica[t]));
                xAnalitico.Add(tempo);

                double[] pesosA;
                double[] abscissasA;
                MomentosBase.CalcularPesosEAbscissas(MomentosBase.MetodoCoeficientesDosMomentos.Wheeler, momentosAnaliticos[t], out pesosA, out abscissasA);

                abscissasAnaliticas.Add(abscissasA);
                pesosAnaliticos.Add(pesosA);

                concentracao.Add(CalcularFCarbonosFourier(x, dqmom.Pesos[t], dqmom.Abscissas[t]));
            }

            var listaX = new List<double[]>();
            var listaCAnalitica = new List<double[]>();
            var listaCNumerica = new List<double[]>();

            int fator = 30;

            for (int i = 0; i < tempo.Length; i += fator)
            {
                listaX.Add(x);
                listaCAnalitica.Add(concentracaoAnalitica[i]);
                listaCNumerica.Add(concentracao[i]);
            }

            CriarScripParaMatlabMomentos(@"DQMoMMcCoy\momentosMcCoyDQmom", tempo, momentos, fator);
            CriarScripParaMatlabMomentos(@"DQMoMMcCoy\comparacaoMomentosMcCoyDQmom", "A", tempo, momentosAnaliticos, momentos, fator);

            CriarScripParaMatlabMomentos(@"DQMoMMcCoy\comparacaoAbscissasMcCoyDQmom", "A", tempo, abscissasAnaliticas, dqmom.Abscissas, fator);
            CriarScripParaMatlabMomentos(@"DQMoMMcCoy\comparacaoPesosMcCoyDQmom", "A", tempo, pesosAnaliticos, dqmom.Pesos, fator);

            CriarScripParaMatlabConcentracao(@"DQMoMMcCoy\concentracaoMcCoyDQmom", tempo, concentracao);
            CriarScripParaMatlabConcentracao(@"DQMoMMcCoy\comparacaoConcentracaoMcCoyDQmom", "A", listaX, listaCAnalitica, listaX, listaCNumerica);

            CriarScripParaMatlabAlfaBeta(@"DQMoMMcCoy\alfaDQMOM", tempo, alfa);
            CriarScripParaMatlabAlfaBeta(@"DQMoMMcCoy\betaDQMOM", tempo, beta);
            CriarScripParaMatlabPesos(@"DQMoMMcCoy\pesos", "A", tempo, dqmom.Pesos, fator);
            CriarScripParaMatlabAbscissas(@"DQMoMMcCoy\abscissas", "A", tempo, dqmom.Abscissas, fator);
        }
示例#3
0
        public void CalcularMCCoyCasoPropostoNaQualificacaoTeste()
        {
            double passoDeTempo = 0.001;
            int numeroDePassosDeTempo = 3;
            double t0 = 0.0;
            const int numeroDeMomentos = 6;
            const double limiteMinimo = 125.0;
            double limiteMaximo = Double.MaxValue;

            Integral.Funcao funcaoInicial = FuncaoMcCoy;

            DQMoM.TermoFonteDQMoM termoFonteDqmoM = TermoFonteDqmoMMcCoyCasoProposto;
            DQMoM dqmom = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDeMomentos, funcaoInicial, limiteMinimo,
                limiteMaximo,
                termoFonteDqmoM);
            dqmom.MetodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;
            dqmom.MetodoDeCoeficientesInicial = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;
            dqmom.MomentosIniciais = CalcularMomentosIniciaisMcCoy(numeroDeMomentos, funcaoInicial, MomentosBase.MetodoCoeficientesDosMomentos.Wheeler);

            dqmom.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            //dqmom.PassoMaximoDasslc = 0.001;
            //dqmom.PassoInicialDasslc = 0.001;
            //dqmom.ToleranciaRelativaDasslc = 1e-10;
            //dqmom.ToleranciaAbsolutaDasslc = 1e-10;
            List<double[]> momentos = dqmom.CalcularMomentos();

            //Loop do cálculo da concentração a partir dos momentos

            double[] Mi = new double[(1200 - 125)];

            Mi[0] = 125;
            for (int i = 1; i < Mi.Length; i++)
            {
                Mi[i] = Mi[i - 1] + 1.0;
            }

            List<double[]> momentosNormalizados = new List<double[]>();

            double[] alfa = new double[numeroDePassosDeTempo];
            double[] beta = new double[numeroDePassosDeTempo];
            List<double[]> concentracao = new List<double[]>();

            for (int t = 0; t < numeroDePassosDeTempo; t++)
            {
                //CalcularAlfaEBeta(momentos[t], out alfa[t], out beta[t]);

                double[] m = new double[numeroDeMomentos];

                for (int j = 0; j < m.Length; j++)
                {
                    m[j] = momentos[t][j];// / momentos[t][1];
                }

                //double[] pesosf;
                //double[] abscissasf;

                //MomentosBase.CalcularPesosEAbscissas(MomentosBase.MetodoCoeficientesDosMomentos.Wheeler, m, out pesosf, out abscissasf);

                //var FMi = CalcularFMi(Mi, dqmom.Pesos[t], dqmom.Abscissas[t]);

                //concentracao.Add(CalcularConcentracao(alfa[t], beta[t]));

                momentosNormalizados.Add(m);

                //concentracao.Add(FMi);
            }

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            CriarScripParaMatlabMomentos(@"DQMoMMcCoy\momentosMcCoyDQmom", tempo, momentosNormalizados, 1);
            //CriarScripParaMatlabMomentos(@"DQMoMMcCoy\concentracaoMcCoyDQmom", Mi, concentracao[concentracao.Count - 1], 10);
            //CriarScripParaMatlabConcentracao(@"DQMoMMcCoy\concentracaoMcCoyDQmom", tempo, concentracao);
            //CriarScripParaMatlabAlfaBeta(@"DQMoMMcCoy\alfaDQMOM", tempo, alfa);
            //CriarScripParaMatlabAlfaBeta(@"DQMoMMcCoy\betaDQMOM", tempo, beta);
            CriarScripParaMatlabPesos(@"DQMoMMcCoy\pesos", "A", tempo, dqmom.Pesos, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMMcCoy\abscissas", "A", tempo, dqmom.Abscissas, 1);
        }
示例#4
0
        public void CalcularDQMOMTeseMukhtarTeste()
        {
            double passoDeTempo = 0.001;
            numeroDePassosDeTempo = 5;
            numeroDePontos = 3;
            double t0 = 0.0;
            const double limiteMinimo = 0.001;
            const double limiteMaximo = Double.MaxValue;

            Integral.Funcao funcaoInicial = FuncaoMukhtar;

            DQMoM.TermoFonteDQMoM termoFonteDqmoM = TermoFonteDqmoMMukhatar;
            DQMoM dqmom = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, 2 * numeroDePontos, funcaoInicial,
                limiteMinimo, limiteMaximo,
                termoFonteDqmoM);
            dqmom.MomentosIniciais = CalcularMomentosIniciaisMukkhatar();
            //dqmom.MomentosIniciaisMaisUm = CalcularMomentosIniciaisMukkhatar();
            //dqmom.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;

            List<double[]> momentos = dqmom.CalcularMomentos();
            List<double[]> momentosAnaliticos = CalcularMomentosAnaliticosMukhatar();

            CriarScripParaMatlabMomentosNormalizados(@"DQMoMMukhtar\momentosDqmomMukhatar", dqmom.Passos, momentos);
            CriarScripParaMatlabMomentos(@"DQMoMMukhtar\comparacaoMomentosDqmomMukhatar", "A", dqmom.Passos, momentosAnaliticos, momentos, 1);
        }
示例#5
0
        // [TestMethod]
        public void CalcularDQMOMReacaoHidrogenacaoEspecieBPrimeiraOrdemPDATeste()
        {
            Integral.Funcao funcaoInicialEspecieB = FuncaoReacaoHidrogenacaoEspecieBPrimeiraOrdem;

            var momentosAnaliticosB = CalcularMomentosAnaliticosEspecieBHidrogenacao();

            DQMoM.TermoFonteDQMoM termoFonteDQMoMEspecieB = TermoFonteDqmoMEspecieBHidrogenacao;
            DQMoM dqmomEspecieB = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicialEspecieB,
                limiteMinimo, limiteMaximo, termoFonteDQMoMEspecieB);

            dqmomEspecieB.funcaoDeltaAbscissas = FuncaoDelta;
            //dqmomEspecieB.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            dqmomEspecieB.MomentosIniciais = ObterMomentosIniciaisEspecieBNaoNormalizadosHidrogenacao();

            Integral.Funcao funcaoInicialEspecieA = FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem;

            DQMoM.TermoFonteDQMoM termoFonteDQMoMEspecieA = TermoFonteDqmoMEspecieAHidrogenacao;
            DQMoM dqmomEspecieA = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicialEspecieA,
                limiteMinimo, limiteMaximo, termoFonteDQMoMEspecieA);
            dqmomEspecieA.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            dqmomEspecieA.MomentosIniciais = ObterMomentosIniciaisEspecieANaoNormalizadosHidrogenacao(numeroDePontos);

            var momentosAnaliticosA = CalcularMomentosAnaliticosEspecieAHidrogenacao();

            List<double[]> momentosEspecieA = dqmomEspecieA.CalcularMomentos();

            dqmomEspecieB.DecorarAbscissas = delegate(double[] abscissas, double t)
            {
                double[] abscissasDecoradas = new double[abscissas.Length];

                //for (int i = 0; i < abscissasDecoradas.Length; i++)
                //{
                //    abscissasDecoradas[i] = dqmomEspecieA.Abscissas[indiceTempo][i];
                //}
                throw new NotImplementedException("Não implementada a correção");

                return abscissasDecoradas;
            };

            dqmomEspecieB.DecorarPesos = delegate(double[] pesos, double t)
            {
                double[] pesosDecorados = new double[pesos.Length];

                //for (int i = 0; i < pesosDecorados.Length; i++)
                //{
                //    pesosDecorados[i] = dqmomEspecieA.Pesos[indiceTempo][i];
                //}
                throw new NotImplementedException("Não implementada a correção");

                return pesosDecorados;
            };

            List<double[]> momentosEspecieB = dqmomEspecieB.CalcularMomentos();

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            string caso = "CasoAlfa" + alfa + "a" + a + "b" + b;
            caso = caso.Replace('.', 'p');
            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\momentosEspecieB" + caso, "B", tempo, momentosAnaliticosB, momentosEspecieB, 1);
            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\momentosEspecieA" + caso, "A", tempo, momentosAnaliticosA, momentosEspecieA, 1);
            CriarScripParaMatlabPesos(@"DQMoMHidrogenacao\pesosEspecieB" + caso, "B", tempo, dqmomEspecieB.Pesos, 1);
            CriarScripParaMatlabPesos(@"DQMoMHidrogenacao\pesosEspecieA" + caso, "A", tempo, dqmomEspecieA.Pesos, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrogenacao\abscissasEspecieB" + caso, "B", tempo, dqmomEspecieB.Abscissas, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrogenacao\abscissasEspecieA" + caso, "A", tempo, dqmomEspecieA.Abscissas, 1);
        }
示例#6
0
        public void CalcularDQMOMReacaoHidrogenacaoEspecieBPrimeiraOrdemPDANormalizadoTeste()
        {
            #region Espécie A

            #region Definições

            Integral.Funcao funcaoInicialA = FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem;
            DQMoM.TermoFonteDQMoM termoFonteDqmoMA = TermoFonteDqmoMEspecieAHidrogenacao;
            DQMoM dqmomA = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicialA,
                limiteMinimo, limiteMaximo,
                termoFonteDqmoMA);

            dqmomA.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            dqmomA.ToleranciaRelativaDasslc = 1.0;
            dqmomA.ToleranciaAbsolutaDasslc = 0.0;
            dqmomA.PassoMaximoDasslc = 1e-3;
            dqmomA.PassoInicialDasslc = 1e-4;

            #endregion Definições

            #region Normalizações

            double[] momentosIniciaisANaoNormalizados = ObterMomentosIniciaisEspecieANaoNormalizadosHidrogenacao(numeroDePontos);

            double[] momentosIniciaisANormalizados = ObterMomentosIniciaisEspecieANormalizadosHidrogenacao(momentosIniciaisANaoNormalizados);

            dqmomA.MomentosIniciais = new double[numeroDePontos];

            for (int i = 0; i < momentosIniciaisANormalizados.Length; i++)
            {
                dqmomA.MomentosIniciais[i] = momentosIniciaisANormalizados[i];
            }
            #endregion Normalizações

            //Cálculo numérico
            List<double[]> momentosNormalizadosA = dqmomA.CalcularMomentos();

            //Cálculo analítico
            var momentosAnaliticosA = CalcularMomentosAnaliticosEspecieAHidrogenacao();

            var momentosAnaliticosNormalizadosA = ObterMomentosComNormalizacao(momentosAnaliticosA,
                momentosIniciaisANaoNormalizados);

            #endregion Espécie A

            #region Espécie B

            #region Definições

            Integral.Funcao funcaoInicialB = FuncaoReacaoHidrogenacaoEspecieBPrimeiraOrdem;
            DQMoM.TermoFonteDQMoM termoFonteDqmoMB = TermoFonteDqmoMEspecieBHidrogenacao;
            DQMoM dqmomB = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicialB,
                limiteMinimo, limiteMaximo, termoFonteDqmoMB);

            dqmomB.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            dqmomB.ToleranciaRelativaDasslc = 1.0;
            dqmomB.ToleranciaAbsolutaDasslc = 0.0;
            dqmomB.PassoMaximoDasslc = 1e-3;
            dqmomB.PassoInicialDasslc = 1e-4;

            #endregion Definições

            #region Definições especiais para a espécie B, que depende do A

            dqmomB.funcaoDeltaAbscissas = FuncaoDelta;

            dqmomB.DecorarAbscissas = delegate(double[] abscissas, double t)
            {
                double[] abscissasDecoradas = new double[abscissas.Length];

                for (int i = 0; i < abscissasDecoradas.Length; i++)
                {
                    abscissasDecoradas[i] = dqmomA.Abscissas[Convert.ToInt32(t)][i];
                }
                //throw new NotImplementedException("Não implementada a correção");

                return abscissasDecoradas;
            };

            dqmomB.DecorarPesos = delegate(double[] pesos, double t)
            {
                double[] pesosDecorados = new double[pesos.Length];

                for (int i = 0; i < pesosDecorados.Length; i++)
                {
                    pesosDecorados[i] = dqmomA.Pesos[Convert.ToInt32(t)][i];
                }

                // throw new NotImplementedException("Não implementada a correção");

                return pesosDecorados;
            };
            #endregion Definições especiais para a espécie B, que depende do A

            #region Normalizações

            double[] momentosIniciaisBNormalizados = ObterMomentosIniciaisEspecieBNormalizadosHidrogenacao(momentosIniciaisANaoNormalizados);

            dqmomB.MomentosIniciais = new double[numeroDePontos];

            for (int i = 0; i < momentosIniciaisBNormalizados.Length; i++)
            {
                dqmomB.MomentosIniciais[i] = momentosIniciaisBNormalizados[i];
            }
            #endregion Normalizações

            //Cálculo numérico
            List<double[]> momentosNormalizadosB = dqmomB.CalcularMomentos();

            //Cálculo analítico
            var momentosAnaliticosB = CalcularMomentosAnaliticosEspecieBHidrogenacao();

            var momentosAnaliticosNormalizadosB = ObterMomentosComNormalizacao(momentosAnaliticosB,
                momentosIniciaisANaoNormalizados);

            #endregion Espécie B

            #region Impressão dos resultados

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            string caso = "CasoAlfa" + alfa + "a" + a + "b" + b;
            caso = caso.Replace('.', 'p');

            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\momentosNormalizadosEspecieA" + caso, "A", tempo, momentosAnaliticosNormalizadosA, momentosNormalizadosA, 1);
            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\momentosNormalizadosEspecieB" + caso, "B", tempo, momentosAnaliticosNormalizadosB, momentosNormalizadosB, 1);

            #endregion Impressão dos resultados
        }
示例#7
0
        //[TestMethod]
        public void CalcularDQMOMReacaoHidrogenacaoEspecieBPrimeiraOrdemChebyshevTeste()
        {
            #region Especie A

            #region Definições

            Integral.Funcao funcaoInicialEspecieA = FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem;
            DQMoM.TermoFonteDQMoM termoFonteDQMoMEspecieA = TermoFonteDqmoMEspecieAHidrogenacao;
            DQMoM dqmomEspecieA = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicialEspecieA,
                limiteMinimo, limiteMaximo, termoFonteDQMoMEspecieA);

            dqmomEspecieA.MetodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.ChebyShev;

            double[] momentosIniciaisPadraoA = ObterMomentosIniciaisEspecieANaoNormalizadosHidrogenacao(numeroDePontos);

            ChebyshevModificado chebyshevModificadoA = new ChebyshevModificado(numeroDePontos / 2, momentosIniciaisPadraoA, ChebyshevModificado.TipoDeDominio.SemiInfinito);

            dqmomEspecieA.MomentosIniciais = chebyshevModificadoA.MomentosModificados;

            #endregion Definições

            //Cálculo numérico
            List<double[]> momentosEspecieA = dqmomEspecieA.CalcularMomentos();

            //Cálculo analítico
            var momentosAnaliticosA = CalcularMomentosAnaliticosEspecieAHidrogenacao();

            #endregion Especie A

            #region Espécie B

            #region Definições

            Integral.Funcao funcaoInicialEspecieB = FuncaoReacaoHidrogenacaoEspecieBPrimeiraOrdem;
            DQMoM.TermoFonteDQMoM termoFonteDQMoMEspecieB = TermoFonteDqmoMEspecieBHidrogenacao;
            DQMoM dqmomEspecieB = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicialEspecieB,
                limiteMinimo, limiteMaximo, termoFonteDQMoMEspecieB);

            dqmomEspecieB.MetodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.ChebyShev;

            double[] momentosIniciaisPadraoB = ObterMomentosIniciaisEspecieBNaoNormalizadosHidrogenacao();

            ChebyshevModificado chebyshevModificadoB = new ChebyshevModificado(numeroDePontos / 2, momentosIniciaisPadraoB, ChebyshevModificado.TipoDeDominio.SemiInfinito);

            dqmomEspecieB.MomentosIniciais = chebyshevModificadoB.MomentosModificados;

            #endregion Definições

            #region Definições especiais para a espécie B, que depende do A

            dqmomEspecieB.funcaoDeltaAbscissas = FuncaoDelta;

            dqmomEspecieB.DecorarAbscissas = delegate(double[] abscissas, double t)
            {
                double[] abscissasDecoradas = new double[abscissas.Length];

                //for (int i = 0; i < abscissasDecoradas.Length; i++)
                //{
                //    abscissasDecoradas[i] = dqmomEspecieA.Abscissas[indiceTempo][i];
                //}
                throw new NotImplementedException("Não implementada a correção");

                return abscissasDecoradas;
            };

            dqmomEspecieB.DecorarPesos = delegate(double[] pesos, double t)
            {
                double[] pesosDecorados = new double[pesos.Length];

                //for (int i = 0; i < pesosDecorados.Length; i++)
                //{
                //    pesosDecorados[i] = dqmomEspecieA.Pesos[indiceTempo][i];
                //}
                throw new NotImplementedException("Não implementada a correção");

                return pesosDecorados;
            };

            #endregion Definições especiais para a espécie B, que depende do A

            //Cálculo numérico
            List<double[]> momentosEspecieB = dqmomEspecieB.CalcularMomentos();

            //Cálculo analítico
            var momentosAnaliticosB = CalcularMomentosAnaliticosEspecieBHidrogenacao();

            #endregion Espécie B

            #region Impressão dos Resultados

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            string caso = "CasoAlfa" + alfa + "a" + a + "b" + b;
            caso = caso.Replace('.', 'p');
            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\momentosEspecieBCheb" + caso, "B", tempo, momentosAnaliticosB, momentosEspecieB, 1);
            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\momentosEspecieACheb" + caso, "A", tempo, momentosAnaliticosA, momentosEspecieA, 1);
            CriarScripParaMatlabPesos(@"DQMoMHidrogenacao\pesosEspecieBCheb" + caso, "B", tempo, dqmomEspecieB.Pesos, 1);
            CriarScripParaMatlabPesos(@"DQMoMHidrogenacao\pesosEspecieACheb" + caso, "A", tempo, dqmomEspecieA.Pesos, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrogenacao\abscissasEspecieBCheb" + caso, "B", tempo, dqmomEspecieB.Abscissas, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrogenacao\abscissasEspecieACheb" + caso, "A", tempo, dqmomEspecieA.Abscissas, 1);

            #endregion Impressão dos Resultados
        }
示例#8
0
        public void CalcularDQMOMReacaoHidrogenacaoEspecieAPrimeiraOrdemPDANormalizadoTeste()
        {
            Integral.Funcao funcaoInicial = FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem;

            DQMoM.TermoFonteDQMoM termoFonteDqmoM = TermoFonteDqmoMEspecieAHidrogenacao;
            DQMoM dqmom = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicial,
                limiteMinimo, limiteMaximo,
                termoFonteDqmoM);
            dqmom.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            dqmom.ToleranciaRelativaDasslc = 1e-10;
            dqmom.ToleranciaAbsolutaDasslc = 1e-12;
            dqmom.PassoInicialDasslc = 1e-4;
            dqmom.PassoMaximoDasslc = 1e-4;

            double[] momentosIniciaisNaoNormalizados = ObterMomentosIniciaisEspecieANaoNormalizadosHidrogenacao(numeroDePontos);

            double[] momentosIniciaisNormalizados = ObterMomentosIniciaisEspecieANormalizadosHidrogenacao(momentosIniciaisNaoNormalizados);

            dqmom.MomentosIniciais = new double[numeroDePontos];

            for (int i = 0; i < momentosIniciaisNormalizados.Length; i++)
            {
                dqmom.MomentosIniciais[i] = momentosIniciaisNormalizados[i];
            }

            List<double[]> momentos = dqmom.CalcularMomentos();

            var momentosAnaliticos = CalcularMomentosAnaliticosEspecieAHidrogenacao();

            var momentosAnaliticosNormalizados = ObterMomentosComNormalizacao(momentosAnaliticos,
                momentosIniciaisNaoNormalizados);

            List<double[]> listaPesosAnaliticos = new List<double[]>(momentosAnaliticosNormalizados.Count);
            List<double[]> listaAbscissasAnaliticas = new List<double[]>(momentosAnaliticosNormalizados.Count);

            for (int i = 0; i < momentosAnaliticosNormalizados.Count; i++)
            {
                double[] pesosAnaliticos;
                double[] abscissasAnaliticas;
                MomentosBase.CalcularPesosEAbscissas(MomentosBase.MetodoCoeficientesDosMomentos.PDA, momentosAnaliticosNormalizados[i], out pesosAnaliticos, out abscissasAnaliticas);
                listaPesosAnaliticos.Add(pesosAnaliticos);
                listaAbscissasAnaliticas.Add(abscissasAnaliticas);
            }

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            string caso = "CasoAlfa" + alfa + "a" + a + "b" + b;
            caso = caso.Replace('.', 'p');

            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\momentosNormalizadosEspecieA" + caso, "A", tempo, momentosAnaliticosNormalizados, momentos, 1);
            CriarScripParaMatlabPesos(@"DQMoMHidrogenacao\pesosEspecieA" + caso, "A", tempo, dqmom.Pesos, listaPesosAnaliticos, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrogenacao\abscissasEspecieA" + caso, "A", tempo, dqmom.Abscissas, listaAbscissasAnaliticas, 1);
        }
示例#9
0
        //[TestMethod]
        public void CalcularDQMOMReacaoHidrogenacaoEspecieAPrimeiraOrdemChebyshevTeste()
        {
            Integral.Funcao funcaoInicial = FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem;

            DQMoM.TermoFonteDQMoM termoFonteDqmoM = TermoFonteDqmoMEspecieAHidrogenacao;
            DQMoM dqmom = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicial,
                limiteMinimo, limiteMaximo,
                termoFonteDqmoM);

            double[] momentosIniciaisPadrao = ObterMomentosIniciaisEspecieANaoNormalizadosHidrogenacao(numeroDePontos);
            dqmom.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            ChebyshevModificado chebyshevModificado = new ChebyshevModificado(numeroDePontos / 2, momentosIniciaisPadrao, ChebyshevModificado.TipoDeDominio.SemiInfinito);

            dqmom.MomentosIniciais = chebyshevModificado.MomentosModificados;

            dqmom.MetodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.ChebyShev;

            var momentosAnaliticos = CalcularMomentosAnaliticosEspecieAHidrogenacao();

            List<double[]> momentos = dqmom.CalcularMomentos();

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            string caso = "CasoAlfa" + alfa + "a" + a + "b" + b;
            caso = caso.Replace('.', 'p');

            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\momentosEspecieA" + caso, "A", tempo, momentosAnaliticos, momentos, 10);
            CriarScripParaMatlabPesos(@"DQMoMHidrogenacao\pesosEspecieA" + caso, "A", tempo, dqmom.Pesos, 10);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrogenacao\abscissasEspecieA" + caso, "A", tempo, dqmom.Abscissas, 10);
        }
示例#10
0
        public void Hidrogenacao_ComMomentoZeroAnalitico()
        {
            Integral.Funcao funcaoInicial = FuncaoInicialDoMomentoZeroAnalitico;

            DQMoM.TermoFonteDQMoM termoFonteDqmoM = TermoFonteHidrogenacao_ComMomentoZeroAnalitico;
            DQMoM dqmom = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicial,
                limiteMinimo, limiteMaximo,
                termoFonteDqmoM);

            dqmom.MomentosIniciais = ObterMomentosIniciaisHidrogenacao_ComMomentoZeroAnalitico(numeroDePontos);

            dqmom.MetodoDeCoeficientesInicial = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;
            dqmom.MetodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;

            List<double[]> momentos = dqmom.CalcularMomentos();

            var momentosAnaliticos = CalcularMomentosAnaliticosHidrogenacao_ComMomentoZeroAnalitico();

            List<double[]> listaPesosAnaliticos = new List<double[]>(momentosAnaliticos.Count);
            List<double[]> listaAbscissasAnaliticas = new List<double[]>(momentosAnaliticos.Count);

            for (int i = 0; i < momentosAnaliticos.Count; i++)
            {
                double[] pesosAnaliticos;
                double[] abscissasAnaliticas;
                MomentosBase.CalcularPesosEAbscissas(MomentosBase.MetodoCoeficientesDosMomentos.Wheeler, momentosAnaliticos[i], out pesosAnaliticos, out abscissasAnaliticas);
                listaPesosAnaliticos.Add(pesosAnaliticos);
                listaAbscissasAnaliticas.Add(abscissasAnaliticas);
            }

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            string caso = "CasoAlfa" + alfa + "a" + a + "b" + b;
            caso = caso.Replace('.', 'p');

            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacaoMomentoZeroAnalitico\momentosNormalizadosEspecieA" + caso, "A", tempo, momentosAnaliticos, momentos, 1);
            CriarScripParaMatlabPesos(@"DQMoMHidrogenacaoMomentoZeroAnalitico\pesosEspecieA" + caso, "A", tempo, dqmom.Pesos, listaPesosAnaliticos, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrogenacaoMomentoZeroAnalitico\abscissasEspecieA" + caso, "A", tempo, dqmom.Abscissas, listaAbscissasAnaliticas, 1);
        }
示例#11
0
        public void CalcularFuncaoHidrogenacaoEspecieATeste()
        {
            Integral.Funcao funcaoInicial = FuncaoGammaA;
            var metodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;

            DQMoM.TermoFonteDQMoM termoFonteDqmoM = TermoFonteEspecieA;
            DQMoM dqmom = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, 2 * m, funcaoInicial,
                0, 1000,
                termoFonteDqmoM);

            dqmom.MomentosIniciais = CalcularMomentosIniciais(FuncaoGammaA, metodoDeCoeficientes);
            dqmom.MetodoDeCoeficientesInicial = metodoDeCoeficientes;
            dqmom.MetodoDeCoeficientes = metodoDeCoeficientes;

            dqmom.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            //dqmom.PassoMaximoDasslc = passoDeTempo;
            //dqmom.ToleranciaRelativaDasslc = 1e-8;
            //dqmom.ToleranciaAbsolutaDasslc = 1e-10;
            //dqmom.PassoInicialDasslc = passoDeTempo;

            List<double[]> momentos;

            Stopwatch stopwatch = new Stopwatch();

            stopwatch.Start();

            momentos = dqmom.CalcularMomentos();

            Trace.WriteLine(stopwatch.ElapsedMilliseconds);

            //stopwatch.Restart();

            //momentos = dqmom.CalcularMomentos();

            //Trace.WriteLine(stopwatch.ElapsedMilliseconds);

            //stopwatch.Restart();

            //momentos = dqmom.CalcularMomentos();

            //Trace.WriteLine(stopwatch.ElapsedMilliseconds);

            //stopwatch.Stop();

            double[] Mi = new double[Mmax - Mmin + 1];

            Mi[0] = Mmin;
            for (int i = 1; i < Mi.Length; i++)
            {
                Mi[i] = Mi[i - 1] + 1;
            }

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 1; i < numeroDePassosDeTempo; i++)
            {
                tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            var funcaoAnalitica = CalcularFuncaoAnaliticaA(Mi, tempo);

            var listaFMi = new List<double[]>();

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                var funcao = CalcularFMi(Mi, dqmom.Pesos[i], dqmom.Abscissas[i]);

                listaFMi.Add(funcao);
            }

            string caso = "CasoBeta" + beta + "N" + m + "deltaN" + deltaN;
            caso = caso.Replace('.', 'p');

            var listaDeTetai = new List<double[]>();
            var listaDeFuncoes = new List<double[]>();

            var listaDeTetaiAnaliticas = new List<double[]>();
            var listaDeFuncoesAnaliticas = new List<double[]>();

            var listaDeMomentosAnaliticos = new List<double[]>();
            var listaDePesosAnaliticos = new List<double[]>();
            var listaDeAbscissasAnaliticas = new List<double[]>();

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                var i1 = i;

                Integral.Funcao funcao = delegate(double x)
                {
                    double valor = FuncaoAnalitica(x, tempo[i1]);

                    return valor;
                };

                var momentosAnaliticos = CalcularMomentosIniciais(funcao, metodoDeCoeficientes);

                double[] pesosf;
                double[] abscissasf;

                MomentosBase.CalcularPesosEAbscissas(metodoDeCoeficientes, momentosAnaliticos, out pesosf, out abscissasf);

                listaDeMomentosAnaliticos.Add(momentosAnaliticos);
                listaDeAbscissasAnaliticas.Add(abscissasf);
                listaDePesosAnaliticos.Add(pesosf);
            }

            listaDeTetai.Add(Mi);
            listaDeTetai.Add(Mi);

            listaDeFuncoes.Add(listaFMi[0]);
            listaDeFuncoes.Add(listaFMi[listaFMi.Count - 1]);

            listaDeTetaiAnaliticas.Add(Mi);
            listaDeTetaiAnaliticas.Add(Mi);
            listaDeFuncoesAnaliticas.Add(funcaoAnalitica[0]);
            listaDeFuncoesAnaliticas.Add(funcaoAnalitica[funcaoAnalitica.Count - 1]);

            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\funcaoA" + caso, "A", listaDeTetaiAnaliticas, listaDeFuncoesAnaliticas, listaDeTetai, listaDeFuncoes);
               // CriarScripParaMatlabPesos(@"DQMoMHidrogenacao\pesosA" + caso, tempo, dqmom.Pesos, 1);
            CriarScripParaMatlabPesos(@"DQMoMHidrogenacao\comparacaoPesosA" + caso,"A", tempo,listaDePesosAnaliticos, dqmom.Pesos, 1);
            CriarScripParaGnuplot(@"DQMoMHidrogenacao\gnuplotPesosA" + caso, tempo, listaDePesosAnaliticos, dqmom.Pesos);
            CriarScripParaGnuplot(@"DQMoMHidrogenacao\gnuplotAbscissasA" + caso, tempo, listaDeAbscissasAnaliticas, dqmom.Abscissas);
            CriarScripParaGnuplot(@"DQMoMHidrogenacao\gnuplotMomentosA" + caso, tempo, listaDeMomentosAnaliticos, momentos);
            CriarScripParaGnuplotFuncao(@"DQMoMHidrogenacao\gnuplotfuncaoA" + caso, Mi, listaDeFuncoesAnaliticas, listaDeFuncoes);

            CriarScriptExecucaoGnuplot(@"gnuplotbase", @"gnuplotPesosA" + caso, dqmom.Pesos,
                "{/Symbol w}");

            CriarScriptExecucaoGnuplot(@"gnuplotbase", @"gnuplotAbscissasA" + caso, dqmom.Pesos,
                "I");

            CriarScriptExecucaoGnuplot(@"gnuplotbase", @"gnuplotMomentosA" + caso, dqmom.Pesos,
                "{/Symbol m}");

            //CriarScripParaMatlabAbscissas(@"DQMoMHidrogenacao\abscissasA" + caso, tempo, dqmom.Abscissas, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrogenacao\comparacaoAbscissasA" + caso,"A", tempo,listaDeAbscissasAnaliticas, dqmom.Abscissas, 1);
            //CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\momentosA" + caso, tempo, momentos, 1);
            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\comparacaoMomentosA" + caso,"A", tempo,listaDeMomentosAnaliticos, momentos, 1);
        }
示例#12
0
        public void CalcularFuncaoHidrogenacaoEspecieBTeste()
        {
            Integral.Funcao funcaoInicial = FuncaoGammaA;
            var metodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.Wheeler;

            DQMoM.TermoFonteDQMoM termoFonteDqmoMA = TermoFonteEspecieA;
            DQMoM dqmomA = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, 2 * m, funcaoInicial,
                0, 1000,
                termoFonteDqmoMA);

            dqmomA.MomentosIniciais = CalcularMomentosIniciais(FuncaoGammaA, metodoDeCoeficientes);

            dqmomA.MetodoDeCoeficientesInicial = metodoDeCoeficientes;
            dqmomA.MetodoDeCoeficientes = metodoDeCoeficientes;

            dqmomA.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            //dqmom.PassoMaximoDasslc = passoDeTempo;
            //dqmomA.ToleranciaRelativaDasslc = 1e-12;
            //dqmomA.ToleranciaAbsolutaDasslc = 1e-14;
            //dqmom.PassoInicialDasslc = passoDeTempo;

            var momentosA = dqmomA.CalcularMomentos();

            pesosA = dqmomA.Pesos;

            DQMoM.TermoFonteDQMoM termoFonteDqmoMB = TermoFonteEspecieB;
            DQMoM dqmomB = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, 2 * m, funcaoInicial,
                0, 1000,
                termoFonteDqmoMB);

            dqmomB.MomentosIniciais = CalcularMomentosIniciais(FuncaoGammaA, metodoDeCoeficientes);

            dqmomB.MetodoDeCoeficientesInicial = metodoDeCoeficientes;
            dqmomB.MetodoDeCoeficientes = metodoDeCoeficientes;

            dqmomB.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            //dqmom.PassoMaximoDasslc = passoDeTempo;
            //dqmomB.ToleranciaRelativaDasslc = 1e-12;
            //dqmomB.ToleranciaAbsolutaDasslc = 1e-14;
            //dqmom.PassoInicialDasslc = passoDeTempo;

               var momentosB = dqmomB.CalcularMomentos();

            double[] Mi = new double[Mmax - Mmin + 1];

            Mi[0] = Mmin+2;
            for (int i = 1; i < Mi.Length; i++)
            {
                Mi[i] = Mi[i - 1] + 1;
            }

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            var funcaoAnalitica = CalcularFuncaoAnaliticaB(Mi, tempo);

            var listaFMi = new List<double[]>();

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                var funcao = CalcularFMi(Mi, dqmomB.Pesos[i], dqmomB.Abscissas[i]);

                listaFMi.Add(funcao);
            }

            string caso = "CasoAlfa" + alfa + "a" + a + "b" + b;
            caso = caso.Replace('.', 'p');

            var listaDeTetai = new List<double[]>();
            var listaDeFuncoes = new List<double[]>();

            var listaDeTetaiAnaliticas = new List<double[]>();
            var listaDeFuncoesAnaliticas = new List<double[]>();

            listaDeTetai.Add(Mi);
            listaDeTetai.Add(Mi);

            listaDeFuncoes.Add(listaFMi[0]);
            listaDeFuncoes.Add(listaFMi[listaFMi.Count-1]);

            listaDeTetaiAnaliticas.Add(Mi);
            listaDeTetaiAnaliticas.Add(Mi);
            listaDeFuncoesAnaliticas.Add(funcaoAnalitica[0]);
            listaDeFuncoesAnaliticas.Add(funcaoAnalitica[funcaoAnalitica.Count-1]);

            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\funcaoB" + caso, "A", listaDeTetaiAnaliticas, listaDeFuncoesAnaliticas, listaDeTetai, listaDeFuncoes);
            CriarScripParaMatlabPesos(@"DQMoMHidrogenacao\pesosB" + caso, tempo, dqmomB.Pesos, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrogenacao\abscissasB" + caso, tempo, dqmomB.Abscissas, 1);
            CriarScripParaMatlabMomentos(@"DQMoMHidrogenacao\momentosB" + caso, tempo, momentosB, 1);
        }
示例#13
0
        private void CalcularEspecieB()
        {
            #region Definições

            Integral.Funcao funcaoInicialB = FuncaoReacaoHidrogenacaoEspecieBPrimeiraOrdem;

            switch (Metodo)
            {
                case MomentosBase.TipoDeMetodo.QMOM:
                    QMoM.TermoFonteQMoM termoFonteQmoMB = TermoFonteQMOMEspecieBHidrogenacao;
                    momB = new QMoM(NumeroDePassosDeTempo, PassoDeTempo, t0, NumeroDePontos, funcaoInicialB,
                        limiteMinimo, limiteMaximo, termoFonteQmoMB);
                    break;
                case MomentosBase.TipoDeMetodo.DQMOM:
                    DQMoM.TermoFonteDQMoM termoFonteDqmoMB = TermoFonteDqmoMEspecieBHidrogenacao;
                    momB = new DQMoM(NumeroDePassosDeTempo, PassoDeTempo, t0, NumeroDePontos, funcaoInicialB,
                        limiteMinimo, limiteMaximo, termoFonteDqmoMB);
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }

            momB.MetodoDeIntegracaoTemporal = TipoDeMetodoDeIntegracaoTemporal;
            momB.ToleranciaRelativaDasslc = ToleranciaRelativaDasslc;
            momB.ToleranciaAbsolutaDasslc = ToleranciaAbsolutaDasslc;
            momB.PassoMaximoDasslc = PassoMaximoDasslc;
            momB.PassoInicialDasslc = PassoInicialDasslc;

            #endregion Definições

            #region Definições especiais para a espécie B, que depende do A

            momB.funcaoDeltaAbscissas = FuncaoDelta;

            momB.DecorarAbscissas = delegate(double[] abscissas, double tempo)
            {
                double[] abscissasDecoradas = new double[abscissas.Length];

                throw new NotImplementedException("Não implementada a correção");

                //for (int i = 0; i < abscissasDecoradas.Length; i++)
                //{
                //    abscissasDecoradas[i] = momA.Abscissas[indiceTempo][i];
                //}

                return abscissasDecoradas;
            };

            momB.DecorarPesos = delegate(double[] pesos, double tempo)
            {
                double[] pesosDecorados = new double[pesos.Length];

                throw new NotImplementedException("Não implementada a correção");

                //for (int i = 0; i < pesosDecorados.Length; i++)
                //{
                //    if (Metodo == MomentosBase.TipoDeMetodo.QMOM)
                //        pesosDecorados[i] = momA.Pesos[indiceTempo][i] * Math.Pow(momA.Abscissas[indiceTempo][i], b);
                //    else
                //        pesosDecorados[i] = momA.Pesos[indiceTempo][i];
                //}

                return pesosDecorados;
            };

            #endregion Definições especiais para a espécie B, que depende do A

            #region Normalizações

            double[] momentosIniciaisBNormalizados = ObterMomentosIniciaisEspecieBNormalizadosHidrogenacao();

            momB.MomentosIniciais = new double[NumeroDePontos];

            for (int i = 0; i < momentosIniciaisBNormalizados.Length; i++)
            {
                momB.MomentosIniciais[i] = momentosIniciaisBNormalizados[i];
            }

            //ChebyshevModificado chebyshevModificadoB = new ChebyshevModificado(NumeroDePontos / 2, momentosIniciaisBNormalizados);

            //momB.MomentosIniciais = chebyshevModificadoB.ObterMomentosModificados(new Laguerre(NumeroDePontos));

            //momB.MetodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.ChebyShev;

            #endregion Normalizações

            //Cálculo analítico
            var momentosAnaliticosB = CalcularMomentosAnaliticosEspecieBHidrogenacao();

            MomentosAnaliticosB = ObterMomentosComNormalizacao(momentosAnaliticosB, momentosIniciaisANaoNormalizados);

            PesosAnaliticosB = new List<double[]>();
            AbscissasAnaliticasB = new List<double[]>();

            try
            {
                for (int i = 0; i < MomentosAnaliticosB.Count; i++)
                {
                    double[] pesos;
                    double[] abscissas;
                    ChebyshevModificado chebyshevModificado = new ChebyshevModificado(NumeroDePontos / 2, MomentosAnaliticosB[i], ChebyshevModificado.TipoDeDominio.SemiInfinito);

                    var momentosModificados = chebyshevModificado.MomentosModificados;

                    MomentosBase.CalcularPesosEAbscissas(MomentosBase.MetodoCoeficientesDosMomentos.ChebyShev, momentosModificados, out pesos, out abscissas);
                    PesosAnaliticosB.Add(pesos);
                    AbscissasAnaliticasB.Add(abscissas);
                }
            }
            catch
            {
            }

            //Cálculo numérico
            MomentosNumericosB = momB.CalcularMomentos();

            double[,] erro = new double[momB.Passos.Length, MomentosAnaliticosB[0].Length];
            ErroMedioB = new double[MomentosAnaliticosB[0].Length];

            for (int i = 0; i < MomentosAnaliticosB[0].Length; i++)
            {
                for (int j = 1; j < momB.Passos.Length; j++)
                {
                    if (MomentosAnaliticosB[j][i] != 0.0)
                        erro[j, i] = 100*Math.Abs((MomentosAnaliticosB[j][i] - MomentosNumericosB[j][i])/MomentosAnaliticosB[j][i]);

                    ErroMedioB[i] += erro[j, i];
                }

                ErroMedioB[i] = ErroMedioB[i]/momB.Passos.Length;
            }
        }
示例#14
0
        private void CalcularEspecieA()
        {
            #region Definições

            Integral.Funcao funcaoInicialA = FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem;

            switch (Metodo)
            {
                case MomentosBase.TipoDeMetodo.QMOM:
                    QMoM.TermoFonteQMoM termoFonteQmoMA = TermoFonteQMOMEspecieAHidrogenacao;
                    momA = new QMoM(NumeroDePassosDeTempo, PassoDeTempo, t0, NumeroDePontos, funcaoInicialA,
                        limiteMinimo, limiteMaximo, termoFonteQmoMA);
                    break;
                case MomentosBase.TipoDeMetodo.DQMOM:
                    DQMoM.TermoFonteDQMoM termoFonteDqmoMA = TermoFonteDqmoMEspecieAHidrogenacao;
                    momA = new DQMoM(NumeroDePassosDeTempo, PassoDeTempo, t0, NumeroDePontos, funcaoInicialA,
                        limiteMinimo, limiteMaximo, termoFonteDqmoMA);
                    break;
                default:
                    throw new ArgumentOutOfRangeException();
            }

            momA.MetodoDeIntegracaoTemporal = TipoDeMetodoDeIntegracaoTemporal;
            momA.ToleranciaRelativaDasslc = ToleranciaRelativaDasslc;
            momA.ToleranciaAbsolutaDasslc = ToleranciaAbsolutaDasslc;
            momA.PassoMaximoDasslc = PassoMaximoDasslc;
            momA.PassoInicialDasslc = PassoInicialDasslc;

            #endregion Definições

            #region Normalizações

            momentosIniciaisANaoNormalizados = ObterMomentosIniciaisEspecieANaoNormalizadosHidrogenacao();

            double[] momentosIniciaisANormalizados = ObterMomentosIniciaisEspecieANormalizadosHidrogenacao();

            //ChebyshevModificado chebyshevModificadoA = new ChebyshevModificado(NumeroDePontos/2, momentosIniciaisANormalizados);

            //momA.MomentosIniciais = chebyshevModificadoA.ObterMomentosModificados(new Laguerre(NumeroDePontos));

            //momA.MetodoDeCoeficientes = MomentosBase.MetodoCoeficientesDosMomentos.ChebyShev;
            momA.MomentosIniciais = momentosIniciaisANormalizados;

            #endregion Normalizações

            //Cálculo analítico
            var momentosAnaliticosA = CalcularMomentosAnaliticosEspecieAHidrogenacao();

            MomentosAnaliticosA = ObterMomentosComNormalizacao(momentosAnaliticosA, momentosIniciaisANaoNormalizados);

            PesosAnaliticosA = new List<double[]>();
            AbscissasAnaliticasA = new List<double[]>();

            try
            {
                for (int i = 0; i < MomentosAnaliticosA.Count; i++)
                {
                    double[] pesos;
                    double[] abscissas;

                    ChebyshevModificado chebyshevModificado = new ChebyshevModificado(NumeroDePontos/2, MomentosAnaliticosA[i],ChebyshevModificado.TipoDeDominio.SemiInfinito);

                    var momentosModificados = chebyshevModificado.MomentosModificados;

                    MomentosBase.CalcularPesosEAbscissas(MomentosBase.MetodoCoeficientesDosMomentos.ChebyShev, momentosModificados, out pesos, out abscissas);
                    PesosAnaliticosA.Add(pesos);
                    AbscissasAnaliticasA.Add(abscissas);
                }
            }
            catch
            {
            }

            //Cálculo numérico
            MomentosNumericosA = momA.CalcularMomentos();

            MomentosNumericosA[0] = momentosIniciaisANormalizados;

            double[,] erro = new double[momA.Passos.Length, MomentosAnaliticosA[0].Length];
            ErroMedioA = new double[MomentosAnaliticosA[0].Length];

            for (int i = 0; i < MomentosAnaliticosA[0].Length; i++)
            {
                for (int j = 1; j < momA.Passos.Length; j++)
                {
                    if (MomentosAnaliticosA[j][i] != 0.0)
                        erro[j, i] = 100*Math.Abs((MomentosAnaliticosA[j][i] - MomentosNumericosA[j][i])/MomentosAnaliticosA[j][i]);

                    ErroMedioA[i] += erro[j, i];
                }

                ErroMedioA[i] = ErroMedioA[i]/momA.Passos.Length;
            }
        }
示例#15
0
        public void TestarLaxminaraHidrocraqueamento()
        {
            string caso = "CasoN" + numeroDePontos + "delta" + deltaN;

            //int numeroDePassosDeTempo = Convert.ToInt32(2.0/passoDeTempo +1);
            int numeroDePassosDeTempo = 1000;
            double t0 = 0.0;

            DQMoM.TermoFonteDQMoM termoFonteDqmoM = TermoFonteHidrocraqueamento;
            DQMoM dqmom = new DQMoM(numeroDePassosDeTempo, passoDeTempo, t0, 2 * numeroDePontos, null, limiteInferiorDistribuicao,
                limiteSuperiorDistribuicao,
                termoFonteDqmoM);

            var momentosIniciais = CalcularMomentosIniciais();

            dqmom.MomentosIniciais = momentosIniciais;

            dqmom.MetodoDeCoeficientes = metodoDeCoeficientes;
            dqmom.MetodoDeCoeficientesInicial = metodoDeCoeficientes;

            dqmom.MetodoDeIntegracaoTemporal = MomentosBase.TipoDeMetodoDeIntegracaoTemporal.Dasslc;
            //dqmom.PassoMaximoDasslc = passoDeTempo;
            //dqmom.ToleranciaRelativaDasslc = 1e-12;
            //dqmom.ToleranciaAbsolutaDasslc = 1e-12;
            dqmom.PassoInicialDasslc = passoDeTempo;

            //writer = new StreamWriter(@"C:\Users\uqk2\Desktop\" + caso + ".txt");

            //try
            //{
            var momentos = dqmom.CalcularMomentos(escreverMensagem, writer);

            momentosfinais = momentos[momentos.Count - 1];
            // }
            //catch (Exception e)
            //{
            //    string mensagem = e.Message;

            //    if (e.InnerException != null) mensagem += "\n" + e.InnerException.Message;

            //    writer.WriteLine(mensagem);
            //    if (escreverMensagem != null)
            //        escreverMensagem(mensagem);
            //    writer.Close();

            //    return;
            //}
            //if (escreverMensagem != null)
            //    escreverMensagem("Cálculos finalizados com sucesso.");
            //writer.WriteLine("Cálculos finalizados com sucesso.");
            ////writer.Close();

            double[] numeroDeCarbonos = new double[(int)((Lmax - Lmin) * 50 + 1)];

            numeroDeCarbonos[0] = Lmin;
            for (int i = 1; i < numeroDeCarbonos.Length; i++)
            {
                numeroDeCarbonos[i] = numeroDeCarbonos[i - 1] + 1.0 / 50;
            }

            double[] tempo = new double[numeroDePassosDeTempo];

            tempo[0] = t0;

            for (int i = 0; i < numeroDePassosDeTempo; i++)
            {
                if (i > 0) tempo[i] = tempo[i - 1] + passoDeTempo;
            }

            double[] FCi = null;

            FCi = CalcularFCarbonosFourier(numeroDeCarbonos, dqmom.Pesos[0], dqmom.Abscissas[0]);

            funcaoFinal = new double[numeroDeCarbonos.Length];

                    double[] m = new double[2 * numeroDePontos];

                    for (int j = 0; j < m.Length; j++)
                    {
                        m[j] = momentos[numeroDePassosDeTempo - 1][j];
                    }

                    double[] pesosf;
                    double[] abscissasf;

                    MomentosBase.CalcularPesosEAbscissas(metodoDeCoeficientes, m, out pesosf, out abscissasf);

                    funcaoFinal = CalcularFCarbonosFourier(numeroDeCarbonos, pesosf, abscissasf);

            var momentosAnaliticos = CalcularMomentosFinais();

            var listaAbscissasAnaliticas = new List<double[]>();
            var listaPesosAnaliticas = new List<double[]>();

            double[] pesosA;
            double[] abscissasA;

            MomentosBase.CalcularPesosEAbscissas(metodoDeCoeficientes, momentosAnaliticos, out pesosA, out abscissasA);

            listaAbscissasAnaliticas.Add(dqmom.Abscissas[0]);
            listaAbscissasAnaliticas.Add(abscissasA);

            listaPesosAnaliticas.Add(dqmom.Pesos[0]);
            listaPesosAnaliticas.Add(pesosA);

            var listaDeTetai = new List<double[]>();
            var listaDeFuncoes = new List<double[]>();

            var listaDeTetaiAnaliticas = new List<double[]>();
            var listaDeFuncoesAnaliticas = new List<double[]>();

            var listaDeMomentosAnaliticos = new List<double[]>();

            listaDeMomentosAnaliticos.Add(momentosIniciais);
            listaDeMomentosAnaliticos.Add(momentosAnaliticos);

            listaDeTetai.Add(numeroDeCarbonos);
            listaDeTetai.Add(numeroDeCarbonos);

            listaDeFuncoes.Add(FCi);
            listaDeFuncoes.Add(funcaoFinal);

            listaDeTetaiAnaliticas.Add(CarbonNumberAdamInicial());
            listaDeFuncoesAnaliticas.Add(FuncaoAdamInicial());

            listaDeTetaiAnaliticas.Add(CarbonNumberAdamT324Celcius());
            listaDeFuncoesAnaliticas.Add(FuncaoAdamT324Celsius());

            //string caso = "CasoN" + numeroDePontos;

            CriarScripParaMatlabMomentos(@"DQMoMHidrocraqueamento\funcao" + caso, "A", listaDeTetaiAnaliticas,
                listaDeFuncoesAnaliticas, listaDeTetai, listaDeFuncoes);
            CriarScripParaMatlabPesos(@"DQMoMHidrocraqueamento\pesos" + caso, tempo, dqmom.Pesos, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrocraqueamento\abscissas" + caso, tempo, dqmom.Abscissas, 1);

            CriarScripParaMatlabPesos(@"DQMoMHidrocraqueamento\pesosAnaliticos" + caso, new double[] { 0.0, 2.0 }, listaPesosAnaliticas, 1);
            CriarScripParaMatlabAbscissas(@"DQMoMHidrocraqueamento\abscissasAnaliticas" + caso, new double[] { 0.0, 2.0 }, listaAbscissasAnaliticas, 1);

            CriarScripParaMatlabMomentos(@"DQMoMHidrocraqueamento\momentos" + caso, tempo, momentos, 1);
            CriarScripParaMatlabMomentos(@"DQMoMHidrocraqueamento\momentosAnaliticos" + caso, new double[] { 0.0, 2.0 }, listaDeMomentosAnaliticos, 1);

            //CriarScripParaMatlabMomentos(@"DQMoMHidrocraqueamento\momentosC" + caso, "A", listaDeTempoMomento, listaDeMomentosAnaliticos, tempo, momentos);
        }