Пример #1
0
        private double[] TermoFonteDqmoMMcCoySegundoCaso(double[] pesos, double[] abscissas, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double kc = 0.01838;
            double kf = 0.0001;
            int r = 1;

            double[] termoFonte = new double[2 * pesos.Length];

            for (int k = 0; k < termoFonte.Length; k++)
            {
                double fracao = (double)(1 - k) / (k + 1);
                termoFonte[k] = kc * fracao * MomentosBase.CalcularMomento(metodoCoeficientesDosMomentos, pesos, abscissas, null, k) - kf * MomentosBase.CalcularMomento(metodoCoeficientesDosMomentos, pesos, abscissas, null, k + r);
            }

            return termoFonte;
        }
Пример #2
0
        private double[] TermoFonteDqmoMEspecieBHidrogenacao(double[] pesos, double[] abscissas, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double[] resultado = new double[numeroDePontos];

            for (int k = 0; k < resultado.Length; k++)
            {
                resultado[k] = 0.0;
                for (int i = 0; i < numeroDePontos / 2; i++)
                {
                    resultado[k] = resultado[k] +
                                   KI(abscissas[i]) * pesos[i] *
                                   MomentosBase.Polinomio(metodoCoeficientesDosMomentos, (abscissas[i] + FuncaoDelta(abscissas[i])), k);
                }
            }

            return resultado;
        }
Пример #3
0
        private double[] TermoFonteDqmoMMcCoyCasoProposto(double[] pesos, double[] abscissas, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double kc = 1.0;
            double r = 0.5;

            double[] termoFonte = new double[2 * pesos.Length];

            for (int k = 0; k < termoFonte.Length; k++)
            {
                double fracao = (double)(1 - k) / (k + 1);
                termoFonte[k] = kc * fracao * MomentosBase.CalcularMomento(metodoCoeficientesDosMomentos, pesos, abscissas, null, k+r-1.0) ;
            }

            return termoFonte;
        }
Пример #4
0
        private double[] TermoFonteDqmoMCSTRAnaliticoEspecieA(double[] pesos, double[] abscissas,
            MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double[] resultado = new double[numeroDePontos];
            double[] termoEntrada = new double[numeroDePontos];
            double[] termoSaida = new double[numeroDePontos];
            double[] termoReacao = new double[numeroDePontos];

            var momentosEntrada = ObterMomentosEntradaEspecieACSTRAnalitico(numeroDePontos);

            for (int k = 0; k < resultado.Length; k++)
            {
                resultado[k] = 0.0;
                termoEntrada[k] = 0.0;
                termoSaida[k] = 0.0;
                termoReacao[k] = 0.0;

                termoEntrada[k] = momentosEntrada[k];

                termoEntrada[k] = (q0 / V) * termoEntrada[k];

                for (int i = 0; i < pesos.Length - 1; i++)
                {
                    termoSaida[k] = termoSaida[k] +
                                    pesos[i] * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k);
                }

                termoSaida[k] = (q / V) * termoSaida[k];

                for (int i = 0; i < pesos.Length - 1; i++)
                {
                    termoReacao[k] = termoReacao[k] +
                                     KI(abscissas[i]) * pesos[i] *
                                     MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k);
                }

                resultado[k] = termoEntrada[k] - termoSaida[k] - termoReacao[k];

            }

            return resultado;
        }
Пример #5
0
        private double[] TermoFonteDqmoMCSTREspecieA(double[] pesos, double[] abscissas,
            MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double[] resultado = new double[numeroDePontos];
            double[] termoEntrada = new double[numeroDePontos];
            double[] termoSaida = new double[numeroDePontos];
            double[] termoReacao = new double[numeroDePontos];

            //var momentosIniciais = ObterMomentosIniciaisEspecieACSTR(numeroDePontos);
            //Momentos Iniciais com um número maior de pontos, para estimular a adaptabilidade das abscissas.

            var momentosEntrada = ObterMomentosEntradaEspecieACSTR(metodoCoeficientesDosMomentos, numeroDePontos);

            //double[] pesosIniciais;
            //double[] abscissasIniciais;

            //MomentosBase.CalcularPesosEAbscissas(MomentosBase.MetodoCoeficientesDosMomentos.PDA, momentosIniciais,
            //    out pesosIniciais, out abscissasIniciais);
            //double[] pesosAnaliticos;
            //double[] abscissasAnaliticas;

            //ObterPesosEAbscissasAnaliticasPeloTempo(tempo, out pesosAnaliticos, out abscissasAnaliticas);

            for (int k = 0; k < resultado.Length; k++)
            {
                resultado[k] = 0.0;
                termoEntrada[k] = 0.0;
                termoSaida[k] = 0.0;
                termoReacao[k] = 0.0;

                //for (int i = 0; i < pesosIniciais.Length; i++)
                //{
                //    termoEntrada[k] = termoEntrada[k] +
                //                      pesosIniciais[i]*
                //                      MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissasIniciais[i], k);
                //}

                termoEntrada[k] = momentosEntrada[k];

                termoEntrada[k] = (q0 / V) * termoEntrada[k];

                for (int i = 0; i < pesos.Length - 1; i++)
                {
                    termoSaida[k] = termoSaida[k] +
                                    pesos[i] * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k);
                }

                //termoSaida[k] = MomentosBase.CalcularMomento(MomentosBase.MetodoCoeficientesDosMomentos.PDA, pesos,
                //    abscissas, null, k);

                termoSaida[k] = (q / V) * termoSaida[k];

                for (int i = 0; i < pesos.Length - 1; i++)
                {
                    termoReacao[k] = termoReacao[k] +
                                     KI(abscissas[i]) * pesos[i] *
                                     MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k);
                }

                //termoReacao[k] = MomentosBase.CalcularMomento(MomentosBase.MetodoCoeficientesDosMomentos.PDA, pesos,
                //    abscissas, KI, k);

                //termoReacao[k] = a* MomentosBase.CalcularMomento(MomentosBase.MetodoCoeficientesDosMomentos.PDA, pesos,
                //    abscissas, null, k+b);

                resultado[k] = termoEntrada[k] - termoSaida[k] - termoReacao[k];

            }

            return resultado;
        }
Пример #6
0
        private double[] TermoFonteHidrocraqueamento(double[] pesos, double[] abscissas, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double[] termoFonte = new double[2 * numeroDePontos];
            double[] primeiroTermo = new double[2 * numeroDePontos];
            double[] segundoTermo = new double[2 * numeroDePontos];

            for (int k = 0; k < termoFonte.Length; k++)
            {
                termoFonte[k] = 0.0;
                primeiroTermo[k] = 0.0;
                segundoTermo[k] = 0.0;

                ordemDoPolinomio = k;

                for (int i = 0; i < pesos.Length; i++)
                {
                    var funcaoKI = KI(abscissas[i]);

                    CalcularS0(funcaoKI);

                    primeiroTermo[k] = primeiroTermo[k] +
                                       funcaoKI *
                                       MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k) * pesos[i];

                    var funcaoE = FuncaoE(abscissas[i]);

                    //var funcaoE = FuncaoE(1.0);

                    segundoTermo[k] = segundoTermo[k] + funcaoKI * funcaoE * pesos[i]; //Termo integral....para as abscissas variarem, este termo deve ser significativo.

                }

                termoFonte[k] = N * segundoTermo[k] - primeiroTermo[k];

            }

            return termoFonte;
        }
Пример #7
0
        private double[] ObterMomentosIniciaisEspecieACSTR(MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, int numeroDePontos)
        {
            double[] momentosIniciais = new double[numeroDePontos];

            for (int i = 0; i < numeroDePontos; i++)
            {
                momentosIniciais[i] =
                    CalcularIntegralFuncaoInicialVezesPolinomio(metodoCoeficientesDosMomentos, i);
            }

            return momentosIniciais;
        }
Пример #8
0
        private double CalcularIntegralFuncaoInicialVezesPolinomio(MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, int ordemDoPolinomio)
        {
            double precisaoRequerida = 1e-12;
            AutoQuad autoQuad = new AutoQuad(numeroDeIntervalosAutoQuad, limiteInferiorAutoQuad, limiteSuperiorAutoQuad, precisaoRequerida, 10);

            Integral.Funcao funcaoInicialVezesPolinomio = delegate(double I)
            {
                return FuncaoCSTREspecieAInicial(I) *
                           MomentosBase.Polinomio(metodoCoeficientesDosMomentos, I, ordemDoPolinomio);
            };

            double valorAutoquad;
            double valorComPrecisaoAutoquad;
            double precisaoAutoquad;

            if (!autoQuad.Calcular(funcaoInicialVezesPolinomio, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                throw new Exception("Erro no cálculo da AutoQuad");

            if (precisaoAutoquad > precisaoRequerida)
                throw new Exception("Precisão não foi atingida na AutoQuad");

            return valorAutoquad;
        }
Пример #9
0
        private List<double[]> CalcularMomentosAnaliticosNumericosCSTREspecieA(MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, int numeroDePontos, int numeroDePassosDeTempo, double passoDeTempo)
        {
            List<double[]> momentosAnaliticos = new List<double[]>(numeroDePassosDeTempo);

            double precisaoRequerida = 1e-12;
            AutoQuad autoQuad = new AutoQuad(numeroDeIntervalosAutoQuad, limiteInferiorAutoQuad, limiteSuperiorAutoQuad, precisaoRequerida, 10);

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

                double[] momentos = new double[numeroDePontos];

                for (int j = 0; j < momentos.Length; j++)
                {
                    var k = j;

                    Integral.Funcao funcaoDeMomento = delegate(double I)
                    {
                        Integral.Funcao funcaoBase = delegate
                        {
                            return ((q0 / V) * FuncaoCSTREspecieAEntrada(I) * (Math.Exp(tempo[t]) - 1) +
                                    FuncaoCSTREspecieAInicial(I) * (q / V + KI(I))) /
                                   ((q / V + KI(I)) * Math.Exp(tempo[t]));
                        };

                        return funcaoBase(I) * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, I, k);
                    };

                    double valorAutoquad;
                    double valorComPrecisaoAutoquad;
                    double precisaoAutoquad;

                    if (!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                        throw new Exception("Erro no cálculo da AutoQuad");

                    if (precisaoAutoquad > precisaoRequerida)
                        throw new Exception("Precisão não foi atingida na AutoQuad");

                    momentos[j] = valorAutoquad;

                }

                momentosAnaliticos.Add(momentos);
            }
            return momentosAnaliticos;
        }
Пример #10
0
        private double[] TermoFonteEspecieB(double[] pesos, double[] abscissas,
            MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double[] resultado = new double[2 * m];

            int indiceTempo = Convert.ToInt32(tempo);

            for (int k = 0; k < resultado.Length; k++)
            {
                resultado[k] = 0.0;

                for (int i = 0; i < pesos.Length; i++)
                {
                    resultado[k] = resultado[k] +
                                   KI(abscissas[i]-2) * pesosA[indiceTempo][i] *
                                   MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k);
                }

                resultado[k] = resultado[k];
            }

            return resultado;
        }
Пример #11
0
        private double[] CalcularMomentosIniciais(Integral.Funcao funcaoInicial, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos)
        {
            var fator = FatorDeNormalizacao();

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

            for (int i = 0; i < m0.Length; i++)
            {
                var i1 = i;

                Integral.Funcao funcaoDeMomento =
                    x => funcaoInicial(x) * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, x, i1);

                double valorAutoquad;
                double valorComPrecisaoAutoquad;
                double precisaoAutoquad;

                double precisaoRequerida = 1e-13;

                AutoQuad autoQuad = new AutoQuad(10, Mmin, Mmax, precisaoRequerida, 10);

                if (
                    !autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
                        out precisaoAutoquad))
                    throw new Exception("Erro no cálculo da AutoQuad");

                if (precisaoAutoquad > precisaoRequerida)
                    throw new Exception("Precisão não foi atingida na AutoQuad");

                m0[i] = valorAutoquad/fator;
            }

            return m0;
        }
Пример #12
0
        private double[] TermoFonteEspecieA(double[] pesos, double[] abscissas,
            MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double[] resultado = new double[2 * m];

            for (int k = 0; k < resultado.Length; k++)
            {
                resultado[k] = 0.0;

                for (int i = 0; i < pesos.Length; i++)
                {
                    resultado[k] = resultado[k] +
                                   KI(abscissas[i]) * pesos[i] *
                                   MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k);
                }

                resultado[k] = -resultado[k];
            }

            return resultado;
        }
Пример #13
0
        private List<double[]> CalcularMomentosAnaliticosEspecieAHidrogenacao(MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, int numeroDePassosDeTempo, double t0, double passoDeTempo,
           double limiteMaximo, double limiteMinimo, int numeroDePontos)
        {
            List<double[]> momentosAnaliticos = new List<double[]>(numeroDePassosDeTempo);

            double precisaoRequerida = 1e-12;
            AutoQuad autoQuad = new AutoQuad(15, 0.0, 100, precisaoRequerida, 10);

            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 t = i;

                double[] momentos = new double[numeroDePontos];

                for (int j = 0; j < momentos.Length; j++)
                {
                    var k = j;

                    Integral.Funcao funcaoDeMomento = delegate(double I)
                    {
                        Integral.Funcao funcaoBase = delegate
                        {
                            return FuncaoReacaoHidrogenacaoEspecieAPrimeiraOrdem(I) * Math.Exp(-KI(I) * tempo[t]);
                        };

                        return funcaoBase(I) * MomentosBase.Polinomio(MomentosBase.MetodoCoeficientesDosMomentos.PDA, I, k);
                    };

                    double valorAutoquad = 0.0;
                    double valorComPrecisaoAutoquad;
                    double precisaoAutoquad;

                    if (!autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad, out precisaoAutoquad))
                        throw new Exception("Erro no cálculo da AutoQuad");

                    if (precisaoAutoquad > precisaoRequerida)
                        MessageBox.Show("Precisão não foi atingida na AutoQuad");

                    //momentos[j] =valorAutoquad+ Integral.CalcularIntegralImpropriaMidInf(funcaoDeMomento, limiteMinimo,
                    //    limiteMaximo,
                    //    10);
                    momentos[j] = valorAutoquad;

                }

                momentosAnaliticos.Add(momentos);
            }
            return momentosAnaliticos;
        }
Пример #14
0
        private double[] TermoFonteHidrocraqueamentoBackup(double[] pesos, double[] abscissas, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double[] termoFonte = new double[2 * numeroDePontos];
            double[] primeiroTermo = new double[2 * numeroDePontos];
            double[] segundoTermo = new double[2 * numeroDePontos];

            for (int k = 0; k < termoFonte.Length; k++)
            {
                termoFonte[k] = 0.0;
                primeiroTermo[k] = 0.0;
                segundoTermo[k] = 0.0;

                for (int i = 0; i < pesos.Length; i++)
                {
                    ordemDoPolinomio = k;

                    var funcaoG = FuncaoKl(abscissas[i]);

                    primeiroTermo[k] = primeiroTermo[k] +
                                       funcaoG *
                                       MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k) * pesos[i];

                    var funcaoD = FuncaoD(abscissas[i]);

                    var funcaoE = FuncaoE(abscissas[i]);

                    segundoTermo[k] = segundoTermo[k] +
                                      (1.0 / (alfa * (Lmax - Lmin))) * funcaoG * funcaoD * funcaoE * pesos[i]; //Termo integral....para as abscissas variarem, este termo deve ser significativo.

                }

                termoFonte[k] = segundoTermo[k] - primeiroTermo[k];
            }

            return termoFonte;
        }
Пример #15
0
        private double[] TermoFonteDqmoMMukhatar(double[] pesos, double[] abscissas, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double[] termoFonte = new double[2 * numeroDePontos];
            double a0 = 0.01;

            for (int k = 0; k < termoFonte.Length; k++)
            {
                double fracao = (double)(3 - k) / (k + 3);
                termoFonte[k] = a0 * fracao * MomentosBase.CalcularMomento(metodoCoeficientesDosMomentos, pesos, abscissas, null, (int)(k + 3));
            }

            return termoFonte;
        }
Пример #16
0
        private double[] CalcularMomentosIniciaisMcCoy(int numeroDePontos, Integral.Funcao funcaoInicial, MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos)
        {
            double[] m0 = new double[numeroDePontos];

            for (int i = 0; i < m0.Length; i++)
            {
                var i1 = i;

                Integral.Funcao funcaoDeMomento =
                    x => funcaoInicial(x) * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, x, i1);

                double valorAutoquad = 0.0;
                double valorComPrecisaoAutoquad;
                double precisaoAutoquad;

                double precisaoRequerida = 1e-14;

                AutoQuad autoQuad = new AutoQuad(15, 125.0, 1200, precisaoRequerida, 15);

                if (
                    !autoQuad.Calcular(funcaoDeMomento, out valorAutoquad, out valorComPrecisaoAutoquad,
                        out precisaoAutoquad))
                    throw new Exception("Erro no cálculo da AutoQuad");

                if (precisaoAutoquad > precisaoRequerida)
                    MessageBox.Show("Precisão não foi atingida na AutoQuad");

                if (i == 1) fatorNormalizacao = valorAutoquad;

                m0[i] = valorAutoquad;
            }

            for (int i = 0; i < m0.Length; i++)
            {
                m0[i] = m0[i] / fatorNormalizacao;
            }

            return m0;
        }
Пример #17
0
        private double[] TermoFonteHidrogenacao_ComMomentoZeroAnalitico(double[] pesos, double[] abscissas,
            MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double[] resultado = new double[numeroDePontos];

            for (int k = 0; k < resultado.Length; k++)
            {
                resultado[k] = 0.0;

                for (int i = 0; i < pesos.Length; i++)
                {
                    resultado[k] = resultado[k] +
                                   abscissas[i] * pesos[i] *
                                   MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k);
                }

                resultado[k] = -resultado[k];
            }

            return resultado;
        }
        private double[] TermoFonteEspecieA(double[] pesos, double[] abscissas,
            MomentosBase.MetodoCoeficientesDosMomentos metodoCoeficientesDosMomentos, double tempo)
        {
            double[] resultado = new double[2 * m];

            for (int k = 0; k < resultado.Length; k++)
            {
                resultado[k] = 0.0;

                for (int i = 0; i < pesos.Length; i++)
                {
                    var resultadoi = 0.0;

                    for (int j = 0; j < pesos.Length; j++)
                    {
                        //var termo1 = (dKI(abscissas[j]) / fI(abscissas[j]) )* MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[j], k);

                        //var termo2 = (-KI(abscissas[j])/(fI(abscissas[j])*fI(abscissas[j])))*MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[j], k);

                        //var termo3 = (KI(abscissas[j]) / fI(abscissas[j])) * MomentosBase.DerivadaPolinomio(metodoCoeficientesDosMomentos, abscissas[j], k);

                    //    var termo = 4 * Math.PI *(MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[j], k)- MomentosBase.DerivadaPolinomio(metodoCoeficientesDosMomentos, abscissas[j], k));

                    //    resultadoi = resultadoi + pesos[j]*(termo);
                    }

                    resultado[k] = resultado[k] + pesos[i] * pesos[i] * MomentosBase.Polinomio(metodoCoeficientesDosMomentos, abscissas[i], k) ;
                }

                resultado[k] = resultado[k];
            }

            return resultado;
        }