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