OpenWAM
TCCUnionEntreDepositos.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 "TCCUnionEntreDepositos.h"
32 //#include <cmath>
33 #ifdef __BORLANDC__
34 #include <vcl.h>
35 #endif
36 
37 #include "TCDFijo.h"
38 #include "TValvula4T.h"
39 #include "TLamina.h"
40 #include "TDiscoRotativo.h"
41 #include "TLumbrera.h"
42 #include "TValvulaContr.h"
43 #include "TWasteGate.h"
44 #include "TEstatorTurbina.h"
45 #include "TRotorTurbina.h"
46 #include "TCDExterno.h"
47 
48 #include "TDepVolVariable.h"
49 #include "TDepVolCte.h"
50 
51 #include "TTubo.h"
52 
53 //---------------------------------------------------------------------------
54 //---------------------------------------------------------------------------
55 
56 TCCUnionEntreDepositos::TCCUnionEntreDepositos(nmTypeBC TipoCC, int numCC, nmTipoCalculoEspecies SpeciesModel,
57  int numeroespecies, nmCalculoGamma GammaCalculation, bool ThereIsEGR) :
58  TCondicionContorno(TipoCC, numCC, SpeciesModel, numeroespecies, GammaCalculation, ThereIsEGR) {
59  FValvula = NULL;
60  FGasto = 0.;
61  FGastoImpreso = 0.;
62  FTiempoActual = 0.;
63 
64  FPresionDep1SUM = 0.;
65  FAsonidoDep1SUM = 0.;
66  FGammaDep1SUM = 0.;
67  FRDep1SUM = 0.;
68  FTiempoDep1SUM = 0.;
69  FPresionDep2SUM = 0.;
70  FAsonidoDep2SUM = 0.;
71  FGammaDep2SUM = 0.;
72  FRDep2SUM = 0.;
73  FTiempoDep2SUM = 0.;
74 
75  FResInstantUED.Massflow = false;
76 }
77 //---------------------------------------------------------------------------
78 //---------------------------------------------------------------------------
79 
80 TCCUnionEntreDepositos::~TCCUnionEntreDepositos() {
81 
82  if(FValvula != NULL)
83  delete FValvula;
84 
85  FValvula = NULL;
86 
87 }
88 
89 //---------------------------------------------------------------------------
90 //---------------------------------------------------------------------------
91 
92 void TCCUnionEntreDepositos::LeeUEDepositos(const char *FileWAM, fpos_t &filepos, bool Independent) {
93  try {
94  int numid = 0; // Variable necesaria para WAMer.
95 
96  FIndependiente = Independent;
97 
98  FILE *fich = fopen(FileWAM, "r");
99  fsetpos(fich, &filepos);
100 
101  fscanf(fich, "%d ",
102  &numid); // Esto es un dato que necesita el WAMer. Los usuarios de WAM hacemos la vista gorda hasta que se arregle.
103  fscanf(fich, "%d ", &FNumeroDeposito1);
104  fscanf(fich, "%d ", &FNumeroDeposito2);
105 
106  fgetpos(fich, &filepos);
107  fclose(fich);
108 
109  } catch(exception &N) {
110  std::cout << "ERROR: TCCUnionEntreDepositos::LeeNumDepositos en la condicion de contorno: " << FNumeroCC << std::endl;
111  std::cout << "Tipo de error: " << N.what() << std::endl;
112  throw Exception(N.what());
113  }
114 }
115 
116 //-----------------------------------------------------------------------------
117 //-----------------------------------------------------------------------------
118 
119 void TCCUnionEntreDepositos::AsignaDepositos(TDeposito **Plenum) {
120  try {
121 
122  FDeposito1 = Plenum[FNumeroDeposito1 - 1];
123  FDeposito2 = Plenum[FNumeroDeposito2 - 1];
124 
125 // Inicializacion del transporte de especies quimicas.
126  FFraccionMasicaEspecie = new double[FNumeroEspecies - FIntEGR];
127  for(int i = 0; i < FNumeroEspecies - FIntEGR; i++) {
128  FFraccionMasicaEspecie[i] = FDeposito1->GetFraccionMasicaEspecie(
129  i); // Se inicializa con el Deposito1 de modo arbitrario.
130  }
131 
132  } catch(exception &N) {
133  std::cout << "ERROR: TCCUnionEntreDepositos::AsignaDepositos en la condicion de contorno: " << FNumeroCC << 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 TCCUnionEntreDepositos::AsignaTipoValvula(TTipoValvula **Origen, int Valv, int i) {
143  try {
144 
145  switch(Origen[Valv - 1]->getTypeOfValve()) {
146  case nmCDFijo:
147  FValvula = new TCDFijo(dynamic_cast<TCDFijo *>(Origen[Valv - 1]), i);
148  break;
149  case nmValvula4T:
150  FValvula = new TValvula4T(dynamic_cast<TValvula4T *>(Origen[Valv - 1]), i);
151  break;
152  case nmLamina:
153  FValvula = new TLamina(dynamic_cast<TLamina *>(Origen[Valv - 1]), i);
154  break;
155  case nmDiscoRotativo:
156  FValvula = new TDiscoRotativo(dynamic_cast<TDiscoRotativo *>(Origen[Valv - 1]), i);
157  break;
158  case nmLumbrera2T:
159  FValvula = new TLumbrera(dynamic_cast<TLumbrera *>(Origen[Valv - 1]), i);
160  break;
161  case nmValvulaContr:
162  FValvula = new TValvulaContr(dynamic_cast<TValvulaContr *>(Origen[Valv - 1]), i);
163  break;
164  case nmWasteGate:
165  FValvula = new TWasteGate(dynamic_cast<TWasteGate *>(Origen[Valv - 1]), i);
166  break;
167  case nmStator:
168  FValvula = new TEstatorTurbina(dynamic_cast<TEstatorTurbina *>(Origen[Valv - 1]), i);
169  break;
170  case nmRotor:
171  FValvula = new TRotorTurbina(dynamic_cast<TRotorTurbina *>(Origen[Valv - 1]), i);
172  break;
173  case nmCalcExtern:
174  FValvula = new TCDExterno(dynamic_cast<TCDExterno *>(Origen[Valv - 1]), i);
175  break;
176  }
177 
178  FValvula->PutDiametroTubo(FValvula->getDiametro());
179  if(FValvula->getTypeOfValve() == nmCDFijo) {
180  dynamic_cast<TCDFijo *>(FValvula)->CalculaCD();
181  FCDEntrada = FValvula->getCDTubVol();
182  FCDSalida = FValvula->getCDVolTub();
183  FCTorbellino = FValvula->getCTorb();
184  if(FCDEntrada > 1.) {
185  FValvula->AsignaCRecuperacion(FCDEntrada - 1.);
186  } else
187  FValvula->AsignaCRecuperacion(0.);
188  }
189 
190  } catch(exception &N) {
191  std::cout << "ERROR: TCCUnionEntreDepositos::AsignaTipoValvula en la condicion de contorno: " << FNumeroCC << std::endl;
192  std::cout << "Tipo de error: " << N.what() << std::endl;
193  throw Exception(N.what());
194  }
195 }
196 
197 //-----------------------------------------------------------------------------
198 //-----------------------------------------------------------------------------
199 
200 void TCCUnionEntreDepositos::CalculaCoeficientesDescarga(double TiempoActual, double mfcomb, double RegimenMotor) {
201  try {
202 
203  double PVol = 0., PTub = 0., PAdm = 0., DeltaP = 0., distancia = 0., CDExt = 0., nodoadm = 0., p1 = 0., p2 = 0.;
204  int turb = 0, entr = 0;
205 
206  if(FValvula->getTypeOfValve() == nmLumbrera2T) {
207  FRegimen = dynamic_cast<TDepVolVariable*>(FDeposito1)->getRegimen();
208  FTime0 = FTime1;
209  FTime1 = TiempoActual;
210  FDeltaT = FTime1 - FTime0;
211  FDeltaAngulo = 360. * FRegimen * dynamic_cast<TDepVolVariable*>(FDeposito1)->getRelacionVelocidades() / 60. * FDeltaT;
212  FAnguloAnterior = FAnguloActual;
213  FAnguloActual = FAnguloAnterior + FDeltaAngulo;
214  if(FAnguloActual > 360.) {
215  FAnguloActual -= 360.;
216  }
217  }
218 
219  if(FValvula->getTypeOfValve() == nmDiscoRotativo) {
220  if(FValvula->getControlRegimen() == nmMotor) {
221  FRegimen = RegimenMotor;
222  } else {
223  FRegimen = FValvula->getRegimen();
224  }
225  FTime0 = FTime1;
226  FTime1 = TiempoActual;
227  FDeltaT = FTime1 - FTime0;
228  FDeltaAngulo = 360. * FRegimen * FValvula->getRelacionVelocidades() / 60. * FDeltaT;
229  FAnguloAnterior = FAnguloActual;
230  FAnguloActual = FAnguloAnterior + FDeltaAngulo;
231  if(FAnguloActual > 360.) {
232  FAnguloActual -= 360.;
233  }
234  }
235 
236  if(FValvula->getTypeOfValve() == nmValvula4T) {
237  if(FValvula->getControlRegimen() == nmMotor) {
238  FRegimen = RegimenMotor;
239  } else {
240  FRegimen = FValvula->getRegimen();
241  }
242  FTime0 = FTime1;
243  FTime1 = TiempoActual;
244  FDeltaT = FTime1 - FTime0;
245  FDeltaAngulo = 360. * FRegimen * FValvula->getRelacionVelocidades() / 60. * FDeltaT;
246  FAnguloAnterior = FAnguloActual;
247  FAnguloActual = FAnguloAnterior + FDeltaAngulo;
248  if(FAnguloActual > 360.) {
249  FAnguloActual -= 360.;
250  }
251  }
252 
253  if(FValvula->getTypeOfValve() == nmValvulaContr) {
254  FRegimen = RegimenMotor;
255  FTime0 = FTime1;
256  FTime1 = TiempoActual;
257  FDeltaT = FTime1 - FTime0;
258  FDeltaAngulo = 360. * FRegimen / 60. * FDeltaT;
259  FAnguloAnterior = FAnguloActual;
260  FAnguloActual = FAnguloAnterior + FDeltaAngulo;
261  if(FAnguloActual > 720.) {
262  FAnguloActual -= 720.;
263  }
264  }
265 
266  switch(FValvula->getTypeOfValve()) {
267  case nmCDFijo:
268  dynamic_cast<TCDFijo *>(FValvula)->CalculaCD();
269  break;
270 
271  case nmValvula4T:
272  dynamic_cast<TValvula4T *>(FValvula)->CalculaCD(FAnguloActual);
273  break;
274 
275  case nmLamina:
276  PTub = FDeposito1->getPressure();
277  PVol = FDeposito2->getPressure();
278  DeltaP = PTub - PVol;
279  dynamic_cast<TLamina *>(FValvula)->CalculaCD(DeltaP, TiempoActual);
280  break;
281 
282  case nmDiscoRotativo:
283  dynamic_cast<TDiscoRotativo *>(FValvula)->CalculaCD(FAnguloActual);
284  break;
285 
286  case nmLumbrera2T:
287  dynamic_cast<TLumbrera *>(FValvula)->CalculaCD(FAnguloActual);
288  break;
289 
290  case nmValvulaContr:
291  dynamic_cast<TValvulaContr *>(FValvula)->CalculaCD(FAnguloActual, mfcomb);
292  break;
293 
294  case nmWasteGate:
295  PTub = FDeposito1->getPressure();
296  PVol = FDeposito2->getPressure();
297  nodoadm = dynamic_cast<TWasteGate *>(FValvula)->getNodoAdm();
298  distancia = dynamic_cast<TWasteGate *>(FValvula)->getDist();
299  p1 = dynamic_cast<TWasteGate *>(FValvula)->getTuboAdm()->GetPresion(nodoadm);
300  p2 = dynamic_cast<TWasteGate *>(FValvula)->getTuboAdm()->GetPresion(nodoadm + 1);
301  PAdm = InterpolaDeposito(p1, p2, 1.0, distancia);
302  dynamic_cast<TWasteGate *>(FValvula)->CalculaCD(PAdm, PTub, PVol, TiempoActual);
303  break;
304 
305  case nmStator:
306  dynamic_cast<TEstatorTurbina *>(FValvula)->CalculaCD();
307  break;
308 
309  case nmRotor:
310  dynamic_cast<TRotorTurbina *>(FValvula)->CalculaCD();
311  break;
312 
313  case nmCalcExtern:
314  dynamic_cast<TCDExterno *>(FValvula)->CalculaCD();
315  break;
316  }
317 
318  FCDEntrada = FValvula->getCDTubVol();
319  FCDEntrada = FValvula->getCDTubVol();
320  FCDSalida = FValvula->getCDVolTub();
321  FCTorbellino = FValvula->getCTorb();
322 
323  if(FCDEntrada > 2.0 || FCDEntrada < 0.0) {
324  printf("ERROR: TCCUnionEntreDepositos::CalculaCoeficientesDescarga, en calculo coeficiente descarga entrante: %lf, en %lf grados,en la condicion de contorno: %d\n",
325  FCDEntrada,
326  FAnguloActual, FNumeroCC);
327  throw Exception(
328  "ERROR:TCCUnionEntreDepositos::CalculaCoeficientesDescarga en calculo coeficiente descarga entrante: " + std::to_string(
329  FCDEntrada) + ", en " + std::to_string(FAnguloActual) + " grados ");
330 
331  }
332  if(FCDSalida > 1.0 || FCDSalida < 0.0) {
333  printf("ERROR: TCCUnionEntreDepositos::CalculaCoeficientesDescarga, en calculo coeficiente descarga saliente: %lf, en %lf grados, en la condicion de contorno: %d\n",
334  FCDSalida,
335  FAnguloActual, FNumeroCC);
336  throw Exception(
337  "ERROR: TCCUnionEntreDepositos::CalculaCoeficientesDescarga en calculo coeficiente descarga saliente: " +
338  std::to_string(FCDSalida) + ", en " + std::to_string(FAnguloActual) + " grados ");
339  }
340  } catch(exception &N) {
341  std::cout << "ERROR: TCCUnionEntreDepositos::CalculaCoeficientesDescarga en la condicion de contorno: " << FNumeroCC <<
342  std::endl;
343  std::cout << "Tipo de error: " << N.what() << std::endl;
344  throw Exception(N.what());
345  }
346 }
347 
348 //-----------------------------------------------------------------------------
349 //-----------------------------------------------------------------------------
350 
351 double TCCUnionEntreDepositos::InterpolaDeposito(double vizq, double vder, double axid, double xif) {
352  try {
353  double xx = 0., yy = 0., ret_val = 0.;
354 
355  xx = vder - vizq;
356  if(axid != 0.) {
357  yy = (xx / axid) * xif;
358  ret_val = vizq + yy;
359  } else {
360  std::cout << "ERROR: valores entrada TCCUnionEntreDepositos::InterpolaDeposito: " << std::endl;
361  throw Exception(" ");
362  }
363  return ret_val;
364  } catch(exception &N) {
365  std::cout << "ERROR: TCCUnionEntreDepositos::InterpolaDeposito en la condicion de contorno: " << FNumeroCC << std::endl;
366  std::cout << "Tipo de error: " << N.what() << std::endl;
367  throw Exception(N.what());
368  }
369 }
370 
371 //---------------------------------------------------------------------------
372 //---------------------------------------------------------------------------
373 
374 void TCCUnionEntreDepositos::CalculaCondicionContorno(double Time) {
375  try {
376 
377  if(FIndependiente) {
378 
379  /*FPresionDep1SUM+=FDeposito1->getPressure()*(FTiempoActual-FDeposito1->getTiempo());
380  FGammaDep1SUM+=FDeposito1->getGamma()*(FTiempoActual-FDeposito1->getTiempo());
381  FRDep1SUM+=FDeposito1->getR()*(FTiempoActual-FDeposito1->getTiempo());
382  FAsonidoDep1SUM+=FDeposito1->getSpeedsound()*(FTiempoActual-FDeposito1->getTiempo());
383  FTiempoDep1SUM+=(FTiempoActual-FDeposito1->getTiempo());
384 
385  FPresionDep2SUM+=FDeposito2->getPressure()*(FTiempoActual-FDeposito2->getTiempo());
386  FGammaDep2SUM+=FDeposito2->getGamma()*(FTiempoActual-FDeposito2->getTiempo());
387  FRDep2SUM+=FDeposito2->getR()*(FTiempoActual-FDeposito2->getTiempo());
388  FAsonidoDep2SUM+=FDeposito2->getSpeedsound()*(FTiempoActual-FDeposito2->getTiempo());
389  FTiempoDep2SUM+=(FTiempoActual-FDeposito2->getTiempo()); */
390 
391  double p0, p1, T0,/*T1,*/gasto_isen, a0, FraccionMasicaAcum = 0., Massflow;
392  double paso1 = 0., paso2 = 0., paso3 = 0., paso4 = 0.;
393  int signodep1 = 0, signodep2 = 0;
394 
395  /* if(FNumeroCC==3){
396  printf(".\n");
397  } */
398  if(FDeposito1->getPressure() > FDeposito2->getPressure()) {
399  FGamma = FDeposito1->getGamma();
400  FRMezcla = FDeposito1->getR();
401  p0 = __units::BarToPa(FDeposito1->getPressure());
402  T0 = pow2(FDeposito1->getSpeedsound() * __cons::ARef) / (FGamma * FRMezcla);
403  Fa0 = FDeposito1->getSpeedsound();
404  //Fa1=FDeposito2->getSpeedsound();
405  p1 = __units::BarToPa(FDeposito2->getPressure());
406  //T1=pow(FDeposito2->getSpeedsound()*__cons::ARef,2)/(FGamma*FRMezcla);
407 
408  } else {
409  FGamma = FDeposito2->getGamma();
410  FRMezcla = FDeposito2->getR();
411  p0 = __units::BarToPa(FDeposito2->getPressure());
412  T0 = pow2(FDeposito2->getSpeedsound() * __cons::ARef) / (FGamma * FRMezcla);
413  Fa0 = FDeposito2->getSpeedsound();
414  //Fa1=FDeposito1->getSpeedsound();
415  p1 = __units::BarToPa(FDeposito1->getPressure());
416  //T1=pow(FDeposito1->getSpeedsound()*__cons::ARef,2)/(FGamma*FRMezcla);
417  }
418 
419  FGamma1 = __Gamma::G1(FGamma);
420  FGamma2 = __Gamma::G2(FGamma);
421 
422  paso1 = (__cons::Pi_4 * pow2(FValvula->getDiametro())) * p0 * sqrt(2 * FGamma / (FRMezcla * FGamma1 * T0));
423  paso2 = pow(p1 / p0, 2 / FGamma);
424  paso3 = pow(p1 / p0, FGamma2 / FGamma);
425  paso4 = sqrt(paso2 - paso3);
426  gasto_isen = paso1 * paso4;
427 
428  /* FGasto es el valor del massflow en modulo. Asi lo necesitan recibir los depositos, que ademas conocen el signo por
429  el que han de multiplicar este valor. */
430  /* FGastoImpreso es el valor del massflow con el signo de acuerdo al convenio de WAMer. Es decir, massflow positivo en el
431  sentido del deposito con la union (deposito 1) al deposito al que llega el hilo (deposito 2). Este massflow es el que
432  se imprime como resultado y el que se pasa a los sensores. */
433 
434  if(FDeposito1->getPressure() > FDeposito2->getPressure()) { /* Flujo del deposito 1 al deposito 2 */
435  Massflow = FCDSalida * gasto_isen;
436  FGasto = 0.9 * FGasto + 0.1 * Massflow;
437  FVelocity = FGasto / (__geom::Circle_area(FValvula->getDiametro())) / (p0 / (FRMezcla * T0));
438  FSentidoFlujoED1 = -1; /* Saliente -1*/
439  FSentidoFlujoED2 = 1; /* Entrante */
440  FGastoImpreso = FGasto; /* Al imprimir resultados se considera negativo si va del deposito
441  del que sale el hilo hacia el que tiene la union */
442 
443  //Transporte de especies quimicas.
444  for(int j = 0; j < FNumeroEspecies - 2; j++) {
445  FFraccionMasicaEspecie[j] = FDeposito1->GetFraccionMasicaEspecie(j);
446  FraccionMasicaAcum += FFraccionMasicaEspecie[j];
447  }
448  FFraccionMasicaEspecie[FNumeroEspecies - 2] = 1. - FraccionMasicaAcum;
449  if(FHayEGR)
450  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FDeposito1->GetFraccionMasicaEspecie(FNumeroEspecies - 1);
451 
452  } else { /* Flujo del deposito 2 al deposito 1 */
453  Massflow = FCDEntrada * gasto_isen;
454  FGasto = 0.9 * FGasto - 0.1 * Massflow;
455  FVelocity = FGasto / (__geom::Circle_area(FValvula->getDiametro())) / (p0 / (FRMezcla * T0));
456  FSentidoFlujoED1 = -1; /* Entrante */
457  FSentidoFlujoED2 = 1; /* Saliente -1*/
458  FGastoImpreso = FGasto;
459 
460  //Transporte de especies quimicas.
461  for(int j = 0; j < FNumeroEspecies - 2; j++) {
462  FFraccionMasicaEspecie[j] = FDeposito2->GetFraccionMasicaEspecie(j);
463  FraccionMasicaAcum += FFraccionMasicaEspecie[j];
464  }
465  FFraccionMasicaEspecie[FNumeroEspecies - 2] = 1. - FraccionMasicaAcum;
466  if(FHayEGR)
467  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FDeposito2->GetFraccionMasicaEspecie(FNumeroEspecies - 1);
468  }
469 
470  } else {
471 
472  double p0, p1, T0, T1, gasto_isen, a0, FraccionMasicaAcum = 0., Massflow;
473  double paso1 = 0., paso2 = 0., paso3 = 0., paso4 = 0.;
474  int signodep1 = 0, signodep2 = 0;
475 
476  if(FDeposito1->getPressure() > FDeposito2->getPressure()) {
477  FGamma = FDeposito1->getGamma();
478  FRMezcla = FDeposito1->getR();
479  p0 = __units::BarToPa(FDeposito1->getPressure());
480  T0 = pow2(FDeposito1->getSpeedsound() * __cons::ARef) / (FGamma * FRMezcla);
481  Fa0 = FDeposito1->getSpeedsound();
482  //Fa1=FDeposito2->getSpeedsound();
483  p1 = __units::BarToPa(FDeposito2->getPressure());
484  //T1=pow(FDeposito2->getSpeedsound()*__cons::ARef,2)/(FGamma*FRMezcla);
485 
486  } else {
487  FGamma = FDeposito2->getGamma();
488  FRMezcla = FDeposito2->getR();
489  p0 = __units::BarToPa(FDeposito2->getPressure());
490  T0 = pow2(FDeposito2->getSpeedsound() * __cons::ARef) / (FGamma * FRMezcla);
491  Fa0 = FDeposito2->getSpeedsound();
492  //Fa1=FDeposito1->getSpeedsound();
493  p1 = __units::BarToPa(FDeposito1->getPressure());
494  //T1=pow(FDeposito1->getSpeedsound()*__cons::ARef,2)/(FGamma*FRMezcla);
495  }
496 
497  FGamma1 = __Gamma::G1(FGamma);
498  FGamma2 = __Gamma::G2(FGamma);
499 
500  paso1 = (__geom::Circle_area(FValvula->getDiametro())) * p0 * sqrt(2 * FGamma / (FRMezcla * FGamma1 * T0));
501  paso2 = pow(p1 / p0, 2 / FGamma);
502  paso3 = pow(p1 / p0, FGamma2 / FGamma);
503  paso4 = sqrt(paso2 - paso3);
504  gasto_isen = paso1 * paso4;
505 
506  /* FGasto es el valor del massflow en modulo. Asi lo necesitan recibir los depositos, que ademas conocen el signo por
507  el que han de multiplicar este valor. */
508  /* FGastoImpreso es el valor del massflow con el signo de acuerdo al convenio de WAMer. Es decir, massflow positivo en el
509  sentido del deposito con la union (deposito 1) al deposito al que llega el hilo (deposito 2). Este massflow es el que
510  se imprime como resultado y el que se pasa a los sensores. */
511 
512  if(FDeposito1->getPressure() > FDeposito2->getPressure()) { /* Flujo del deposito 1 al deposito 2 */
513  FGasto = FCDSalida * gasto_isen;
514  FVelocity = FGasto / (__geom::Circle_area(FValvula->getDiametro())) / (p0 / (FRMezcla * T0));
515  FSentidoFlujoED1 = -1; /* Saliente */
516  FSentidoFlujoED2 = 1; /* Entrante */
517  FGastoImpreso = FGasto; /* Al imprimir resultados se considera negativo si va del deposito
518  del que sale el hilo hacia el que tiene la union */
519 
520  //Transporte de especies quimicas.
521  for(int j = 0; j < FNumeroEspecies - 2; j++) {
522  FFraccionMasicaEspecie[j] = FDeposito1->GetFraccionMasicaEspecie(j);
523  FraccionMasicaAcum += FFraccionMasicaEspecie[j];
524  }
525  FFraccionMasicaEspecie[FNumeroEspecies - 2] = 1. - FraccionMasicaAcum;
526  if(FHayEGR)
527  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FDeposito1->GetFraccionMasicaEspecie(FNumeroEspecies - 1);
528 
529  } else { /* Flujo del deposito 2 al deposito 1 */
530  FGasto = FCDEntrada * gasto_isen;
531  FVelocity = FGasto / (__geom::Circle_area(FValvula->getDiametro())) / (p0 / (FRMezcla * T0));
532  FSentidoFlujoED1 = 1; /* Entrante */
533  FSentidoFlujoED2 = -1; /* Saliente */
534  FGastoImpreso = FGasto;
535 
536  //Transporte de especies quimicas.
537  for(int j = 0; j < FNumeroEspecies - 2; j++) {
538  FFraccionMasicaEspecie[j] = FDeposito2->GetFraccionMasicaEspecie(j);
539  FraccionMasicaAcum += FFraccionMasicaEspecie[j];
540  }
541  FFraccionMasicaEspecie[FNumeroEspecies - 2] = 1. - FraccionMasicaAcum;
542  if(FHayEGR)
543  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FDeposito2->GetFraccionMasicaEspecie(FNumeroEspecies - 1);
544  }
545  }
546 
547  } catch(exception &N) {
548  std::cout << "ERROR: TCCUnionEntreDepositos::CalculaCondicionContorno en la condicion de contorno: " << FNumeroCC <<
549  std::endl;
550  std::cout << "Tipo de error: " << N.what() << std::endl;
551  throw Exception(N.what());
552  }
553 }
554 
555 //---------------------------------------------------------------------------
556 //---------------------------------------------------------------------------
557 
558 void TCCUnionEntreDepositos::CalculaUED() {
559  try {
560  double p0, p1, T0, gasto_isen, gasto_real, a0, FraccionMasicaAcum = 0.;
561  double paso1 = 0., paso2 = 0., paso3 = 0., paso4 = 0.;
562  int signodep1 = 0, signodep2 = 0;
563 
564  FPresionDep1 = FPresionDep1SUM / FTiempoDep1SUM;
565  FPresionDep2 = FPresionDep2SUM / FTiempoDep2SUM;
566 
567  if(FPresionDep1 > FPresionDep2) {
568  FGamma = FGammaDep1SUM / FTiempoDep1SUM;
569  FRMezcla = FRDep1SUM / FTiempoDep1SUM;
570  p0 = __units::BarToPa(FPresionDep1);
571  a0 = FAsonidoDep1SUM / FTiempoDep1SUM;
572  T0 = pow2(a0 * __cons::ARef) / (FGamma * FRMezcla);
573  Fa1 = FAsonidoDep2SUM / FTiempoDep2SUM;
574  p1 = __units::BarToPa(FPresionDep2);
575 
576  FGamma1 = __Gamma::G1(FGamma);
577  FGamma2 = __Gamma::G2(FGamma);
578 
579  paso1 = (__geom::Circle_area(FValvula->getDiametro())) * p0 * sqrt(2 * FGamma / (FRMezcla * FGamma1 * T0));
580  paso2 = pow(p1 / p0, 2 / FGamma);
581  paso3 = pow(p1 / p0, FGamma2 / FGamma);
582  paso4 = sqrt(paso2 - paso3);
583  gasto_isen = paso1 * paso4;
584 
585  } else if(FPresionDep2 > FPresionDep1) {
586  FGamma = FGammaDep2SUM / FTiempoDep2SUM;
587  FRMezcla = FRDep2SUM / FTiempoDep2SUM;
588  p0 = __units::BarToPa(FPresionDep2);
589  a0 = FAsonidoDep2SUM / FTiempoDep2SUM;
590  ;
591  T0 = pow2(a0 * __cons::ARef) / (FGamma * FRMezcla);
592  Fa1 = FAsonidoDep1SUM / FTiempoDep1SUM;
593  p1 = __units::BarToPa(FPresionDep1);
594 
595  FGamma1 = __Gamma::G1(FGamma);
596  FGamma2 = __Gamma::G2(FGamma);
597 
598  paso1 = (__geom::Circle_area(FValvula->getDiametro())) * p0 * sqrt(2 * FGamma / (FRMezcla * FGamma1 * T0));
599  paso2 = pow(p1 / p0, 2 / FGamma);
600  paso3 = pow(p1 / p0, FGamma2 / FGamma);
601  paso4 = sqrt(paso2 - paso3);
602  gasto_isen = paso1 * paso4;
603  }
604 
605  /* FGasto es el valor del massflow en modulo. Asi lo necesitan recibir los depositos, que ademas conocen el signo por
606  el que han de multiplicar este valor. */
607  /* FGastoImpreso es el valor del massflow con el signo de acuerdo al convenio de WAMer. Es decir, massflow positivo en el
608  sentido del deposito con la union (deposito 1) al deposito al que llega el hilo (deposito 2). Este massflow es el que
609  se imprime como resultado y el que se pasa a los sensores. */
610 
611  if(FPresionDep1 > FPresionDep2) { /* Flujo del deposito 1 al deposito 2 */
612  FGasto = FCDEntrada * gasto_isen;
613  FSentidoFlujoED1 = -1; /* Saliente */
614  FSentidoFlujoED2 = 1; /* Entrante */
615  FGastoImpreso = FGasto; /* Al imprimir resultados se considera negativo si va del deposito
616  del que sale el hilo hacia el que tiene la union */
617 
618  //Transporte de especies quimicas.
619  for(int j = 0; j < FNumeroEspecies - 2; j++) {
620  FFraccionMasicaEspecie[j] = FDeposito1->GetFraccionMasicaEspecie(j);
621  FraccionMasicaAcum += FFraccionMasicaEspecie[j];
622  }
623  FFraccionMasicaEspecie[FNumeroEspecies - 2] = 1. - FraccionMasicaAcum;
624  if(FHayEGR)
625  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FDeposito1->GetFraccionMasicaEspecie(FNumeroEspecies - 1);
626 
627  } else if(FPresionDep2 > FPresionDep1) { /* Flujo del deposito 2 al deposito 1 */
628  FGasto = FCDSalida * gasto_isen;
629  FSentidoFlujoED1 = 1; /* Entrante */
630  FSentidoFlujoED2 = -1; /* Saliente */
631  FGastoImpreso = -FGasto;
632 
633  //Transporte de especies quimicas.
634  for(int j = 0; j < FNumeroEspecies - 2; j++) {
635  FFraccionMasicaEspecie[j] = FDeposito2->GetFraccionMasicaEspecie(j);
636  FraccionMasicaAcum += FFraccionMasicaEspecie[j];
637  }
638  FFraccionMasicaEspecie[FNumeroEspecies - 2] = 1. - FraccionMasicaAcum;
639  if(FHayEGR)
640  FFraccionMasicaEspecie[FNumeroEspecies - 1] = FDeposito2->GetFraccionMasicaEspecie(FNumeroEspecies - 1);
641  }
642 
643  FPresionDep1SUM = 0.;
644  FAsonidoDep1SUM = 0.;
645  FGammaDep1SUM = 0.;
646  FRDep1SUM = 0.;
647  FTiempoDep1SUM = 0.;
648  FPresionDep2SUM = 0.;
649  FAsonidoDep2SUM = 0.;
650  FGammaDep2SUM = 0.;
651  FRDep2SUM = 0.;
652  FTiempoDep2SUM = 0.;
653 
654  } catch(exception &N) {
655  std::cout << "ERROR: TCCUnionEntreDepositos::CalculaUED en la condicion de contorno: " << FNumeroCC << std::endl;
656  std::cout << "Tipo de error: " << N.what() << std::endl;
657  throw Exception(N.what());
658  }
659 }
660 
661 //---------------------------------------------------------------------------
662 //---------------------------------------------------------------------------
663 
664 void TCCUnionEntreDepositos::LeeResultadosInstantUED(const char *FileWAM, fpos_t &filepos) {
665  int nvars = 0, var = 0;
666  try {
667  FILE *fich = fopen(FileWAM, "r");
668  fsetpos(fich, &filepos);
669 
670  fscanf(fich, "%d ", &nvars);
671  for(int i = 0; i < nvars; i++) {
672  fscanf(fich, "%d ", &var);
673  switch(var) {
674  case 0:
675  FResInstantUED.Massflow = true;
676  break;
677  default:
678  std::cout << "Resultados instantaneos en UED(BC) " << FNumeroCC << " no implementados " << std::endl;
679  }
680  }
681  fgetpos(fich, &filepos);
682  fclose(fich);
683  } catch(exception &N) {
684  std::cout << "ERROR: TCCUnionEntreDepositos::LeeResultadosInstantUED en la BC " << FNumeroCC << std::endl;
685  std::cout << "Tipo de error: " << N.what() << std::endl;
686  throw Exception(N.what());
687  }
688 }
689 
690 //---------------------------------------------------------------------------
691 //---------------------------------------------------------------------------
692 
693 void TCCUnionEntreDepositos::CabeceraResultadosInstantUED(stringstream& insoutput) {
694  try {
695 //FILE *fich=fopen(FileSALIDA,"a");
696  std::string Label;
697 
698  if(FResInstantUED.Massflow) {
699  Label = "\t" + PutLabel(411) + std::to_string(FNumeroCC) + PutLabel(904);
700  insoutput << Label.c_str();
701  }
702 
703 //fclose(fich);
704  } catch(exception &N) {
705  std::cout << "ERROR: TCCUnionEntreDepositos::CabeceraResultadosInstantUED en la BC " << FNumeroCC << std::endl;
706  std::cout << "Tipo de error: " << N.what() << std::endl;
707  throw Exception(N.what());
708  }
709 }
710 
711 //---------------------------------------------------------------------------
712 //---------------------------------------------------------------------------
713 
714 void TCCUnionEntreDepositos::ResultadosInstantUED() {
715  try {
716  if(FResInstantUED.Massflow)
717  FResInstantUED.GastoINS = FGastoImpreso;
718 
719  } catch(exception &N) {
720  std::cout << "ERROR: TCCUnionEntreDepositos::ResultadosInstantUED en la BC " << FNumeroCC << std::endl;
721  std::cout << "Tipo de error: " << N.what() << std::endl;
722  throw Exception(N.what());
723  }
724 }
725 
726 //---------------------------------------------------------------------------
727 //---------------------------------------------------------------------------
728 
729 void TCCUnionEntreDepositos::ImprimeResultadosInstantUED(stringstream& insoutput) {
730  try {
731 //FILE *fich=fopen(FileSALIDA,"a");
732 
733  if(FResInstantUED.Massflow)
734  insoutput << "\t" << FResInstantUED.GastoINS;
735 
736 //fclose(fich);
737  } catch(exception &N) {
738  std::cout << "ERROR: TCCUnionEntreDepositos::ImprimeResultadosInstantUED en la BC " << FNumeroCC << std::endl;
739  std::cout << "Tipo de error: " << N.what() << std::endl;
740  throw Exception(N.what());
741  }
742 }
743 
744 //------------------------------------------------------------------------------
745 //------------------------------------------------------------------------------
746 
747 void TCCUnionEntreDepositos::ReadAverageResultsUED(const char *FileWAM, fpos_t &filepos) {
748  int nvars = 0, var = 0;
749  try {
750  FILE *fich = fopen(FileWAM, "r");
751  fsetpos(fich, &filepos);
752 
753  fscanf(fich, "%d ", &nvars);
754  for(int i = 0; i < nvars; i++) {
755  fscanf(fich, "%d ", &var);
756  switch(var) {
757  case 0:
758  FResMediosUED.Massflow = true;
759  break;
760  default:
761  std::cout << "Resultados medios en UED(BC) " << FNumeroCC << " no implementados " << std::endl;
762  }
763  }
764  fgetpos(fich, &filepos);
765  fclose(fich);
766  } catch(exception &N) {
767  std::cout << "ERROR: TCCUnionEntreDepositos::ReadAverageResultsUED en la BC " << FNumeroCC << std::endl;
768  std::cout << "Tipo de error: " << N.what() << std::endl;
769  throw Exception(N.what());
770  }
771 }
772 
773 //---------------------------------------------------------------------------
774 //---------------------------------------------------------------------------
775 
776 void TCCUnionEntreDepositos::HeaderAverageResultsUED(stringstream& medoutput) {
777  try {
778 //FILE *fich=fopen(FileSALIDA,"a");
779  std::string Label;
780 
781  if(FResMediosUED.Massflow) {
782  Label = "\t" + PutLabel(411) + std::to_string(FNumeroCC) + PutLabel(904);
783  medoutput << Label.c_str();
784  }
785 
786 //fclose(fich);
787  } catch(exception &N) {
788  std::cout << "ERROR: TCCUnionEntreDepositos::HeaderAverageResultsUED en la BC " << FNumeroCC << std::endl;
789  std::cout << "Tipo de error: " << N.what() << std::endl;
790  throw Exception(N.what());
791  }
792 }
793 
794 //---------------------------------------------------------------------------
795 //---------------------------------------------------------------------------
796 
797 void TCCUnionEntreDepositos::AcumulaResultadosMediosUED(double Actual) {
798  try {
799 
800  double Delta = Actual - FResMediosUED.Tiempo0;
801 
802  if(FResMediosUED.Massflow) {
803  FResMediosUED.GastoSUM += FGastoImpreso * Delta;
804  }
805  FResMediosUED.TiempoSUM += Delta;
806  FResMediosUED.Tiempo0 = Actual;
807  } catch(exception &N) {
808  std::cout << "ERROR: TCCUnionEntreDepositos::AcumulaResultadosMediosUED en la BC " << FNumeroCC << std::endl;
809  std::cout << "Tipo de error: " << N.what() << std::endl;
810  throw Exception(N.what());
811  }
812 }
813 
814 //---------------------------------------------------------------------------
815 //---------------------------------------------------------------------------
816 
817 void TCCUnionEntreDepositos::ResultadosMediosUED() {
818  try {
819  if(FResMediosUED.Massflow) {
820  FResMediosUED.GastoMED = FResMediosUED.GastoSUM / FResMediosUED.TiempoSUM;
821  FResMediosUED.GastoSUM = 0.;
822  }
823 
824  FResMediosUED.TiempoSUM = 0;
825  } catch(exception &N) {
826  std::cout << "ERROR: TCCUnionEntreDepositos::ResultadosMediosUED en la BC " << FNumeroCC << std::endl;
827  std::cout << "Tipo de error: " << N.what() << std::endl;
828  throw Exception(N.what());
829  }
830 }
831 //---------------------------------------------------------------------------
832 //---------------------------------------------------------------------------
833 
834 void TCCUnionEntreDepositos::ImprimeResultadosMediosUED(stringstream& medoutput) {
835  try {
836 //FILE *fich=fopen(FileSALIDA,"a");
837 
838  if(FResMediosUED.Massflow)
839  medoutput << "\t" << FResMediosUED.GastoMED;
840 
841 //fclose(fich);
842  } catch(exception &N) {
843  std::cout << "ERROR: TCCUnionEntreDepositos::ImprimeResultadosMediosUED en la BC " << FNumeroCC << std::endl;
844  std::cout << "Tipo de error: " << N.what() << std::endl;
845  throw Exception(N.what());
846  }
847 }
848 
849 //---------------------------------------------------------------------------
850 //---------------------------------------------------------------------------
851 
852 #pragma package(smart_init)
TRotorTurbina
Definition: TRotorTurbina.h:48
TTipoValvula
Definition: TTipoValvula.h:53
TWasteGate
Definition: TWasteGate.h:47
TValvulaContr
Definition: TValvulaContr.h:46
TLamina
Definition: TLamina.h:50
TCondicionContorno
Definition: TCondicionContorno.h:54
TCDFijo
Definition: TCDFijo.h:43
TDeposito
Definition: TDeposito.h:44
PutLabel
std::string PutLabel(int idx)
Returns an integer.
Definition: labels.cpp:475
TValvula4T
Definition: TValvula4T.h:45
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