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