OpenWAM
TTurbina.cpp
1 /* --------------------------------------------------------------------------------*\
2 |==========================|
3  |\\ /\ /\ // O pen | OpenWAM: The Open Source 1D Gas-Dynamic Code
4  | \\ | X | // W ave |
5  | \\ \/_\/ // A ction | CMT-Motores Termicos / Universidad Politecnica Valencia
6  | \\/ \// M odel |
7  ----------------------------------------------------------------------------------
8  License
9 
10  This file is part of OpenWAM.
11 
12  OpenWAM is free software: you can redistribute it and/or modify
13  it under the terms of the GNU General Public License as published by
14  the Free Software Foundation, either version 3 of the License, or
15  (at your option) any later version.
16 
17  OpenWAM is distributed in the hope that it will be useful,
18  but WITHOUT ANY WARRANTY; without even the implied warranty of
19  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
20  GNU General Public License for more details.
21 
22  You should have received a copy of the GNU General Public License
23  along with OpenWAM. If not, see <http://www.gnu.org/licenses/>.
24 
25 
26  \*-------------------------------------------------------------------------------- */
27 
28 // ---------------------------------------------------------------------------
29 #pragma hdrstop
30 
31 #include "TTurbina.h"
32 
33 #include "TCCDeposito.h"
34 #include "TTubo.h"
35 
36 // ---------------------------------------------------------------------------
37 // ---------------------------------------------------------------------------
38 
39 TTurbina::TTurbina(int i, nmTipoDeposito TipoDeposito, int nentradas, nmTipoCalculoEspecies SpeciesModel,
40  int numeroespecies, nmCalculoGamma GammaCalculation, bool ThereIsEGR) :
41  TDepVolCteBase(i, TipoDeposito, SpeciesModel, numeroespecies, GammaCalculation, ThereIsEGR) {
42  asgNumeroTurbina = false;
43 
44  FTimeTurbina = 0.;
45  FNumeroEntradas = nentradas;
46  FNodoEntrada = new int[nentradas];
47  FTuboEntrada = new int[nentradas];
48  FExtremoEntrada = new int[nentradas];
49  FSentidoEntrada = new int[nentradas];
50  FPresionEntrada = new double[nentradas];
51  FVelocidadEntrada = new double[nentradas];
52  FGastoEntrada = new double[nentradas];
53  FTempEntrada = new double[nentradas];
54  FAsonidoEntrada = new double[nentradas];
55  FRhoEntrada = new double[nentradas];
56  FTemp0Entrada = new double[nentradas];
57  FEntalpia0Entrada = new double[nentradas];
58  FPresion0Entrada = new double[nentradas];
59  FEntalpiaIsenSalida = new double[nentradas];
60  FRelacionCinematica = new double[nentradas];
61  FRendTurbina = new double[nentradas];
62  FDeltaPaso = 0.;
63  FTrabajoReal = 0.;
64  FTrabajoRealPaso = 0.;
65  FRendInstantaneo = 0.;
66  FTrabajoIsenInstTotal = 0.;
67  FTrabajoFluido = 0.;
68  FRelacionCinGlobalAcum = 0.;
69  FRelacionCinAcum = new double[nentradas];
70  for(int j = 0; j < nentradas; j++) {
71  FRelacionCinAcum[j] = 0.;
72  }
73  FPonderacionRelacionCinematica = new double[nentradas];
74 
75  FCCSalida = NULL;
76  FCCSalida = NULL;
77  FResMediosTurbina.RelaCinematica = false;
78  FResMediosTurbina.RelaCinematicaMED = NULL;
79  FResInstantTurbina.RelaCinematicaINS = NULL;
80  FResInstantTurbina.RelaCinematica = false;
81 
82  FGastoCorregido = NULL;
83  FRegimenCorregido = NULL;
84  FRelacionExpansion = NULL;
85  FGastoCorregido = new double[nentradas];
86  FRegimenCorregido = new double[nentradas];
87  FRelacionExpansion = new double[nentradas];
88 
89  FMapa = NULL;
90 
91  // FHTM=NULL;
92 
93  FRackIsControlled = false;
94  FIsAcoustic = false;
95 
96 }
97 
98 // ---------------------------------------------------------------------------
99 // ---------------------------------------------------------------------------
100 
101 TTurbina::~TTurbina() {
102  delete[] FRelacionCinAcum;
103  delete[] FTuboEntrada;
104  delete[] FNodoEntrada;
105  delete[] FExtremoEntrada;
106  delete[] FSentidoEntrada;
107  delete[] FPresionEntrada;
108  delete[] FVelocidadEntrada;
109  delete[] FGastoEntrada;
110  delete[] FTempEntrada;
111  delete[] FAsonidoEntrada;
112  delete[] FRhoEntrada;
113  delete[] FTemp0Entrada;
114  delete[] FEntalpia0Entrada;
115  delete[] FPresion0Entrada;
116  delete[] FEntalpiaIsenSalida;
117  delete[] FRelacionCinematica;
118  delete[] FRendTurbina;
119  delete[] FGastoCorregido;
120  delete[] FRegimenCorregido;
121  delete[] FRelacionExpansion;
122  delete[] FPonderacionRelacionCinematica;
123 
124  if(FCCEntrada != NULL)
125  delete[] FCCEntrada;
126  if(FCCSalida != NULL)
127  delete[] FCCSalida;
128  if(FResMediosTurbina.RelaCinematicaMED != NULL)
129  delete[] FResMediosTurbina.RelaCinematicaMED;
130  if(FResMediosTurbina.GastoCorregidoMED != NULL)
131  delete[] FResMediosTurbina.GastoCorregidoMED;
132  if(FResMediosTurbina.GastoCorregidoSUM != NULL)
133  delete[] FResMediosTurbina.GastoCorregidoSUM;
134  if(FResMediosTurbina.RegimenCorregidoMED != NULL)
135  delete[] FResMediosTurbina.RegimenCorregidoMED;
136  if(FResMediosTurbina.RegimenCorregidoSUM != NULL)
137  delete[] FResMediosTurbina.RegimenCorregidoSUM;
138  if(FResMediosTurbina.RelacionExpansionMED != NULL)
139  delete[] FResMediosTurbina.RelacionExpansionMED;
140  if(FResMediosTurbina.RelacionExpansionSUM != NULL)
141  delete[] FResMediosTurbina.RelacionExpansionSUM;
142  if(FResInstantTurbina.RelaCinematicaINS != NULL)
143  delete[] FResInstantTurbina.RelaCinematicaINS;
144  if(FResInstantTurbina.GastoCorregidoINS != NULL)
145  delete[] FResInstantTurbina.GastoCorregidoINS;
146  if(FResInstantTurbina.RegimenCorregidoINS != NULL)
147  delete[] FResInstantTurbina.RegimenCorregidoINS;
148  if(FResInstantTurbina.RelacionExpansionINS != NULL)
149  delete[] FResInstantTurbina.RelacionExpansionINS;
150 
151  if(FMapa != NULL) {
152  delete FMapa;
153  }
154 }
155 
156 // ---------------------------------------------------------------------------
157 // ---------------------------------------------------------------------------
158 
159 void TTurbina::ActualizaPropiedades(double TimeCalculo) {
160 
161  double H = 0.; // Entalpia de entrada
162  double Energia = 0.;
163  double MasaEntrante, FraccionMasicaAcum = 0.;
164  double DeltaT = 0.;
165  double g = 0., v = 0., a = 0., m = 0.;
166  int SignoFlujo = 1;
167 
168  try {
169  FMasa0 = FMasa;
170  MasaEntrante = 0.;
171  H = 0.;
172  DeltaT = TimeCalculo - FTime;
173 
174  if(!(DoubEqZero(DeltaT))) {
175  if(FCalculoEspecies == nmCalculoCompleto) {
176 
177  FRMezcla = CalculoCompletoRMezcla(FFraccionMasicaEspecie[0], FFraccionMasicaEspecie[1], FFraccionMasicaEspecie[2], 0,
178  FCalculoGamma, nmMEP);
179  FCpMezcla = CalculoCompletoCpMezcla(FFraccionMasicaEspecie[0], FFraccionMasicaEspecie[1], FFraccionMasicaEspecie[2], 0,
180  __units::degCToK(FTemperature), FCalculoGamma, nmMEP);
181  FGamma = CalculoCompletoGamma(FRMezcla, FCpMezcla, FCalculoGamma);
182 
183  } else if(FCalculoEspecies == nmCalculoSimple) {
184 
185  FRMezcla = CalculoSimpleRMezcla(FFraccionMasicaEspecie[0], FFraccionMasicaEspecie[1], FCalculoGamma, nmMEP);
186  FCvMezcla = CalculoSimpleCvMezcla(__units::degCToK(FTemperature), FFraccionMasicaEspecie[0], FFraccionMasicaEspecie[1],
187  FCalculoGamma, nmMEP);
188  FGamma = CalculoSimpleGamma(FRMezcla, FCvMezcla, FCalculoGamma);
189 
190  }
191 
192  bool FirstStep = true;
193  bool Converge = false;
194  double Error = 0.;
195  double Ason1 = FAsonido;
196  double Ason0 = FAsonido;
197  double MTemp0 = 1 / (FMasa0 * FRMezcla * __units::degCToK(FTemperature));
198  double MTemp1 = 1 / (FMasa0 * FRMezcla * __units::degCToK(FTemperature));
199  double MTemp = 0.;
200  double H0 = 0;
201  double Diff = 0.;
202 #ifdef tchtm
203  FHeatPower = FHTM->Turb_Heat_Flow();
204 #endif
205  double Heat = FHeatPower * DeltaT;
206 
207  while(!Converge) {
208  H = 0.;
209  for(int i = 0; i < FNumeroUniones; i++) {
210  if(dynamic_cast<TCCDeposito*>(FCCDeposito[i])->getSentidoFlujo() == nmEntrante) {
211  SignoFlujo = 1;
212  } else if(dynamic_cast<TCCDeposito*>(FCCDeposito[i])->getSentidoFlujo() == nmSaliente) {
213  SignoFlujo = -1;
214  }
215  g = (double) - dynamic_cast<TCCDeposito*>(FCCDeposito[i])->getMassflow();
216  v = (double) SignoFlujo * dynamic_cast<TCCDeposito*>(FCCDeposito[i])->getVelocity();
217  a = dynamic_cast<TCCDeposito*>(FCCDeposito[i])->getSpeedSound();
218  m = g * DeltaT * FCCDeposito[i]->GetTuboExtremo(0).Pipe->getNumeroConductos();
219  if(FirstStep) {
220  MasaEntrante += m;
221  for(int j = 0; j < FNumeroEspecies - FIntEGR; j++) {
222  FMasaEspecie[j] += FCCDeposito[i]->GetFraccionMasicaEspecie(j) * m;
223  }
224  }
225  if(v > 0) {
226  H += EntalpiaEntrada(a, v, m, Ason1, FMasa, FCCDeposito[i]->getGamma());
227  }
228 
229  }
230  MTemp1 = FGamma / (pow2(Ason1 * __cons::ARef) * FMasa);
231 
232  if(FirstStep) {
233  FMasa = FMasa0 + MasaEntrante;
234  for(int j = 0; j < FNumeroEspecies - 2; j++) {
235  FFraccionMasicaEspecie[j] = FMasaEspecie[j] / FMasa;
236  FraccionMasicaAcum += FFraccionMasicaEspecie[j];
237  }
238  FFraccionMasicaEspecie[FNumeroEspecies - 2] = 1. - FraccionMasicaAcum;
239  if(FHayEGR)
240  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FMasaEspecie[FNumeroEspecies - 1] / FMasa;
241  H0 = H;
242  FirstStep = false;
243  }
244 
245  MTemp = (MTemp0 + MTemp1) / 2.;
246 
247  Energia = pow(FMasa / FMasa0 * exp((H + H0) / 2 - (FTrabajoFluido + Heat) * MTemp), __Gamma::G1(FGamma));
248  Ason1 = FAsonido * sqrt(Energia);
249  Error = (Diff = Ason1 - Ason0, fabs(Diff)) / Ason1;
250  if(Error > 1e-6) {
251  Ason0 = Ason1;
252  } else {
253  Converge = true;
254  }
255 
256  }
257 
258  FAsonido = Ason1;
259  // FTemperature = pow(FAsonido, 2) / (FGamma * FRMezcla) * pow(__cons::ARef, 2);
260  FPressure = __units::PaToBar(pow2(__cons::ARef * FAsonido) / FGamma / FVolumen * FMasa);
261  FPresionIsen = pow(FPressure / FPresRef, __Gamma::G5(FGamma));
262  FTemperature = __units::KTodegC(pow2(FAsonido * __cons::ARef) / FGamma / FRMezcla);
263  }
264  FTime = TimeCalculo;
265  } catch(exception & N) {
266  std::cout << "ERROR: TTurbina::ActualizaPropiedades en la turbina " << FNumeroTurbina << std::endl;
267  std::cout << "Tipo de error: " << N.what() << std::endl;
268  throw Exception(N.what());
269  }
270 }
271 
272 // ---------------------------------------------------------------------------
273 // ---------------------------------------------------------------------------
274 
275 void TTurbina::CalculoPotenciaPaso() {
276  try {
277 
278  if(FDeltaPaso != 0 & FTrabajoRealPaso != 0) {
279  FPotenciaPaso = FTrabajoRealPaso / FDeltaPaso;
280  FTrabajoRealPaso = 0.;
281  FDeltaPaso = 0.;
282  } else {
283  FPotenciaPaso = 0.;
284  FTrabajoRealPaso = 0.;
285  FDeltaPaso = 0.;
286  }
287 
288  } catch(exception & N) {
289  std::cout << "ERROR: TTurbina::CalculoPotenciaPaso en el compresor: " << FNumeroTurbina << std::endl;
290  std::cout << "Tipo de error: " << N.what() << std::endl;
291  throw Exception("ERROR: TTurbina::CalculoPotenciaPaso en la turbina: " + std::to_string(FNumeroTurbina) + N.what());
292  }
293 }
294 // ---------------------------------------------------------------------------
295 // ---------------------------------------------------------------------------
296 
297 void TTurbina::TransformaContorno(double *L, double *B, double *E, double *a, double *v, double *p, int modo,
298  double Gamma) {
299  try {
300  if(modo == 0) {
301  *L = (*a + (Gamma / 2) * *v);
302  *B = (*a - (Gamma / 2) * *v);
303  *E = *a / pow(*p, __Gamma::G5(Gamma));
304  } else {
305  *a = (*L + *B) / 2.;
306  *v = (*L - *B) / __Gamma::G1(Gamma);
307  *p = pow(*a / *E, __Gamma::G4(Gamma));
308  }
309  } catch(exception & N) {
310  std::cout << "ERROR: TTurbina::TransformaContorno en la turbina " << FNumeroTurbina << std::endl;
311  std::cout << "Tipo de error: " << N.what() << std::endl;
312  throw Exception(N.what());
313  }
314 }
315 
316 // ---------------------------------------------------------------------------
317 // ---------------------------------------------------------------------------
318 
319 void TTurbina::LeeTurbina(const char *FileWAM, fpos_t &filepos) {
320  try {
321  int rdturb = 0, tipoturb = 0, ctrl = 0, numctrl = 0, ac = 0;
322  double AngCritico = 0., Beta = 0.;
323 
324  FILE *fich = fopen(FileWAM, "r");
325  fsetpos(fich, &filepos);
326 
327  fscanf(fich, "%d ", &tipoturb);
328  switch(tipoturb) {
329  case 0:
330  FTipoTurbina = nmFixedTurbine;
331  break;
332  case 1:
333  FTipoTurbina = nmVariableGeometry;
334  break;
335  case 2:
336  FTipoTurbina = nmTurbineMap;
337  break;
338  default:
339  std::cout << "ERROR: Unknown turbine type " << std::endl;
340  }
341  fscanf(fich, "%lf ", &FDiametroRodete);
342  if(FTipoTurbina == nmTurbineMap) {
343 
344  fscanf(fich, "%lf %lf %lf ", &FDiametroRodeteOut, &FDiametroTuerca, &FDiametroTurbinaIn);
345  fscanf(fich, "%lf ", &AngCritico);
346  FMapa = new TTurbineMap();
347  FMapa->LoadTurbineMap(fich, FDiametroRodete, FDiametroRodeteOut, FDiametroTuerca, FDiametroTurbinaIn, AngCritico);
348 
349  fscanf(fich, "%d ", &numctrl);
350  for(int i = 0; i < numctrl; ++i) {
351  fscanf(fich, "%d ", &ctrl);
352  switch(ctrl) {
353  case 0:
354  FRackIsControlled = true;
355  break;
356 
357  default:
358  std::cout << "ERROR: Unknown controller for the turbine " << std::endl;
359  }
360  fscanf(fich, "%d ", &FNumControlObject);
361  }
362 
363  if(!FRackIsControlled)
364  fscanf(fich, "%lf ", &FRack);
365  FCalRendTurbina = nmRendMapa;
366 
367 #ifdef tchtm
368 
369  fscanf(fich, "%d ", &ac);
370  if(ac == 1) {
371  iVector InID;
372  iVector VolID;
373  int OutID = 0;
374  FIsAcoustic = true;
375  if(FTipoDeposito == nmTurbinaSimple) {
376  InID.resize(1);
377  InID.resize(1);
378  fscanf(fich, "%d %d %d", &InID[0], &VolID[0], &OutID);
379  FAcTurb = new TAcousticTurbine(InID, VolID, OutID);
380  }
381  }
382 #endif
383  } else {
384  fscanf(fich, "%d ", &rdturb);
385  switch(rdturb) {
386  case 0:
387  FCalRendTurbina = nmWatson;
388  break;
389  case 1:
390  FCalRendTurbina = nmPolinomio;
391  fscanf(fich, "%lf %lf %lf ", &FRcoptima, &FRcmaxima, &FRendmaximo);
392  break;
393  case 2:
394  FCalRendTurbina = nmCalcExtRD;
395  break;
396  default:
397  std::cout << "ERROR: Unknown method to calculate turbine efficiency " << std::endl;
398  }
399  }
400 
401  fscanf(fich, "%lf ", &FAjustRendTurb);
402 
403  fgetpos(fich, &filepos);
404  fclose(fich);
405  } catch(exception & N) {
406  std::cout << "ERROR: TTurbina::LeeRendimientoTurbina en la turbina " << FNumeroTurbina << std::endl;
407  std::cout << "Tipo de error: " << N.what() << std::endl;
408  throw Exception(N.what());
409  }
410 }
411 
412 // ---------------------------------------------------------------------------
413 // ---------------------------------------------------------------------------
414 
416 // try {
417 // if (!asgNumeroTurbina) {
418 // FNumeroTurbina = NumeroTurbina;
419 // asgNumeroTurbina = true;
420 // }
421 // else {
422 // std::cout << "ERROR: Esta turbina ya tiene numero asignada" << std::endl;
423 // throw Exception("");
424 // }
425 // }
426 // catch(Exception & N) {
427 // std::cout << "ERROR: TTurbina::PutNumeroTurbina en la turbina " << FNumeroTurbina << std::endl;
428 // std::cout << "Tipo de error: " << N.what() << std::endl;
429 // throw Exception(N.what());
430 // }
431 // }
432 
433 // ---------------------------------------------------------------------------
434 // ---------------------------------------------------------------------------
435 
436 // void TTurbina::PutRegimen(double valor) {
437 // try {
438 //
439 // FRegimen = valor;
440 //
441 // }
442 // catch(Exception & N) {
443 // std::cout << "ERROR: TTurbina::PutRegimen en la turbina " << FNumeroTurbina << std::endl;
444 // std::cout << "Tipo de error: " << N.what() << std::endl;
445 // throw Exception(N.what());
446 // }
447 // }
448 
449 // ---------------------------------------------------------------------------
450 // ---------------------------------------------------------------------------
451 
452 void TTurbina::AsignaDatosSalida(int nodsaltur, int tubsaltur, int extremo, int sentido) {
453  try {
454  FNodoSalida = nodsaltur;
455  FTuboSalida = tubsaltur;
456  FExtremoSalida = extremo;
457  FSentidoSalida = sentido;
458  } catch(exception & N) {
459  std::cout << "ERROR: TTurbina::AsignaDatosSalida en la turbina " << FNumeroTurbina << std::endl;
460  std::cout << "Tipo de error: " << N.what() << std::endl;
461  throw Exception(N.what());
462  }
463 }
464 
465 // ---------------------------------------------------------------------------
466 // ---------------------------------------------------------------------------
467 
468 double TTurbina::GetRelacionCinematica(int i) {
469  try {
470  if(FRelacionCinematica != NULL && i < FNumeroEntradas) {
471  return FRelacionCinematica[i];
472  } else {
473  std::cout << "ERROR: TTurbina::GetRelacionCinematica: " << FNumeroTurbina << std::endl;
474  std::cout << "ERROR: La entrada de la turbina indicada no existe " << std::endl;
475  return 0.;
476  }
477  } catch(exception & N) {
478  std::cout << "ERROR: TTurbina::GetRelacionCinematica en la turbina " << FNumeroTurbina << std::endl;
479  std::cout << "Tipo de error: " << N.what() << std::endl;
480  throw Exception(N.what());
481  }
482 }
483 
484 // ---------------------------------------------------------------------------
485 // ---------------------------------------------------------------------------
486 
487 void TTurbina::AsignaDatosEntrada(int nodentur, int tubsaltur, int extremo, int sentido, int n) {
488  try {
489  FNodoEntrada[n] = nodentur;
490  FTuboEntrada[n] = tubsaltur;
491  FExtremoEntrada[n] = extremo;
492  FSentidoEntrada[n] = sentido;
493  } catch(exception & N) {
494  std::cout << "ERROR: TTurbina::AsignaDatosEntrada en la turbina " << FNumeroTurbina << std::endl;
495  std::cout << "Tipo de error: " << N.what() << std::endl;
496  throw Exception(N.what());
497  }
498 }
499 
500 // ---------------------------------------------------------------------------
501 // ---------------------------------------------------------------------------
502 
503 TCondicionContorno* TTurbina::GetCCEntrada(int i) {
504  if(FCCEntrada != NULL && i < FNumeroEntradas) {
505  return FCCEntrada[i];
506  } else {
507  std::cout << "ERROR: TTurbina::Peticion CCEntrada: " << FNumeroTurbina << std::endl;
508  }
509 }
510 
511 // ---------------------------------------------------------------------------
512 // ---------------------------------------------------------------------------
513 
514 TCondicionContorno* TTurbina::GetCCSalida(int i) {
515  if(FCCSalida != NULL && i < 1) {
516  return FCCSalida[i];
517  } else {
518  std::cout << "ERROR: TTurbina::Peticion CCSalida: " << FNumeroTurbina << std::endl;
519  }
520 }
521 
522 // ---------------------------------------------------------------------------
523 // ---------------------------------------------------------------------------
524 
525 void TTurbina::AsignaRackController(TController **Controller) {
526  if(FRackIsControlled)
527  FRackController = Controller[FNumControlObject - 1];
528 }
529 
530 void TTurbina::AllocateDatosTGV(stDatosTGV *DatosTGV) {
531  FDatosTGV = DatosTGV;
532 }
533 
534 double TTurbina::CpTurbineSimple(double Temperature, double YBurnt) {
535 
536  double R = __R::Burnt * YBurnt + (__R::Air * (1 - YBurnt - 0.0164) + 0.0164 * __R::H2O);
537  double RaizdeT = sqrt(Temperature);
538 
539  double CvAir = -10.4199 * RaizdeT + 2522.88 + (-67227.1 * RaizdeT + 917124.4 - 4174853.6 / RaizdeT) / Temperature;
540  double CvBurnt = 641.154 + Temperature * (0.43045 + Temperature * (-0.0001125 + Temperature * 8.979e-9));
541  double CvH2O = (22.605 - 0.09067 * RaizdeT + (-826.53 * RaizdeT + 13970.1 - 82114 / RaizdeT) / Temperature) * __R::H2O -
542  __R::H2O;
543 
544  double CpMezcla = CvBurnt * YBurnt + (CvAir * (1 - YBurnt - 0.0164) + 0.0164 * CvH2O) + R;
545 
546  return CpMezcla;
547 }
548 
549 double TTurbina::CpTurbineComplete(double YO2, double YCO2, double YH2O, double Temperature) {
550  double YN2 = 1 - YO2 - YCO2 - YH2O;
551 
552  double RaizdeT = sqrt(Temperature);
553  // Temperature en Kelvin. Calculado segun la correlacion de JANAF.
554  double CpN2 = (12.531 - 0.05932 * RaizdeT + (-352.3 * RaizdeT + 5279.1 - 27358 / RaizdeT) / Temperature) * __R::N2;
555  double CpO2 = (-0.112 + 0.0479 * RaizdeT + (195.42 * RaizdeT - 4426.1 + 32538 / RaizdeT) / Temperature) * __R::O2;
556  double CpCO2 = (12.019 - 0.03566 * RaizdeT + (-142.34 * RaizdeT - 163.7 + 9470 / RaizdeT) / Temperature) * __R::CO2;
557  double CpH2O = (22.605 - 0.09067 * RaizdeT + (-826.53 * RaizdeT + 13970.1 - 82114 / RaizdeT) / Temperature) * __R::H2O;
558 
559  double CpMezcla = CpO2 * YO2 + CpCO2 * YCO2 + CpH2O * YH2O + CpN2 * (YN2 - 0.01292) + 520.32 * 0.01292;
560 
561  return CpMezcla;
562 }
563 
564 void TTurbina::CalculateAdiabaticMap(double TinC) {
565  FMapa->CalculateAdiabaticEfficiency(FHTM, TinC);
566 }
567 
568 void TTurbina::AsignAcousticElements(TTubo **Pipe) {
569 
570  if(FIsAcoustic) {
571  for(int i = 0; i < FNumeroEntradas; i++) {
572  FAcTurb->AsignInPipe(Pipe, i);
573  }
574 
575  FAcTurb->AsignOutPipe(Pipe);
576  }
577 }
578 
579 #pragma package(smart_init)
TTubo
a Finite differences pipe.
Definition: TTubo.h:116
TController
Definition: TController.h:37
TAcousticTurbine
Definition: TAcousticTurbine.h:39
TDepVolCteBase
Definition: TDepVolCteBase.h:33
iVector
std::vector< int > iVector
Integer vector.
Definition: Math_wam.h:72
TCondicionContorno
Definition: TCondicionContorno.h:54
stDatosTGV
Definition: Globales.h:336
Exception
Custom exception class.
Definition: Exception.hpp:39
TTurbineMap
Definition: TTurbineMap.h:34
TTubo.h
TCCDeposito
Definition: TCCDeposito.h:40
pow2
T pow2(T x)
Returns x to the power of 2.
Definition: Math_wam.h:88