Example #1
0
        public void CalcularQMOMMCCoyTeste()
        {
            double passoDeTempo = 0.01;
            int numeroDePassosDeTempo = 1100;
            double t0 = 0.0;
            const int numeroDePontos = 8;
            const double limiteMinimo = 125.0;
            double limiteMaximo = Double.MaxValue;

            Integral.Funcao funcaoInicial = FuncaoMcCoy;

            QMoM.TermoFonteQMoM termoFonteQMoM = TermoFonteQMOMMcCoy;
            QMoM qmom = new QMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicial,
                limiteMinimo, limiteMaximo, termoFonteQMoM);

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

            //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]));
            }

            CriarScripParaMatlabMomentos(@"QMoMMcCoy\momentosMcCoyQmom", qmom.Passos, momentos, 100);
            CriarScripParaMatlabConcentracao(@"QMoMMcCoy\concentracaoMcCoyQmom", qmom.Passos, concentracao);
            CriarScripParaMatlabAlfaBeta(@"QMoMMcCoy\alfaQMOM", qmom.Passos, alfa);
            CriarScripParaMatlabAlfaBeta(@"QMoMMcCoy\betaQMOM", qmom.Passos, beta);
        }
Example #2
0
        public void CalcularQMOMReacaoHidrogenacaoEspecieBPrimeiraOrdemTeste()
        {
            const double passoDeTempo = 0.001;
            const int numeroDePassosDeTempo = 100;
            const int numeroDePontos = numeroDePontosHidrogenacao;
            const double t0 = 0.0;
            const double limiteMinimo = 0.001;
            const double limiteMaximo = Double.MaxValue;

            Integral.Funcao funcaoInicialEspecieB = FuncaoReacaoHidrogenacaoEspecieBPrimeiraOrdem;

            var momentosAnaliticos = CalcularMomentosAnaliticosEspecieBHidrogenacao(numeroDePassosDeTempo, t0, passoDeTempo,
                limiteMaximo, limiteMinimo, numeroDePontos);

            QMoM.TermoFonteQMoM termoFonteQMoMEspecieB = TermoFonteQMOMEspecieBHidrogenacao;
            QMoM qmomEspecieB = new QMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicialEspecieB,
                limiteMinimo, limiteMaximo, termoFonteQMoMEspecieB);

            Integral.Funcao funcaoInicialEspecieA = FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem;

            QMoM.TermoFonteQMoM termoFonteQMoMEspecieA = TermoFonteQMOMEspecieAHidrogenacao;
            QMoM qmomEspecieA = new QMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicialEspecieA,
                limiteMinimo, limiteMaximo, termoFonteQMoMEspecieA);

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

            List<double[]> abscissasEspecieA = new List<double[]>(momentosEspecieA.Count);
            List<double[]> pesosEspecieA = new List<double[]>(momentosEspecieA.Count);

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

                MomentosBase.CalcularPesosEAbscissas(MomentosBase.MetodoCoeficientesDosMomentos.PDA, momentosEspecieA[i],out pesos,out abscissas);

                abscissasEspecieA.Add(abscissas);
                pesosEspecieA.Add(pesos);
            }

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

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

                return abscissasDecoradas;
            };

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

                int b = 1;

                //for (int i = 0; i < pesosDecorados.Length; i++)
                //{
                //    pesosDecorados[i] = pesosEspecieA[indiceTempo][i] * Math.Pow(abscissasEspecieA[indiceTempo][i],b);
                //}

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

                return pesosDecorados;
            };

            List<double[]> momentosEspecieB = qmomEspecieB.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;
            }

            CriarScripParaMatlabMomentos(@"QMoMHidrogenacao\momentosAnaliticosEspecieBHidrogenacao", tempo, momentosAnaliticos, 1);
            CriarScripParaMatlabMomentos(@"QMoMHidrogenacao\momentosEspecieBHidrogenacao", tempo, momentosEspecieB, 1);
        }
Example #3
0
        public void Hidrogenacao_EspecieA_PDA()
        {
            const double passoDeTempo = 0.01;
            const int numeroDePassosDeTempo = 2;
            int numeroDePontos = numeroDePontosHidrogenacao;
            const double t0 = 0.0;
            const double limiteMinimo = 0.0001;
            const double limiteMaximo = Double.MaxValue;

            Integral.Funcao funcaoInicial = FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem;

            QMoM.TermoFonteQMoM termoFonteQMoM = TermoFonteQMOMEspecieAHidrogenacao;
            QMoM qmom = new QMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicial,
                limiteMinimo, limiteMaximo, termoFonteQMoM);

            qmom.MomentosIniciais = ObterMomentosIniciaisEspecieANaoNormalizadosHidrogenacao(numeroDePontos);

            var momentosAnaliticos = CalcularMomentosAnaliticosEspecieAHidrogenacao(qmom.MetodoDeCoeficientes, numeroDePassosDeTempo, t0, passoDeTempo,
                limiteMaximo, limiteMinimo, numeroDePontos);

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

            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.PDA, 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(@"QMoMHidrogenacao\momentosEspecieA" + caso, "A", tempo, momentosAnaliticos, momentos, 1);
            CriarScripParaMatlabPesos(@"QMoMHidrogenacao\pesosEspecieA" + caso, "A", tempo, qmom.Pesos, listaPesosAnaliticos, 1);
            CriarScripParaMatlabAbscissas(@"QMoMHidrogenacao\abscissasEspecieA" + caso, "A", tempo, qmom.Abscissas, listaAbscissasAnaliticas, 1);
        }
Example #4
0
        private double[] TermoFonteQMOMMcCoy(QMoM.CalculoDeMomento calcularMomento)
        {
            double[] resultado = new double[8];
            double k = 0.01838;
            double kf = 0.0001;

            resultado[0] = k * calcularMomento(0) - kf * calcularMomento(1);
            resultado[1] = -kf * calcularMomento(2);
            resultado[2] = -k * calcularMomento(2) / 3 - kf * calcularMomento(3);
            resultado[3] = -k * calcularMomento(3) / 2 - kf * calcularMomento(4);
            resultado[4] = -3 * k * calcularMomento(4) / 5 - kf * calcularMomento(5);
            resultado[5] = -2 * k * calcularMomento(5) / 3 - kf * calcularMomento(6);
            resultado[6] = -5 * k * calcularMomento(6) / 7 - kf * calcularMomento(7);
            resultado[7] = -3 * k * calcularMomento(7) / 4 - kf * calcularMomento(8);

            return resultado;
        }
Example #5
0
        public void CalcularQMOMTeseMukhtarTeste()
        {
            double passoDeTempo = 0.001;
            int numeroDePassosDeTempo = 50000;
            int numeroDePontos = 6;
            double t0 = 0.0;
            const double limiteMinimo = 0.001;
            const double limiteMaximo = Double.MaxValue;

            Integral.Funcao funcaoInicial = FuncaoMukhtar;

            QMoM.TermoFonteQMoM termoFonteQMoM = MomentosMukhtar;
            QMoM qmom = new QMoM(numeroDePassosDeTempo, passoDeTempo, t0, numeroDePontos, funcaoInicial,
                limiteMinimo, limiteMaximo, termoFonteQMoM);
            qmom.MomentosIniciais = null;
            qmom.MomentosIniciais = CalcularMomentosIniciaisMukkhatar(numeroDePontos);
            List<double[]> momentos = qmom.CalcularMomentos();

            CriarScripParaMatlabMomentosNormalizados(@"DQMoMMukhtar\momentosMukhatar", qmom.Passos, momentos);
        }
Example #6
0
        private double[] TermoFonteQMOMEspecieBHidrogenacao(QMoM.CalculoDeMomento calcularMomento)
        {
            double[] resultado = new double[numeroDePontosHidrogenacao];

            for (int i = 0; i < resultado.Length; i++)
            {
                resultado[i] = a * calcularMomento(i);
            }

            return resultado;
        }
Example #7
0
        private double[] TermoFonteQMOMEspecieAHidrogenacao(QMoM.CalculoDeMomento calcularMomento)
        {
            double[] resultado = new double[numeroDePontosHidrogenacao];

            for (int k = 0; k < resultado.Length; k++)
            {
                resultado[k] = -a * calcularMomento(k + b);
            }

            return resultado;
        }
Example #8
0
        private double[] MomentosMukhtar(QMoM.CalculoDeMomento calcularMomento)
        {
            double[] resultado = new double[6];

            double a0 = 0.01;

            resultado[0] = a0 * calcularMomento(3);
            resultado[1] = a0 * (1.0 / 2.0) * calcularMomento(4);
            resultado[2] = a0 * (1.0 / 5.0) * calcularMomento(5);
            resultado[3] = a0 * 0.0;
            resultado[4] = a0 * (-1.0 / 7.0) * calcularMomento(7);
            resultado[5] = a0 * (-1.0 / 4.0) * calcularMomento(8);

            return resultado;
        }
Example #9
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;
            }
        }
Example #10
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;
            }
        }