Exemplo n.º 1
0
        public static void CalcularPesosEAbscissas(MetodoCoeficientesDosMomentos metodoCoeficientes, double[] momentos,
            out double[] pesos, out double[] abscissas)
        {
            int numeroDePontos = momentos.Length / 2;

            switch (metodoCoeficientes)
            {
                case MetodoCoeficientesDosMomentos.PDA:
                    AlgoritmoPD algoritmoPd = new AlgoritmoPD(numeroDePontos, momentos);
                    algoritmoPd.CalcularPesosEAbscissas(out pesos, out abscissas);
                    break;
                case MetodoCoeficientesDosMomentos.ChebyShev:
                    var chebyChev = new ChebyshevModificado(numeroDePontos,momentos,ChebyshevModificado.TipoDeDominio.Finito);
                    //var chebyChev = new ChebyshevModificado(momentos, numeroDePontos, ChebyshevModificado.TipoDeDominio.Finito);
                    chebyChev.CalcularPesosEAbscissas(out pesos, out abscissas);
                    break;
                case MetodoCoeficientesDosMomentos.Wheeler:
                    Wheeler wheeler = new Wheeler(numeroDePontos, momentos);
                    wheeler.CalcularPesosEAbscissas(out pesos, out abscissas);
                    break;
                default:
                    throw new ArgumentOutOfRangeException("metodoCoeficientes", metodoCoeficientes, null);
            }
        }
Exemplo n.º 2
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
        }
Exemplo n.º 3
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;
            }
        }
Exemplo n.º 4
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);
        }
Exemplo n.º 5
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;
            }
        }