OpenWAM
TTurbinaSimple.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 "TTurbinaSimple.h"
32 
33 #include "TCondicionContorno.h"
34 #include "TCCDeposito.h"
35 #include "TRotorTurbina.h"
36 #include "TEstatorTurbina.h"
37 #include "TTubo.h"
38 
39 // ---------------------------------------------------------------------------
40 // ---------------------------------------------------------------------------
41 
42 TTurbinaSimple::TTurbinaSimple(int i, nmTipoCalculoEspecies SpeciesModel, int numeroespecies,
43  nmCalculoGamma GammaCalculation, bool ThereIsEGR) :
44  TTurbina(i, nmTurbinaSimple, 1, SpeciesModel, numeroespecies, GammaCalculation, ThereIsEGR) {
45 
46  FTime = 0.;
47 
48  FResMediosTurbina.RelaCinematicaMED = new double[FNumeroEntradas];
49  FResMediosTurbina.GastoCorregidoMED = new double[FNumeroEntradas];
50  FResMediosTurbina.GastoCorregidoSUM = new double[FNumeroEntradas];
51  FResMediosTurbina.RegimenCorregidoMED = new double[FNumeroEntradas];
52  FResMediosTurbina.RegimenCorregidoSUM = new double[FNumeroEntradas];
53  FResMediosTurbina.RelacionExpansionMED = new double[FNumeroEntradas];
54  FResMediosTurbina.RelacionExpansionSUM = new double[FNumeroEntradas];
55 
56  FResMediosTurbina.Trabajo = false;
57  FResMediosTurbina.Rendimiento = false;
58  FResMediosTurbina.RelaCinematica = false;
59  FResMediosTurbina.GastoCorregido = false;
60  FResMediosTurbina.RegimenCorregido = false;
61  FResMediosTurbina.RelacionExpansion = false;
62 
63  FResInstantTurbina.RelaCinematicaINS = new double[FNumeroEntradas];
64  FResInstantTurbina.GastoCorregidoINS = new double[FNumeroEntradas];
65  FResInstantTurbina.RegimenCorregidoINS = new double[FNumeroEntradas];
66  FResInstantTurbina.RelacionExpansionINS = new double[FNumeroEntradas];
67 
68  FResInstantTurbina.Potencia = false;
69  FResInstantTurbina.Rendimiento = false;
70  FResInstantTurbina.RelaCinematica = false;
71  FResInstantTurbina.GastoCorregido = false;
72  FResInstantTurbina.RegimenCorregido = false;
73  FResInstantTurbina.RelacionExpansion = false;
74 
75  FResInstantTurbina.GastoCorregido = false;
76  FResInstantTurbina.RegimenCorregido = false;
77 
78  for(int i = 0; i < FNumeroEntradas; i++) {
79  FResMediosTurbina.RelaCinematicaMED[i] = 0.;
80  FResMediosTurbina.GastoCorregidoMED[i] = 0.;
81  FResMediosTurbina.GastoCorregidoSUM[i] = 0.;
82  FResMediosTurbina.RegimenCorregidoMED[i] = 0.;
83  FResMediosTurbina.RegimenCorregidoSUM[i] = 0.;
84  FResMediosTurbina.RelacionExpansionMED[i] = 0.;
85  FResMediosTurbina.RelacionExpansionSUM[i] = 0.;
86  FResInstantTurbina.RelaCinematicaINS[i] = 0.;
87  FResInstantTurbina.GastoCorregidoINS[i] = 0.;
88  FResInstantTurbina.RegimenCorregidoINS[i] = 0.;
89  FResInstantTurbina.RelacionExpansionINS[i] = 0.;
90  }
91 
92 }
93 
94 // ---------------------------------------------------------------------------
95 // ---------------------------------------------------------------------------
96 
97 TTurbinaSimple::~TTurbinaSimple() {
98 
99 }
100 
101 // ---------------------------------------------------------------------------
102 // ---------------------------------------------------------------------------
103 
104 void TTurbinaSimple::AsignaEntradaSalidaCC() {
105  try {
106 
107  FCCEntrada = new TCondicionContorno*[FNumeroEntradas];
108  FCCSalida = new TCondicionContorno*[1];
109  for(int i = 0; i < FNumeroUniones; i++) {
110  if(dynamic_cast<TCCDeposito*>(FCCDeposito[i])->getValvula()->getTypeOfValve() == nmStator) {
111  FCCEntrada[0] = FCCDeposito[i];
112  } else if(dynamic_cast<TCCDeposito*>(FCCDeposito[i])->getValvula()->getTypeOfValve() == nmRotor) {
113  FCCSalida[0] = FCCDeposito[i];
114  }
115  }
116 
117  dynamic_cast<TEstatorTurbina*>(dynamic_cast<TCCDeposito*>(FCCEntrada[0])->getValvula())->AsignaTurbina(FNumeroTurbina,
118  0);
119  dynamic_cast<TRotorTurbina*>(dynamic_cast<TCCDeposito*>(FCCSalida[0])->getValvula())->AsignaTurbina(FNumeroTurbina);
120 
121  if(FTipoTurbina == nmFixedTurbine) {
122  dynamic_cast<TEstatorTurbina*>(dynamic_cast<TCCDeposito*>(FCCEntrada[0])->getValvula())->TipodeEstator(nmStFijo);
123  dynamic_cast<TRotorTurbina*>(dynamic_cast<TCCDeposito*>(FCCSalida[0])->getValvula())->TipodeRotor(nmRotFijo);
124  } else if(FTipoTurbina == nmTurbineMap) {
125  dynamic_cast<TEstatorTurbina*>(dynamic_cast<TCCDeposito*>(FCCEntrada[0])->getValvula())->TipodeEstator(nmStMapa);
126  dynamic_cast<TRotorTurbina*>(dynamic_cast<TCCDeposito*>(FCCSalida[0])->getValvula())->TipodeRotor(nmRotMapa);
127  } else {
128  dynamic_cast<TEstatorTurbina*>(dynamic_cast<TCCDeposito*>(FCCEntrada[0])->getValvula())->TipodeEstator(nmStVariable);
129  dynamic_cast<TRotorTurbina*>(dynamic_cast<TCCDeposito*>(FCCSalida[0])->getValvula())->TipodeRotor(nmRotVariable);
130  }
131 
132  } catch(exception & N) {
133  std::cout << "ERROR: TTurbinaSimple::AsignaEntradaSalidaCC en la turbina " << FNumeroTurbina << std::endl;
134  std::cout << "Tipo de error: " << N.what() << std::endl;
135  throw Exception(N.what());
136  }
137 }
138 
139 // ---------------------------------------------------------------------------
140 // ---------------------------------------------------------------------------
141 
142 void TTurbinaSimple::CalculaCondicionTurbina(double TimeCalculo) {
143 
144  double cpte, cpts /* ,gammaent,gammasal,cvte,cvts,Rentrada,Rsalida */;
145  // double B,Cte_R,A;
146  double TempIsentSal = 0.;
147  double DeltaT = 0.;
148  double incrRelCin = 0.;
149  double Landa = 0., Beta = 0., Entropia = 0.;
150  int SentidoSalida = -1, SentidoEntrada = 1;
151  double dd = 0., b = 0., c = 0., d = 0.;
152  int NumberOfPipes = 0;
153  double gam_med = 0.;
154  double gam_te = 0.;
155  double cp_med = 0.;
156 
157  try {
158 
159  DeltaT = TimeCalculo - FTimeTurbina;
160  FTimeTurbina = TimeCalculo;
161 
162  if(DeltaT > 0) {
163 
164  FTrabajoIsenInstTotal = 0.;
165 
166  // Calculo de las propiedades del gas a la salida
167 #ifndef tchtm
168  Landa = FCCSalida[0]->GetTuboExtremo(0).Landa;
169  Beta = FCCSalida[0]->GetTuboExtremo(0).Beta;
170  Entropia = FCCSalida[0]->GetTuboExtremo(0).Entropia;
171 
172  TransformaContorno(&Landa, &Beta, &Entropia, &FAsonidoSalida, &FVelocidadSalida, &FPresionSalida, 1,
173  FCCSalida[0]->getGamma());
174 
175  if(dynamic_cast<TCCDeposito*>(FCCSalida[0])->getSentidoFlujo() == nmEntrante) {
176  SentidoSalida = 1;
177  } else if(dynamic_cast<TCCDeposito*>(FCCSalida[0])->getSentidoFlujo() == nmSaliente) {
178  SentidoSalida = -1;
179  } else
180  SentidoSalida = 0; /* Flujo parado */
181 
182  FTempSalida = pow2(FAsonidoSalida * __cons::ARef) / (FCCSalida[0]->getGamma() * FCCSalida[0]->getR());
183  FVelocidadSalida *= __cons::ARef * SentidoSalida;
184  FRhoSalida = __units::BarToPa(FPresionSalida) / FTempSalida / FCCSalida[0]->getR();
185 
186  FGastoSalida = FRhoSalida * FVelocidadSalida * dynamic_cast<TCCDeposito*>(FCCSalida[0])->getSeccionTubo();
187 
188  // Calculo de las propiedades a la entrada
189 
190  Landa = FCCEntrada[0]->GetTuboExtremo(0).Landa;
191  Beta = FCCEntrada[0]->GetTuboExtremo(0).Beta;
192  Entropia = FCCEntrada[0]->GetTuboExtremo(0).Entropia;
193 
194  TransformaContorno(&Landa, &Beta, &Entropia, &FAsonidoEntrada[0], &FVelocidadEntrada[0], &FPresionEntrada[0], 1,
195  FCCEntrada[0]->getGamma());
196 
197  if(dynamic_cast<TCCDeposito*>(FCCEntrada[0])->getSentidoFlujo() == nmEntrante) {
198  SentidoEntrada = 1;
199  } else if(dynamic_cast<TCCDeposito*>(FCCEntrada[0])->getSentidoFlujo() == nmSaliente) {
200  SentidoEntrada = -1;
201  } else
202  SentidoEntrada = 0; /* Flujo parado */
203  FTempEntrada[0] = pow2(FAsonidoEntrada[0] * __cons::ARef) / (FCCEntrada[0]->getGamma() * FCCEntrada[0]->getR());
204  // Esta en Kelvin
205 
206  FVelocidadEntrada[0] = FVelocidadEntrada[0] * __cons::ARef * SentidoEntrada;
207  FRhoEntrada[0] = __units::BarToPa(FPresionEntrada[0]) / FTempEntrada[0] / FCCEntrada[0]->getR();
208  FGastoEntrada[0] = FRhoEntrada[0] * FVelocidadEntrada[0] * dynamic_cast<TCCDeposito*>(FCCEntrada[0])->getSeccionTubo();
209 
210 #endif
211 
212 #ifdef tchtm
213  FTempEntrada[0] = FAcTurb->T3();
214  FPresionEntrada[0] = FAcTurb->P3();
215 
216  FGastoEntrada[0] = FAcTurb->MassIn();
217 
218  FTempSalida = FAcTurb->T4();
219  FPresionSalida = FAcTurb->P4();
220 
221 #endif
222 
223  // ------------------------------------------------------------------------------
224  // Calculo de la temperatura isentropica del gas a la salida de la turbina,
225  // a partir del transporte de especies.
226  // ------------------------------------------------------------------------------
227 
228  if(FCalculoEspecies == nmCalculoCompleto) {
229  cpte = CpTurbineComplete(FFraccionMasicaEspecie[0], FFraccionMasicaEspecie[1], FFraccionMasicaEspecie[2],
230  FTempEntrada[0]);
231  } else {
232  cpte = CpTurbineSimple(FTempEntrada[0], FFraccionMasicaEspecie[0]);
233  }
234  gam_te = cpte / (cpte - FRMezcla);
235 
236 #ifndef tchtm
237 
238  FTemp0Entrada[0] = FTempEntrada[0] + pow2(FVelocidadEntrada[0]) / (2. * cpte);
239  FPresion0Entrada[0] = FPresionEntrada[0] * pow(FTemp0Entrada[0] / FTempEntrada[0], (gam_te / (gam_te - 1.0)));
240 
241 #endif
242 
243 #ifdef tchtm
244 
245  if(fabs(FGastoEntrada[0]) > 1e-10) {
246 
247  if(FTempEntrada[0] < FHTM->NodeTemperature(10)) {
248 
249  FTempEntrada[0] = FTempEntrada[0] - FHTM->Turb_Heat_Flow()
250  / cpte / FGastoEntrada[0];
251 
252  } else {
253 
254  FTempEntrada[0] = FTempEntrada[0] - FHTM->Turb_Heat_Flow()
255  / cpte / FGastoEntrada[0];
256  // comprobacion para pasos iniciales.
257  if(FTempEntrada[0] < FHTM->NodeTemperature(10))
258  FTempEntrada[0] = FHTM->NodeTemperature(10);
259  }
260  }
261 
262  FVelocidadEntrada[0] = FGastoEntrada[0] * FRMezcla * FTempEntrada
263  [0] / (__units::BarToPa(FPresionEntrada[0]) * FAcTurb->SIn());
264 
265  FTemp0Entrada[0] = FTempEntrada[0] + pow2(FVelocidadEntrada[0]) /
266  (2. * cpte);
267  FPresion0Entrada[0] = FPresionEntrada[0] * pow
268  (FTemp0Entrada[0] / FTempEntrada[0],
269  (gam_te / (gam_te - 1.0)));
270 
271 #endif
272 
273  FGastoCorregido[0] = FGastoEntrada[0] * sqrt(FTemp0Entrada[0]) / FPresion0Entrada[0] / 0.1;
274  FRegimenCorregido[0] = FRegimen / sqrt(FTemp0Entrada[0]);
275 
276  if(FCalculoEspecies == nmCalculoCompleto) {
277  cp_med = CpTurbineComplete(FFraccionMasicaEspecie[0], FFraccionMasicaEspecie[1], FFraccionMasicaEspecie[2],
278  (FTempEntrada[0] + FTempSalida) / 2.);
279  } else {
280  cp_med = CpTurbineSimple((FTempEntrada[0] + FTempSalida) / 2., FFraccionMasicaEspecie[0]);
281  }
282  gam_med = cpte / (cpte - FRMezcla);
283 
284  TempIsentSal = FTemp0Entrada[0] * pow(FPresionSalida / FPresion0Entrada[0], ((gam_med - 1.0) / gam_med));
285 
286  if(FCalculoEspecies == nmCalculoCompleto) {
287  cp_med = CpTurbineComplete(FFraccionMasicaEspecie[0], FFraccionMasicaEspecie[1], FFraccionMasicaEspecie[2],
288  (FTempEntrada[0] + TempIsentSal) / 2.);
289  } else {
290  cp_med = CpTurbineSimple((FTempEntrada[0] + TempIsentSal) / 2., FFraccionMasicaEspecie[0]);
291  }
292 
293  FEntalpia0Entrada[0] = cp_med * FTemp0Entrada[0];
294  double EntalEntr = cp_med * FTempEntrada[0];
295  FEntalpiaIsenSalida[0] = cp_med * TempIsentSal;
296 
297  FRelacionExpansion[0] = FPresion0Entrada[0] / FPresionSalida;
298 
299  // Calculo de la posicion de la turbina
300 
301  if(FTipoTurbina == nmTurbineMap) {
302  if(FRackIsControlled) {
303  FRack = FRackController->Output(FTime);
304  }
305 
306  FMapa->CurrentEffectiveSection(FRegimenCorregido[0] / 60., FRelacionExpansion[0], FRack,
307  __units::degCToK(FTemperature) / FTemp0Entrada[0]);
308 
309  dynamic_cast<TEstatorTurbina*>(dynamic_cast<TCCDeposito*>(FCCEntrada[0])->getValvula())->PutAreaEff(FMapa->StatorEF());
310  dynamic_cast<TRotorTurbina*>(dynamic_cast<TCCDeposito*>(FCCSalida[0])->getValvula())->PutAreaEff(FMapa->RotorEF());
311 
312  }
313 
314  // Calculo del rendimiento de la turbina
315 
316  if((FGastoEntrada[0] > 0.) && (FEntalpia0Entrada[0] - FEntalpiaIsenSalida[0]) >= 0.) {
317 
318  if((FEntalpia0Entrada[0] - FEntalpiaIsenSalida[0]) > 0.) {
319  FRelacionCinematica[0] = __units::RPMToRPS(FRegimen) * __cons::Pi * FDiametroRodete / sqrt(2 *
320  (FEntalpia0Entrada[0] - FEntalpiaIsenSalida[0]));
321  } else {
322  FRelacionCinematica[0] = 0.;
323  }
324  if(FCalRendTurbina == nmWatson) {
325  if(FRelacionCinematica[0] <= 0 || FRelacionCinematica[0] >= 1.19) {
326  FRendTurbina[0] = 0;
327  } else {
328  FRendTurbina[0] = 0.004022 + FRelacionCinematica[0] * (1.55766 + FRelacionCinematica[0] *
329  (-0.511626 + FRelacionCinematica[0] * (-0.121795 - 0.445804 * FRelacionCinematica[0])));
330  }
331  } else if(FCalRendTurbina == nmPolinomio) {
332  if(FRelacionCinematica[0] >= FRcmaxima || FRelacionCinematica[0] <= 0) {
333  FRendTurbina[0] = 0.;
334  } else {
335  dd = 2. * pow3(FRcoptima) * pow2(FRcmaxima) - pow2(FRcoptima) * pow3(FRcmaxima) - pow4(FRcoptima) * FRcmaxima;
336  b = FRendmaximo * (3. * pow2(FRcmaxima) * pow2(FRcoptima) - 2 * pow3(FRcmaxima) * FRcoptima) / dd;
337  c = FRendmaximo * (pow3(FRcmaxima) - 3. * FRcmaxima * pow2(FRcoptima)) / dd;
338  d = FRendmaximo * (2. * FRcmaxima * FRcoptima - pow2(FRcmaxima)) / dd;
339 
340  FRendTurbina[0] = b * FRelacionCinematica[0] + c * pow2(FRelacionCinematica[0]) + d * pow3(FRelacionCinematica[0]);
341  }
342  } else if(FCalRendTurbina == nmCalcExtRD) {
343  // Todavia no esta hecha la asignacion de FNumeroTurbinaTGV
344  if(FDatosTGV[FNumeroTurbinaTGV].Rendimiento[0] < 0) {
345  FRendTurbina[0] = 0.;
346  } else {
347  FRendTurbina[0] = FDatosTGV[FNumeroTurbinaTGV].Rendimiento[0];
348  }
349  } else if(FCalRendTurbina == nmRendMapa) {
350  // FRendTurbina=FMapa->
351  // FCCEntrada[0]->
352  FRendTurbina[0] = FMapa->EffTurb();
353 
354  } else {
355  std::cout << "ERROR: Calculo del rendimiento de la turbina desconocido " << std::endl;
356  throw Exception("");
357  }
358  FRendTurbina[0] = FRendTurbina[0] * FAjustRendTurb;
359  } else {
360  FRelacionCinematica[0] = 0.;
361  FRendTurbina[0] = 0.;
362  }
363 
364  incrRelCin = 0;
365 
366  FTrabajoIsen = FGastoEntrada[0] * (FEntalpia0Entrada[0] - FEntalpiaIsenSalida[0]) * DeltaT;
367  double TurbWork = FTrabajoIsen * FRendTurbina[0];
368  FTrabajoFluido = TurbWork - FGastoEntrada[0] * (FEntalpia0Entrada[0] - EntalEntr) * DeltaT;
369  FTrabajoReal += TurbWork; // Lo usa para calcular el rendimiento medio
370  FTrabajoRealPaso += TurbWork; // Para el calculo de la potencia del paso.
371  FRendInstantaneo += FRendTurbina[0] * FGastoEntrada[0];
372  incrRelCin += TurbWork * FRelacionCinematica[0];
373 
374  FDeltaPaso += DeltaT;
375 
376  FPotencia = TurbWork / DeltaT;
377  FTrabajoTotal += FTrabajoIsen; // Lo usa para calcular el rendimiento medio
378  FRelacionCinAcum[0] += incrRelCin;
379  FPonderacionRelacionCinematica[0] += TurbWork;
380  }
381 
382  } catch(exception & N) {
383  std::cout << "ERROR: TTurbinaSimple::CalculaCondicionTurbina en la turbina: " << FNumeroTurbina << std::endl;
384  std::cout << "Tipo de error: " << N.what() << std::endl;
385  throw Exception(N.what());
386  }
387 }
388 
389 // ---------------------------------------------------------------------------
390 // ---------------------------------------------------------------------------
391 
392 void TTurbinaSimple::ImprimeResultadosMediosPantalla() {
393  try {
394 
395  printf("TURBINE WORK %d = %6.3lf Julios \n", FNumeroTurbina, FTrabajoReal);
396  if(FTrabajoTotal != 0.) {
397  printf("TURBINE EFFICIENCY %d = %6.3lf \n", FNumeroTurbina, FTrabajoReal / FTrabajoTotal);
398  } else {
399  printf("TURBINE EFFICIENCY %d = %6.3lf \n", FNumeroTurbina, 0.);
400  }
401  if(FTrabajoReal != 0.) {
402  printf("BLADE SPEED RATIO TURB %d= %6.3lf \n", FNumeroTurbina, FRelacionCinAcum[0] / FTrabajoReal);
403  } else {
404  printf("BLADE SPEED RATIO TURB %d= %6.3lf \n", FNumeroTurbina, 0.);
405  }
406 
407  } catch(exception & N) {
408  std::cout << "ERROR: TTurbinaSimple::ImprimeResultadosMediosPantalla en la turbina: " << FNumeroTurbina << std::endl;
409  std::cout << "Tipo de error: " << N.what() << std::endl;
410  throw Exception(N.what());
411  }
412 }
413 
414 // ---------------------------------------------------------------------------
415 // ---------------------------------------------------------------------------
416 
417 void TTurbinaSimple::ReadAverageResultsTurb(const char *FileWAM, fpos_t &filepos) {
418  try {
419  int nvars = 0, var = 0;
420 
421  FILE *fich = fopen(FileWAM, "r");
422  fsetpos(fich, &filepos);
423 
424  fscanf(fich, "%d ", &nvars);
425  for(int i = 0; i < nvars; i++) {
426  fscanf(fich, "%d ", &var);
427  switch(var) {
428  case 0:
429  FResMediosTurbina.Trabajo = true;
430  break;
431  case 1:
432  FResMediosTurbina.Rendimiento = true;
433  break;
434  case 2:
435  FResMediosTurbina.RelaCinematica = true;
436  break;
437  case 3:
438  FResMediosTurbina.GastoCorregido = true;
439  break;
440  case 4:
441  FResMediosTurbina.RegimenCorregido = true;
442  break;
443  case 5:
444  FResMediosTurbina.RelacionExpansion = true;
445  break;
446  default:
447  std::cout << "Resultados medios en turbina " << FNumeroTurbina << " no implementados " << std::endl;
448  }
449  }
450 
451  fgetpos(fich, &filepos);
452  fclose(fich);
453  } catch(exception & N) {
454  std::cout << "ERROR: TTurbinaSimple::ReadAverageResultsTurb en la turbina " << FNumeroTurbina << std::endl;
455  std::cout << "Tipo de error: " << N.what() << std::endl;
456  throw Exception(N.what());
457  }
458 }
459 
460 // ---------------------------------------------------------------------------
461 // ---------------------------------------------------------------------------
462 
463 void TTurbinaSimple::CabeceraResultadosMedTurb(stringstream& medoutput) {
464  try {
465  // FILE *fich=fopen(FileSALIDA,"a");
466  std::string Label;
467 
468  if(FResMediosTurbina.Trabajo) {
469  Label = "\t" + PutLabel(511) + std::to_string(FNumeroTurbina) + PutLabel(907);
470  medoutput << Label.c_str();
471  }
472  if(FResMediosTurbina.Rendimiento) {
473  Label = "\t" + PutLabel(512) + std::to_string(FNumeroTurbina) + PutLabel(901);
474  medoutput << Label.c_str();
475  }
476  if(FResMediosTurbina.RelaCinematica) {
477  for(int i = 0; i < FNumeroEntradas; i++) {
478  Label = "\t" + PutLabel(513) + std::to_string(i + 1) + PutLabel(514) + std::to_string(FNumeroTurbina) + PutLabel(901);
479  medoutput << Label.c_str();
480  }
481  // fprintf(fich,"\tRelacion_cinematica_global_turb_%d(-)",std::to_string(FNumeroTurbina));
482  }
483  if(FResMediosTurbina.GastoCorregido) {
484  for(int i = 0; i < FNumeroEntradas; i++) {
485  Label = "\t" + PutLabel(516) + std::to_string(i + 1) + PutLabel(514) + std::to_string(FNumeroTurbina) + PutLabel(905);
486  medoutput << Label.c_str();
487  }
488  }
489  if(FResMediosTurbina.RegimenCorregido) {
490  for(int i = 0; i < FNumeroEntradas; i++) {
491  Label = "\t" + PutLabel(517) + std::to_string(i + 1) + PutLabel(514) + std::to_string(FNumeroTurbina) + PutLabel(906);
492  medoutput << Label.c_str();
493  }
494  }
495  if(FResMediosTurbina.RelacionExpansion) {
496  for(int i = 0; i < FNumeroEntradas; i++) {
497  Label = "\t" + PutLabel(518) + std::to_string(i + 1) + PutLabel(514) + std::to_string(FNumeroTurbina) + PutLabel(901);
498  medoutput << Label.c_str();
499  }
500  }
501 
502  // fclose(fich);
503  } catch(exception & N) {
504  std::cout << "ERROR: TTurbinaSimple::CabeceraResultadosMedTurb en la turbina " << FNumeroTurbina << std::endl;
505  std::cout << "Tipo de error: " << N.what() << std::endl;
506  throw Exception(N.what());
507  }
508 }
509 
510 // ---------------------------------------------------------------------------
511 // ---------------------------------------------------------------------------
512 
513 void TTurbinaSimple::IniciaMedias() {
514  try {
515 
516  FResMediosTurbina.TiempoSUM = 0.;
517  FResMediosTurbina.TrabajoSUM = 0.;
518  FResMediosTurbina.Tiempo0 = 0.;
519 
520  } catch(exception & N) {
521  std::cout << "ERROR: TTurbinaSimple::IniciaMedias en el turbina: " << FNumeroTurbina << std::endl;
522  std::cout << "Tipo de error: " << N.what() << std::endl;
523  throw Exception("ERROR: TTurbinaSimple::IniciaMedias en el turbina: " + std::to_string(FNumeroTurbina) + N.what());
524  }
525 }
526 
527 // ---------------------------------------------------------------------------
528 // ---------------------------------------------------------------------------
529 
530 void TTurbinaSimple::AcumulaMedias(double Tiempo) {
531  double DeltaT = 0.;
532  try {
533  DeltaT = Tiempo - FResMediosTurbina.Tiempo0;
534  FResMediosTurbina.TiempoSUM += DeltaT;
535  // FResMediosTurbina.TrabajoSUM+=FTrabajoFluido;
536  FResMediosTurbina.TrabajoSUM += FPotencia * DeltaT;
537  FResMediosTurbina.Tiempo0 = Tiempo;
538  for(int i = 0; i < FNumeroEntradas; i++) {
539  if(FResMediosTurbina.GastoCorregido) {
540  FResMediosTurbina.GastoCorregidoSUM[i] += FGastoCorregido[i] * DeltaT;
541  }
542  if(FResMediosTurbina.RegimenCorregido) {
543  FResMediosTurbina.RegimenCorregidoSUM[i] += FRegimenCorregido[i] * DeltaT;
544  }
545  if(FResMediosTurbina.RelacionExpansion) {
546  FResMediosTurbina.RelacionExpansionSUM[i] += FRelacionExpansion[i] * DeltaT;
547  }
548  }
549  } catch(exception & N) {
550  std::cout << "ERROR: TTurbinaSimple::AcumulaMedias en la turbina: " << FNumeroTurbina << std::endl;
551  std::cout << "Tipo de error: " << N.what() << std::endl;
552  throw Exception("ERROR: TTurbinaSimple::AcumulaMedias en la Turbine: " + std::to_string(FNumeroTurbina) + N.what());
553  }
554 }
555 
556 // ---------------------------------------------------------------------------
557 // ---------------------------------------------------------------------------
558 
559 void TTurbinaSimple::ImprimeResultadosMedTurb(stringstream& medoutput) {
560  try {
561  // FILE *fich=fopen(FileSALIDA,"a");
562 
563  if(FResMediosTurbina.Trabajo)
564  medoutput << "\t" << FResMediosTurbina.TrabajoMED;
565  if(FResMediosTurbina.Rendimiento)
566  medoutput << "\t" << FResMediosTurbina.RendimientoMED;
567  if(FResMediosTurbina.RelaCinematica) {
568  for(int i = 0; i < FNumeroEntradas; i++) {
569  medoutput << "\t" << FResMediosTurbina.RelaCinematicaMED[i];
570  }
571  // fprintf(fich,"\t%g",FResMediosTurbina.RelaCinematicaGlobalMED);
572  }
573  if(FResMediosTurbina.GastoCorregido) {
574  for(int i = 0; i < FNumeroEntradas; i++) {
575  medoutput << "\t" << FResMediosTurbina.GastoCorregidoMED[i];
576  }
577  }
578  if(FResMediosTurbina.RegimenCorregido) {
579  for(int i = 0; i < FNumeroEntradas; i++) {
580  medoutput << "\t" << FResMediosTurbina.RegimenCorregidoMED[i];
581  }
582  }
583  if(FResMediosTurbina.RelacionExpansion) {
584  for(int i = 0; i < FNumeroEntradas; i++) {
585  medoutput << "\t" << FResMediosTurbina.RelacionExpansionMED[i];
586  }
587  }
588 
589  // fclose(fich);
590  } catch(exception & N) {
591  std::cout << "ERROR: TTurbinaSimple::ImprimerResultadosMedTurb en la turbina " << FNumeroTurbina << std::endl;
592  std::cout << "Tipo de error: " << N.what() << std::endl;
593  throw Exception(N.what());
594  }
595 }
596 
597 // ---------------------------------------------------------------------------
598 // ---------------------------------------------------------------------------
599 
600 void TTurbinaSimple::CalculaResultadosMediosTurb() {
601  try {
602 
603  if(FResMediosTurbina.Trabajo) {
604  FResMediosTurbina.TrabajoMED = FResMediosTurbina.TrabajoSUM;
605  }
606  if(FResMediosTurbina.Rendimiento) {
607  if(FTrabajoTotal != 0.) {
608  FResMediosTurbina.RendimientoMED = FTrabajoReal / FTrabajoTotal;
609  } else {
610  FResMediosTurbina.RendimientoMED = 0.;
611  }
612  }
613  if(FResMediosTurbina.RelaCinematica) {
614  for(int i = 0; i < FNumeroEntradas; i++) {
615  FResMediosTurbina.RelaCinematicaMED[i] = FRelacionCinAcum[i] / FPonderacionRelacionCinematica[i];
616  }
617  /* if(FTrabajoReal!=0.){
618  FResMediosTurbina.RelaCinematicaGlobalMED=FRelacionCinGlobalAcum/FTrabajoReal;
619  }else{
620  FResMediosTurbina.RelaCinematicaGlobalMED=0.;
621  } */
622  }
623  if(FResMediosTurbina.GastoCorregido) {
624  for(int i = 0; i < FNumeroEntradas; i++) {
625  FResMediosTurbina.GastoCorregidoMED[i] = FResMediosTurbina.GastoCorregidoSUM[i] / FResMediosTurbina.TiempoSUM;
626  }
627  }
628  if(FResMediosTurbina.RegimenCorregido) {
629  for(int i = 0; i < FNumeroEntradas; i++) {
630  FResMediosTurbina.RegimenCorregidoMED[i] = FResMediosTurbina.RegimenCorregidoSUM[i] / FResMediosTurbina.TiempoSUM;
631  }
632  }
633  if(FResMediosTurbina.RelacionExpansion) {
634  for(int i = 0; i < FNumeroEntradas; i++) {
635  FResMediosTurbina.RelacionExpansionMED[i] = FResMediosTurbina.RelacionExpansionSUM[i] / FResMediosTurbina.TiempoSUM;
636  }
637  }
638 
639  for(int i = 0; i < FNumeroEntradas; i++) {
640  FRelacionCinAcum[i] = 0.;
641  FResMediosTurbina.GastoCorregidoSUM[i] = 0.;
642  FResMediosTurbina.RegimenCorregidoSUM[i] = 0.;
643  FResMediosTurbina.RelacionExpansionSUM[i] = 0.;
644  FPonderacionRelacionCinematica[i] = 0.;
645  }
646 
647  FTrabajoReal = 0.;
648  FTrabajoTotal = 0.;
649  FResMediosTurbina.TrabajoSUM = 0.;
650  FResMediosTurbina.TiempoSUM = 0.;
651 
652  } catch(exception & N) {
653  std::cout << "ERROR: TTurbinaSimple::CalculaResultadosMediosTurb en la turbina " << FNumeroTurbina << std::endl;
654  std::cout << "Tipo de error: " << N.what() << std::endl;
655  throw Exception(N.what());
656  }
657 }
658 
659 // ---------------------------------------------------------------------------
660 // ---------------------------------------------------------------------------
661 
662 void TTurbinaSimple::LeeResultadosInstantTurb(const char *FileWAM, fpos_t &filepos) {
663  int nvars = 0, var = 0;
664 
665  try {
666  FILE *fich = fopen(FileWAM, "r");
667  fsetpos(fich, &filepos);
668 
669  fscanf(fich, "%d ", &nvars);
670  for(int i = 0; i < nvars; i++) {
671  fscanf(fich, "%d ", &var);
672  switch(var) {
673  case 0:
674  FResInstantTurbina.Potencia = true;
675  break;
676  case 1:
677  FResInstantTurbina.Rendimiento = true;
678  break;
679  case 2:
680  FResInstantTurbina.RelaCinematica = true;
681  break;
682  case 3:
683  FResInstantTurbina.GastoCorregido = true;
684  break;
685  case 4:
686  FResInstantTurbina.RegimenCorregido = true;
687  break;
688  case 5:
689  FResInstantTurbina.RelacionExpansion = true;
690  break;
691  default:
692  std::cout << "Instantaneous results in turbine " << FNumeroTurbina << " are not implemented " << std::endl;
693  }
694  }
695  fgetpos(fich, &filepos);
696  fclose(fich);
697  } catch(exception & N) {
698  std::cout << "ERROR: TTurbinaSimple::LeeResultadosInstantTurb en la turbina " << FNumeroTurbina << std::endl;
699  std::cout << "Tipo de error: " << N.what() << std::endl;
700  throw Exception(N.what());
701  }
702 }
703 
704 // ---------------------------------------------------------------------------
705 // ---------------------------------------------------------------------------
706 
707 void TTurbinaSimple::CabeceraResultadosInstantTurb(stringstream& insoutput) {
708  try {
709  // FILE *fich=fopen(FileSALIDA,"a");
710  std::string Label;
711 
712  if(FResInstantTurbina.Potencia) {
713  Label = "\t" + PutLabel(519) + std::to_string(FNumeroTurbina) + PutLabel(903);
714  insoutput << Label.c_str();
715  }
716  if(FResInstantTurbina.Rendimiento) {
717  Label = "\t" + PutLabel(512) + std::to_string(FNumeroTurbina) + PutLabel(901);
718  insoutput << Label.c_str();
719  }
720  if(FResInstantTurbina.RelaCinematica) {
721  for(int i = 0; i < FNumeroEntradas; i++) {
722  Label = "\t" + PutLabel(513) + std::to_string(i + 1) + PutLabel(514) + std::to_string(FNumeroTurbina) + PutLabel(901);
723  insoutput << Label.c_str();
724  }
725  }
726  if(FResInstantTurbina.GastoCorregido) {
727  for(int i = 0; i < FNumeroEntradas; i++) {
728  Label = "\t" + PutLabel(516) + std::to_string(i + 1) + PutLabel(514) + std::to_string(FNumeroTurbina) + PutLabel(905);
729  insoutput << Label.c_str();
730  }
731  }
732  if(FResInstantTurbina.RegimenCorregido) {
733  for(int i = 0; i < FNumeroEntradas; i++) {
734  Label = "\t" + PutLabel(517) + std::to_string(i + 1) + PutLabel(514) + std::to_string(FNumeroTurbina) + PutLabel(906);
735  insoutput << Label.c_str();
736  }
737  }
738  if(FResInstantTurbina.RelacionExpansion) {
739  for(int i = 0; i < FNumeroEntradas; i++) {
740  Label = "\t" + PutLabel(518) + std::to_string(i + 1) + PutLabel(514) + std::to_string(FNumeroTurbina) + PutLabel(901);
741  insoutput << Label.c_str();
742  }
743  }
744  // fclose(fich);
745  } catch(exception & N) {
746  std::cout << "ERROR: TTurbinaSimple::CabeceraResultadosInstantTurb en la turbina " << FNumeroTurbina << std::endl;
747  std::cout << "Tipo de error: " << N.what() << std::endl;
748  throw Exception(N.what());
749  }
750 }
751 
752 // ---------------------------------------------------------------------------
753 // ---------------------------------------------------------------------------
754 
755 void TTurbinaSimple::ResultadosInstantTurb() {
756  try {
757  if(FResInstantTurbina.Potencia)
758  FResInstantTurbina.PotenciaINS = FPotencia;
759  if(FResInstantTurbina.Rendimiento)
760  FResInstantTurbina.RendimientoINS = FRendTurbina[0];
761  if(FResInstantTurbina.RelaCinematica) {
762  for(int i = 0; i < FNumeroEntradas; i++) {
763  FResInstantTurbina.RelaCinematicaINS[i] = FRelacionCinematica[i];
764  }
765  }
766  if(FResInstantTurbina.GastoCorregido) {
767  for(int i = 0; i < FNumeroEntradas; i++) {
768  FResInstantTurbina.GastoCorregidoINS[i] = FGastoCorregido[i];
769  }
770  }
771  if(FResInstantTurbina.RegimenCorregido) {
772  for(int i = 0; i < FNumeroEntradas; i++) {
773  FResInstantTurbina.RegimenCorregidoINS[i] = FRegimenCorregido[i];
774  }
775  }
776  if(FResInstantTurbina.RelacionExpansion) {
777  for(int i = 0; i < FNumeroEntradas; i++) {
778  FResInstantTurbina.RelacionExpansionINS[i] = FRelacionExpansion[i];
779  }
780  }
781 
782  } catch(exception & N) {
783  std::cout << "ERROR: TTurbinaSimple::ResultadosInstantTurb en la turbina " << FNumeroTurbina << std::endl;
784  std::cout << "Tipo de error: " << N.what() << std::endl;
785  throw Exception(N.what());
786  }
787 }
788 
789 // ---------------------------------------------------------------------------
790 // ---------------------------------------------------------------------------
791 
792 void TTurbinaSimple::ImprimeResultadosInstantTurb(stringstream& insoutput) {
793  try {
794  // FILE *fich=fopen(FileSALIDA,"a");
795 
796  if(FResInstantTurbina.Potencia)
797  insoutput << "\t" << FResInstantTurbina.PotenciaINS;
798  if(FResInstantTurbina.Rendimiento)
799  insoutput << "\t" << FResInstantTurbina.RendimientoINS;
800  if(FResInstantTurbina.RelaCinematica) {
801  for(int i = 0; i < FNumeroEntradas; i++) {
802  insoutput << "\t" << FResInstantTurbina.RelaCinematicaINS[i];
803  }
804  }
805  if(FResInstantTurbina.GastoCorregido) {
806  for(int i = 0; i < FNumeroEntradas; i++) {
807  insoutput << "\t" << FResInstantTurbina.GastoCorregidoINS[i];
808  }
809  }
810  if(FResInstantTurbina.RegimenCorregido) {
811  for(int i = 0; i < FNumeroEntradas; i++) {
812  insoutput << "\t" << FResInstantTurbina.RegimenCorregidoINS[i];
813  }
814  }
815  if(FResInstantTurbina.RelacionExpansion) {
816  for(int i = 0; i < FNumeroEntradas; i++) {
817  insoutput << "\t" << FResInstantTurbina.RelacionExpansionINS[i];
818  }
819  }
820 
821  // fclose(fich);
822  } catch(exception & N) {
823  std::cout << "ERROR: TTurbinaSimple::CabeceraResultadosInstantTurb en la turbina " << FNumeroTurbina << std::endl;
824  std::cout << "Tipo de error: " << N.what() << std::endl;
825  throw Exception(N.what());
826  }
827 }
828 
829 void TTurbinaSimple::UpdateProperties0DModel(double TimeCalculo) {
830 
831  CalculaCondicionTurbina(TimeCalculo);
832 
833  ActualizaPropiedades(TimeCalculo);
834 
835  AcumulaMedias(TimeCalculo);
836 
837  AcumulaResultadosMedios(TimeCalculo);
838 
839 }
840 
841 // ---------------------------------------------------------------------------
842 // ---------------------------------------------------------------------------
843 #pragma package(smart_init)
TRotorTurbina
Definition: TRotorTurbina.h:48
TTurbina
Definition: TTurbina.h:41
pow3
T pow3(T x)
Returns x to the power of 3.
Definition: Math_wam.h:101
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
pow4
T pow4(T x)
Returns x to the power of 4.
Definition: Math_wam.h:114
TTubo.h
TEstatorTurbina
Definition: TEstatorTurbina.h:47
TCCDeposito
Definition: TCCDeposito.h:40
pow2
T pow2(T x)
Returns x to the power of 2.
Definition: Math_wam.h:88
TController::Output
virtual double Output(double Time)=0