OpenWAM
TCCCompresorVolumetrico.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 "TCCCompresorVolumetrico.h"
32 //#include <cmath>
33 #include <iostream>
34 #include "TTubo.h"
35 
36 //---------------------------------------------------------------------------
37 //---------------------------------------------------------------------------
38 
39 TCCCompresorVolumetrico::TCCCompresorVolumetrico(nmTypeBC TipoCC, int numCC, nmTipoCalculoEspecies SpeciesModel,
40  int numeroespecies, nmCalculoGamma GammaCalculation, bool ThereIsEGR) :
41  TCondicionContorno(TipoCC, numCC, SpeciesModel, numeroespecies, GammaCalculation, ThereIsEGR) {
42 
43  FTuboExtremo = NULL;
44  asgNumeroCV = false;
45 
46  FResMediosCV.Potencia = false;
47  FResMediosCV.Massflow = false;
48  FResMediosCV.Pressure = false;
49 
50  FResInstantCV.Potencia = false;
51  FResInstantCV.Massflow = false;
52  FResInstantCV.Pressure = false;
53 
54  FComposicion = NULL;
55 
56 }
57 
58 //---------------------------------------------------------------------------
59 //---------------------------------------------------------------------------
60 
61 TCCCompresorVolumetrico::~TCCCompresorVolumetrico() {
62 
63  delete[] FTuboExtremo;
64  if(FComposicion != NULL)
65  delete[] FComposicion;
66 
67 }
68 
69 //---------------------------------------------------------------------------
70 //---------------------------------------------------------------------------
71 
72 void TCCCompresorVolumetrico::LeeCCCompresorVol(const char *FileWAM, fpos_t &filepos, int NumberOfPipes, TTubo **Pipe,
73  bool HayMotor) {
74  try {
75  int i = 0, ControlRegimen;
76  double fracciontotal = 0.;
77 
78  FTuboExtremo = new stTuboExtremo[1];
79  FTuboExtremo[0].Pipe = NULL;
80 
81  while(FNumeroTubosCC < 1 && i < NumberOfPipes) {
82  if(Pipe[i]->getNodoIzq() == FNumeroCC) {
83  FTuboExtremo[FNumeroTubosCC].Pipe = Pipe[i];
84  FTuboExtremo[FNumeroTubosCC].TipoExtremo = nmLeft;
85  FNodoFin = 0;
86  FIndiceCC = 0;
87  FCC = &(FTuboExtremo[FNumeroTubosCC].Beta);
88  FCD = &(FTuboExtremo[FNumeroTubosCC].Landa);
89  FSeccionTubo = __geom::Circle_area(Pipe[i]->GetDiametro(FNodoFin));
90  FNumeroTubosCC++;
91  }
92  if(Pipe[i]->getNodoDer() == FNumeroCC) {
93  FTuboExtremo[FNumeroTubosCC].Pipe = Pipe[i];
94  FTuboExtremo[FNumeroTubosCC].TipoExtremo = nmRight;
95  FNodoFin = Pipe[i]->getNin() - 1;
96  FIndiceCC = 1;
97  FCC = &(FTuboExtremo[FNumeroTubosCC].Landa);
98  FCD = &(FTuboExtremo[FNumeroTubosCC].Beta);
99  FSeccionTubo = __geom::Circle_area(Pipe[i]->GetDiametro(FNodoFin));
100  FNumeroTubosCC++;
101  }
102  i++;
103  }
104 
105  FILE *fich = fopen(FileWAM, "r");
106  fsetpos(fich, &filepos);
107 
108  fscanf(fich, "%d ", &ControlRegimen);
109 
110  switch(ControlRegimen) {
111  case 0:
112  FControlRegimen = nmPropio;
113  break;
114  case 1:
115  FControlRegimen = nmMotor;
116  break;
117  }
118 
119  if(FControlRegimen == nmPropio) {
120  fscanf(fich, "%lf ", &FRegimen);
121  FRelacionVelocidadesCV = 1.;
122  } else if(FControlRegimen == nmMotor && HayMotor) {
123  fscanf(fich, "%lf ", &FRelacionVelocidadesCV);
124  } else {
125  std::cout <<
126  "ERROR: TCCCompresorVolumetrico::LeeCCDeposito Lectura del Control del Regimen erronea en la condicion de contorno: " <<
127  FNumeroCC << std::endl;
128  throw Exception(" ");
129  }
130 
131  fscanf(fich, "%lf %lf ", &FPresionCV, &FTemperaturaCV);
132  fscanf(fich, "%lf %lf %lf ", &FC1Caudal, &FC2Caudal, &FC3Caudal);
133  fscanf(fich, "%lf %lf %lf ", &FC1Temperatura, &FC2Temperatura, &FC3Temperatura);
134  fscanf(fich, "%lf %lf %lf ", &FC1Potencia, &FC2Potencia, &FC3Potencia);
135  fscanf(fich, "%lf %lf %lf ", &FC4Potencia, &FC5Potencia, &FC6Potencia);
136 
137 // Inicializacion del transporte de especies quimicas.
138  FFraccionMasicaEspecie = new double[FNumeroEspecies - FIntEGR];
139  FComposicion = new double[FNumeroEspecies - FIntEGR];
140  for(int i = 0; i < FNumeroEspecies - 1; i++) {
141  fscanf(fich, "%lf ", &FComposicion[i]);
142  FFraccionMasicaEspecie[i] = FTuboExtremo[0].Pipe->GetFraccionMasicaInicial(i);
143  fracciontotal += FComposicion[i];
144  }
145  if(FHayEGR) {
146  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FTuboExtremo[0].Pipe->GetFraccionMasicaInicial(FNumeroEspecies - 1);
147  if(FCalculoEspecies == nmCalculoCompleto) {
148  if(FComposicion[0] > 0.2)
149  FComposicion[FNumeroEspecies - 1] = 0.;
150  else
151  FComposicion[FNumeroEspecies - 1] = 1.;
152  } else {
153  if(FComposicion[0] > 0.5)
154  FComposicion[FNumeroEspecies - 1] = 1.;
155  else
156  FComposicion[FNumeroEspecies - 1] = 0.;
157  }
158  }
159  if(fracciontotal != 1.) {
160  std::cout <<
161  "ERROR: La fraccion masica total no puede ser distinta de 1. Repasa la lectura en la condicion de contorno " <<
162  FNumeroCC << std::endl;
163  throw Exception(" ");
164  }
165 
166  fgetpos(fich, &filepos);
167  fclose(fich);
168 
169  }
170 
171  catch(exception &N) {
172  std::cout << "ERROR: TCCCompresorVolumetrico::LeeCCCompresorVol en la condicion de contorno: " << FNumeroCC <<
173  std::endl;
174  std::cout << "Tipo de error: " << N.what() << std::endl;
175  throw Exception(N.what());
176  }
177 }
178 
179 //---------------------------------------------------------------------------
180 //---------------------------------------------------------------------------
181 
182 void TCCCompresorVolumetrico::ObtencionValoresInstantaneos(double RegimenMotor) {
183  try {
184 
185  FPressure = FTuboExtremo[FNumeroTubosCC - 1].Pipe->GetPresion(FNodoFin);
186  if(FControlRegimen == nmMotor) {
187  FRegimen = RegimenMotor;
188  }
189 
190  } catch(exception &N) {
191  std::cout << "ERROR: TCCCompresorVolumetrico::ObtencionValoresInstantaneos en la condicion de contorno: " << FNumeroCC
192  << std::endl;
193  std::cout << "Tipo de error: " << N.what() << std::endl;
194  throw Exception(N.what());
195  }
196 }
197 
198 //---------------------------------------------------------------------------
199 //---------------------------------------------------------------------------
200 
202  try {
203  double ei, ed, massflow, entropia, FraccionMasicaAcum = 0.;
204  int cd = 0;
205 
206  FGamma = FTuboExtremo[0].Pipe->GetGamma(FNodoFin);
207  FRMezcla = FTuboExtremo[0].Pipe->GetRMezcla(FNodoFin);
208  FGamma3 = __Gamma::G3(FGamma);
209  FGamma4 = __Gamma::G4(FGamma);
210 
211  /* Calculo del massflow volumetrico (l/s) */
212  massflow = FC1Caudal + FC2Caudal * FPressure + FC3Caudal * FRelacionVelocidadesCV * FRegimen;
213 
214  /* Calculo del massflow masico (kg/s) */
215  FDensidad = __units::BarToPa(FPresionCV) / (FRMezcla * __units::degCToK(FTemperaturaCV));
216  FGasto = massflow * FDensidad / 1000.;
217 
218  /* Temperature del gas entrante en grados centigrados */
219  FTemperature = FC1Temperatura * pow2(FPressure) + FC2Temperatura * FPressure + FC3Temperatura;
220 
221  /* Velocity del sonido en el tubo */
222  FSonido = sqrt(FGamma * __units::degCToK(FTemperature) * FRMezcla) / __cons::ARef;
223 
224  /* Potencia */
225  FPotencia = FC1Potencia * pow3(FPressure) + FC2Potencia * pow2(FPressure) + FC3Potencia * FPressure + FC4Potencia +
226  FC5Potencia * exp(FC6Potencia * FRelacionVelocidadesCV * FRegimen);
227 
229  ei = 0;
230  ed = FSonido;
231 
232  stComprVol CV(FTuboExtremo[0].Entropia, *FCC, FGamma, FSonido, FGasto, FSeccionTubo, __cons::PRef, __cons::ARef);
233  FVelocity = FindRoot(CV, ei, ed);
234 
235  /* printf("ERROR: TCCCompresorVolumetrico::CalculaCondicionContorno No hay convergencia en el compresor volumetrico en la condicion de contorno: %d.\n",FNumeroCC);
236  printf("Repasar los datos. El compresor esta en condiciones supersonicas.\n");
237  throw Exception("ERROR: TCCCompresorVolumetrico::CalculaCondicionContorno No hay convergencia en el compresor volumetrico.");*/
238 
239  /* Obtencion de las variables de Riemann */ // Tal y como esta planteada esta BC, el flujo siempre sera entrante al tubo.
240  FTuboExtremo[0].Entropia = CV.entropia;
241  *FCC = FSonido - FGamma3 * FVelocity;
242  *FCD = FSonido + FGamma3 * FVelocity;
243 
244 // Transporte de Especies Quimicas
245  if(*FCC > *FCD) { // Flujo saliente del tubo
246  for(int j = 0; j < FNumeroEspecies - 2; j++) {
247  FFraccionMasicaEspecie[j] = FTuboExtremo[0].Pipe->GetFraccionMasicaCC(FIndiceCC, j);
248  FraccionMasicaAcum += FFraccionMasicaEspecie[j];
249  }
250  FFraccionMasicaEspecie[FNumeroEspecies - 2] = 1. - FraccionMasicaAcum;
251  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FTuboExtremo[0].Pipe->GetFraccionMasicaCC(FIndiceCC, FNumeroEspecies - 1);
252  } else if(*FCD > *FCC) { // Flujo entrante al tubo
253  for(int j = 0; j < FNumeroEspecies - FIntEGR; j++) {
254  FFraccionMasicaEspecie[j] = FComposicion[j];
255  }
256  }
257  /* La ultima opcion es que *FCC=*FCD. En este caso el flujo esta parado y la fraccion masica
258  de las especies permanece constante en dicho instante */
259 
260  AcumulaResultadosMediosCV(Time);
261 
262  } catch(exception &N) {
263  std::cout << "ERROR: TCCCompresorVolumetrico::CalculaCondicionContorno en la condicion de contorno: " << FNumeroCC <<
264  std::endl;
265  std::cout << "Tipo de error: " << N.what() << std::endl;
266  throw Exception(N.what());
267  }
268 }
269 
270 //---------------------------------------------------------------------------
271 //---------------------------------------------------------------------------
272 
273 //void TCCCompresorVolumetrico::PutNumeroCV(int valor)
274 //{
275 //try
276 //{
277 //if(!asgNumeroCV){
278 // FNumeroCV=valor;
279 // asgNumeroCV=true;
280 //}else{
281 // std::cout << "ERROR: Este Compressor Volumetrico ya tiene numero asignado" << std::endl;
282 // throw Exception("");
283 //}
284 //}
285 //catch(Exception &N)
286 //{
287 //std::cout << "ERROR: TCCCompresorVolumetrico::PutNumeroCV en la BC " << FNumeroCC << std::endl;
288 //std::cout << "Tipo de error: " << N.what() << std::endl;
289 //throw Exception(N.what());
290 //}
291 //}
292 
293 //---------------------------------------------------------------------------
294 //---------------------------------------------------------------------------
295 
296 void TCCCompresorVolumetrico::ReadAverageResultsCV(const char *FileWAM, fpos_t &filepos) {
297  try {
298  int nvars = 0, var = 0;
299 
300  FILE *fich = fopen(FileWAM, "r");
301  fsetpos(fich, &filepos);
302 
303  fscanf(fich, "%d ", &nvars);
304  for(int i = 0; i < nvars; i++) {
305  fscanf(fich, "%d ", &var);
306  switch(var) {
307  case 0:
308  FResMediosCV.Potencia = true;
309  break;
310  case 1:
311  FResMediosCV.Massflow = true;
312  break;
313  case 2:
314  FResMediosCV.Pressure = true;
315  break;
316  default:
317  std::cout << "Resultados medios en CV(BC) " << FNumeroCC << " no implementados " << std::endl;
318  }
319  }
320 
321  fgetpos(fich, &filepos);
322  fclose(fich);
323  } catch(exception &N) {
324  std::cout << "ERROR: TCCCompresorVolumetrico::ReadAverageResultsCV en la BC " << FNumeroCC << std::endl;
325  std::cout << "Tipo de error: " << N.what() << std::endl;
326  throw Exception(N.what());
327  }
328 }
329 
330 //---------------------------------------------------------------------------
331 //---------------------------------------------------------------------------
332 
333 void TCCCompresorVolumetrico::CabeceraResultadosMedCV(stringstream& medoutput) {
334  try {
335 //FILE *fich=fopen(FileSALIDA,"a");
336 
337  std::string Label;
338 
339  if(FResMediosCV.Potencia) {
340  Label = "\t" + PutLabel(401) + std::to_string(FNumeroCC) + PutLabel(903);
341  medoutput << Label.c_str();
342  }
343  if(FResMediosCV.Massflow) {
344  Label = "\t" + PutLabel(402) + std::to_string(FNumeroCC) + PutLabel(904);
345  medoutput << Label.c_str();
346  }
347  if(FResMediosCV.Pressure) {
348  Label = "\t" + PutLabel(402) + std::to_string(FNumeroCC) + PutLabel(908);
349  medoutput << Label.c_str();
350  }
351 
352 //fclose(fich);
353  } catch(exception &N) {
354  std::cout << "ERROR: TCCCompresorVolumetrico::CabeceraResultadosMedCV en la BC " << FNumeroCC << std::endl;
355  std::cout << "Tipo de error: " << N.what() << std::endl;
356  throw Exception(N.what());
357  }
358 }
359 
360 //---------------------------------------------------------------------------
361 //---------------------------------------------------------------------------
362 
363 void TCCCompresorVolumetrico::ImprimeResultadosMedCV(stringstream& medoutput) {
364  try {
365 //FILE *fich=fopen(FileSALIDA,"a");
366 
367  if(FResMediosCV.Potencia)
368  medoutput << "\t" << FResMediosCV.PotenciaMED;
369  if(FResMediosCV.Potencia)
370  medoutput << "\t" << FResMediosCV.GastoMED;
371  if(FResMediosCV.Potencia)
372  medoutput << "\t" << FResMediosCV.PresionMED;
373 
374 //fclose(fich);
375  } catch(exception &N) {
376  std::cout << "ERROR: TCCCompresorVolumetrico::ImprimerResultadosMedCV en la BC " << FNumeroCC << std::endl;
377  std::cout << "Tipo de error: " << N.what() << std::endl;
378  throw Exception(N.what());
379  }
380 }
381 
382 //---------------------------------------------------------------------------
383 //---------------------------------------------------------------------------
384 
385 void TCCCompresorVolumetrico::IniciaMedias() {
386  try {
387 
388  FResMediosCV.PotenciaSUM = 0.;
389  FResMediosCV.GastoSUM = 0.;
390  FResMediosCV.PresionSUM = 0.;
391  FResMediosCV.TiempoSUM = 0.;
392  FResMediosCV.Tiempo0 = 0.;
393 
394  } catch(exception &N) {
395  std::cout << "ERROR: TCCCompresorVolumetrico::IniciaMedias en la BC: " << FNumeroCC << std::endl;
396 //std::cout << "Tipo de error: " << N.what() << std::endl;
397  throw Exception(N.what());
398  }
399 }
400 
401 //---------------------------------------------------------------------------
402 //---------------------------------------------------------------------------
403 
404 void TCCCompresorVolumetrico::ResultadosMediosCV() {
405  try {
406  if(FResMediosCV.Potencia) {
407  FResMediosCV.PotenciaMED = FResMediosCV.PotenciaSUM / FResMediosCV.TiempoSUM;
408  FResMediosCV.PotenciaSUM = 0.;
409  }
410  if(FResMediosCV.Massflow) {
411  FResMediosCV.GastoMED = FResMediosCV.GastoSUM / FResMediosCV.TiempoSUM;
412  FResMediosCV.GastoSUM = 0.;
413  }
414  if(FResMediosCV.Pressure) {
415  FResMediosCV.PresionMED = FResMediosCV.PresionSUM / FResMediosCV.TiempoSUM;
416  FResMediosCV.PresionSUM = 0.;
417  }
418  FResMediosCV.TiempoSUM = 0;
419  } catch(exception &N) {
420  std::cout << "ERROR: TCCCompresorVolumetrico::ResultadosMediosCV en la BC: " << FNumeroCC << std::endl;
421  std::cout << "Tipo de error: " << N.what() << std::endl;
422  throw Exception(N.what());
423  }
424 }
425 
426 //---------------------------------------------------------------------------
427 //---------------------------------------------------------------------------
428 
429 void TCCCompresorVolumetrico::AcumulaResultadosMediosCV(double Actual) {
430  try {
431 
432  double Delta = Actual - FResMediosCV.Tiempo0;
433 
434  if(FResMediosCV.Potencia) {
435  FResMediosCV.PotenciaSUM += FPotencia * Delta;
436  }
437  if(FResMediosCV.Massflow) {
438  FResMediosCV.GastoSUM += FGasto * Delta;
439  }
440  if(FResMediosCV.Pressure) {
441  FResMediosCV.PresionSUM += FPressure * Delta;
442  }
443 
444  FResMediosCV.TiempoSUM += Delta;
445  FResMediosCV.Tiempo0 = Delta;
446  } catch(exception &N) {
447  std::cout << "ERROR: TCCCompresorVolumetrico::AcumulaResultadosMediosCV en la BC: " << FNumeroCC << std::endl;
448  std::cout << "Tipo de error: " << N.what() << std::endl;
449  throw Exception(N.what());
450  }
451 }
452 
453 //---------------------------------------------------------------------------
454 //---------------------------------------------------------------------------
455 
456 void TCCCompresorVolumetrico::LeeResultadosInstantCV(const char *FileWAM, fpos_t &filepos) {
457  int nvars = 0, var = 0;
458 
459  try {
460  FILE *fich = fopen(FileWAM, "r");
461  fsetpos(fich, &filepos);
462 
463  fscanf(fich, "%d ", &nvars);
464  for(int i = 0; i < nvars; i++) {
465  fscanf(fich, "%d ", &var);
466  switch(var) {
467  case 0:
468  FResInstantCV.Potencia = true;
469  break;
470  case 1:
471  FResInstantCV.Massflow = true;
472  break;
473  case 2:
474  FResInstantCV.Pressure = true;
475  break;
476  default:
477  std::cout << "Resultados medios en CV(BC) " << FNumeroCC << " no implementados " << std::endl;
478  }
479  }
480  fgetpos(fich, &filepos);
481  fclose(fich);
482  } catch(exception &N) {
483  std::cout << "ERROR: TCCCompresorVolumetrico::LeeResultadosInstantCV en la BC " << FNumeroCC << std::endl;
484  std::cout << "Tipo de error: " << N.what() << std::endl;
485  throw Exception(N.what());
486  }
487 }
488 
489 //---------------------------------------------------------------------------
490 //---------------------------------------------------------------------------
491 
492 void TCCCompresorVolumetrico::CabeceraResultadosInstantCV(stringstream& insoutput) {
493  try {
494 //FILE *fich=fopen(FileSALIDA,"a");
495  std::string Label;
496 
497  if(FResInstantCV.Potencia) {
498  Label = "\t" + PutLabel(401) + std::to_string(FNumeroCC) + PutLabel(903);
499  insoutput << Label.c_str();
500  }
501  if(FResInstantCV.Massflow) {
502  Label = "\t" + PutLabel(402) + std::to_string(FNumeroCC) + PutLabel(904);
503  insoutput << Label.c_str();
504  }
505  if(FResInstantCV.Pressure) {
506  Label = "\t" + PutLabel(403) + std::to_string(FNumeroCC) + PutLabel(908);
507  insoutput << Label.c_str();
508  }
509 //fclose(fich);
510  } catch(exception &N) {
511  std::cout << "ERROR: TCCCompresorVolumetrico::CabeceraResultadosInstantCV en la BC " << FNumeroCC << std::endl;
512  std::cout << "Tipo de error: " << N.what() << std::endl;
513  throw Exception(N.what());
514  }
515 }
516 
517 //---------------------------------------------------------------------------
518 //---------------------------------------------------------------------------
519 
520 void TCCCompresorVolumetrico::ResultadosInstantCV() {
521  try {
522  if(FResInstantCV.Potencia)
523  FResInstantCV.PotenciaINS = FPotencia;
524  if(FResInstantCV.Massflow)
525  FResInstantCV.GastoINS = FGasto;
526  if(FResInstantCV.Pressure)
527  FResInstantCV.PresionINS = FPressure;
528 
529  } catch(exception &N) {
530  std::cout << "ERROR: TCCCompresorVolumetrico::ResultadosInstantCV en la BC " << FNumeroCC << std::endl;
531  std::cout << "Tipo de error: " << N.what() << std::endl;
532  throw Exception(N.what());
533  }
534 }
535 
536 //---------------------------------------------------------------------------
537 //---------------------------------------------------------------------------
538 
539 void TCCCompresorVolumetrico::ImprimeResultadosInstantCV(stringstream& insoutput) {
540  try {
541 //FILE *fich=fopen(FileSALIDA,"a");
542 
543  if(FResInstantCV.Potencia)
544  insoutput << "\t" << FResInstantCV.PotenciaINS;
545  if(FResInstantCV.Massflow)
546  insoutput << "\t" << FResInstantCV.GastoINS;
547  if(FResInstantCV.Pressure)
548  insoutput << "\t" << FResInstantCV.PresionINS;
549 
550 //fclose(fich);
551  } catch(exception &N) {
552  std::cout << "ERROR: TCCCompresorVolumetrico::ImprimeResultadosInstantCV en la BC " << FNumeroCC << std::endl;
553  std::cout << "Tipo de error: " << N.what() << std::endl;
554  throw Exception(N.what());
555  }
556 }
557 
558 //---------------------------------------------------------------------------
559 //---------------------------------------------------------------------------
560 
561 #pragma package(smart_init)
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
pow3
T pow3(T x)
Returns x to the power of 3.
Definition: Math_wam.h:101
stTuboExtremo
Definition: Globales.h:730
stComprVol
Definition: BoundaryFunctions.h:439
TTubo::GetFraccionMasicaCC
double GetFraccionMasicaCC(int j, int i)
Definition: TTubo.h:953
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
PutLabel
std::string PutLabel(int idx)
Returns an integer.
Definition: labels.cpp:475
Exception
Custom exception class.
Definition: Exception.hpp:39
TTubo.h
pow2
T pow2(T x)
Returns x to the power of 2.
Definition: Math_wam.h:88
TTubo::GetRMezcla
double GetRMezcla(int i) const
Gets the gas constant of the mixture at a given cell.
Definition: TTubo.cpp:5476
TCCCompresorVolumetrico::CalculaCondicionContorno
void CalculaCondicionContorno(double Time)
Definition: TCCCompresorVolumetrico.cpp:201