OpenWAM
TCCDeposito.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 // ---------------------------------------------------------------------------
30 #pragma hdrstop
31 
32 #include "TCCDeposito.h"
33 //#include <cmath>
34 #ifdef __BORLANDC__
35 #include <vcl.h>
36 #endif
37 
38 #include "TCDFijo.h"
39 #include "TValvula4T.h"
40 #include "TLamina.h"
41 #include "TDiscoRotativo.h"
42 #include "TLumbrera.h"
43 #include "TValvulaContr.h"
44 #include "TWasteGate.h"
45 #include "TEstatorTurbina.h"
46 #include "TRotorTurbina.h"
47 #include "TCDExterno.h"
48 #include "TMariposa.h"
49 
50 #include "TDepVolVariable.h"
51 #include "TDepVolCte.h"
52 #include "TTurbinaSimple.h"
53 #include "TTurbinaTwin.h"
54 #include "TVenturi.h"
55 #include "TUnionDireccional.h"
56 
57 #include "TTubo.h"
58 #include "TDPF.h"
59 #include "TCanalDPF.h"
60 
61 // ---------------------------------------------------------------------------
62 // ---------------------------------------------------------------------------
63 
64 TCCDeposito::TCCDeposito(nmTypeBC TipoCC, int numCC, nmTipoCalculoEspecies SpeciesModel, int numeroespecies,
65  nmCalculoGamma GammaCalculation, bool ThereIsEGR) :
66  TCondicionContorno(TipoCC, numCC, SpeciesModel, numeroespecies, GammaCalculation, ThereIsEGR) {
67 
68  FTuboExtremo = NULL;
69  FValvula = NULL;
70  FGasto = 0;
71  FVelocity = 0;
72  FSonido = 1;
73  FVelocidadGarganta = 0;
74  FMachGarganta = 1;
75  FRelacionPresionGarganta = 1;
76  FSentidoFlujo = nmParado;
77  FMachVenturi = 0;
78 
79  FTime0 = 0.;
80  FTime1 = 0.;
81  FAnguloAnterior = 0.;
82  FAnguloActual = 0.;
83 
84 }
85 // ---------------------------------------------------------------------------
86 // ---------------------------------------------------------------------------
87 
88 TCCDeposito::~TCCDeposito() {
89 
90  delete[] FTuboExtremo;
91 
92  if(FValvula != NULL)
93  delete FValvula;
94 
95  FValvula = NULL;
96 
97 }
98 
99 // ---------------------------------------------------------------------------
100 // ---------------------------------------------------------------------------
101 
102 void TCCDeposito::ReadBoundaryData(const char *FileWAM, fpos_t &filepos, int NumberOfPipes, TTubo **Pipe, int nDPF,
103  TDPF **DPF) {
104  try {
105  int i = 0, j = 0;
106  int numid = 0; // Variable necesaria para WAMer.
107 
108  FTuboExtremo = new stTuboExtremo[1];
109  FTuboExtremo[0].Pipe = NULL;
110 #ifdef ParticulateFilter
111  FTuboExtremo[0].DPF = NULL;
112 #endif
113  FTuboExtremo[0].NumeroHaz = -1;
114  FTuboExtremo[0].TipoCanal = -1;
115 
116  FPref = 1;
117 
118  while(FNumeroTubosCC < 1 && i < NumberOfPipes) {
119  if(Pipe[i]->getNodoIzq() == FNumeroCC) {
120  FTuboExtremo[FNumeroTubosCC].Pipe = Pipe[i];
121  FTuboExtremo[FNumeroTubosCC].TipoExtremo = nmLeft;
122  FNodoFin = 0;
123  FIndiceCC = 0;
124  FCC = &(FTuboExtremo[FNumeroTubosCC].Beta);
125  FCD = &(FTuboExtremo[FNumeroTubosCC].Landa);
126  FNumeroTubosCC++;
127  FUnionDPF = false;
128  FEncontrado = true;
129  }
130  if(Pipe[i]->getNodoDer() == FNumeroCC) {
131  FTuboExtremo[FNumeroTubosCC].Pipe = Pipe[i];
132  FTuboExtremo[FNumeroTubosCC].TipoExtremo = nmRight;
133  FNodoFin = Pipe[i]->getNin() - 1;
134  FIndiceCC = 1;
135  FCC = &(FTuboExtremo[FNumeroTubosCC].Landa);
136  FCD = &(FTuboExtremo[FNumeroTubosCC].Beta);
137  FNumeroTubosCC++;
138  FUnionDPF = false;
139  FEncontrado = true;
140  }
141  i++;
142  }
143 #ifdef ParticulateFilter
144  if(!FEncontrado) { // It is a junction between a plenum and a DPF
145  int k = 0;
146  while(FNumeroTubosCC < 1 && j < nDPF) {
147  while(k < DPF[j]->getNumeroHacesCanales()) {
148  if(DPF[j]->GetCanal(k, 0)->getNodoIzq() == FNumeroCC) {
149  FTuboExtremo[FNumeroTubosCC].NumeroHaz = k;
150  FTuboExtremo[FNumeroTubosCC].TipoCanal = 0;
151  FTuboExtremo[FNumeroTubosCC].DPF = DPF[j];
152  FTuboExtremo[FNumeroTubosCC].TipoExtremo = nmLeft;
153  FNodoFin = 0;
154  FIndiceCC = 0;
155  FCC = & (FTuboExtremo[FNumeroTubosCC].Beta);
156  FCD = & (FTuboExtremo[FNumeroTubosCC].Landa);
157  FNumeroTubosCC++;
158  }
159  if(DPF[j]->GetCanal(k, 0)->getNodoDer() == FNumeroCC) {
160  FTuboExtremo[FNumeroTubosCC].NumeroHaz = k;
161  FTuboExtremo[FNumeroTubosCC].TipoCanal = 0;
162  FTuboExtremo[FNumeroTubosCC].DPF = DPF[j];
163  FTuboExtremo[FNumeroTubosCC].TipoExtremo = nmRight;
164  FNodoFin = DPF[j]->GetCanal(k, 0)->getNin() - 1;
165  FIndiceCC = 1;
166  FCC = & (FTuboExtremo[FNumeroTubosCC].Landa);
167  FCD = & (FTuboExtremo[FNumeroTubosCC].Beta);
168  FNumeroTubosCC++;
169  }
170  if(DPF[j]->GetCanal(k, 1)->getNodoIzq() == FNumeroCC) {
171  FTuboExtremo[FNumeroTubosCC].NumeroHaz = k;
172  FTuboExtremo[FNumeroTubosCC].TipoCanal = 1;
173  FTuboExtremo[FNumeroTubosCC].DPF = DPF[j];
174  FTuboExtremo[FNumeroTubosCC].TipoExtremo = nmLeft;
175  FNodoFin = 0;
176  FIndiceCC = 0;
177  FCC = & (FTuboExtremo[FNumeroTubosCC].Beta);
178  FCD = & (FTuboExtremo[FNumeroTubosCC].Landa);
179  FNumeroTubosCC++;
180  }
181  if(DPF[j]->GetCanal(k, 1)->getNodoDer() == FNumeroCC) {
182  FTuboExtremo[FNumeroTubosCC].NumeroHaz = k;
183  FTuboExtremo[FNumeroTubosCC].TipoCanal = 1;
184  FTuboExtremo[FNumeroTubosCC].DPF = DPF[j];
185  FTuboExtremo[FNumeroTubosCC].TipoExtremo = nmRight;
186  FNodoFin = DPF[j]->GetCanal(k, 1)->getNin() - 1;
187  FIndiceCC = 1;
188  FCC = & (FTuboExtremo[FNumeroTubosCC].Landa);
189  FCD = & (FTuboExtremo[FNumeroTubosCC].Beta);
190  FNumeroTubosCC++;
191  }
192  k++;
193  }
194  j++;
195  k = 0;
196  }
197  FEncontrado = true;
198  FUnionDPF = true;
199  }
200 #endif
201  FILE *fich = fopen(FileWAM, "r");
202  fsetpos(fich, &filepos);
203 
204  fscanf(fich, "%d ",
205  &numid); // Esto es un dato que necesita el WAMer. Los usuarios de WAM hacemos la vista gorda hasta que se arregle.
206  fscanf(fich, "%d ", &FNumeroDeposito);
207 
208  fgetpos(fich, &filepos);
209  fclose(fich);
210 
211  // Inicializacion del transporte de especies quimicas
212  FFraccionMasicaEspecie = new double[FNumeroEspecies - FIntEGR];
213  if(!FUnionDPF) {
214  for(int i = 0; i < FNumeroEspecies - FIntEGR; i++) {
215  FFraccionMasicaEspecie[i] = FTuboExtremo[0].Pipe->GetFraccionMasicaInicial(i);
216  }
217  } else {
218 #ifdef ParticulateFilter
219  for(int i = 0; i < FNumeroEspecies - FIntEGR; i++) {
220  FFraccionMasicaEspecie[i] = FTuboExtremo[0].DPF->GetCanal(FTuboExtremo[0].NumeroHaz, 0)->GetFraccionMasicaInicial(i);
221  }
222 #endif
223  }
224 
225  } catch(exception & N) {
226  std::cout << "ERROR: TCCDeposito::LeeCCDeposito en la condicion de contorno: " << FNumeroCC << std::endl;
227  std::cout << "Tipo de error: " << N.what() << std::endl;
228  throw Exception(N.what());
229  }
230 }
231 
232 // ---------------------------------------------------------------------------
233 // ---------------------------------------------------------------------------
234 
235 void TCCDeposito::AsignaDeposito(TDeposito **Plenum) {
236  try {
237 
238  FDeposito = Plenum[FNumeroDeposito - 1];
239  FValvula->PutPlenum(FDeposito);
240 
241  } catch(exception & N) {
242  std::cout << "ERROR: TCCDeposito::AsignaDeposito en la condicion de contorno: " << FNumeroCC << std::endl;
243  std::cout << "Tipo de error: " << N.what() << std::endl;
244  throw Exception(N.what());
245  }
246 }
247 
248 // ---------------------------------------------------------------------------
249 // ---------------------------------------------------------------------------
250 
251 void TCCDeposito::AsignaTipoValvula(TTipoValvula **Origen, int Valv, int i) {
252  try {
253 
254  switch(Origen[Valv - 1]->getTypeOfValve()) {
255  case nmCDFijo:
256  FValvula = new TCDFijo(dynamic_cast<TCDFijo*>(Origen[Valv - 1]), i);
257  break;
258  case nmValvula4T:
259  FValvula = new TValvula4T(dynamic_cast<TValvula4T*>(Origen[Valv - 1]), i);
260  break;
261  case nmLamina:
262  FValvula = new TLamina(dynamic_cast<TLamina*>(Origen[Valv - 1]), i);
263  break;
264  case nmDiscoRotativo:
265  FValvula = new TDiscoRotativo(dynamic_cast<TDiscoRotativo*>(Origen[Valv - 1]), i);
266  break;
267  case nmLumbrera2T:
268  FValvula = new TLumbrera(dynamic_cast<TLumbrera*>(Origen[Valv - 1]), i);
269  break;
270  case nmValvulaContr:
271  FValvula = new TValvulaContr(dynamic_cast<TValvulaContr*>(Origen[Valv - 1]), i);
272  break;
273  case nmWasteGate:
274  FValvula = new TWasteGate(dynamic_cast<TWasteGate*>(Origen[Valv - 1]), i);
275  break;
276  case nmStator:
277  FValvula = new TEstatorTurbina(dynamic_cast<TEstatorTurbina*>(Origen[Valv - 1]), i);
278  break;
279  case nmRotor:
280  FValvula = new TRotorTurbina(dynamic_cast<TRotorTurbina*>(Origen[Valv - 1]), i);
281  break;
282  case nmCalcExtern:
283  FValvula = new TCDExterno(dynamic_cast<TCDExterno*>(Origen[Valv - 1]), i);
284  break;
285  case nmMariposa:
286  FValvula = new TMariposa(dynamic_cast<TMariposa*>(Origen[Valv - 1]), i);
287  break;
288  }
289 
290  if(!FUnionDPF) {
291  FValvula->PutPipe(FTuboExtremo[0].Pipe, FNodoFin);
292  FValvula->PutDiametroTubo(FTuboExtremo[0].Pipe->GetDiametro(FNodoFin));
293  } else {
294 #ifdef ParticulateFilter
295  FValvula->PutDiametroTubo(FTuboExtremo[0].DPF->GetCanal(FTuboExtremo[0].NumeroHaz,
296  FTuboExtremo[0].TipoCanal)->GetDiametro(FNodoFin));
297 #endif
298  }
299 
300  if(FValvula->getTypeOfValve() == nmCDFijo) {
301  // dynamic_cast<TCDFijo *>(FValvula)->CalculaCD();
302  FCDEntrada = FValvula->getCDTubVol();
303  FCDSalida = FValvula->getCDVolTub();
304  // FCTorbellino=FValvula->getCTorb();
305  if(FCDEntrada > 1.) {
306  FValvula->AsignaCRecuperacion(FCDEntrada - 1.);
307  } else
308  FValvula->AsignaCRecuperacion(0.);
309  }
310 
311  } catch(exception & N) {
312  std::cout << "ERROR: TCCDeposito::AsignaTipoValvula en la condicion de contorno: " << FNumeroCC << std::endl;
313  std::cout << "Tipo de error: " << N.what() << std::endl;
314  throw Exception(N.what());
315  }
316 }
317 
318 // ---------------------------------------------------------------------------
319 // ---------------------------------------------------------------------------
320 
321 void TCCDeposito::CalculaCoeficientesDescarga(double TiempoActual, double mfcomb, double RegimenMotor) {
322  try {
323  double PVol = 0., PTub = 0., PAdm = 0., DeltaP = 0., distancia = 0., CDExt = 0., nodoadm = 0., p1 = 0., p2 = 0.;
324  int turb = 0, entr = 0, NodoFin = 0;
325 
326  switch(FValvula->getTypeOfValve()) {
327  case nmCDFijo:
328  dynamic_cast<TCDFijo*>(FValvula)->CalculaCD();
329  break;
330 
331  case nmValvula4T:
332  if(FValvula->getControlRegimen() == nmMotor) {
333  FRegimen = RegimenMotor;
334  } else {
335  FRegimen = FValvula->getRegimen();
336  }
337  FTime0 = FTime1;
338  FTime1 = TiempoActual;
339  FDeltaT = FTime1 - FTime0;
340  FDeltaAngulo = 360. * FRegimen * FValvula->getRelacionVelocidades() / 60. * FDeltaT;
341  FAnguloAnterior = FAnguloActual;
342  FAnguloActual = FAnguloAnterior + FDeltaAngulo;
343  if(FAnguloActual > 360.) {
344  FAnguloActual -= 360.;
345  }
346  dynamic_cast<TValvula4T*>(FValvula)->CalculaCD(FAnguloActual);
347  break;
348 
349  case nmStator:
350  dynamic_cast<TEstatorTurbina*>(FValvula)->CalculaCD();
351  break;
352 
353  case nmRotor:
354  dynamic_cast<TRotorTurbina*>(FValvula)->CalculaCD();
355  break;
356 
357  case nmLamina:
358  if(FTuboExtremo[0].TipoExtremo == nmLeft) {
359  NodoFin = 0;
360  } else
361  NodoFin = FTuboExtremo[0].Pipe->getNin() - 1;
362  DeltaP = FTuboExtremo[0].Pipe->GetPresion(NodoFin) - FDeposito->getPressure();
363  dynamic_cast<TLamina*>(FValvula)->CalculaCD(DeltaP, FTuboExtremo[0].Pipe->getTime1());
364  break;
365 
366  case nmDiscoRotativo:
367  if(FValvula->getControlRegimen() == nmMotor) {
368  FRegimen = RegimenMotor;
369  } else {
370  FRegimen = FValvula->getRegimen();
371  }
372  FTime0 = FTime1;
373  FTime1 = TiempoActual;
374  FDeltaT = FTime1 - FTime0;
375  FDeltaAngulo = 360. * FRegimen * FValvula->getRelacionVelocidades() / 60. * FDeltaT;
376  FAnguloAnterior = FAnguloActual;
377  FAnguloActual = FAnguloAnterior + FDeltaAngulo;
378  if(FAnguloActual > 360.) {
379  FAnguloActual -= 360.;
380  }
381  dynamic_cast<TDiscoRotativo*>(FValvula)->CalculaCD(FAnguloActual);
382  break;
383 
384  case nmLumbrera2T:
385  FRegimen = dynamic_cast<TDepVolVariable*>(FDeposito)->getRegimen();
386  FTime0 = FTime1;
387  FTime1 = TiempoActual;
388  FDeltaT = FTime1 - FTime0;
389  FDeltaAngulo = 360. * FRegimen * dynamic_cast<TDepVolVariable*>(FDeposito)->getRelacionVelocidades() / 60. * FDeltaT;
390  FAnguloAnterior = FAnguloActual;
391  FAnguloActual = FAnguloAnterior + FDeltaAngulo;
392  if(FAnguloActual > 360.) {
393  FAnguloActual -= 360.;
394  }
395  dynamic_cast<TLumbrera*>(FValvula)->CalculaCD(FAnguloActual);
396  break;
397 
398  case nmValvulaContr:
399  FRegimen = RegimenMotor;
400  FTime0 = FTime1;
401  FTime1 = TiempoActual;
402  FDeltaT = FTime1 - FTime0;
403  FDeltaAngulo = 360. * FRegimen / 60. * FDeltaT;
404  FAnguloAnterior = FAnguloActual;
405  FAnguloActual = FAnguloAnterior + FDeltaAngulo;
406  if(FAnguloActual > 720.) {
407  FAnguloActual -= 720.;
408  }
409  dynamic_cast<TValvulaContr*>(FValvula)->CalculaCD(FAnguloActual, mfcomb);
410  break;
411 
412  case nmWasteGate:
413  if(FTuboExtremo[0].TipoExtremo == nmLeft) {
414  NodoFin = 0;
415  } else
416  NodoFin = FTuboExtremo[0].Pipe->getNin() - 1;
417  PTub = FTuboExtremo[0].Pipe->GetPresion(NodoFin);
418  PVol = FDeposito->getPressure();
419  nodoadm = dynamic_cast<TWasteGate*>(FValvula)->getNodoAdm();
420  distancia = dynamic_cast<TWasteGate*>(FValvula)->getDist();
421  p1 = dynamic_cast<TWasteGate*>(FValvula)->getTuboAdm()->GetPresion(nodoadm);
422  p2 = dynamic_cast<TWasteGate*>(FValvula)->getTuboAdm()->GetPresion(nodoadm + 1);
423  PAdm = Interpola(p1, p2, 1.0, distancia);
424  dynamic_cast<TWasteGate*>(FValvula)->CalculaCD(PAdm, PTub, PVol, FTuboExtremo[0].Pipe->getTime1());
425  break;
426 
427  case nmCalcExtern:
428  dynamic_cast<TCDExterno*>(FValvula)->CalculaCD();
429  break;
430 
431  case nmMariposa:
432  dynamic_cast<TMariposa*>(FValvula)->CalculaCD(TiempoActual);
433  break;
434  }
435 
436  FCDEntrada = FValvula->getCDTubVol();
437  FCDEntrada = FValvula->getCDTubVol();
438  FCDSalida = FValvula->getCDVolTub();
439  FCTorbellino = FValvula->getCTorb();
440  if(FCDEntrada > 1.) {
441  FValvula->AsignaCRecuperacion(FCDEntrada - 1.);
442  } else
443  FValvula->AsignaCRecuperacion(0.);
444 
445  if(FCDEntrada > 2.0 || FCDEntrada < 0.0) {
446  printf("ERROR: TCCDeposito::CalculaCoeficientesDescarga, en calculo coeficiente descarga entrante: %lf, en %lf grados,en la condicion de contorno: %d \n",
447  FCDEntrada, FAnguloActual,
448  FNumeroCC);
449  throw Exception(
450  "ERROR: TCCDeposito::CalculaCoeficientesDescarga en calculo coeficiente descarga entrante: " + std::to_string(
451  FCDEntrada) + ", en " + std::to_string(FAnguloActual) + " grados ");
452 
453  }
454  if(FCDSalida > 1.0 || FCDSalida < 0.0) {
455  printf("ERROR: TCCDeposito::CalculaCoeficientesDescarga, en calculo coeficiente descarga saliente: %lf, en %lf grados, en la condicion de contorno: %d\n",
456  FCDSalida, FAnguloActual,
457  FNumeroCC);
458  throw Exception(
459  "ERROR: TCCDeposito::CalculaCoeficientesDescarga en calculo coeficiente descarga saliente: " + std::to_string(
460  FCDSalida) + ", en " + std::to_string(FAnguloActual) + " grados ");
461  }
462  } catch(exception & N) {
463  std::cout << "ERROR: TCCDeposito::CalculaCoeficientesDescarga en la condicion de contorno: " << FNumeroCC << std::endl;
464  std::cout << "Tipo de error: " << N.what() << std::endl;
465  throw Exception(N.what());
466  }
467 }
468 
469 // ---------------------------------------------------------------------------
470 // ---------------------------------------------------------------------------
471 
472 void TCCDeposito::IniciaGamma() {
473  try {
474 
475  if(!FUnionDPF) {
476  FRMezcla = FTuboExtremo[0].Pipe->GetRMezcla(FNodoFin);
477  FGamma = FTuboExtremo[0].Pipe->GetGamma(FNodoFin);
478  FSeccionTubo = __geom::Circle_area(FTuboExtremo[0].Pipe->GetDiametro(FNodoFin));
479  } else {
480 #ifdef ParticulateFilter
481  FRMezcla = FTuboExtremo[0].DPF->GetCanal(FTuboExtremo[0].NumeroHaz,
482  FTuboExtremo[0].TipoCanal)->GetRMezcla(FNodoFin);
483  FGamma = FTuboExtremo[0].DPF->GetCanal(FTuboExtremo[0].NumeroHaz,
484  FTuboExtremo[0].TipoCanal)->GetGamma(FNodoFin);
485  FSeccionTubo = __geom::Circle_area(
486  FTuboExtremo[0].DPF->GetCanal(
487  FTuboExtremo[0].NumeroHaz,
488  FTuboExtremo[0].TipoCanal)->GetDiametro(
489  FNodoFin));
490 #endif
491  }
492  FSeccionValvula = FSeccionTubo;
493 
494  } catch(exception & N) {
495  std::cout << "ERROR: TCCDeposito::CalculaCondicionContorno en la condicion de contorno: " << FNumeroCC << std::endl;
496  std::cout << "Tipo de error: " << N.what() << std::endl;
497  throw Exception(N.what());
498  }
499 }
500 
501 // ---------------------------------------------------------------------------
502 // ---------------------------------------------------------------------------
503 
504 void TCCDeposito::CalculaCondicionContorno(double Time) {
505  try {
506  double rel_CCon_Entropia, FraccionMasicaAcum = 0.;
507 
508  if(!FUnionDPF) {
509  FGamma = FTuboExtremo[0].Pipe->GetGamma(FNodoFin);
510  } else {
511 #ifdef ParticulateFilter
512  FGamma = FTuboExtremo[0].DPF->GetCanal(FTuboExtremo[0].NumeroHaz, FTuboExtremo[0].TipoCanal)->GetGamma(FNodoFin);
513 #endif
514  }
515  FGamma1 = __Gamma::G1(FGamma);
516  FGamma2 = __Gamma::G2(FGamma);
517  FGamma3 = __Gamma::G3(FGamma);
518  FGamma4 = __Gamma::G4(FGamma);
519  FGamma5 = __Gamma::G5(FGamma);
520  FGamma6 = __Gamma::G6(FGamma);
521 
522  FAd = pow(FDeposito->getPressure() / FPref, 1. / FGamma4);
523  rel_CCon_Entropia = *FCC / FTuboExtremo[0].Entropia;
524  FAdCr = FAd / sqrt(1 + pow2(FMachVenturi) * FGamma3); // Importante solo si hay venturi.
525  // Si no es asi, no modifica el valor de Ad.
526  if(rel_CCon_Entropia / FAdCr > 1 + 1e-5) { // Flujo entrante al deposito
527  FValvula->GetCDin(Time);
528  FCDEntrada = FValvula->getCDTubVol();
529  FSentidoFlujo = nmEntrante;
530  if(FCDEntrada > 0.0001) { /* Abierto */
531  if(FCDEntrada <= 1.0) {
532  FSeccionEficaz = FCDEntrada * FSeccionValvula;
533  FlujoEntranteDeposito();
534  } else { /* Recuperacion de la energia cinetica */
535  FEDRecuperacionEnergiaCinetica();
536  }
537 
538  // Transporte de especies quimicas.
539  for(int j = 0; j < FNumeroEspecies - 2; j++) {
540  if(!FUnionDPF) {
541  FFraccionMasicaEspecie[j] = FTuboExtremo[0].Pipe->GetFraccionMasicaCC(FIndiceCC, j);
542  } else {
543 #ifdef ParticulateFilter
544  FFraccionMasicaEspecie[j] = FTuboExtremo[0].DPF->GetCanal(FTuboExtremo[0].NumeroHaz,
545  FTuboExtremo[0].TipoCanal)->GetFraccionMasicaCC(FIndiceCC, j);
546 #endif
547  }
548  FraccionMasicaAcum += FFraccionMasicaEspecie[j];
549  }
550  FFraccionMasicaEspecie[FNumeroEspecies - 2] = 1. - FraccionMasicaAcum;
551  if(!FUnionDPF) {
552  if(FHayEGR)
553  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FTuboExtremo[0].Pipe->GetFraccionMasicaCC(FIndiceCC, FNumeroEspecies - 1);
554  } else {
555 #ifdef ParticulateFilter
556  if(FHayEGR) FFraccionMasicaEspecie[FNumeroEspecies - 1] = FTuboExtremo[0].DPF->GetCanal(FTuboExtremo[0].NumeroHaz,
557  FTuboExtremo[0].TipoCanal)->GetFraccionMasicaCC(FIndiceCC, FNumeroEspecies - 1);
558 #endif
559  }
560  } else { /* Cerrado */
561  *FCD = *FCC;
562  FGasto = 0.;
563  FVelocity = 0.;
564  FSonido = *FCC;
565  // La composicion se mantiene, al estar el deposito cerrado.
566  }
567  } else if(rel_CCon_Entropia / FAdCr < 1 - 1e-5) { // Flujo saliente del deposito
568  FSentidoFlujo = nmSaliente;
569  FValvula->GetCDout(Time);
570  FCDSalida = FValvula->getCDVolTub();
571  if(FCDSalida > 0.0001) { /* Abierto */
572  // double TmpAa=FTuboExtremo[0].Entropia; // nuevo para ver que pasa
573  FSeccionEficaz = FCDSalida * FSeccionValvula;
574  if(FDeposito->getTipoDeposito() == nmUnionDireccional) {
575  FValvula->AsignaCDVolTub(FCDSalida);
576  }
577  FlujoSalienteDeposito();
578 
579  // Transporte de especies quimicas.
580  for(int j = 0; j < FNumeroEspecies - 2; j++) {
581  FFraccionMasicaEspecie[j] = FDeposito->GetFraccionMasicaEspecie(j);
582  FraccionMasicaAcum += FFraccionMasicaEspecie[j];
583  }
584  FFraccionMasicaEspecie[FNumeroEspecies - 2] = 1. - FraccionMasicaAcum;
585  if(FHayEGR)
586  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FDeposito->GetFraccionMasicaEspecie(FNumeroEspecies - 1);
587  // } // nuevo para ver que pasa
588  } else { /* Cerrado */
589  *FCD = *FCC;
590  FGasto = 0.;
591  FVelocity = 0.;
592  FSonido = *FCC;
593  // La composicion se mantiene, al estar el deposito cerrado.
594  }
595  } else { // Flujo Parado
596  FSentidoFlujo = nmParado;
597  *FCD = *FCC;
598  FGasto = 0.;
599  FVelocity = 0.;
600  FSonido = *FCC;
601  // La composicion se mantiene, al estar el flujo parado.
602  }
603  FValvula->AcumulaCDMedio(Time);
604  } catch(exception & N) {
605  std::cout << "ERROR: TCCDeposito::CalculaCondicionContorno en la condicion de contorno: " << FNumeroCC << std::endl;
606  std::cout << "Tipo de error: " << N.what() << std::endl;
607  throw Exception(N.what());
608  }
609 }
610 
611 // ---------------------------------------------------------------------------
612 // ---------------------------------------------------------------------------
613 
614 void TCCDeposito::FEDRecuperacionEnergiaCinetica() {
615  try {
616  double xaa2 = 0., ed = 0., ei = 0., a1 = 0., a2supuesta = 0.;
617 
618  ed = *FCC;
619  ei = *FCC * 2. / FGamma2;
620  a2supuesta = ei; // Se suponen condiciones sonicas.
621 
622  stRecover FA2(FTuboExtremo[0].Entropia, FAdCr, FGamma, FValvula->getCRecuperacion(), *FCC);
623  double error = FA2(a2supuesta);
624 
625  if(error > 0) {
626  FSonido = FindRoot(FA2, ed, ei);
627  FVelocity = FA2.U2;
628  FVelocidadGarganta = FA2.UThroat;
629  a1 = FA2.A1;
630  } else {
631  FVelocity = 0.9999 * ei;
632  FSonido = FA2.A2_2;
633  FVelocidadGarganta = FA2.UThroat;
634  a1 = FA2.A1;
635  }
636 
637  xaa2 = pow(FTuboExtremo[0].Entropia, FGamma4);
638  *FCD = FSonido - FGamma3 * FVelocity;
639  *FCC = FSonido + FGamma3 * FVelocity;
640  FGasto = __units::BarToPa(-FGamma * FSeccionTubo * pow(FSonido,
641  2 * FGamma6) * FVelocity) / (__cons::ARef * xaa2); // Massflow entrante al deposito negativo.
642  FRelacionPresionGarganta = pow(FSonido / (FTuboExtremo[0].Entropia * FAdCr), FGamma4);
643  FGastoGarganta = FGasto / (FValvula->getCRecuperacion() * FSeccionValvula);
644  FMachGarganta = FVelocidadGarganta / a1; // En valor absoluto.
645 
646  } catch(exception & N) {
647  std::cout << "ERROR: TCCDeposito::FEDRecuperacionEnergiaCinetica en la condicion de contorno: " << FNumeroCC <<
648  std::endl;
649  std::cout << "Tipo de error: " << N.what() << std::endl;
650  throw Exception(N.what());
651  }
652 }
653 
654 // ---------------------------------------------------------------------------
655 // ---------------------------------------------------------------------------
656 
657 void TCCDeposito::FlujoEntranteDeposito() {
658  try {
659  double vel_son_garganta = 0., velocidad_garganta = 0., Mach = 0., xaa2 = 0., ycal = 0., d1 = 0.;
660 
661  Fk = FSeccionTubo / FSeccionEficaz;
662  if(Fk < 1)
663  Fk = 1.0;
664  vel_son_garganta = FTuboExtremo[0].Entropia * FAdCr;
665  // Velocity del sonido en la garganta. Adimensional.
666 
667  // Calculo de la velocidad en la garganta.Caso de salto subcritico.
668  FCaso = nmFlujoEntranteSaltoSubcritico;
669  if(Fk == 1) {
670  FSonido = FTuboExtremo[0].Entropia * FAdCr;
671  FVelocity = (*FCC - FSonido) / FGamma3;
672  } else
673  Resolucion(vel_son_garganta, *FCC, FCaso, &FVelocity, &FSonido);
674 
675  // Ecuacion de la energia
676  velocidad_garganta = sqrt(2. * FGamma6 * (pow2(FSonido) + FGamma3 * pow2(FVelocity) - pow2(vel_son_garganta)));
677  // Se ha calculado la velocidad en la garganta en valor absoluto.
678 
679  // Calculo de la velocidad en la garganta en el caso de salto supercritico
680  if(velocidad_garganta > vel_son_garganta) {
681  FCaso = nmFlujoEntranteSaltoSupercritico;
682  Resolucion(0.0, 1.0, FCaso, &ycal, &Mach);
683  FVelocity = *FCC / (1 / Mach + FGamma3);
684  FSonido = FVelocity / Mach;
685 
686  d1 = Fk * FVelocity * pow(FSonido, 1. / FGamma3);
687  vel_son_garganta = pow(d1, FGamma1 / FGamma2);
688  velocidad_garganta = vel_son_garganta;
689  }
690  // Fin caso de salto supercritico
691 
692  xaa2 = pow(FTuboExtremo[0].Entropia, FGamma4);
693  FGasto = __units::BarToPa(-FGamma * FSeccionTubo * pow(FSonido,
694  2 * FGamma6) * FVelocity) / (__cons::ARef * xaa2); // Massflow entrante al deposito negativo
695  *FCD = FSonido - FGamma3 * FVelocity;
696  *FCC = FSonido + FGamma3 * FVelocity;
697  FRelacionPresionGarganta = pow(FSonido / (FTuboExtremo[0].Entropia * FAdCr), FGamma4);
698  FGastoGarganta = FGasto / (FCDEntrada * FSeccionValvula);
699  FMachGarganta = velocidad_garganta / vel_son_garganta;
700  // En valor absoluto.Antes tenia signo.
701  FVelocidadGarganta = velocidad_garganta;
702 
703  }
704 
705  catch(exception & N) {
706  std::cout << "ERROR: TCCDeposito::FlujoEntranteDeposito en la condicion de contorno: " << FNumeroCC << std::endl;
707  std::cout << "Tipo de error: " << N.what() << std::endl;
708  throw Exception(N.what());
709  }
710 }
711 
712 // ---------------------------------------------------------------------------
713 // ---------------------------------------------------------------------------
714 
715 void TCCDeposito::FlujoSalienteDeposito() {
716  try {
717 
718  double a1 = 0., xx = 0., yy = 0., d1 = 0.;
719  double a2cr = 0., val1 = 0., val2 = 0., u2cr = 0., ycal = 0., error = 0., valde = 0., miembro2 = 0.;
720  // Variables para resolver la onda de choque.
721  double relacion_velocidades_son, Mach_tras_ondachoque, Mach, temp_antes_ondachoque, temp_tras_ondachoque;
722 
723  Fk = FSeccionTubo / FSeccionEficaz;
724  if(Fk < 1)
725  Fk = 1;
726 
727  /* Calculo del valor de la velocidad del sonido en el extremo del tubo para
728  el cual el salto es critico. */
729  u2cr = FDeposito->getSpeedsound() * sqrt(2. / FGamma2) * (sqrt(pow2(Fk) + FGamma1 * FGamma2) - Fk) / FGamma1;
730  a2cr = sqrt(pow2(FDeposito->getSpeedsound()) - FGamma3 * pow2(u2cr));
731  // Ecuacion de la energia. Garganta-Deposito.
732 
733  /* A partir de a2cr se determina el error en el calculo de A2 al suponer salto
734  subcritico. Si es negativo, el salto es supercritico. Si es positivo, el salto
735  es subcritico. */
736  // FSSubcritico(a2cr,&error,&miembro2);
737  stFSSub FSA2(FTuboExtremo[0].Entropia, FAdCr, FGamma, Fk, *FCC, FDeposito->getSpeedsound());
738 
739  error = FSA2(a2cr);
740 
741  if(error < 0.) { // Salto de presiones supercritico.
742 
743  /* Determinacion del intervalo de iteracion. Para ello se supone que
744  en el extremo del tubo se dan las condiciones criticas. Explicado en
745  los apuntes de Pedro. */
746  a1 = sqrt(2. / FGamma2) * FDeposito->getSpeedsound();
747  FVelocidadGarganta = a1;
748  xx = pow(FAdCr / FDeposito->getSpeedsound(), FGamma4);
749  yy = pow(a1, 2. / FGamma1);
750  Fcc = FVelocidadGarganta * yy * xx / Fk;
751 
752  stFSSup FU2(FTuboExtremo[0].Entropia, Fcc, FGamma, Fk, *FCC, FDeposito->getSpeedsound());
753  val1 = FU2(FVelocidadGarganta);
754 
755  // FSSupercritico(FVelocidadGarganta,&val1,&val2);
756  if(val1 < 0.)
757  valde = FVelocidadGarganta;
758  if(val1 >= 0.) {
759  double Epsilon = numeric_limits<double>::epsilon();
760  valde = FDeposito->getSpeedsound() / sqrt(FGamma3) - Epsilon;
761  }
762 
763  /* Una vez conocido el intervalo de iteracion, se pasa a la resolucion
764  del caso flujo saliente salto supercritico. */
765  FCaso = nmFlujoSalienteSaltoSupercritico;
766  Resolucion(0.0, valde, FCaso, &FVelocity, &FSonido);
767 
768  // Calcula del massflow. Como es saliente del deposito, siempre es positivo.
769  xx = pow(sqrt(2. / FGamma2), (FGamma2 / FGamma1));
770  yy = pow(FAdCr, FGamma4);
771  FGasto = __units::BarToPa(FCDSalida * FSeccionValvula * FGamma * xx * yy) / (FDeposito->getSpeedsound() * __cons::ARef);
772 
773  /* Reduccion a flujo subsonico mediante onda de choque plana en el caso
774  de que se hayan obtenido condiciones supersonicas en el extremo del
775  tubo. Explicado en la tesis Corberan (pagina de la 47 a la 52
776  (punto 2.5) y de la 122 a la 129 (lo importante a partir de la 127) */
777  Mach = FVelocity / FSonido;
778  xx = *FCC + FGamma3 * FVelocity;
779  FTuboExtremo[0].Entropia = FTuboExtremo[0].Entropia * FSonido / xx;
780  // Ecuacion de la caracteristica incidente.
781  if(Mach > 1.) {
782 
783  /* Las ecuaciones siguientes corresponden a la resolucion de la onda
784  de choque plana. Se pueden encontrar en el punto 2.5 de la tesis
785  de Corberan. */
786  xx = FGamma4 * pow2(Mach) - 1.;
787  Mach_tras_ondachoque = sqrt((pow2(Mach) + 2. / FGamma1) / xx);
788  temp_tras_ondachoque = FGamma3 * pow2(Mach) + 1.;
789  temp_antes_ondachoque = FGamma3 * pow2(Mach_tras_ondachoque) + 1.;
790  relacion_velocidades_son = sqrt(temp_tras_ondachoque / temp_antes_ondachoque);
791  FSonido = FSonido * relacion_velocidades_son;
792  FVelocity = FSonido * Mach_tras_ondachoque;
793  d1 = xx * FGamma1 / FGamma2;
794  FTuboExtremo[0].Entropia = FTuboExtremo[0].Entropia * relacion_velocidades_son / pow(d1, FGamma5);
795  }
796  } else { // Salto de presiones subcritico.
797 
798  // Resolucion del caso de flujo saliente salto subcritico.
799  FCaso = nmFlujoSalienteSaltoSubcritico;
800  Resolucion(a2cr, FDeposito->getSpeedsound(), FCaso, &ycal, &FSonido);
801  // Aplicando la Ecuacion de la Energia entre el deposito y la garganta:
802  FVelocity = sqrt((pow2(FDeposito->getSpeedsound()) - pow2(FSonido)) / FGamma3);
803 
804  // Calculo del massflow. Como es saliente del deposito, siempre es positivo.
805  a1 = FDeposito->getSpeedsound() * (*FCC + FGamma3 * FVelocity) / (FTuboExtremo[0].Entropia * FAd);
806  FVelocidadGarganta = Fk * pow2(a1) * FVelocity / pow2(FSonido);
807  FGasto = __units::BarToPa(FCDSalida * FSeccionValvula * FGamma * pow(FAd / FDeposito->getSpeedsound(),
808  FGamma4) * FVelocidadGarganta * pow(a1, 2. / FGamma1)) / __cons::ARef;
809  xx = *FCC + FGamma3 * FVelocity;
810  FTuboExtremo[0].Entropia = FTuboExtremo[0].Entropia * FSonido / xx;
811  // Ecuacion de la caracteristica incidente.
812  }
813  *FCD = FSonido + FGamma3 * FVelocity;
814  *FCC = FSonido - FGamma3 * FVelocity;
815  d1 = FSonido / (FTuboExtremo[0].Entropia * FAdCr);
816  FRelacionPresionGarganta = pow(d1, FGamma4);
817  FMachGarganta = FVelocidadGarganta / a1; // En valor absoluto.
818  FGastoGarganta = FGasto / (FCDSalida * FSeccionValvula);
819  } catch(exception & N) {
820  std::cout << "ERROR: TCCDeposito::FlujoSalienteDeposito en la condicion de contorno: " << FNumeroCC << std::endl;
821  std::cout << "Tipo de error: " << N.what() << std::endl;
822  throw Exception(N.what());
823  }
824 }
825 // ---------------------------------------------------------------------------
826 // ---------------------------------------------------------------------------
827 
828 void TCCDeposito::Resolucion(double ext1, double ext2, nmCaso Caso, double *u2t, double *a2t) {
829  try {
830  /* std::cout << FNumeroCC << std::endl;
831  if(FNumeroCC==26){
832  std::cout << "peta";
833  } */
834 
835  if(Caso == nmFlujoEntranteSaltoSubcritico) {
836  stFESub FEA2(FTuboExtremo[0].Entropia, FAdCr, FGamma, Fk, *FCC);
837  *a2t = FindRoot(FEA2, ext1, ext2);
838  *u2t = FEA2.U2;
839  } else if(Caso == nmFlujoEntranteSaltoSupercritico) {
840  stFESup FMatch(FGamma, Fk);
841  *a2t = FindRoot(FMatch, ext1, ext2);
842  *u2t = 0.;
843  } else if(Caso == nmFlujoSalienteSaltoSubcritico) {
844  stFSSub FSA2(FTuboExtremo[0].Entropia, FAdCr, FGamma, Fk, *FCC, FDeposito->getSpeedsound());
845  *a2t = FindRoot(FSA2, ext1, ext2);
846  *u2t = FSA2.U2;
847  } else if(Caso == nmFlujoSalienteSaltoSupercritico) {
848  stFSSup FU2(FTuboExtremo[0].Entropia, Fcc, FGamma, Fk, *FCC, FDeposito->getSpeedsound());
849  *u2t = FindRoot(FU2, ext1, ext2);
850  *a2t = FU2.A2;
851  } else {
852  printf("Error en la definicion del flujo TCCDeposito::Resolucion en la condicion de contorno: %d\n", FNumeroCC);
853  throw Exception("");
854  }
855  }
856 
857  catch(exception & N) {
858  std::cout << "ERROR: TCCDeposito::Resolucion en la condicion de contorno: " << FNumeroCC << std::endl;
859  std::cout << "Tipo de error: " << N.what() << std::endl;
860  throw Exception(N.what());
861  }
862 }
863 
866 //
867 // void TCCDeposito::FESubcritico(double vel_son_supuesta,double *u2_1,double *u2_2)
868 // {
869 // try
870 // {
871 //
872 // double xx,yy;
873 //
874 // /* Resolucion de la ecuacion (20) del articulo "Solucion a la condicion de
875 // contorno de la union cilindro-conducto de los MCIA". Ecuacion 4.30 en la
876 // tesis de Corberan */
877 //
878 // xx=vel_son_supuesta/(FTuboExtremo[0].Entropia*FAdCr);
879 // yy=pow(xx,4.*FGamma6);
880 // yy=pow(Fk,2.)*yy-1.;
881 // *u2_2=FTuboExtremo[0].Entropia*FAdCr*sqrt(2.*FGamma6*(pow(xx,2.)-1.)/yy); // Valor absoluto
882 //
883 //
884 // /* Resolucion de la ecuacion de la caracteristica incidente. */
885 //
886 // *u2_1=(*FCC-vel_son_supuesta)/FGamma3; // En valor absoluto
887 //
888 //
889 //
890 // }
891 // catch(Exception &N)
892 // {
893 // std::cout << "ERROR: TCCDeposito::FESubcritico en la condicion de contorno: " << FNumeroCC << std::endl;
894 // std::cout << "Tipo de error: " << N.what() << std::endl;
895 // throw Exception(N.what());
896 // }
897 // }
898 //
901 //
902 // void TCCDeposito::FESupercritico(double mach_supuesto,double *miembro1,
903 // double *miembro2)
904 // {
905 // try
906 // {
907 //
908 // double xx,yy;
909 //
910 // /* Resolucion de la ecuacion (21) del articulo "Solucion a la condicion de
911 // contorno de la union cilindro-conducto de los MCIA". Ecuacion (4.31) de
912 // la tesis de Corberan */
913 //
914 // yy=(FGamma2/2.)*pow(Fk*mach_supuesto,2.*FGamma1/FGamma2);
915 // xx=FGamma3*pow(mach_supuesto,2);
916 // *miembro1=xx-yy+1.; // Miembro 1 de la ecuacion (21)
917 // *miembro2=0; // Miembro 2 de la ecuacion (21)
918 //
919 // }
920 // catch(Exception &N)
921 // {
922 // std::cout << "ERROR: TCCDeposito::FESupercritico en la condicion de contorno: " << FNumeroCC << std::endl;
923 // std::cout << "Tipo de error: " << N.what() << std::endl;
924 // throw Exception(N.what());
925 // }
926 // }
927 //
930 //
931 // void TCCDeposito::FSSubcritico(double vel_son_supuesta,double *error,double *miembro2)
932 // {
933 // try
934 // {
935 // double a1,u1,u2;
936 //
937 // *miembro2=0;
938 //
939 // /* Resolucion del algoritmo de calculo propuesto en la pagina 113 de la tesis
940 // de Corberan. */
941 //
942 // u2 = sqrt((pow(FDeposito->getSpeedsound(),2)-pow(vel_son_supuesta,2))/FGamma3);
943 // a1 = FDeposito->getSpeedsound()*(*FCC+FGamma3*u2)/(FTuboExtremo[0].Entropia*FAdCr);
944 // u1 = Fk*u2*pow(a1,2)/pow(vel_son_supuesta,2);
945 // *error=pow(a1,2)+FGamma3*pow(u1,2)-pow(FDeposito->getSpeedsound(),2);
946 //
947 // }
948 // catch(Exception &N)
949 // {
950 // std::cout << "ERROR: TCCDeposito::FSSubcritico en la condicion de contorno: " << FNumeroCC << std::endl;
951 // std::cout << "Tipo de error: " << N.what() << std::endl;
952 // throw Exception(N.what());
953 // }
954 // }
955 //
958 //
959 // void TCCDeposito::FSSupercritico(double vel_supuesta,double *a2_1,double *a2_2)
960 // {
961 // try
962 // {
963 //
964 // // Resolucion de la ecuacion de la energia entre el deposito y el extremo del tubo.
965 // *a2_1 = sqrt(pow(FDeposito->getSpeedsound(),2)-FGamma3*pow(vel_supuesta,2));
966 //
967 // // Resolucion de la ecuacion 4.20 de la tesis de Corberan.
968 // *a2_2 = sqrt(vel_supuesta*pow((*FCC+FGamma3*vel_supuesta)/
969 // FTuboExtremo[0].Entropia,FGamma4)/Fcc);
970 //
971 // }
972 // catch(Exception &N)
973 // {
974 // std::cout << "ERROR: TCCDeposito::FSSupercritico en la condicion de contorno: " << FNumeroCC << std::endl;
975 // std::cout << "Tipo de error: " << N.what() << std::endl;
976 // throw Exception(N.what());
977 // }
978 // }
979 //
982 
983 #pragma package(smart_init)
stRecover
Definition: BoundaryFunctions.h:162
TRotorTurbina
Definition: TRotorTurbina.h:48
TTubo
a Finite differences pipe.
Definition: TTubo.h:116
TTubo::GetGamma
double GetGamma(int i) const
Gets the specific heat capacities ratio at a given cell.
Definition: TTubo.cpp:5444
FindRoot
double FindRoot(T &func, const double x1, const double x2)
Finds the root of a function.
Definition: Math_wam.h:459
stFESub
Definition: BoundaryFunctions.h:37
stTuboExtremo
Definition: Globales.h:730
TTipoValvula
Definition: TTipoValvula.h:53
TDPF
Definition: TDPF.h:45
TWasteGate
Definition: TWasteGate.h:47
TValvulaContr
Definition: TValvulaContr.h:46
TTubo::GetFraccionMasicaCC
double GetFraccionMasicaCC(int j, int i)
Definition: TTubo.h:953
TLamina
Definition: TLamina.h:50
TTubo::GetFraccionMasicaInicial
double GetFraccionMasicaInicial(int i) const
Gets the initial mass fraction of species i.
Definition: TTubo.cpp:5440
TTubo::GetPresion
double GetPresion(int i) const
Gets the fluid pressure.
Definition: TTubo.cpp:5468
TCondicionContorno
Definition: TCondicionContorno.h:54
stFESup
Definition: BoundaryFunctions.h:70
TCDFijo
Definition: TCDFijo.h:43
TDeposito
Definition: TDeposito.h:44
TMariposa
Definition: TMariposa.h:43
TValvula4T
Definition: TValvula4T.h:45
stFSSub
Definition: BoundaryFunctions.h:93
Exception
Custom exception class.
Definition: Exception.hpp:39
TDiscoRotativo
Definition: TDiscoRotativo.h:44
TLumbrera
Definition: TLumbrera.h:45
TTubo.h
TEstatorTurbina
Definition: TEstatorTurbina.h:47
pow2
T pow2(T x)
Returns x to the power of 2.
Definition: Math_wam.h:88
TCDExterno
Definition: TCDExterno.h:43
TDepVolVariable
Definition: TDepVolVariable.h:35
TTubo::GetRMezcla
double GetRMezcla(int i) const
Gets the gas constant of the mixture at a given cell.
Definition: TTubo.cpp:5476
stFSSup
Definition: BoundaryFunctions.h:125