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