OpenWAM
TCilindro.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 "TCilindro.h"
32 #include "TBloqueMotor.h"
33 #include "TTubo.h"
34 #include "TCCCilindro.h"
35 #include "TValvula4T.h"
36 #include "TLumbrera.h"
37 
38 //#include <cmath>
39 
40 // ---------------------------------------------------------------------------
41 // ---------------------------------------------------------------------------
42 
43 TCilindro::TCilindro(TBloqueMotor *Engine, bool ThereIsEGR) {
44 
45  FMotor = Engine;
46 
47  FAngDesplazado = NULL;
48  FTempPared = NULL;
49  FTrabajoNeto = 0.;
50  FSwirlSUM = 0.;
51 
52  FHayEGR = ThereIsEGR;
53  if(FHayEGR)
54  FIntEGR = 0;
55  else
56  FIntEGR = 1;
57 
58  FResInstantCilindro.FraccionINS = NULL;
59  FResInstantCilindro.MomentoAngularEscINS = NULL;
60  FResInstantCilindro.MomentoAngularAdmINS = NULL;
61  FResInstantCilindro.GastoEscINS = NULL;
62  FResInstantCilindro.GastoAdmINS = NULL;
63  FResInstantCilindro.MachEscINS = NULL;
64  FResInstantCilindro.MachAdmINS = NULL;
65  FResInstantCilindro.SeccionEfectivaEscINS = NULL;
66  FResInstantCilindro.SeccionEfectivaAdmINS = NULL;
67  FResInstantCilindro.NITINS = NULL;
68  FResMediosCilindro.NITMED = NULL;
69 
70  FCCValvulaAdm = NULL;
71  FCCValvulaEsc = NULL;
72 
73  FValvEsc = NULL;
74  FValvAdm = NULL;
75 
76  FSaturado = false;
77 
78  FInyeccion = false;
79 
80  FHaydll = false;
81  FModComb = false;
82 
83  FIniComb = 0.;
84  FFinComb = 0.;
85 
86  FMfControlled = false;
87 
88  if(FMotor->getACT()) {
89  Fengine_parameters = (double*) malloc(25 * sizeof(double));
90  Fengine_parameters[0] = FMotor->getGeometria().Diametro;
91  // Piston diameter
92  Fengine_parameters[1] = FMotor->getGeometria().Carrera; // Piston stroke
93  Fengine_parameters[2] = FMotor->getGeometria().Carrera / 2.;
94  // Crank length
95  Fengine_parameters[3] = FMotor->getGeometria().Biela;
96  // Connecting Rod Length
97  Fengine_parameters[4] = FMotor->getGeometria().Excentricidad;
98  // Piston Eccentricity
99  Fengine_parameters[5] = FMotor->getGeometria().DiametroBulon;
100  // Piston Axis Diameter
101  Fengine_parameters[6] = FMotor->getGeometria().AlturaCoronaPiston;
102  // Piston Crown Height
103  Fengine_parameters[7] = FMotor->getGeometria().DiametroBowl;
104  // Maximum Diameter of Bowl
105  Fengine_parameters[8] = FMotor->getGeometria().DiametroBowl * FMotor->getGeometria().DiametroBowl * __cons::Pi_4 *
106  FMotor->getGeometria().AlturaBowl;
107  // Volume of Bowl
108  Fengine_parameters[9] = FMotor->getGeometria().MasaBiela;
109  // Mass connecting rod
110  Fengine_parameters[10] = FMotor->getGeometria().MasaPistonSegmentosBulon;
111  // Mass of piston + rings + piston axis
112  Fengine_parameters[11] = FMotor->getGeometria().ModuloElasticidad;
113  // Elasticity steel module
114  Fengine_parameters[12] = FMotor->getGeometria().CoefDeformaciones;
115  // Mechanical deformations coefficient
116  Fengine_parameters[13] = FMotor->getGeometria().AreaBlowBy;
117  // Coefficient of leak's section of blow-by
118  Fengine_parameters[14] = FMotor->getGeometria().RelaCompresion;
119  // Geometric compression ratio
120  Fengine_parameters[15] = FMotor->getInjectionSys().HoleNumber;
121  // Number of nozzle holes
122  Fengine_parameters[16] = FMotor->getInjectionSys().HoleDiame;
123  // Nozzle diameter
124  Fengine_parameters[17] = FMotor->getInjectionSys().CDHole;
125  // Discharge coefficient of the nozzle
126  Fengine_parameters[18] = 2.15; // CTM
127  Fengine_parameters[19] = FMotor->getWoschni().cw1;
128  // Constant A to calculate CW1
129  Fengine_parameters[20] = FMotor->getWoschni().cw2;
130  // Constant B to calculate CW1
131  Fengine_parameters[21] = 0.001; // Woshni calculus coefficient CW2
132  Fengine_parameters[22] = FDistribucion.CA - 720.; // Inlet valve closing
133  Fengine_parameters[23] = FDistribucion.AE; // Exhaust valve opening
134  Fengine_parameters[24] = FMotor->getMixtureProcessCte();
135  // Mixture process constant
136 
137  Fengine_model_constants = (double*) malloc(22 * sizeof(double));
138 
139  Fengine_model_constants[0] = -1.5; // Kmixture2
140  Fengine_model_constants[1] = 13000; // Kpmx1
141  Fengine_model_constants[2] = 500; // Kpmx2
142  Fengine_model_constants[3] = 0.5; // Kpmx3
143  Fengine_model_constants[4] = 0.5; // Kpmx4
144  Fengine_model_constants[5] = 0.22; // Kpmx5
145  Fengine_model_constants[6] = 1; // KID1
146  Fengine_model_constants[7] = 0.03; // KID2
147  Fengine_model_constants[8] = 5.47896; // KID3
148  Fengine_model_constants[9] = 0.118895; // KID4
149  Fengine_model_constants[10] = 0.0684351; // KID5
150  Fengine_model_constants[11] = 1.23; // KNOx1
151  Fengine_model_constants[12] = 0.203644; // KNOx2
152  Fengine_model_constants[13] = 1; // KNOx_EC
153  Fengine_model_constants[14] = 0.0023326; // KSOOTA1
154  Fengine_model_constants[15] = 0.5; // KSOOTA2
155  Fengine_model_constants[16] = 6296.9; // KSOOTA3
156  Fengine_model_constants[17] = 1.8197; // KSOOTA4
157  Fengine_model_constants[18] = 1; // KSOOTA5
158  Fengine_model_constants[19] = 1.8; // KSOOTA6
159  Fengine_model_constants[20] = 7050; // KSOOTA7
160  Fengine_model_constants[21] = 0.01; // PMlhp_error
161 
162  Ftest_variables = (double*) malloc(18 * sizeof(double));
163 
164  Ftest_variables[0] = FMotor->getRegimen();
165  Ftest_variables[1] = FMotor->getMasaInicial() * 1000;
166  // Measured air mass
167  Ftest_variables[2] = FMotor->getMasaInicial() * 1000;
168  // In-cylinder air mass at inlet valve closing
169  Ftest_variables[3] = 372.434622123441; // In-cylinder temperature at inlet valve closing
170  Ftest_variables[4] = FMotor->getMasaFuel() * 1e6; // Fuel injected mass
171  Ftest_variables[5] = FMotor->getInjectionSys().InjectPressure;
172  // Injection pressure
173  Ftest_variables[6] = 170100; // Inlet pressure
174  Ftest_variables[7] = 188300; // Exhaust pressure
175  Ftest_variables[8] = FMotor->getGeometria().CDBlowBy;
176  // Blow-by coefficient
177  Ftest_variables[9] = __units::BarToPa(FMotor->getPresionAmb());
178  // Atmosphere pressure
179  Ftest_variables[10] = 318.15; // Fuel injection temperature
180  Ftest_variables[11] = 390.85; // Cylinder head temperature
181  Ftest_variables[12] = 383.45; // Cylinder temperature
182  Ftest_variables[13] = 457.65; // Piston temperature
183  Ftest_variables[14] = 0; // NOx concentration at IVC
184  Ftest_variables[15] = 0; // SOOT concentration at IVC
185  Ftest_variables[16] = 0; // CO concentration at IVC
186  Ftest_variables[17] = 0; // HC concentration at IVC
187 
188  Fsize_inlet_inj = 1801;
189  FCAI = 1801;
190 
191  Finjection_rate = (double*) malloc(FCAI * sizeof(double));
192 
193  FCAD_injection_rate = (double*) malloc(FCAI * sizeof(double));
194 
195  FCAD_injection_rate[0] = -180;
196  for(int counter = 1; counter < FCAI; counter++) {
197  FCAD_injection_rate[counter] = FCAD_injection_rate[counter - 1] + ((360. / (FCAI - 1)));
198  }
199 
200  FCAD_exit = (double*) malloc(FCAI * sizeof(double));
201 
202  FHRF_exit = (double*) malloc(FCAI * sizeof(double));
203 
204  FROHR_exit = (double*) malloc(FCAI * sizeof(double));
205 
206  Fp_cyl_exit = (double*) malloc(FCAI * sizeof(double));
207 
208  Fdp_da_cyl_exit = (double*) malloc(FCAI * sizeof(double));
209 
210  FT_cyl_exit = (double*) malloc(FCAI * sizeof(double));
211 
212  Finjection_rate_exit = (double*) malloc(FCAI * sizeof(double));
213 
214  Faccum_injection_rate_exit = (double*) malloc(FCAI * sizeof(double));
215 
216  FH_cooler_exit = (double*) malloc(FCAI * sizeof(double));
217 
218  Fmean_var_exit = (double*) malloc(11 * sizeof(double));
219 
220  Fheat_transfer = (double*) malloc(4 * sizeof(double));
221 
222  dataOUT.evol_Soot = (double*) malloc(FCAI * sizeof(double));
223  dataOUT.evol_Soot_CIL = (double*) malloc(FCAI * sizeof(double));
224  dataOUT.evol_Radiacion = (double*) malloc(FCAI * sizeof(double));
225  dataOUT.HRF_PMX = (double*) malloc(FCAI * sizeof(double));
226  dataOUT.evol_LOL = (double*) malloc(FCAI * sizeof(double));
227 
228  dataIN.KSOOTC1 = 1.2771738e-3;
229 
230  FIN = FMotor->getInjectionSys().NumPulsos;
231 
232  FSOP = (double*) malloc(8 * sizeof(double));
233 
234  for(int i = 0; i < 8; i++) {
235  if(i < FIN) {
236  FSOP[i] = FMotor->getInjecPulse(i).Angulo;
237  } else {
238  FSOP[i] = 180.;
239  }
240  }
241 
242  FMFI = (double*) malloc(8 * sizeof(double));
243 
244  for(int i = 0; i < 8; i++) {
245  if(i < FIN) {
246  FMFI[i] = FMotor->getInjecPulse(i).Masa * FMotor->getMasaFuel() * 1e6;
247  } else {
248  FMFI[i] = 0.;
249  }
250  }
251 
252  FSOI = (double*) malloc(8 * sizeof(double));
253  FEOI = (double*) malloc(8 * sizeof(double));
254 
255  FA_TASA = (double*) malloc(2 * sizeof(double));
256 
257  FA_TASA[0] = FMotor->getInjectionSys().PendOpen_A1;
258  FA_TASA[1] = FMotor->getInjectionSys().PendOpen_A2;
259 
260  FB_TASA = (double*) malloc(2 * sizeof(double));
261 
262  FB_TASA[0] = FMotor->getInjectionSys().LevMax_B1;
263  FB_TASA[1] = FMotor->getInjectionSys().LevMax_B2;
264 
265  FC_TASA = (double*) malloc(2 * sizeof(double));
266 
267  FC_TASA[0] = FMotor->getInjectionSys().PendClose_C1;
268  FC_TASA[1] = FMotor->getInjectionSys().PendClose_C2;
269 
270  FD_TASA = (double*) malloc(2 * sizeof(double));
271 
272  FD_TASA[0] = FMotor->getInjectionSys().Desfase_D1;
273  FD_TASA[1] = FMotor->getInjectionSys().Desfase_D2;
274 
275  if(FMotor->getSpeciesNumber() == 9) {
276  dataOUT.species_EVO[0] = FMotor->GetComposicionInicial(7); // N2
277  } else if(FMotor->getSpeciesNumber() == 10) {
278  dataOUT.species_EVO[0] = FMotor->GetComposicionInicial(8); // N2
279  }
280  dataOUT.species_EVO[1] = FMotor->GetComposicionInicial(0); // O2
281  dataOUT.species_EVO[2] = FMotor->GetComposicionInicial(1); // CO2
282  dataOUT.species_EVO[3] = FMotor->GetComposicionInicial(2); // H2O
283  dataOUT.species_EVO[4] = FMotor->GetComposicionInicial(5); // NOx
284  dataOUT.species_EVO[5] = FMotor->GetComposicionInicial(6); // CO
285  dataOUT.species_EVO[6] = FMotor->GetComposicionInicial(4); // SOOT
286  dataOUT.species_EVO[7] = FMotor->GetComposicionInicial(3); // HC
287 
288  FSpecies_IVC = (double*) malloc(8 * sizeof(double));
289 
290  if(FMotor->getSpeciesNumber() == 9) {
291  FSpecies_IVC[0] = FMotor->GetComposicionInicial(7); // N2
292  } else if(FMotor->getSpeciesNumber() == 10) {
293  FSpecies_IVC[0] = FMotor->GetComposicionInicial(8); // N2
294  }
295  FSpecies_IVC[1] = FMotor->GetComposicionInicial(0); // O2
296  FSpecies_IVC[2] = FMotor->GetComposicionInicial(1); // CO2
297  FSpecies_IVC[3] = FMotor->GetComposicionInicial(2); // H2O
298  FSpecies_IVC[4] = FMotor->GetComposicionInicial(5); // NOx
299  FSpecies_IVC[5] = FMotor->GetComposicionInicial(6); // CO
300  FSpecies_IVC[6] = FMotor->GetComposicionInicial(4); // SOOT
301  FSpecies_IVC[7] = FMotor->GetComposicionInicial(3); // HC
302 
303  FPresionMedAdm = 0.;
304  FPresionMedEsc = 0.;
305  FTimeAcumAct = 0.;
306  }
307 }
308 
309 // ---------------------------------------------------------------------------
310 // ---------------------------------------------------------------------------
311 
312 TCilindro::~TCilindro() {
313 
314  if(FAngDesplazado != NULL)
315  delete[] FAngDesplazado;
316  if(FTempPared != NULL)
317  delete[] FTempPared;
318 
319  if(FCCValvulaAdm != NULL)
320  delete[] FCCValvulaAdm;
321  if(FCCValvulaEsc != NULL)
322  delete[] FCCValvulaEsc;
323 
324  if(FResInstantCilindro.FraccionINS != NULL)
325  delete[] FResInstantCilindro.FraccionINS;
326  if(FResInstantCilindro.MomentoAngularEscINS != NULL)
327  delete[] FResInstantCilindro.MomentoAngularEscINS;
328  if(FResInstantCilindro.MomentoAngularAdmINS != NULL)
329  delete[] FResInstantCilindro.MomentoAngularAdmINS;
330  if(FResInstantCilindro.GastoEscINS != NULL)
331  delete[] FResInstantCilindro.GastoEscINS;
332  if(FResInstantCilindro.GastoAdmINS != NULL)
333  delete[] FResInstantCilindro.GastoAdmINS;
334  if(FResInstantCilindro.MachEscINS != NULL)
335  delete[] FResInstantCilindro.MachEscINS;
336  if(FResInstantCilindro.MachAdmINS != NULL)
337  delete[] FResInstantCilindro.MachAdmINS;
338  if(FResInstantCilindro.SeccionEfectivaEscINS != NULL)
339  delete[] FResInstantCilindro.SeccionEfectivaEscINS;
340  if(FResInstantCilindro.SeccionEfectivaAdmINS != NULL)
341  delete[] FResInstantCilindro.SeccionEfectivaAdmINS;
342  if(FResInstantCilindro.NITINS != NULL)
343  delete[] FResInstantCilindro.NITINS;
344  if(FResMediosCilindro.NITMED != NULL)
345  delete[] FResMediosCilindro.NITMED;
346 
347  if(FValvAdm != NULL)
348  delete[] FValvAdm;
349  if(FValvEsc != NULL)
350  delete[] FValvEsc;
351 
352  if(FMotor->getACT()) {
353  free(Fengine_parameters);
354  free(Fengine_model_constants);
355  free(Ftest_variables);
356  free(Finjection_rate);
357  free(FCAD_injection_rate);
358  free(FCAD_exit);
359  free(FHRF_exit);
360  free(FROHR_exit);
361  free(Fp_cyl_exit);
362  free(Fdp_da_cyl_exit);
363  free(FT_cyl_exit);
364  free(FH_cooler_exit);
365  free(Fmean_var_exit);
366  free(Fheat_transfer);
367  free(Finjection_rate_exit);
368  free(Faccum_injection_rate_exit);
369  free(FSOP);
370  free(FMFI);
371  free(FSOI);
372  free(FEOI);
373  free(FA_TASA);
374  free(FB_TASA);
375  free(FC_TASA);
376  free(FD_TASA);
377  free(FSpecies_IVC);
378  free(dataOUT.evol_Soot);
379  free(dataOUT.evol_Soot_CIL);
380  free(dataOUT.evol_Radiacion);
381  free(dataOUT.HRF_PMX);
382  free(dataOUT.evol_LOL);
383  }
384 }
385 
386 // ---------------------------------------------------------------------------
387 // ---------------------------------------------------------------------------
388 
389 void TCilindro::AsignacionCC(TCondicionContorno **BC, int numCC) {
390  try {
391  bool UnionAsignada;
392 
393  /* Union Cylinder-Pipe */
394 
395  FNumeroUnionesAdm = 0;
396  FNumeroUnionesEsc = 0;
397 
398  for(int i = 0; i < numCC; i++) {
399  if(BC[i]->getTipoCC() == nmIntakeValve) {
400  if(FNumeroCilindro == dynamic_cast<TCCCilindro*>(BC[i])->getNumeroCilindro()) {
401  FNumeroUnionesAdm++;
402  }
403  } else if(BC[i]->getTipoCC() == nmExhaustValve) {
404  if(FNumeroCilindro == dynamic_cast<TCCCilindro*>(BC[i])->getNumeroCilindro()) {
405  FNumeroUnionesEsc++;
406  }
407  }
408  }
409 
410  if(FNumeroUnionesAdm != 0)
411  FCCValvulaAdm = new TCondicionContorno*[FNumeroUnionesAdm];
412  if(FNumeroUnionesEsc != 0)
413  FCCValvulaEsc = new TCondicionContorno*[FNumeroUnionesEsc];
414 
415  bool *CCasignadaAdm;
416  CCasignadaAdm = new bool[numCC];
417  for(int i = 0; i < numCC; i++)
418  CCasignadaAdm[i] = false;
419 
420  for(int j = 0; j < FNumeroUnionesAdm; j++) {
421  UnionAsignada = false;
422  for(int i = 0; i < numCC; i++) {
423  if(BC[i]->getTipoCC() == nmIntakeValve) {
424  if(FNumeroCilindro == dynamic_cast<TCCCilindro*>(BC[i])->getNumeroCilindro() && !CCasignadaAdm[i] && !UnionAsignada) {
425  FCCValvulaAdm[j] = BC[i];
426  UnionAsignada = true;
427  CCasignadaAdm[i] = true;
428  }
429  }
430  }
431  }
432 
433  delete[] CCasignadaAdm;
434 
435  bool *CCasignadaEsc;
436  CCasignadaEsc = new bool[numCC];
437  for(int i = 0; i < numCC; i++)
438  CCasignadaEsc[i] = false;
439 
440  for(int j = 0; j < FNumeroUnionesEsc; j++) {
441  UnionAsignada = false;
442  for(int i = 0; i < numCC; i++) {
443  if(BC[i]->getTipoCC() == nmExhaustValve) {
444  if(FNumeroCilindro == dynamic_cast<TCCCilindro*>(BC[i])->getNumeroCilindro() && !CCasignadaEsc[i] && !UnionAsignada) {
445  FCCValvulaEsc[j] = BC[i];
446  UnionAsignada = true;
447  CCasignadaEsc[i] = true;
448  }
449  }
450  }
451  }
452 
453  delete[] CCasignadaEsc;
454 
455  Fctorbadmp = CalculaCTorbAdmProm();
456  FKctm = exp(-0.200679 * pow(Fctorbadmp, 0.431202));
457  Fratioctm = pow2(FMotor->getGeometria().DiametroBowl / FMotor->getGeometria().Diametro) / FKctm;
458 
459  nmTipoValvula IntakeValveType = dynamic_cast<TCCCilindro*>(FCCValvulaAdm[0])->getValvula()->getTypeOfValve();
460  switch(IntakeValveType) {
461  case nmValvula4T:
462  FDistribucion.AA = dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>
463  (FCCValvulaAdm[0])->getValvula())->getAnguloApertura();
464  FDistribucion.CA = dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>
465  (FCCValvulaAdm[0])->getValvula())->getAnguloCierre();
466  for(int i = 0; i < FNumeroUnionesAdm; i++) {
467  if(dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getValvula())->getAnguloApertura() <
468  FDistribucion.AA) {
469  FDistribucion.AA = dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>
470  (FCCValvulaAdm[i])->getValvula())->getAnguloApertura();
471  }
472  if(dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getValvula())->getAnguloCierre() >
473  FDistribucion.CA) {
474  FDistribucion.CA = dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>
475  (FCCValvulaAdm[i])->getValvula())->getAnguloCierre();
476  }
477  }
478  break;
479  case nmLumbrera2T:
480  FDistribucion.AA = dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>
481  (FCCValvulaAdm[0])->getValvula())->getAnguloApertura();
482  FDistribucion.CA = dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>
483  (FCCValvulaAdm[0])->getValvula())->getAnguloCierre();
484  for(int i = 0; i < FNumeroUnionesAdm; i++) {
485  if(dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getValvula())->getAnguloApertura() <
486  FDistribucion.AA) {
487  FDistribucion.AA = dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>
488  (FCCValvulaAdm[i])->getValvula())->getAnguloApertura();
489  }
490  if(dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getValvula())->getAnguloCierre() >
491  FDistribucion.CA) {
492  FDistribucion.CA = dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>
493  (FCCValvulaAdm[i])->getValvula())->getAnguloCierre();
494  }
495  }
496  break;
497  default:
498  std::cout << "ERROR: Intake valve is not a poppet valve nor a cylinder port " << std::endl;
499  }
500 
501  nmTipoValvula ExhaustValveType = dynamic_cast<TCCCilindro*>(FCCValvulaEsc[0])->getValvula()->getTypeOfValve();
502  switch(ExhaustValveType) {
503  case nmValvula4T:
504  FDistribucion.AE = dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>
505  (FCCValvulaEsc[0])->getValvula())->getAnguloApertura();
506  FDistribucion.CE = dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>
507  (FCCValvulaEsc[0])->getValvula())->getAnguloCierre();
508  for(int i = 0; i < FNumeroUnionesEsc; i++) {
509  if(dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getValvula())->getAnguloApertura() <
510  FDistribucion.AE) {
511  FDistribucion.AE = dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>
512  (FCCValvulaEsc[i])->getValvula())->getAnguloApertura();
513  }
514  if(dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getValvula())->getAnguloCierre() >
515  FDistribucion.CE) {
516  FDistribucion.CE = dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>
517  (FCCValvulaEsc[i])->getValvula())->getAnguloCierre();
518  }
519  }
520  break;
521  case nmLumbrera2T:
522  FDistribucion.AE = dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>
523  (FCCValvulaEsc[0])->getValvula())->getAnguloApertura();
524  FDistribucion.CE = dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>
525  (FCCValvulaEsc[0])->getValvula())->getAnguloCierre();
526  for(int i = 0; i < FNumeroUnionesEsc; i++) {
527  if(dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getValvula())->getAnguloApertura() <
528  FDistribucion.AE) {
529  FDistribucion.AE = dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>
530  (FCCValvulaEsc[i])->getValvula())->getAnguloApertura();
531  }
532  if(dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getValvula())->getAnguloCierre() >
533  FDistribucion.CE) {
534  FDistribucion.CE = dynamic_cast<TLumbrera*>(dynamic_cast<TCCCilindro*>
535  (FCCValvulaEsc[i])->getValvula())->getAnguloCierre();
536  }
537  }
538  break;
539  default:
540  std::cout << "ERROR: Exhaust valve is not a poppet valve nor a cylinder port " << std::endl;
541  }
542 
543  if(FMotor->getACT()) {
544  Fengine_parameters[18] = Fctorbadmp; // CTM
545  if(FMotor->getEngineType() == nm4T)
546  Fengine_parameters[22] = FDistribucion.CA - 720;
547  else
548  Fengine_parameters[22] = FDistribucion.CA - 360;
549  // Inlet valve closing
550  Fengine_parameters[23] = FDistribucion.AE; // Exhaust valve opening
551  }
552 
553  // Valor de alpha para el modelo de cortocircuito.
554  if(FMotor->getEngineType() == nm4T) {
555  FAlphaEscape = asin((dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>
556  (FCCValvulaEsc[0])->getValvula())->getDiametro() / 2.) / FMotor->getGeometria().DistanciaValvulas);
557  FAlphaAdmision = asin((dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>
558  (FCCValvulaAdm[0])->getValvula())->getDiametro() / 2.) / FMotor->getGeometria().DistanciaValvulas);
559  }
560 
561  if(FResInstantCilindro.MomentoAngularEsc) {
562  FResInstantCilindro.MomentoAngularEscINS = new double[FNumeroUnionesEsc];
563  for(int i = 0; i < FNumeroUnionesEsc; i++) {
564  FResInstantCilindro.MomentoAngularEscINS[i] = 0.;
565  }
566  }
567  if(FResInstantCilindro.MomentoAngularAdm) {
568  FResInstantCilindro.MomentoAngularAdmINS = new double[FNumeroUnionesAdm];
569  for(int i = 0; i < FNumeroUnionesAdm; i++) {
570  FResInstantCilindro.MomentoAngularAdmINS[i] = 0.;
571  }
572  }
573  if(FResInstantCilindro.GastoEsc) {
574  FResInstantCilindro.GastoEscINS = new double[FNumeroUnionesEsc];
575  for(int i = 0; i < FNumeroUnionesEsc; i++) {
576  FResInstantCilindro.GastoEscINS[i] = 0.;
577  }
578  }
579  if(FResInstantCilindro.GastoAdm) {
580  FResInstantCilindro.GastoAdmINS = new double[FNumeroUnionesAdm];
581  for(int i = 0; i < FNumeroUnionesAdm; i++) {
582  FResInstantCilindro.GastoAdmINS[i] = 0.;
583  }
584  }
585  if(FResInstantCilindro.MachEsc) {
586  FResInstantCilindro.MachEscINS = new double[FNumeroUnionesEsc];
587  for(int i = 0; i < FNumeroUnionesEsc; i++) {
588  FResInstantCilindro.MachEscINS[i] = 0.;
589  }
590  }
591  if(FResInstantCilindro.MachAdm) {
592  FResInstantCilindro.MachAdmINS = new double[FNumeroUnionesAdm];
593  for(int i = 0; i < FNumeroUnionesAdm; i++) {
594  FResInstantCilindro.MachAdmINS[i] = 0;
595  }
596  }
597  if(FResInstantCilindro.SeccionEfectivaEsc) {
598  FResInstantCilindro.SeccionEfectivaEscINS = new double[FNumeroUnionesEsc];
599  for(int i = 0; i < FNumeroUnionesEsc; i++) {
600  FResInstantCilindro.SeccionEfectivaEscINS[i] = 0.;
601  }
602  }
603  if(FResInstantCilindro.SeccionEfectivaAdm) {
604  FResInstantCilindro.SeccionEfectivaAdmINS = new double[FNumeroUnionesAdm];
605  for(int i = 0; i < FNumeroUnionesAdm; i++) {
606  FResInstantCilindro.SeccionEfectivaAdmINS[i] = 0.;
607  }
608  }
609  if(FResInstantCilindro.NIT) {
610  FResInstantCilindro.NITINS = new double[FNumeroUnionesEsc];
611  for(int i = 0; i < FNumeroUnionesEsc; i++) {
612  FResInstantCilindro.NITINS[i] = 0.;
613  }
614  }
615  if(FResMediosCilindro.NITMedio) {
616  FResMediosCilindro.NITMED = new double[FNumeroUnionesEsc];
617  for(int i = 0; i < FNumeroUnionesEsc; i++) {
618  FResMediosCilindro.NITMED[i] = 0.;
619  }
620  }
621 
622  // Solo se usa el NIT de las valvulas de escape, pero como antes estaba como resultados por pantalla,
623  // lo dejo por lo que pueda pasar, y al menos la estructura ya existe.
624  FValvAdm = new stValvulasCilindro[FNumeroUnionesAdm];
625  for(int i = 0; i < FNumeroUnionesAdm; i++) {
626  FValvAdm[i].GastoSUM = 0.;
627  FValvAdm[i].GastoSeccionSUM = 0.;
628  FValvAdm[i].MachSUM = 0.;
629  FValvAdm[i].RelacionPresionGargantaSUM = 0.;
630  }
631 
632  FValvEsc = new stValvulasCilindro[FNumeroUnionesEsc];
633  for(int i = 0; i < FNumeroUnionesEsc; i++) {
634  FValvEsc[i].GastoSUM = 0.;
635  FValvEsc[i].GastoSeccionSUM = 0.;
636  FValvEsc[i].MachSUM = 0.;
637  FValvEsc[i].RelacionPresionGargantaSUM = 0.;
638  FValvEsc[i].NITSUM = 0.;
639  }
640 
641  } catch(exception & N) {
642  std::cout << "ERROR: TCilindro::AsignacionCC en cilindro: " << FNumeroCilindro << std::endl;
643  std::cout << "Tipo de error: " << N.what() << std::endl;
644  throw Exception(N.what());
645  }
646 }
647 
648 // ---------------------------------------------------------------------------
649 // ---------------------------------------------------------------------------
650 
651 void TCilindro::ReadAverageResultsCilindro(const char *FileWAM, fpos_t &filepos) {
652  try {
653  int Tipovar = 0;
654 
655  FILE *fich = fopen(FileWAM, "r");
656  fsetpos(fich, &filepos);
657 
658  FResMediosCilindro.TrabajoNeto = false;
659  FResMediosCilindro.TrabajoNetoMED = 0.;
660  FResMediosCilindro.TrabajoNetoSUM = 0.;
661  FResMediosCilindro.PresionMediaNeta = false;
662  FResMediosCilindro.PresionMediaNetaMED = 0.;
663  FResMediosCilindro.TrabajoBombeo = false;
664  FResMediosCilindro.TrabajoBombeoMED = 0.;
665  FResMediosCilindro.TrabajoBombeoSUM = 0.;
666  FResMediosCilindro.PresionMediaBombeo = false;
667  FResMediosCilindro.PresionMediaBombeoMED = 0.;
668  FResMediosCilindro.CalorCombustion = false;
669  FResMediosCilindro.CalorCombustionMED = 0.;
670  FResMediosCilindro.CalorCombustionSUM = 0.;
671  FResMediosCilindro.CalorCilindro = false;
672  FResMediosCilindro.CalorCilindroMED = 0.;
673  FResMediosCilindro.CalorCilindroSUM = 0.;
674  FResMediosCilindro.CalorCulata = false;
675  FResMediosCilindro.CalorCulataMED = 0.;
676  FResMediosCilindro.CalorCulataSUM = 0.;
677  FResMediosCilindro.CalorPiston = false;
678  FResMediosCilindro.CalorPistonMED = 0.;
679  FResMediosCilindro.CalorPistonSUM = 0.;
680  FResMediosCilindro.PresionMediaIndicada = false;
681  FResMediosCilindro.PresionMediaIndicadaMED = 0.;
682  FResMediosCilindro.MasaAtrapada = false;
683  FResMediosCilindro.MasaAtrapadaMED = 0.;
684  FResMediosCilindro.TemperaturaCilindroInterna = false;
685  FResMediosCilindro.TemperaturaCilindroInternaMED = 0.;
686  FResMediosCilindro.TemperaturaCilindroInternaSUM = 0.;
687  FResMediosCilindro.TemperaturaCilindroMedia = false;
688  FResMediosCilindro.TemperaturaCilindroMediaMED = 0.;
689  FResMediosCilindro.TemperaturaCilindroMediaSUM = 0.;
690  FResMediosCilindro.TemperaturaCilindroExterna = false;
691  FResMediosCilindro.TemperaturaCilindroExternaMED = 0.;
692  FResMediosCilindro.TemperaturaCilindroExternaSUM = 0.;
693  FResMediosCilindro.TemperaturaPistonInterna = false;
694  FResMediosCilindro.TemperaturaPistonInternaMED = 0.;
695  FResMediosCilindro.TemperaturaPistonInternaSUM = 0.;
696  FResMediosCilindro.TemperaturaPistonMedia = false;
697  FResMediosCilindro.TemperaturaPistonMediaMED = 0.;
698  FResMediosCilindro.TemperaturaPistonMediaSUM = 0.;
699  FResMediosCilindro.TemperaturaPistonExterna = false;
700  FResMediosCilindro.TemperaturaPistonExternaMED = 0.;
701  FResMediosCilindro.TemperaturaPistonExternaSUM = 0.;
702  FResMediosCilindro.TemperaturaCulataInterna = false;
703  FResMediosCilindro.TemperaturaCulataInternaMED = 0.;
704  FResMediosCilindro.TemperaturaCulataInternaSUM = 0.;
705  FResMediosCilindro.TemperaturaCulataMedia = false;
706  FResMediosCilindro.TemperaturaCulataMediaMED = 0.;
707  FResMediosCilindro.TemperaturaCulataMediaSUM = 0.;
708  FResMediosCilindro.TemperaturaCulataExterna = false;
709  FResMediosCilindro.TemperaturaCulataExternaMED = 0.;
710  FResMediosCilindro.TemperaturaCulataExternaSUM = 0.;
711  FResMediosCilindro.NITMedio = false;
712  FResMediosCilindro.NITMedioMED = 0.;
713  FResMediosCilindro.NITMedioSUM = 0.;
714  FResMediosCilindro.AFRMedio = false;
715  FResMediosCilindro.AFRMedioMED = 0.;
716  FResMediosCilindro.MasaBlowBy = false;
717  FResMediosCilindro.MasaBlowByMED = 0.;
718  FResMediosCilindro.MasaBlowBySUM = 0.;
719  FResMediosCilindro.MasaAdmision = false;
720  FResMediosCilindro.MasaAdmisionMED = 0.;
721  FResMediosCilindro.MasaEscape = false;
722  FResMediosCilindro.MasaEscapeMED = 0.;
723  FResMediosCilindro.TemperaturaMedia = false;
724  FResMediosCilindro.TemperaturaMediaMED = 0.;
725  FResMediosCilindro.TemperaturaMediaSUM = 0.;
726  FResMediosCilindro.Swirl = false;
727  FResMediosCilindro.SwirlMED = 0.;
728  FResMediosCilindro.RendVolumetrico = false;
729  FResMediosCilindro.RendVolumetricoMED = 0.;
730  FResMediosCilindro.DensidadReferenciaSUM = 0.;
731  FResMediosCilindro.MasaCortocircuito = false;
732  FResMediosCilindro.MasaCortocircuitoMED = 0.;
733  FResMediosCilindro.MasaCortocircuitoSUM = 0.;
734 
735  FResMediosCilindro.Tiempo0 = 0.;
736  FResMediosCilindro.TiempoSUM = 0.;
737 
738  fscanf(fich, "%d ", &FNumVarMed);
739  for(int i = 0; i < FNumVarMed; i++) {
740  fscanf(fich, "%d ", &Tipovar);
741  switch(Tipovar) {
742  case 0:
743  FResMediosCilindro.TrabajoNeto = true;
744  break;
745  case 1:
746  FResMediosCilindro.PresionMediaNeta = true;
747  break;
748  case 2:
749  FResMediosCilindro.TrabajoBombeo = true;
750  break;
751  case 3:
752  FResMediosCilindro.PresionMediaBombeo = true;
753  break;
754  case 4:
755  FResMediosCilindro.CalorCombustion = true;
756  break;
757  case 5:
758  FResMediosCilindro.CalorCilindro = true;
759  break;
760  case 6:
761  FResMediosCilindro.CalorCulata = true;
762  break;
763  case 7:
764  FResMediosCilindro.CalorPiston = true;
765  break;
766  case 8:
767  FResMediosCilindro.PresionMediaIndicada = true;
768  break;
769  case 9:
770  FResMediosCilindro.MasaAtrapada = true;
771  break;
772  case 10:
773  FResMediosCilindro.TemperaturaCilindroInterna = true;
774  break;
775  case 11:
776  FResMediosCilindro.TemperaturaCilindroMedia = true;
777  break;
778  case 12:
779  FResMediosCilindro.TemperaturaCilindroExterna = true;
780  break;
781  case 13:
782  FResMediosCilindro.TemperaturaPistonInterna = true;
783  break;
784  case 14:
785  FResMediosCilindro.TemperaturaPistonMedia = true;
786  break;
787  case 15:
788  FResMediosCilindro.TemperaturaPistonExterna = true;
789  break;
790  case 16:
791  FResMediosCilindro.TemperaturaCulataInterna = true;
792  break;
793  case 17:
794  FResMediosCilindro.TemperaturaCulataMedia = true;
795  break;
796  case 18:
797  FResMediosCilindro.TemperaturaCulataExterna = true;
798  break;
799  case 19:
800  FResMediosCilindro.NITMedio = true;
801  break;
802  case 20:
803  FResMediosCilindro.AFRMedio = true;
804  break;
805  case 21:
806  FResMediosCilindro.MasaBlowBy = true;
807  break;
808  case 22:
809  FResMediosCilindro.MasaAdmision = true;
810  break;
811  case 23:
812  FResMediosCilindro.MasaEscape = true;
813  break;
814  case 24:
815  FResMediosCilindro.MasaCortocircuito = true;
816  break;
817  case 25:
818  FResMediosCilindro.TemperaturaMedia = true;
819  break;
820  case 26:
821  FResMediosCilindro.Swirl = true;
822  break;
823  case 27:
824  FResMediosCilindro.RendVolumetrico = true;
825  break;
826  default:
827  std::cout << "Resultados medios en cilindro " << FNumeroCilindro << " no implementado " << std::endl;
828  }
829  }
830 
831  fgetpos(fich, &filepos);
832  fclose(fich);
833 
834  } catch(exception & N) {
835  std::cout << "ERROR: TCilindro::ReadAverageResultsCilindro en cilindro: " << FNumeroCilindro << std::endl;
836  std::cout << "Tipo de error: " << N.what() << std::endl;
837  throw Exception(N.what());
838  }
839 }
840 
841 // ---------------------------------------------------------------------------
842 // ---------------------------------------------------------------------------
843 
844 void TCilindro::HeaderAverageResultsCilindro(stringstream& medoutput, stEspecies *DatosEspecies) {
845  try {
846  // FILE *fich=fopen(FileSALIDA,"a");
847 
848  std::string Label;
849 
850  if(FNumVarMed > 0) {
851  if(FResMediosCilindro.TrabajoNeto) {
852  Label = "\t" + PutLabel(631) + std::to_string(FNumeroCilindro) + PutLabel(907);
853  medoutput << Label.c_str();
854  }
855  if(FResMediosCilindro.PresionMediaNeta) {
856  Label = "\t" + PutLabel(632) + std::to_string(FNumeroCilindro) + PutLabel(908);
857  medoutput << Label.c_str();
858  }
859  if(FResMediosCilindro.TrabajoBombeo) {
860  Label = "\t" + PutLabel(633) + std::to_string(FNumeroCilindro) + PutLabel(907);
861  medoutput << Label.c_str();
862  }
863  if(FResMediosCilindro.PresionMediaBombeo) {
864  Label = "\t" + PutLabel(634) + std::to_string(FNumeroCilindro) + PutLabel(908);
865  medoutput << Label.c_str();
866  }
867  if(FResMediosCilindro.CalorCombustion) {
868  Label = "\t" + PutLabel(635) + std::to_string(FNumeroCilindro) + PutLabel(907);
869  medoutput << Label.c_str();
870  }
871  if(FResMediosCilindro.CalorCilindro) {
872  Label = "\t" + PutLabel(636) + std::to_string(FNumeroCilindro) + PutLabel(907);
873  medoutput << Label.c_str();
874  }
875  if(FResMediosCilindro.CalorCulata) {
876  Label = "\t" + PutLabel(637) + std::to_string(FNumeroCilindro) + PutLabel(907);
877  medoutput << Label.c_str();
878  }
879  if(FResMediosCilindro.CalorPiston) {
880  Label = "\t" + PutLabel(638) + std::to_string(FNumeroCilindro) + PutLabel(907);
881  medoutput << Label.c_str();
882  }
883  if(FResMediosCilindro.PresionMediaIndicada) {
884  Label = "\t" + PutLabel(639) + std::to_string(FNumeroCilindro) + PutLabel(908);
885  medoutput << Label.c_str();
886  }
887  if(FResMediosCilindro.MasaAtrapada) {
888  Label = "\t" + PutLabel(640) + std::to_string(FNumeroCilindro) + PutLabel(913);
889  medoutput << Label.c_str();
890  }
891  if(FResMediosCilindro.TemperaturaCilindroInterna) {
892  Label = "\t" + PutLabel(641) + std::to_string(FNumeroCilindro) + PutLabel(910);
893  medoutput << Label.c_str();
894  }
895  if(FResMediosCilindro.TemperaturaCilindroMedia) {
896  Label = "\t" + PutLabel(642) + std::to_string(FNumeroCilindro) + PutLabel(910);
897  medoutput << Label.c_str();
898  }
899  if(FResMediosCilindro.TemperaturaCilindroExterna) {
900  Label = "\t" + PutLabel(643) + std::to_string(FNumeroCilindro) + PutLabel(910);
901  medoutput << Label.c_str();
902  }
903  if(FResMediosCilindro.TemperaturaPistonInterna) {
904  Label = "\t" + PutLabel(644) + std::to_string(FNumeroCilindro) + PutLabel(910);
905  medoutput << Label.c_str();
906  }
907  if(FResMediosCilindro.TemperaturaPistonMedia) {
908  Label = "\t" + PutLabel(645) + std::to_string(FNumeroCilindro) + PutLabel(910);
909  medoutput << Label.c_str();
910  }
911  if(FResMediosCilindro.TemperaturaPistonExterna) {
912  Label = "\t" + PutLabel(646) + std::to_string(FNumeroCilindro) + PutLabel(910);
913  medoutput << Label.c_str();
914  }
915  if(FResMediosCilindro.TemperaturaCulataInterna) {
916  Label = "\t" + PutLabel(647) + std::to_string(FNumeroCilindro) + PutLabel(910);
917  medoutput << Label.c_str();
918  }
919  if(FResMediosCilindro.TemperaturaCulataMedia) {
920  Label = "\t" + PutLabel(648) + std::to_string(FNumeroCilindro) + PutLabel(910);
921  medoutput << Label.c_str();
922  }
923  if(FResMediosCilindro.TemperaturaCulataExterna) {
924  Label = "\t" + PutLabel(649) + std::to_string(FNumeroCilindro) + PutLabel(910);
925  medoutput << Label.c_str();
926  }
927  if(FResMediosCilindro.NITMedio) {
928  for(int i = 0; i < FNumeroUnionesEsc; i++) {
929  Label = "\t" + PutLabel(650) + std::to_string(i) + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(903);
930  medoutput << Label.c_str();
931  }
932  Label = "\t" + PutLabel(652) + std::to_string(FNumeroCilindro) + PutLabel(903);
933  medoutput << Label.c_str();
934  }
935  if(FResMediosCilindro.AFRMedio) {
936  Label = "\t" + PutLabel(653) + std::to_string(FNumeroCilindro) + PutLabel(901);
937  medoutput << Label.c_str();
938  }
939  if(FResMediosCilindro.MasaBlowBy) {
940  Label = "\t" + PutLabel(654) + std::to_string(FNumeroCilindro) + PutLabel(914);
941  medoutput << Label.c_str();
942  }
943  if(FResMediosCilindro.MasaAdmision) {
944  Label = "\t" + PutLabel(655) + std::to_string(FNumeroCilindro) + PutLabel(914);
945  medoutput << Label.c_str();
946  }
947  if(FResMediosCilindro.MasaEscape) {
948  Label = "\t" + PutLabel(656) + std::to_string(FNumeroCilindro) + PutLabel(914);
949  medoutput << Label.c_str();
950  }
951  if(FResMediosCilindro.MasaCortocircuito) {
952  Label = "\t" + PutLabel(657) + std::to_string(FNumeroCilindro) + PutLabel(914);
953  medoutput << Label.c_str();
954  }
955  if(FResMediosCilindro.TemperaturaMedia) {
956  Label = "\t" + PutLabel(658) + std::to_string(FNumeroCilindro) + PutLabel(910);
957  medoutput << Label.c_str();
958  }
959  if(FResMediosCilindro.Swirl) {
960  Label = "\t" + PutLabel(659) + std::to_string(FNumeroCilindro) + PutLabel(901);
961  medoutput << Label.c_str();
962  }
963  if(FResMediosCilindro.RendVolumetrico) {
964  Label = "\t" + PutLabel(660) + std::to_string(FNumeroCilindro) + PutLabel(901);
965  medoutput << Label.c_str();
966  }
967  }
968 
969  // fclose(fich);
970 
971  } catch(exception & N) {
972  std::cout << "ERROR: TCilindro::HeaderAverageResultsCilindro en cilindro: " << FNumeroCilindro << std::endl;
973  std::cout << "Tipo de error: " << N.what() << std::endl;
974  throw Exception(N.what());
975  }
976 }
977 
978 // ---------------------------------------------------------------------------
979 // ---------------------------------------------------------------------------
980 
981 void TCilindro::ImprimeResultadosMediosCilindro(stringstream& medoutput) {
982  try {
983  // FILE *fich=fopen(FileSALIDA,"a");
984 
985  if(FNumVarMed > 0) {
986  if(FResMediosCilindro.TrabajoNeto)
987  medoutput << "\t" << FResMediosCilindro.TrabajoNetoMED;
988  if(FResMediosCilindro.PresionMediaNeta)
989  medoutput << "\t" << FResMediosCilindro.PresionMediaNetaMED;
990  if(FResMediosCilindro.TrabajoBombeo)
991  medoutput << "\t" << FResMediosCilindro.TrabajoBombeoMED;
992  if(FResMediosCilindro.PresionMediaBombeo)
993  medoutput << "\t" << FResMediosCilindro.PresionMediaBombeoMED;
994  if(FResMediosCilindro.CalorCombustion)
995  medoutput << "\t" << FResMediosCilindro.CalorCombustionMED;
996  if(FResMediosCilindro.CalorCilindro)
997  medoutput << "\t" << FResMediosCilindro.CalorCilindroMED;
998  if(FResMediosCilindro.CalorCulata)
999  medoutput << "\t" << FResMediosCilindro.CalorCulataMED;
1000  if(FResMediosCilindro.CalorPiston)
1001  medoutput << "\t" << FResMediosCilindro.CalorPistonMED;
1002  if(FResMediosCilindro.PresionMediaIndicada)
1003  medoutput << "\t" << FResMediosCilindro.PresionMediaIndicadaMED;
1004  if(FResMediosCilindro.MasaAtrapada)
1005  medoutput << "\t" << FResMediosCilindro.MasaAtrapadaMED;
1006  if(FResMediosCilindro.TemperaturaCilindroInterna)
1007  medoutput << "\t" << FResMediosCilindro.TemperaturaCilindroInternaMED;
1008  if(FResMediosCilindro.TemperaturaCilindroMedia)
1009  medoutput << "\t" << FResMediosCilindro.TemperaturaCilindroMediaMED;
1010  if(FResMediosCilindro.TemperaturaCilindroExterna)
1011  medoutput << "\t" << FResMediosCilindro.TemperaturaCilindroExternaMED;
1012  if(FResMediosCilindro.TemperaturaPistonInterna)
1013  medoutput << "\t" << FResMediosCilindro.TemperaturaPistonInternaMED;
1014  if(FResMediosCilindro.TemperaturaPistonMedia)
1015  medoutput << "\t" << FResMediosCilindro.TemperaturaPistonMediaMED;
1016  if(FResMediosCilindro.TemperaturaPistonExterna)
1017  medoutput << "\t" << FResMediosCilindro.TemperaturaPistonExternaMED;
1018  if(FResMediosCilindro.TemperaturaCulataInterna)
1019  medoutput << "\t" << FResMediosCilindro.TemperaturaCulataInternaMED;
1020  if(FResMediosCilindro.TemperaturaCulataMedia)
1021  medoutput << "\t" << FResMediosCilindro.TemperaturaCulataMediaMED;
1022  if(FResMediosCilindro.TemperaturaCulataExterna)
1023  medoutput << "\t" << FResMediosCilindro.TemperaturaCulataExternaMED;
1024  if(FResMediosCilindro.NITMedio) {
1025  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1026  medoutput << "\t" << FResMediosCilindro.NITMED[i];
1027  }
1028  medoutput << "\t" << FResMediosCilindro.NITMedioMED;
1029  }
1030  if(FResMediosCilindro.AFRMedio)
1031  medoutput << "\t" << FResMediosCilindro.AFRMedioMED;
1032  if(FResMediosCilindro.MasaBlowBy)
1033  medoutput << "\t" << FResMediosCilindro.MasaBlowByMED;
1034  if(FResMediosCilindro.MasaAdmision)
1035  medoutput << "\t" << FResMediosCilindro.MasaAdmisionMED;
1036  if(FResMediosCilindro.MasaEscape)
1037  medoutput << "\t" << FResMediosCilindro.MasaEscapeMED;
1038  if(FResMediosCilindro.MasaCortocircuito)
1039  medoutput << "\t" << FResMediosCilindro.MasaCortocircuitoMED;
1040  if(FResMediosCilindro.TemperaturaMedia)
1041  medoutput << "\t" << FResMediosCilindro.TemperaturaMediaMED;
1042  if(FResMediosCilindro.Swirl)
1043  medoutput << "\t" << FResMediosCilindro.SwirlMED;
1044  if(FResMediosCilindro.RendVolumetrico)
1045  medoutput << "\t" << FResMediosCilindro.RendVolumetricoMED;
1046  }
1047 
1048  // fclose(fich);
1049  } catch(exception & N) {
1050  std::cout << "ERROR: TCilindro::ImprimeResultadosMediosCilindro " << std::endl;
1051  std::cout << "Tipo de error: " << N.what() << std::endl;
1052  throw Exception(N.what());
1053  }
1054 }
1055 
1056 // ---------------------------------------------------------------------------
1057 // ---------------------------------------------------------------------------
1058 
1059 void TCilindro::AcumulaResultadosMediosCilindro(double TActual) {
1060  try {
1061 
1062  if(FNumVarMed > 0) {
1063  double DeltaT = TActual - FResMediosCilindro.Tiempo0;
1064  // double DeltaAngulo=360.*FMotor->PutRegimen(360.*FMotor->getRegimen()/60.*DeltaT);
1065 
1066  FResMediosCilindro.TrabajoNetoSUM += __units::BarToPa(FPreMed) * (FVolumen - FVolumen0);
1067  if(FAnguloActual > 180. && FAnguloActual < 540.) {
1068  FResMediosCilindro.TrabajoBombeoSUM += __units::BarToPa(FPreMed) * (FVolumen - FVolumen0);
1069  }
1070 
1071  if(FResMediosCilindro.CalorCombustion && DeltaT > 0.)
1072  //FResMediosCilindro.CalorCombustionSUM += FCalor.Liberado;
1073  if(FResMediosCilindro.CalorCilindro)
1074  FResMediosCilindro.CalorCilindroSUM += FCalor.TransCilindro * DeltaT;
1075  if(FResMediosCilindro.CalorCulata)
1076  FResMediosCilindro.CalorCulataSUM += FCalor.TransCulata * DeltaT;
1077  if(FResMediosCilindro.CalorPiston)
1078  FResMediosCilindro.CalorPistonSUM += FCalor.TransPiston * DeltaT;
1079 
1080  if(FResMediosCilindro.TemperaturaCilindroInterna)
1081  FResMediosCilindro.TemperaturaCilindroInternaSUM += FTempPared[0].Cylinder * DeltaT;
1082  if(FResMediosCilindro.TemperaturaCilindroMedia)
1083  FResMediosCilindro.TemperaturaCilindroMediaSUM += FTempPared[1].Cylinder * DeltaT;
1084  if(FResMediosCilindro.TemperaturaCilindroExterna)
1085  FResMediosCilindro.TemperaturaCilindroExternaSUM += FTempPared[2].Cylinder * DeltaT;
1086 
1087  if(FResMediosCilindro.TemperaturaCulataInterna)
1088  FResMediosCilindro.TemperaturaCulataInternaSUM += FTempPared[0].Culata * DeltaT;
1089  if(FResMediosCilindro.TemperaturaCulataMedia)
1090  FResMediosCilindro.TemperaturaCulataMediaSUM += FTempPared[1].Culata * DeltaT;
1091  if(FResMediosCilindro.TemperaturaCulataExterna)
1092  FResMediosCilindro.TemperaturaCulataExternaSUM += FTempPared[2].Culata * DeltaT;
1093 
1094  if(FResMediosCilindro.TemperaturaPistonInterna)
1095  FResMediosCilindro.TemperaturaPistonInternaSUM += FTempPared[0].Piston * DeltaT;
1096  if(FResMediosCilindro.TemperaturaPistonMedia)
1097  FResMediosCilindro.TemperaturaPistonMediaSUM += FTempPared[1].Piston * DeltaT;
1098  if(FResMediosCilindro.TemperaturaPistonExterna)
1099  FResMediosCilindro.TemperaturaPistonExternaSUM += FTempPared[2].Piston * DeltaT;
1100 
1101  if(FResMediosCilindro.NITMedio)
1102  FResMediosCilindro.NITMedioSUM += FNIT * DeltaT;
1103  if(FResMediosCilindro.MasaBlowBy)
1104  FResMediosCilindro.MasaBlowBySUM += FMasaBlowBy;
1105  if(FResMediosCilindro.MasaCortocircuito)
1106  FResMediosCilindro.MasaCortocircuitoSUM += FMasaCortocircuito;
1107  if(FResMediosCilindro.TemperaturaMedia)
1108  FResMediosCilindro.TemperaturaMediaSUM += FTemperature * FDeltaT;
1109  if(FResMediosCilindro.RendVolumetrico)
1110  FResMediosCilindro.DensidadReferenciaSUM += FDensidadReferencia * FDeltaT;
1111 
1112  FResMediosCilindro.TiempoSUM += DeltaT;
1113  FResMediosCilindro.Tiempo0 = TActual;
1114  }
1115  } catch(exception & N) {
1116  std::cout << "ERROR: TCilindro::AcumulaResultadosMediosCilindro " << std::endl;
1117  std::cout << "Tipo de error: " << N.what() << std::endl;
1118  throw Exception(N.what());
1119  }
1120 }
1121 
1122 // ---------------------------------------------------------------------------
1123 // ---------------------------------------------------------------------------
1124 
1125 void TCilindro::CalculaResultadosMediosCilindro() {
1126  try {
1127 
1128  if(FNumVarMed > 0) {
1129  if(FResMediosCilindro.TrabajoNeto || FResMediosCilindro.PresionMediaNeta || FResMediosCilindro.PresionMediaIndicada) {
1130  FResMediosCilindro.TrabajoNetoMED = FResMediosCilindro.TrabajoNetoSUM;
1131  FResMediosCilindro.TrabajoNetoSUM = 0.;
1132  }
1133  if(FResMediosCilindro.PresionMediaNeta || FResMediosCilindro.PresionMediaIndicada) {
1134  FResMediosCilindro.PresionMediaNetaMED = __units::PaToBar(FResMediosCilindro.TrabajoNetoMED /
1135  FMotor->getGeometria().CilindradaUnitaria);
1136  }
1137  if(FResMediosCilindro.TrabajoBombeo || FResMediosCilindro.PresionMediaBombeo
1138  || FResMediosCilindro.PresionMediaIndicada) {
1139  FResMediosCilindro.TrabajoBombeoMED = FResMediosCilindro.TrabajoBombeoSUM;
1140  FResMediosCilindro.TrabajoBombeoSUM = 0.;
1141  }
1142  if(FResMediosCilindro.PresionMediaBombeo || FResMediosCilindro.PresionMediaIndicada) {
1143  FResMediosCilindro.PresionMediaBombeoMED = __units::PaToBar(-FResMediosCilindro.TrabajoBombeoMED /
1144  FMotor->getGeometria().CilindradaUnitaria);
1145  }
1146  if(FResMediosCilindro.CalorCombustion) {
1147  FResMediosCilindro.CalorCombustionMED = FResMediosCilindro.CalorCombustionSUM;
1148  FResMediosCilindro.CalorCombustionSUM = 0.;
1149  }
1150  if(FResMediosCilindro.CalorCilindro) {
1151  FResMediosCilindro.CalorCilindroMED = FResMediosCilindro.CalorCilindroSUM;
1152  FResMediosCilindro.CalorCilindroSUM = 0.;
1153  }
1154  if(FResMediosCilindro.CalorCulata) {
1155  FResMediosCilindro.CalorCulataMED = FResMediosCilindro.CalorCulataSUM;
1156  FResMediosCilindro.CalorCulataSUM = 0.;
1157  }
1158  if(FResMediosCilindro.CalorPiston) {
1159  FResMediosCilindro.CalorPistonMED = FResMediosCilindro.CalorPistonSUM;
1160  FResMediosCilindro.CalorPistonSUM = 0.;
1161  }
1162  if(FResMediosCilindro.PresionMediaIndicada) {
1163  FResMediosCilindro.PresionMediaIndicadaMED = FResMediosCilindro.PresionMediaNetaMED +
1164  FResMediosCilindro.PresionMediaBombeoMED;
1165  }
1166  if(FResMediosCilindro.MasaAtrapada) {
1167  FResMediosCilindro.MasaAtrapadaMED = FMasaAtrapada;
1168  }
1169  if(FResMediosCilindro.TemperaturaCilindroInterna) {
1170  FResMediosCilindro.TemperaturaCilindroInternaMED = FResMediosCilindro.TemperaturaCilindroInternaSUM /
1171  FResMediosCilindro.TiempoSUM;
1172  FResMediosCilindro.TemperaturaCilindroInternaSUM = 0.;
1173  }
1174  if(FResMediosCilindro.TemperaturaCilindroMedia) {
1175  FResMediosCilindro.TemperaturaCilindroMediaMED = FResMediosCilindro.TemperaturaCilindroMediaSUM /
1176  FResMediosCilindro.TiempoSUM;
1177  FResMediosCilindro.TemperaturaCilindroMediaSUM = 0.;
1178  }
1179  if(FResMediosCilindro.TemperaturaCilindroExterna) {
1180  FResMediosCilindro.TemperaturaCilindroExternaMED = FResMediosCilindro.TemperaturaCilindroExternaSUM /
1181  FResMediosCilindro.TiempoSUM;
1182  FResMediosCilindro.TemperaturaCilindroExternaSUM = 0.;
1183  }
1184  if(FResMediosCilindro.TemperaturaCulataInterna) {
1185  FResMediosCilindro.TemperaturaCulataInternaMED = FResMediosCilindro.TemperaturaCulataInternaSUM /
1186  FResMediosCilindro.TiempoSUM;
1187  FResMediosCilindro.TemperaturaCulataInternaSUM = 0.;
1188  }
1189  if(FResMediosCilindro.TemperaturaCulataMedia) {
1190  FResMediosCilindro.TemperaturaCulataMediaMED = FResMediosCilindro.TemperaturaCulataMediaSUM /
1191  FResMediosCilindro.TiempoSUM;
1192  FResMediosCilindro.TemperaturaCulataMediaSUM = 0.;
1193  }
1194  if(FResMediosCilindro.TemperaturaCulataExterna) {
1195  FResMediosCilindro.TemperaturaCulataExternaMED = FResMediosCilindro.TemperaturaCulataExternaSUM /
1196  FResMediosCilindro.TiempoSUM;
1197  FResMediosCilindro.TemperaturaCulataExternaSUM = 0.;
1198  }
1199  if(FResMediosCilindro.TemperaturaPistonInterna) {
1200  FResMediosCilindro.TemperaturaPistonInternaMED = FResMediosCilindro.TemperaturaPistonInternaSUM /
1201  FResMediosCilindro.TiempoSUM;
1202  FResMediosCilindro.TemperaturaPistonInternaSUM = 0.;
1203  }
1204  if(FResMediosCilindro.TemperaturaPistonMedia) {
1205  FResMediosCilindro.TemperaturaPistonMediaMED = FResMediosCilindro.TemperaturaPistonMediaSUM /
1206  FResMediosCilindro.TiempoSUM;
1207  FResMediosCilindro.TemperaturaPistonMediaSUM = 0.;
1208  }
1209  if(FResMediosCilindro.TemperaturaPistonExterna) {
1210  FResMediosCilindro.TemperaturaPistonExternaMED = FResMediosCilindro.TemperaturaPistonExternaSUM /
1211  FResMediosCilindro.TiempoSUM;
1212  FResMediosCilindro.TemperaturaPistonExternaSUM = 0.;
1213  }
1214  if(FResMediosCilindro.AFRMedio) {
1215  FResMediosCilindro.AFRMedioMED = FAFR;
1216  }
1217  if(FResMediosCilindro.NITMedio) {
1218  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1219  FResMediosCilindro.NITMED[i] = FValvEsc[i].NITSUM / FResMediosCilindro.TiempoSUM;
1220  FValvEsc[i].NITSUM = 0.;
1221  }
1222  FResMediosCilindro.NITMedioMED = FResMediosCilindro.NITMedioSUM / FResMediosCilindro.TiempoSUM;
1223  FResMediosCilindro.NITMedioSUM = 0.;
1224  }
1225 
1226  if(FResMediosCilindro.MasaBlowBy) {
1227  FResMediosCilindro.MasaBlowByMED = FResMediosCilindro.MasaBlowBySUM;
1228  FResMediosCilindro.MasaBlowBySUM = 0.;
1229  }
1230  if(FResMediosCilindro.MasaAdmision) {
1231  FResMediosCilindro.MasaAdmisionMED = FMasaPorAdmision;
1232  }
1233  if(FResMediosCilindro.MasaEscape) {
1234  FResMediosCilindro.MasaEscapeMED = FMasaPorEscape;
1235  }
1236  if(FResMediosCilindro.MasaCortocircuito) {
1237  FResMediosCilindro.MasaCortocircuitoMED = FResMediosCilindro.MasaCortocircuitoSUM;
1238  FResMediosCilindro.MasaCortocircuitoSUM = 0.;
1239  }
1240  if(FResMediosCilindro.TemperaturaMedia) {
1241  FResMediosCilindro.TemperaturaMediaMED = FResMediosCilindro.TemperaturaMediaSUM / FResMediosCilindro.TiempoSUM;
1242  FResMediosCilindro.TemperaturaMediaSUM = 0.;
1243  }
1244  if(FResMediosCilindro.Swirl) {
1245  FResMediosCilindro.SwirlMED = FSwirlSUM / FResMediosCilindro.TiempoSUM;
1246  FSwirlSUM = 0.;
1247  }
1248  if(FResMediosCilindro.RendVolumetrico) {
1249  double DensidadReferencia = FResMediosCilindro.DensidadReferenciaSUM / FResMediosCilindro.TiempoSUM;
1250  FResMediosCilindro.RendVolumetricoMED = FMasaAtrapada / DensidadReferencia / FMotor->getGeometria().CilindradaUnitaria;
1251  FResMediosCilindro.DensidadReferenciaSUM = 0.;
1252  }
1253 
1254  FResMediosCilindro.TiempoSUM = 0;
1255  }
1256 
1257  } catch(exception & N) {
1258  std::cout << "ERROR: TCilindro::CalculaResultadosMediosCilindro " << std::endl;
1259  std::cout << "Tipo de error: " << N.what() << std::endl;
1260  throw Exception(N.what());
1261  }
1262 }
1263 
1264 // ---------------------------------------------------------------------------
1265 // ---------------------------------------------------------------------------
1266 
1267 void TCilindro::ReadInstantaneousResultsCilindro(const char *FileWAM, fpos_t &filepos) {
1268  try {
1269  int nvars = 0, var = 0;
1270 
1271  FILE *fich = fopen(FileWAM, "r");
1272  fsetpos(fich, &filepos);
1273 
1274  FResInstantCilindro.Pressure = false;
1275  FResInstantCilindro.PresionINS = 0.;
1276  FResInstantCilindro.Temperature = false;
1277  FResInstantCilindro.TemperaturaINS = 0.;
1278  FResInstantCilindro.MomentoAngularEsc = false;
1279  FResInstantCilindro.MomentoAngularTotalEscINS = 0.;
1280  FResInstantCilindro.MomentoAngularAdm = false;
1281  FResInstantCilindro.MomentoAngularTotalAdmINS = 0.;
1282  FResInstantCilindro.GastoEsc = false;
1283  FResInstantCilindro.GastoTotalEscINS = 0.;
1284  FResInstantCilindro.GastoAdm = false;
1285  FResInstantCilindro.GastoTotalAdmINS = 0.;
1286  FResInstantCilindro.MachEsc = false;
1287  FResInstantCilindro.MachAdm = false;
1288  FResInstantCilindro.SeccionEfectivaAdm = false;
1289  FResInstantCilindro.SeccionEfectivaTotalAdmINS = 0.;
1290  FResInstantCilindro.SeccionEfectivaEsc = false;
1291  FResInstantCilindro.SeccionEfectivaTotalEscINS = 0.;
1292  FResInstantCilindro.Masa = false;
1293  FResInstantCilindro.MasaINS = 0.;
1294  FResInstantCilindro.Volumen = false;
1295  FResInstantCilindro.VolumenINS = 0.;
1296  FResInstantCilindro.CoeficienteWoschni = false;
1297  FResInstantCilindro.CoeficienteWoschniINS = 0.;
1298  FResInstantCilindro.MasaCombustible = false;
1299  FResInstantCilindro.MasaCombustibleINS = 0.;
1300  FResInstantCilindro.FQL = false;
1301  FResInstantCilindro.FQLINS = 0.;
1302  FResInstantCilindro.TemperaturaCilindroInterna = false;
1303  FResInstantCilindro.TemperaturaCilindroInternaINS = 0.;
1304  FResInstantCilindro.TemperaturaCilindroMedia = false;
1305  FResInstantCilindro.TemperaturaCilindroMediaINS = 0.;
1306  FResInstantCilindro.TemperaturaCilindroExterna = false;
1307  FResInstantCilindro.TemperaturaCilindroExternaINS = 0.;
1308  FResInstantCilindro.TemperaturaPistonInterna = false;
1309  FResInstantCilindro.TemperaturaPistonInternaINS = 0.;
1310  FResInstantCilindro.TemperaturaPistonMedia = false;
1311  FResInstantCilindro.TemperaturaPistonMediaINS = 0.;
1312  FResInstantCilindro.TemperaturaPistonExterna = false;
1313  FResInstantCilindro.TemperaturaPistonExternaINS = 0.;
1314  FResInstantCilindro.TemperaturaCulataInterna = false;
1315  FResInstantCilindro.TemperaturaCulataInternaINS = 0.;
1316  FResInstantCilindro.TemperaturaCulataMedia = false;
1317  FResInstantCilindro.TemperaturaCulataMediaINS = 0.;
1318  FResInstantCilindro.TemperaturaCulataExterna = false;
1319  FResInstantCilindro.TemperaturaCulataExternaINS = 0.;
1320  FResInstantCilindro.NIT = false;
1321  FResInstantCilindro.GastoCortocircuito = false;
1322  FResInstantCilindro.GastoCortocircuitoINS = 0.;
1323  FResInstantCilindro.ParInstantaneo = false;
1324  FResInstantCilindro.ParInstantaneoINS = 0.;
1325  FResInstantCilindro.GastoBlowBy = false;
1326  FResInstantCilindro.GastoBlowByINS = 0.;
1327  FResInstantCilindro.FraccionMasica = false;
1328  FResInstantCilindro.FraccionINS = new double[FMotor->getSpeciesNumber() - FIntEGR];
1329  for(int i = 0; i < FMotor->getSpeciesNumber() - FIntEGR; i++) {
1330  FResInstantCilindro.FraccionINS[i] = 0.;
1331  }
1332  FResInstantCilindro.Gamma = false;
1333  FResInstantCilindro.GammaINS = 0.;
1334 
1335  FResInstantCilindro.HeatHead = false;
1336  FResInstantCilindro.HeatHeadINS = 0;
1337  FResInstantCilindro.HeatCyl = false;
1338  FResInstantCilindro.HeatCylINS = 0;
1339  FResInstantCilindro.HeatPis = false;
1340  FResInstantCilindro.HeatPisINS = 0;
1341 
1342  fscanf(fich, "%d ", &FNumVarIns);
1343  for(int i = 0; i < FNumVarIns; i++) {
1344  fscanf(fich, "%d ", &var);
1345  switch(var) {
1346  case 0:
1347  FResInstantCilindro.Pressure = true;
1348  break;
1349  case 1:
1350  FResInstantCilindro.Temperature = true;
1351  break;
1352  case 2:
1353  FResInstantCilindro.MomentoAngularEsc = true;
1354  break;
1355  case 3:
1356  FResInstantCilindro.MomentoAngularAdm = true;
1357  break;
1358  case 4:
1359  FResInstantCilindro.GastoEsc = true;
1360  break;
1361  case 5:
1362  FResInstantCilindro.GastoAdm = true;
1363  break;
1364  case 6:
1365  FResInstantCilindro.MachEsc = true;
1366  break;
1367  case 7:
1368  FResInstantCilindro.MachAdm = true;
1369  break;
1370  case 8:
1371  FResInstantCilindro.SeccionEfectivaAdm = true;
1372  break;
1373  case 9:
1374  FResInstantCilindro.SeccionEfectivaEsc = true;
1375  break;
1376  case 10:
1377  FResInstantCilindro.Masa = true;
1378  break;
1379  case 11:
1380  FResInstantCilindro.Volumen = true;
1381  break;
1382  case 12:
1383  FResInstantCilindro.MasaCombustible = true;
1384  break;
1385  case 13:
1386  FResInstantCilindro.FQL = true;
1387  break;
1388  case 14:
1389  FResInstantCilindro.CoeficienteWoschni = true;
1390  break;
1391  case 15:
1392  FResInstantCilindro.TemperaturaCilindroInterna = true;
1393  break;
1394  case 16:
1395  FResInstantCilindro.TemperaturaCilindroMedia = true;
1396  break;
1397  case 17:
1398  FResInstantCilindro.TemperaturaCilindroExterna = true;
1399  break;
1400  case 18:
1401  FResInstantCilindro.TemperaturaPistonInterna = true;
1402  break;
1403  case 19:
1404  FResInstantCilindro.TemperaturaPistonMedia = true;
1405  break;
1406  case 20:
1407  FResInstantCilindro.TemperaturaPistonExterna = true;
1408  break;
1409  case 21:
1410  FResInstantCilindro.TemperaturaCulataInterna = true;
1411  break;
1412  case 22:
1413  FResInstantCilindro.TemperaturaCulataMedia = true;
1414  break;
1415  case 23:
1416  FResInstantCilindro.TemperaturaCulataExterna = true;
1417  break;
1418  case 24:
1419  FResInstantCilindro.NIT = true;
1420  break;
1421  case 25:
1422  FResInstantCilindro.ParInstantaneo = true;
1423  break;
1424  case 26:
1425  FResInstantCilindro.GastoCortocircuito = true;
1426  break;
1427  case 27:
1428  FResInstantCilindro.GastoBlowBy = true;
1429  break;
1430  case 28:
1431  FResInstantCilindro.FraccionMasica = true;
1432  break;
1433  case 29:
1434  FResInstantCilindro.Gamma = true;
1435  break;
1436 
1437  case 30:
1438  FResInstantCilindro.HeatHead = true;
1439  break;
1440 
1441  case 31:
1442  FResInstantCilindro.HeatCyl = true;
1443  break;
1444 
1445  case 32:
1446  FResInstantCilindro.HeatPis = true;
1447  break;
1448  }
1449  }
1450 
1451  fgetpos(fich, &filepos);
1452  fclose(fich);
1453 
1454  } catch(exception & N) {
1455  std::cout << "ERROR: TCilindro::ReadInstantaneousResultsCilindro en cilindro: " << FNumeroCilindro << std::endl;
1456  std::cout << "Tipo de error: " << N.what() << std::endl;
1457  throw Exception(N.what());
1458  }
1459 }
1460 
1461 // ---------------------------------------------------------------------------
1462 // ---------------------------------------------------------------------------
1463 
1464 void TCilindro::HeaderInstantaneousResultsCilindro(stringstream& insoutput, stEspecies *DatosEspecies) {
1465  try {
1466  // FILE *fich=fopen(FileSALIDA,"a");
1467 
1468  if(FNumVarIns > 0) {
1469 
1470  char *label1, *label2, *label3;
1471  std::string Label;
1472  string kkkk;
1473  // cadena Label7;
1474 
1475  if(FResInstantCilindro.Pressure) {
1476  Label = "\t" + PutLabel(661) + std::to_string(FNumeroCilindro) + PutLabel(908);
1477  insoutput << Label.c_str();
1478  }
1479  if(FResInstantCilindro.Temperature) {
1480  Label = "\t" + PutLabel(662) + std::to_string(FNumeroCilindro) + PutLabel(910);
1481  insoutput << Label.c_str();
1482  }
1483  if(FResInstantCilindro.MomentoAngularEsc) {
1484  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1485  Label = "\t" + PutLabel(663) + std::to_string(i) + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(901);
1486  insoutput << Label.c_str();
1487  }
1488  if(FNumeroUnionesEsc > 1) {
1489  Label = "\t" + PutLabel(664) + std::to_string(FNumeroCilindro) + PutLabel(901);
1490  insoutput << Label.c_str();
1491  }
1492  }
1493  if(FResInstantCilindro.MomentoAngularAdm) {
1494  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1495  Label = "\t" + PutLabel(665) + std::to_string(i) + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(901);
1496  insoutput << Label.c_str();
1497  }
1498  if(FNumeroUnionesAdm > 1) {
1499  Label = "\t" + PutLabel(666) + std::to_string(FNumeroCilindro) + PutLabel(901);
1500  insoutput << Label.c_str();
1501  }
1502  }
1503  if(FResInstantCilindro.GastoEsc) {
1504  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1505  Label = "\t" + PutLabel(667) + std::to_string(i) + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(904);
1506  insoutput << Label.c_str();
1507  }
1508  if(FNumeroUnionesEsc > 1) {
1509  Label = "\t" + PutLabel(668) + std::to_string(FNumeroCilindro) + PutLabel(904);
1510  insoutput << Label.c_str();
1511  }
1512  }
1513  if(FResInstantCilindro.GastoAdm) {
1514  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1515  Label = "\t" + PutLabel(669) + std::to_string(i) + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(904);
1516  insoutput << Label.c_str();
1517  }
1518  if(FNumeroUnionesAdm > 1) {
1519  Label = "\t" + PutLabel(670) + std::to_string(FNumeroCilindro) + PutLabel(901);
1520  insoutput << Label.c_str();
1521  }
1522  }
1523  if(FResInstantCilindro.MachEsc) {
1524  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1525  Label = "\t" + PutLabel(671) + std::to_string(i) + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(901);
1526  insoutput << Label.c_str();
1527  }
1528  }
1529  if(FResInstantCilindro.MachAdm) {
1530  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1531  Label = "\t" + PutLabel(672) + std::to_string(i) + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(901);
1532  insoutput << Label.c_str();
1533  }
1534  }
1535  if(FResInstantCilindro.SeccionEfectivaEsc) {
1536  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1537  Label = "\t" + PutLabel(673) + std::to_string(i) + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(915);
1538  insoutput << Label.c_str();
1539  }
1540  if(FNumeroUnionesEsc > 1) {
1541  Label = "\t" + PutLabel(674) + std::to_string(FNumeroCilindro) + PutLabel(915);
1542  insoutput << Label.c_str();
1543  }
1544  }
1545  if(FResInstantCilindro.SeccionEfectivaAdm) {
1546  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1547  Label = "\t" + PutLabel(675) + std::to_string(i) + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(915);
1548  insoutput << Label.c_str();
1549  }
1550  if(FNumeroUnionesAdm > 1) {
1551  Label = "\t" + PutLabel(676) + std::to_string(FNumeroCilindro) + PutLabel(915);
1552  insoutput << Label.c_str();
1553  }
1554  }
1555  if(FResInstantCilindro.Masa) {
1556  Label = "\t" + PutLabel(677) + std::to_string(FNumeroCilindro) + PutLabel(913);
1557  insoutput << Label.c_str();
1558  }
1559  if(FResInstantCilindro.Volumen) {
1560  Label = "\t" + PutLabel(678) + std::to_string(FNumeroCilindro) + PutLabel(912);
1561  insoutput << Label.c_str();
1562  }
1563  if(FResInstantCilindro.CoeficienteWoschni) {
1564  Label = "\t" + PutLabel(679) + std::to_string(FNumeroCilindro) + PutLabel(911);
1565  insoutput << Label.c_str();
1566  }
1567  if(FResInstantCilindro.MasaCombustible) {
1568  Label = "\t" + PutLabel(680) + std::to_string(FNumeroCilindro) + PutLabel(916);
1569  insoutput << Label.c_str();
1570  }
1571  if(FResInstantCilindro.FQL) {
1572  Label = "\t" + PutLabel(681) + std::to_string(FNumeroCilindro) + PutLabel(901);
1573  insoutput << Label.c_str();
1574  }
1575  if(FResInstantCilindro.TemperaturaCilindroInterna) {
1576  Label = "\t" + PutLabel(641) + std::to_string(FNumeroCilindro) + PutLabel(901);
1577  insoutput << Label.c_str();
1578  }
1579  if(FResInstantCilindro.TemperaturaCilindroMedia) {
1580  Label = "\t" + PutLabel(642) + std::to_string(FNumeroCilindro) + PutLabel(910);
1581  insoutput << Label.c_str();
1582  }
1583  if(FResInstantCilindro.TemperaturaCilindroExterna) {
1584  Label = "\t" + PutLabel(643) + std::to_string(FNumeroCilindro) + PutLabel(910);
1585  insoutput << Label.c_str();
1586  }
1587  if(FResInstantCilindro.TemperaturaPistonInterna) {
1588  Label = "\t" + PutLabel(644) + std::to_string(FNumeroCilindro) + PutLabel(910);
1589  insoutput << Label.c_str();
1590  }
1591  if(FResInstantCilindro.TemperaturaPistonMedia) {
1592  Label = "\t" + PutLabel(645) + std::to_string(FNumeroCilindro) + PutLabel(910);
1593  insoutput << Label.c_str();
1594  }
1595  if(FResInstantCilindro.TemperaturaPistonExterna) {
1596  Label = "\t" + PutLabel(646) + std::to_string(FNumeroCilindro) + PutLabel(910);
1597  insoutput << Label.c_str();
1598  }
1599  if(FResInstantCilindro.TemperaturaCulataInterna) {
1600  Label = "\t" + PutLabel(647) + std::to_string(FNumeroCilindro) + PutLabel(910);
1601  insoutput << Label.c_str();
1602  }
1603  if(FResInstantCilindro.TemperaturaCulataMedia) {
1604  Label = "\t" + PutLabel(648) + std::to_string(FNumeroCilindro) + PutLabel(910);
1605  insoutput << Label.c_str();
1606  }
1607  if(FResInstantCilindro.TemperaturaCulataExterna) {
1608  Label = "\t" + PutLabel(649) + std::to_string(FNumeroCilindro) + PutLabel(910);
1609  insoutput << Label.c_str();
1610  }
1611  if(FResInstantCilindro.NIT) {
1612  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1613  Label = "\t" + PutLabel(682) + std::to_string(i) + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(901);
1614  insoutput << Label.c_str();
1615  }
1616  Label = "\t" + PutLabel(683) + std::to_string(FNumeroCilindro) + PutLabel(901);
1617  insoutput << Label.c_str();
1618  }
1619  if(FResInstantCilindro.ParInstantaneo) {
1620  Label = "\t" + PutLabel(684) + std::to_string(FNumeroCilindro) + PutLabel(917);
1621  insoutput << Label.c_str();
1622  }
1623  if(FResInstantCilindro.GastoCortocircuito) {
1624  Label = "\t" + PutLabel(685) + std::to_string(FNumeroCilindro) + PutLabel(904);
1625  insoutput << Label.c_str();
1626  }
1627  if(FResInstantCilindro.GastoBlowBy) {
1628  Label = "\t" + PutLabel(686) + std::to_string(FNumeroCilindro) + PutLabel(904);
1629  insoutput << Label.c_str();
1630  }
1631  if(FResInstantCilindro.FraccionMasica) {
1632  for(int i = 0; i < FMotor->getSpeciesNumber() - FIntEGR; i++) {
1633  Label = "\t" + PutLabel(687) + DatosEspecies[i].Nombre + PutLabel(651) + std::to_string(FNumeroCilindro) + PutLabel(
1634  901);
1635  insoutput << Label.c_str();
1636  }
1637  }
1638  if(FResInstantCilindro.Gamma) {
1639  Label = "\t" + PutLabel(688) + std::to_string(FNumeroCilindro) + PutLabel(901);
1640  insoutput << Label.c_str();
1641  }
1642  if(FResInstantCilindro.HeatHead) {
1643  Label = "\t" + PutLabel(689) + std::to_string(FNumeroCilindro) + PutLabel(903);
1644  insoutput << Label.c_str();
1645  }
1646  if(FResInstantCilindro.HeatCyl) {
1647  Label = "\t" + PutLabel(690) + std::to_string(FNumeroCilindro) + PutLabel(903);
1648  insoutput << Label.c_str();
1649  }
1650  if(FResInstantCilindro.HeatPis) {
1651  Label = "\t" + PutLabel(691) + std::to_string(FNumeroCilindro) + PutLabel(903);
1652  insoutput << Label.c_str();
1653  }
1654  }
1655 
1656  // fclose(fich);
1657 
1658  } catch(exception & N) {
1659  std::cout << "ERROR: TCilindro::HeaderInstantaneousResultsCilindro en cilindro: " << FNumeroCilindro << std::endl;
1660  std::cout << "Tipo de error: " << N.what() << std::endl;
1661  throw Exception(N.what());
1662  }
1663 }
1664 
1665 // ---------------------------------------------------------------------------
1666 // ---------------------------------------------------------------------------
1667 
1668 void TCilindro::ImprimeResultadosInstantaneosCilindro(stringstream& insoutput) {
1669  try {
1670  // FILE *fich=fopen(FileSALIDA,"a");
1671 
1672  if(FNumVarIns > 0) {
1673 
1674  if(FResInstantCilindro.Pressure)
1675  insoutput << "\t" << FResInstantCilindro.PresionINS;
1676  if(FResInstantCilindro.Temperature)
1677  insoutput << "\t" << FResInstantCilindro.TemperaturaINS;
1678  if(FResInstantCilindro.MomentoAngularEsc) {
1679  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1680  insoutput << "\t" << FResInstantCilindro.MomentoAngularEscINS[i];
1681  }
1682  if(FNumeroUnionesEsc > 1) {
1683  insoutput << "\t" << FResInstantCilindro.MomentoAngularTotalEscINS;
1684  }
1685  }
1686  if(FResInstantCilindro.MomentoAngularAdm) {
1687  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1688  insoutput << "\t" << FResInstantCilindro.MomentoAngularAdmINS[i];
1689  }
1690  if(FNumeroUnionesAdm > 1) {
1691  insoutput << "\t" << FResInstantCilindro.MomentoAngularTotalAdmINS;
1692  }
1693  }
1694  if(FResInstantCilindro.GastoEsc) {
1695  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1696  insoutput << "\t" << FResInstantCilindro.GastoEscINS[i];
1697  }
1698  if(FNumeroUnionesEsc > 1) {
1699  insoutput << "\t" << FResInstantCilindro.GastoTotalEscINS;
1700  }
1701  }
1702  if(FResInstantCilindro.GastoAdm) {
1703  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1704  insoutput << "\t" << FResInstantCilindro.GastoAdmINS[i];
1705  }
1706  if(FNumeroUnionesAdm > 1) {
1707  insoutput << "\t" << FResInstantCilindro.GastoTotalAdmINS;
1708  }
1709  }
1710  if(FResInstantCilindro.MachEsc) {
1711  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1712  insoutput << "\t" << FResInstantCilindro.MachEscINS[i];
1713  }
1714  }
1715  if(FResInstantCilindro.MachAdm) {
1716  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1717  insoutput << "\t" << FResInstantCilindro.MachAdmINS[i];
1718  }
1719  }
1720  if(FResInstantCilindro.SeccionEfectivaEsc) {
1721  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1722  insoutput << "\t" << FResInstantCilindro.SeccionEfectivaEscINS[i];
1723  }
1724  if(FNumeroUnionesEsc > 1) {
1725  insoutput << "\t" << FResInstantCilindro.SeccionEfectivaTotalEscINS;
1726  }
1727  }
1728  if(FResInstantCilindro.SeccionEfectivaAdm) {
1729  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1730  insoutput << "\t" << FResInstantCilindro.SeccionEfectivaAdmINS[i];
1731  }
1732  if(FNumeroUnionesAdm > 1) {
1733  insoutput << "\t" << FResInstantCilindro.SeccionEfectivaTotalAdmINS;
1734  }
1735  }
1736  if(FResInstantCilindro.Masa)
1737  insoutput << "\t" << FResInstantCilindro.MasaINS;
1738  if(FResInstantCilindro.Volumen)
1739  insoutput << "\t" << FResInstantCilindro.VolumenINS;
1740  if(FResInstantCilindro.CoeficienteWoschni)
1741  insoutput << "\t" << FResInstantCilindro.CoeficienteWoschniINS;
1742  if(FResInstantCilindro.MasaCombustible)
1743  insoutput << "\t" << FResInstantCilindro.MasaCombustibleINS;
1744  if(FResInstantCilindro.FQL)
1745  insoutput << "\t" << FResInstantCilindro.FQLINS;
1746  if(FResInstantCilindro.TemperaturaCilindroInterna)
1747  insoutput << "\t" << FResInstantCilindro.TemperaturaCilindroInternaINS;
1748  if(FResInstantCilindro.TemperaturaCilindroMedia)
1749  insoutput << "\t" << FResInstantCilindro.TemperaturaCilindroMediaINS;
1750  if(FResInstantCilindro.TemperaturaCilindroExterna)
1751  insoutput << "\t" << FResInstantCilindro.TemperaturaCilindroExternaINS;
1752  if(FResInstantCilindro.TemperaturaPistonInterna)
1753  insoutput << "\t" << FResInstantCilindro.TemperaturaPistonInternaINS;
1754  if(FResInstantCilindro.TemperaturaPistonMedia)
1755  insoutput << "\t" << FResInstantCilindro.TemperaturaPistonMediaINS;
1756  if(FResInstantCilindro.TemperaturaPistonExterna)
1757  insoutput << "\t" << FResInstantCilindro.TemperaturaPistonExternaINS;
1758  if(FResInstantCilindro.TemperaturaCulataInterna)
1759  insoutput << "\t" << FResInstantCilindro.TemperaturaCulataInternaINS;
1760  if(FResInstantCilindro.TemperaturaCulataMedia)
1761  insoutput << "\t" << FResInstantCilindro.TemperaturaCulataMediaINS;
1762  if(FResInstantCilindro.TemperaturaCulataExterna)
1763  insoutput << "\t" << FResInstantCilindro.TemperaturaCulataExternaINS;
1764  if(FResInstantCilindro.NIT) {
1765  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1766  insoutput << "\t" << FResInstantCilindro.NITINS[i];
1767  }
1768  insoutput << "\t" << FResInstantCilindro.NITTotalINS;
1769  }
1770  if(FResInstantCilindro.ParInstantaneo)
1771  insoutput << "\t" << FResInstantCilindro.ParInstantaneoINS;
1772  if(FResInstantCilindro.GastoCortocircuito)
1773  insoutput << "\t" << FResInstantCilindro.GastoCortocircuitoINS;
1774  if(FResInstantCilindro.GastoBlowBy)
1775  insoutput << "\t" << FResInstantCilindro.GastoBlowByINS;
1776  if(FResInstantCilindro.FraccionMasica) {
1777  for(int i = 0; i < FMotor->getSpeciesNumber() - FIntEGR; i++) {
1778  insoutput << "\t" << FResInstantCilindro.FraccionINS[i];
1779  }
1780  }
1781  if(FResInstantCilindro.Gamma)
1782  insoutput << "\t" << FResInstantCilindro.GammaINS;
1783 
1784  if(FResInstantCilindro.HeatHead)
1785  insoutput << "\t" << FResInstantCilindro.HeatHeadINS;
1786  if(FResInstantCilindro.HeatCyl)
1787  insoutput << "\t" << FResInstantCilindro.HeatCylINS;
1788  if(FResInstantCilindro.HeatPis)
1789  insoutput << "\t" << FResInstantCilindro.HeatPisINS;
1790 
1791  }
1792 
1793  // fclose(fich);
1794  } catch(exception & N) {
1795  std::cout << "ERROR: TCilindro::HeaderInstantaneousResultsCilindro en cilindro: " << FNumeroCilindro << std::endl;
1796  std::cout << "Tipo de error: " << N.what() << std::endl;
1797  throw Exception(N.what());
1798  }
1799 }
1800 
1801 // ---------------------------------------------------------------------------
1802 // ---------------------------------------------------------------------------
1803 
1804 void TCilindro::CalculaResultadosInstantaneosCilindro() {
1805  try {
1806 
1807  if(FNumVarIns > 0) {
1808 
1809  double gastoesc = 0., gastoadm = 0.;
1810  double secefectotaladm = 0., secefectotalesc = 0.;
1811 
1812  if(FResInstantCilindro.Pressure)
1813  FResInstantCilindro.PresionINS = FPressure;
1814  if(FResInstantCilindro.Temperature)
1815  FResInstantCilindro.TemperaturaINS = FTemperature;
1816  if(FResInstantCilindro.MomentoAngularEsc) {
1817  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1818  FResInstantCilindro.MomentoAngularEscINS[i] = dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getMomento();
1819  }
1820  if(FNumeroUnionesEsc > 1) {
1821  FResInstantCilindro.MomentoAngularTotalEscINS = FMomentoAngularEsc;
1822  }
1823  }
1824  if(FResInstantCilindro.MomentoAngularAdm) {
1825  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1826  FResInstantCilindro.MomentoAngularAdmINS[i] = dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getMomento();
1827  }
1828  if(FNumeroUnionesAdm > 1) {
1829  FResInstantCilindro.MomentoAngularTotalAdmINS = FMomentoAngularAdm;
1830  }
1831  }
1832  if(FResInstantCilindro.GastoEsc) {
1833  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1834  FResInstantCilindro.GastoEscINS[i] = dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getMassflow();
1835  gastoesc += dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getMassflow();
1836  }
1837  if(FNumeroUnionesEsc > 1) {
1838  FResInstantCilindro.GastoTotalEscINS = gastoesc;
1839  }
1840  }
1841  if(FResInstantCilindro.GastoAdm) {
1842  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1843  FResInstantCilindro.GastoAdmINS[i] = dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getMassflow();
1844  gastoadm += dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getMassflow();
1845  }
1846  if(FNumeroUnionesAdm > 1) {
1847  FResInstantCilindro.GastoTotalAdmINS = gastoadm;
1848  }
1849  }
1850  if(FResInstantCilindro.MachEsc) {
1851  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1852  FResInstantCilindro.MachEscINS[i] = dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getMach();
1853  }
1854  }
1855  if(FResInstantCilindro.MachAdm) {
1856  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1857  FResInstantCilindro.MachAdmINS[i] = dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getMach();
1858  }
1859  }
1860  if(FResInstantCilindro.SeccionEfectivaEsc) {
1861  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1862  FResInstantCilindro.SeccionEfectivaEscINS[i] = dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getSeccionEficaz();
1863  secefectotalesc += dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getSeccionEficaz();
1864  }
1865  if(FNumeroUnionesEsc > 1) {
1866  FResInstantCilindro.SeccionEfectivaTotalEscINS = secefectotalesc;
1867  }
1868  }
1869  if(FResInstantCilindro.SeccionEfectivaAdm) {
1870  for(int i = 0; i < FNumeroUnionesAdm; i++) {
1871  FResInstantCilindro.SeccionEfectivaAdmINS[i] = dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getSeccionEficaz();
1872  secefectotaladm += dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getSeccionEficaz();
1873  }
1874  if(FNumeroUnionesAdm > 1) {
1875  FResInstantCilindro.SeccionEfectivaTotalAdmINS = secefectotaladm;
1876  }
1877  }
1878  if(FResInstantCilindro.Masa)
1879  FResInstantCilindro.MasaINS = FMasa;
1880  if(FResInstantCilindro.Volumen)
1881  FResInstantCilindro.VolumenINS = FVolumen;
1882  if(FResInstantCilindro.CoeficienteWoschni)
1883  FResInstantCilindro.CoeficienteWoschniINS = Fh;
1884  if(FResInstantCilindro.MasaCombustible)
1885  FResInstantCilindro.MasaCombustibleINS = FFuelTotal;
1886  if(FResInstantCilindro.FQL)
1887  FResInstantCilindro.FQLINS = FCalor.FQL;
1888  if(FResInstantCilindro.TemperaturaCilindroInterna)
1889  FResInstantCilindro.TemperaturaCilindroInternaINS = FTempPared[0].Cylinder;
1890  if(FResInstantCilindro.TemperaturaCilindroMedia)
1891  FResInstantCilindro.TemperaturaCilindroMediaINS = FTempPared[1].Cylinder;
1892  if(FResInstantCilindro.TemperaturaCilindroExterna)
1893  FResInstantCilindro.TemperaturaCilindroExternaINS = FTempPared[2].Cylinder;
1894  if(FResInstantCilindro.TemperaturaPistonInterna)
1895  FResInstantCilindro.TemperaturaPistonInternaINS = FTempPared[0].Piston;
1896  if(FResInstantCilindro.TemperaturaPistonMedia)
1897  FResInstantCilindro.TemperaturaPistonMediaINS = FTempPared[1].Piston;
1898  if(FResInstantCilindro.TemperaturaPistonExterna)
1899  FResInstantCilindro.TemperaturaPistonExternaINS = FTempPared[2].Piston;
1900  if(FResInstantCilindro.TemperaturaCulataInterna)
1901  FResInstantCilindro.TemperaturaCulataInternaINS = FTempPared[0].Culata;
1902  if(FResInstantCilindro.TemperaturaCulataMedia)
1903  FResInstantCilindro.TemperaturaCulataMediaINS = FTempPared[1].Culata;
1904  if(FResInstantCilindro.TemperaturaCulataExterna)
1905  FResInstantCilindro.TemperaturaCulataExternaINS = FTempPared[2].Culata;
1906  if(FResInstantCilindro.NIT) {
1907  for(int i = 0; i < FNumeroUnionesEsc; i++) {
1908  FResInstantCilindro.NITINS[i] = FValvEsc[i].NIT;
1909  }
1910  FResInstantCilindro.NITTotalINS = FNIT;
1911  }
1912  if(FResInstantCilindro.ParInstantaneo)
1913  FResInstantCilindro.ParInstantaneoINS = FParInstantaneo;
1914  if(FResInstantCilindro.GastoCortocircuito)
1915  FResInstantCilindro.GastoCortocircuitoINS = FGastoCortocircuito;
1916  if(FResInstantCilindro.GastoBlowBy)
1917  FResInstantCilindro.GastoBlowByINS = FGastoBlowBy;
1918  if(FResInstantCilindro.FraccionMasica) {
1919  for(int i = 0; i < FMotor->getSpeciesNumber() - FIntEGR; i++) {
1920  FResInstantCilindro.FraccionINS[i] = FFraccionMasicaEspecie[i];
1921  }
1922  }
1923  if(FResInstantCilindro.Gamma)
1924  FResInstantCilindro.GammaINS = FGamma;
1925  if(FResInstantCilindro.HeatHead)
1926  FResInstantCilindro.HeatHeadINS = FCalor.TransCulata;
1927  if(FResInstantCilindro.HeatCyl)
1928  FResInstantCilindro.HeatCylINS = FCalor.TransCilindro;
1929  if(FResInstantCilindro.HeatPis)
1930  FResInstantCilindro.HeatPisINS = FCalor.TransPiston;
1931 
1932  }
1933  } catch(exception & N) {
1934  std::cout << "ERROR: TCilindro::CalculaResultadosInstantaneosCilindro en cilindro: " << FNumeroCilindro << std::endl;
1935  std::cout << "Tipo de error: " << N.what() << std::endl;
1936  throw Exception(N.what());
1937  }
1938 }
1939 
1940 // ---------------------------------------------------------------------------
1941 // ---------------------------------------------------------------------------
1942 
1943 double TCilindro::CalculaVolumen(double AnguloActual) {
1944  try {
1945  double tt = 0., ttt = 0., xxx = 0.;
1946  double ret_val, deltaVol, acel = 0., c;
1947 
1948  double a = __units::DegToRad(AnguloActual);
1949  double b = FMotor->getGeometria().Biela;
1950  double m = FMotor->getGeometria().Carrera / 2.;
1951  double e = FMotor->getGeometria().Excentricidad / 1000;
1952  double area = __geom::Circle_area(FMotor->getGeometria().Diametro);
1953 
1954  double Lact = m * sqrt(pow2(1. + b / m) - pow2(e / m)) - m * (cos(a) + sqrt(pow2((b / m)) - pow2(sin(a) - e / m)));
1955 
1956  // Lact=b+m*(1-cos(a))-sqrt(pow(b,2.)-pow(m*sin(a),2.));
1957  ret_val = Lact * area + FMotor->getGeometria().VCC;
1958 
1959  if(FMotor->getGeometria().CoefDeformaciones != 0) {
1960  double aux = FMotor->getGeometria().CoefDeformaciones / FMotor->getGeometria().ModuloElasticidad * pow(
1961  FMotor->getGeometria().Diametro / FMotor->getGeometria().DiametroBulon,
1962  2.) * (FMotor->getGeometria().AlturaCoronaPiston + b + m);
1963 
1964  if(FDeltaAngulo != 0) {
1965  double Lant = m * sqrt(pow2(1. + b / m) - pow2(e / m)) - m * (cos(a - __units::DegToRad(FDeltaAngulo)) + sqrt(pow2((
1966  b / m)) - pow2(sin(a - __units::DegToRad(FDeltaAngulo)) - e / m)));
1967 
1968  double Lpos = m * sqrt(pow2(1. + b / m) - pow2(e / m)) - m * (cos(a + __units::DegToRad(FDeltaAngulo)) + sqrt(pow2((
1969  b / m)) - pow2(sin(a + __units::DegToRad(FDeltaAngulo)) - e / m)));
1970 
1971  c = Lant + Lpos - Lact * 2.;
1972  if(c < 1e-5)
1973  c = 0.;
1974  acel = c / pow2((FDeltaAngulo / (6. * FMotor->getRegimen())));
1975 
1976  double Msist = 0.33 * FMotor->getGeometria().MasaBiela + FMotor->getGeometria().MasaPistonSegmentosBulon;
1977 
1978  deltaVol = (area * __units::BarToPa(FPressure) + Msist * acel) * aux;
1979  } else {
1980  deltaVol = area * __units::BarToPa(FPressure) * aux;
1981  }
1982 
1983  ret_val += deltaVol;
1984  }
1985  return ret_val;
1986  } catch(exception & N) {
1987  std::cout << "ERROR: TCilindro::CalculaVolumen en cilindro: " << FNumeroCilindro << std::endl;
1988  std::cout << "Tipo de error: " << N.what() << std::endl;
1989  throw Exception(N.what());
1990  }
1991 }
1992 
1993 // ---------------------------------------------------------------------------
1994 // ---------------------------------------------------------------------------
1995 
1996 void TCilindro::IniciaVariables() {
1997  try {
1998  double TemperaturaInicial = 0.;
1999  double RAtmosfera, PMAtmosfera, FraccionMolarO2, FraccionMolarH2O, FraccionMolarN2;
2000 
2001  if(FMotor->getTheta() > FMotor->GetDesfase(FNumeroCilindro - 1)) {
2002  FAnguloActual = FMotor->getTheta() - FMotor->GetDesfase(FNumeroCilindro - 1);
2003  } else {
2004  FAnguloActual = FMotor->getTheta() - FMotor->GetDesfase(FNumeroCilindro - 1) + FMotor->getAngTotalCiclo();
2005  }
2006  FNumeroCiclo = 0;
2007 
2008  FAnguloAnterior = 0.;
2009  FDeltaAngulo = 0.;
2010  FTime1 = 0.;
2011  FTime0 = 0.;
2012  FDeltaT = 0.;
2013  FVolumen = CalculaVolumen(FAnguloActual);
2014  FVolumen0 = FVolumen;
2015  FVolumenCA = CalculaVolumen(FDistribucion.CA);
2016  FMomentoAngular = 0.;
2017  FAFR = 15.;
2018 
2019  // Transporte de Especies Quimicas
2020  FComposicionSaliente.resize(FMotor->getSpeciesNumber() - FIntEGR, 0.);
2021  FFraccionMasicaEspecie.resize(FMotor->getSpeciesNumber() - FIntEGR, 0.);
2022  FFraccionComienzoCicloCerrado.resize(FMotor->getSpeciesNumber() - FIntEGR, 0.);
2023  FMasaEspecie.resize(FMotor->getSpeciesNumber() - FIntEGR, 0.);
2024  FMasaEspecieCicloCerrado.resize(3, 0.);
2025  FComposicionCicloCerrado.resize(3, 0.);
2026  for(int i = 0; i < FMotor->getSpeciesNumber() - FIntEGR; i++) {
2027  FFraccionMasicaEspecie[i] = FMotor->GetComposicionInicial(i);
2028  FComposicionSaliente[i] = FMotor->GetComposicionInicial(i);
2029  FFraccionComienzoCicloCerrado[i] = FMotor->GetComposicionInicial(i);
2030  }
2031  if(FMotor->getSpeciesModel() == nmCalculoCompleto) {
2032  if(FMotor->getSpeciesNumber() == 9) {
2033  FComposicionCicloCerrado[1] = 0.;
2034  // No llega combustible de los tubos
2035  FComposicionCicloCerrado[2] = FFraccionMasicaEspecie[0] / FMotor->GetComposicionAtmosfera(0); // Aire fresco
2036  FComposicionCicloCerrado[0] = 1 - FComposicionCicloCerrado[2];
2037  // Gases Quemados
2038  } else if(FMotor->getSpeciesNumber() == 10) {
2039  FComposicionCicloCerrado[1] = FFraccionMasicaEspecie[7];
2040  // Combustible
2041  FComposicionCicloCerrado[2] = FFraccionMasicaEspecie[0] / FMotor->GetComposicionAtmosfera(0); // Aire fresco
2042  FComposicionCicloCerrado[0] = 1 - FComposicionCicloCerrado[1] - FComposicionCicloCerrado[2]; // Gases Quemados
2043  }
2044  } else if(FMotor->getSpeciesModel() == nmCalculoSimple) {
2045  if(FMotor->getSpeciesNumber() == 3) {
2046  FComposicionCicloCerrado[1] = 0.;
2047  // No llega combustible de los tubos
2048  FComposicionCicloCerrado[2] = FFraccionMasicaEspecie[1];
2049  // Aire fresco
2050  FComposicionCicloCerrado[0] = FFraccionMasicaEspecie[0];
2051  // Gases Quemados
2052  } else if(FMotor->getSpeciesNumber() == 4) {
2053  FComposicionCicloCerrado[1] = FFraccionMasicaEspecie[1];
2054  // Combustible
2055  FComposicionCicloCerrado[2] = FFraccionMasicaEspecie[2];
2056  // Aire fresco
2057  FComposicionCicloCerrado[0] = FFraccionMasicaEspecie[0];
2058  // Gases Quemados
2059  }
2060  }
2061 
2062  if(FMotor->getSpeciesModel() == nmCalculoCompleto) {
2063  RAtmosfera = FMotor->GetComposicionAtmosfera(0) * __R::O2 + FMotor->GetComposicionAtmosfera(2) * __R::H2O +
2064  (FMotor->GetComposicionAtmosfera(7) - 0.01292 * (1 - FMotor->GetComposicionAtmosfera(
2065  2))) * __R::N2 + FMotor->GetComposicionAtmosfera(1) * __R::CO2 + (0.01292 * (1 - FMotor->GetComposicionAtmosfera(
2066  2))) * __R::Ar;
2067  PMAtmosfera = __R::Universal / RAtmosfera;
2068  FraccionMolarO2 = FMotor->GetComposicionAtmosfera(0) * PMAtmosfera / __PM::O2;
2069  FraccionMolarH2O = FMotor->GetComposicionAtmosfera(2) * PMAtmosfera / __PM::H2O;
2070  FraccionMolarN2 = 1 - FraccionMolarO2 - FraccionMolarH2O;
2071  // FRelacionMolarH2O_O2=FraccionMolarH2O/FraccionMolarO2;
2072  FRelacionMolarN2_O2 = FraccionMolarN2 / FraccionMolarO2;
2073  }
2074 
2075  if(FMotor->getSpeciesModel() == nmCalculoCompleto) {
2076  if(FMotor->getSpeciesNumber() == 9) {
2077  FFraccionMasicaEspecieFuel = 0; // No se tiene en cuenta el combustible
2078  } else if(FMotor->getSpeciesNumber() == 10) {
2079  FFraccionMasicaEspecieFuel = FFraccionMasicaEspecie[7];
2080  }
2081  FRMezcla = CalculoCompletoRMezcla(FFraccionMasicaEspecie[0], FFraccionMasicaEspecie[1], FFraccionMasicaEspecie[2],
2082  FFraccionMasicaEspecieFuel, FMotor->getGammaCalculation(),
2083  FMotor->getCombustible());
2084  TemperaturaInicial = __units::KTodegC(__units::BarToPa(FMotor->getPresionInicial()) * FVolumen /
2085  FMotor->getMasaInicial() / FRMezcla);
2086  FCpMezcla = CalculoCompletoCpMezcla(FFraccionMasicaEspecie[0], FFraccionMasicaEspecie[1], FFraccionMasicaEspecie[2],
2087  FFraccionMasicaEspecieFuel, __units::degCToK(TemperaturaInicial),
2088  FMotor->getGammaCalculation(), FMotor->getCombustible());
2089  FGamma = CalculoCompletoGamma(FRMezcla, FCpMezcla, FMotor->getGammaCalculation());
2090 
2091  } else if(FMotor->getSpeciesModel() == nmCalculoSimple) {
2092 
2093  FRMezcla = CalculoSimpleRMezcla(FFraccionMasicaEspecie[0], 0, FMotor->getGammaCalculation(), FMotor->getCombustible());
2094  TemperaturaInicial = __units::KTodegC(__units::BarToPa(FMotor->getPresionInicial()) * FVolumen /
2095  FMotor->getMasaInicial() / FRMezcla);
2096  FCvMezcla = CalculoSimpleCvMezcla(__units::degCToK(TemperaturaInicial), FFraccionMasicaEspecie[0], 0,
2097  FMotor->getGammaCalculation(), FMotor->getCombustible());
2098  FGamma = CalculoSimpleGamma(FRMezcla, FCvMezcla, FMotor->getGammaCalculation());
2099  FHcl = -1852564 + 2195 * (30 + 273 +
2100  125); //Temperatura del combustible en K +125, que es el incremento de la temperatura de combustible hasta la tobera del inyector
2101 
2102  }
2103 
2104  FPresionRCA = FMotor->getPresionInicial();
2105 
2106  if(FMotor->GetDesfase(FNumeroCilindro - 1) == 0) {
2107 
2108  FCicloCerrado = false;
2109  FPressure = FMotor->getPresionInicial();
2110  FTemperature = 60;
2111  FMasa = __units::BarToPa(FPressure) * FVolumen / __units::degCToK(FTemperature) / FRMezcla;
2112  FMasaAtrapada = __units::BarToPa(FPressure) * FVolumen / __units::degCToK(FTemperature) / FRMezcla;
2113  for(int j = 0; j < FMotor->getSpeciesNumber() - FIntEGR; j++) {
2114  FMasaEspecie[j] = FMasa * FFraccionMasicaEspecie[j];
2115  }
2116  for(int j = 0; j < 3; j++) {
2117  FMasaEspecieCicloCerrado[j] = FMasa * FComposicionCicloCerrado[j];
2118  }
2119  FAsonido = sqrt(FGamma * FRMezcla * __units::degCToK(FTemperature));
2120  } else {
2121  // Ciclo cerrado. Compresion Isoentropica.
2122  if(FAnguloActual < 180. || FAnguloActual > 540.) {
2123  FCicloCerrado = true;
2124  FPressure = FMotor->getPresionInicial() * pow((FVolumenCA / FVolumen), FGamma);
2125  //FMasa = FMotor->getMasaInicial();
2126  FMasa = __units::BarToPa(FMotor->getPresionInicial()) * FVolumenCA / __units::degCToK(60) / FRMezcla;
2127  FMasaAtrapada = FMasa;
2128  for(int j = 0; j < FMotor->getSpeciesNumber() - FIntEGR; j++) {
2129  FMasaEspecie[j] = FMasa * FFraccionMasicaEspecie[j];
2130  }
2131  for(int j = 0; j < 3; j++) {
2132  FMasaEspecieCicloCerrado[j] = FMasa * FComposicionCicloCerrado[j];
2133  }
2134 
2135  FTemperature = __units::KTodegC(__units::BarToPa(FPressure) * FVolumen / FMasa / FRMezcla);
2136  // Como cambia la Temperature, cambia Cp o Cv y por tanto cambia el valor de Gamma.
2137  if(FMotor->getSpeciesModel() == nmCalculoCompleto) {
2138  if(FMotor->getSpeciesNumber() == 9) {
2139  FFraccionMasicaEspecieFuel = 0; // No se tiene en cuenta el combustible
2140  } else if(FMotor->getSpeciesNumber() == 10) {
2141  FFraccionMasicaEspecieFuel = FFraccionMasicaEspecie[7];
2142  }
2143  FCpMezcla = CalculoCompletoCpMezcla(FFraccionMasicaEspecie[0], FFraccionMasicaEspecie[1], FFraccionMasicaEspecie[2],
2144  FFraccionMasicaEspecieFuel, __units::degCToK(FTemperature),
2145  FMotor->getGammaCalculation(), FMotor->getCombustible());
2146  FGamma = CalculoCompletoGamma(FRMezcla, FCpMezcla, FMotor->getGammaCalculation());
2147 
2148  } else if(FMotor->getSpeciesModel() == nmCalculoSimple) {
2149 
2150  FCvMezcla = CalculoSimpleCvMezcla(__units::degCToK(FTemperature), FFraccionMasicaEspecie[0], 0,
2151  FMotor->getGammaCalculation(), FMotor->getCombustible());
2152  FGamma = CalculoSimpleGamma(FRMezcla, FCvMezcla, FMotor->getGammaCalculation());
2153 
2154  }
2155  FAsonido = sqrt(FGamma * FRMezcla * __units::degCToK(FTemperature));
2156  // Ciclo abierto. Density constante.
2157  } else {
2158  FCicloCerrado = false;
2159  FPressure = FMotor->getPresionInicial();
2160  FTemperature = 60;
2161  FMasa = __units::BarToPa(FPressure) * FVolumen / __units::degCToK(FTemperature) / FRMezcla;
2162  FMasaAtrapada = __units::BarToPa(FPressure) * FVolumen / __units::degCToK(FTemperature) / FRMezcla;
2163  for(int j = 0; j < FMotor->getSpeciesNumber() - FIntEGR; j++) {
2164  FMasaEspecie[j] = FMasa * FFraccionMasicaEspecie[j];
2165  }
2166  for(int j = 0; j < 3; j++) {
2167  FMasaEspecieCicloCerrado[j] = FMasa * FComposicionCicloCerrado[j];
2168  }
2169  FAsonido = sqrt(FGamma * FRMezcla * __units::degCToK(FTemperature));
2170  }
2171  }
2172  FMasa0 = FMasa;
2173  FPresion0 = FPressure;
2174  FTemperatura0 = FTemperature;
2175  FAsonido0 = FAsonido;
2176 
2177  if(FMotor->getCombustible() == nmMEC) {
2178  FMasaFuel = FMotor->getMasaFuel();
2179  FXComb = 10.8;
2180  FYComb = 18.7;
2181  FZComb = 0;
2182  } else if(FMotor->getCombustible() == nmMEP) {
2183  if(FMotor->getDosadoInicial() < 5) {
2184  FMasaFuel = FMotor->getMasaInicial() / 5.;
2185  } else {
2186  FMasaFuel = FMotor->getMasaInicial() / FMotor->getDosadoInicial();
2187  }
2188  FXComb = 7.97;
2189  FYComb = 14.8;
2190  FZComb = 0;
2191  } else {
2192  std::cout << "ERROR: Tipo de motor desconocido" << std::endl;
2193  }
2194 
2195  if(FMotor->getSpeciesModel() == nmCalculoCompleto) {
2196  FDosadoEstequiometrico = 1 / ((FXComb + FYComb / 4 - FZComb / 2) * __PM::O2) * (FXComb * 12.01 + FYComb * 1.01 + FZComb
2197  * 16) * 0.23136;
2198  } else if(FMotor->getSpeciesModel() == nmCalculoSimple) {
2199  if(FMotor->getCombustible() == nmMEC) {
2200  FDosadoEstequiometrico = 0.069424352;
2201  } else if(FMotor->getCombustible() == nmMEP) {
2202  FDosadoEstequiometrico = 0.068468349;
2203  }
2204  }
2205 
2206  FMfint = FMasaFuel; // kg/cc
2207  FMaint = FMasa; // kg/cc
2208  FRegInt = FMotor->getRegimen();
2209 
2210  FMasaPorAdmision = FMasa;
2211 
2212  FTempPared = new stTemperaturasPared[3];
2213  for(int i = 0; i < 3; i++) {
2214  FTempPared[i].Piston = FMotor->getTempInicial().Piston;
2215  FTempPared[i].PistonSUMup = 0.;
2216  FTempPared[i].PistonSUMdown = 0.;
2217  FTempPared[i].Culata = FMotor->getTempInicial().Culata;
2218  FTempPared[i].CulataSUMup = 0.;
2219  FTempPared[i].CulataSUMdown = 0.;
2220  FTempPared[i].Cylinder = FMotor->getTempInicial().Cylinder;
2221  FTempPared[i].CilindroSUMup = 0.;
2222  FTempPared[i].CilindroSUMdown = 0.;
2223  }
2224  FTiempoCiclo = 0;
2225 
2226  FAngDesplazado = new double[FMotor->getLeyQuemadoBD().size()];
2227  FPrimeraCombustion = true;
2228 
2229  } catch(exception & N) {
2230  std::cout << "ERROR: TCilindro::IniciaVariables en cilindro: " << FNumeroCilindro << std::endl;
2231  std::cout << "Tipo de error: " << N.what() << std::endl;
2232  throw Exception(N.what());
2233  }
2234 }
2235 
2236 // ---------------------------------------------------------------------------
2237 // ---------------------------------------------------------------------------
2238 
2239 void TCilindro::InicioFinCombustion() {
2240  try {
2241  double distReg = 0;
2242  double distMf = 0;
2243  double distMa = 0;
2244  double Numerador = 0;
2245  double Denominador = 0;
2246  double Ang01 = 0.;
2247  double dist = 0., e = 0., b = 0., DistMax = 0., DistMin = 0., Weight = 0.;
2248  int k = 0;
2249 
2250  if(FMotor->getMasaFuel() == 0.) {
2251  FIniComb = 0.;
2252  FFinComb = 0.;
2253  } else {
2254 
2255  if(FMotor->getLeyQuemadoBD().size() == 1) {
2256  FIniComb = FMotor->getLeyQuemadoBD()[0].Wiebes[0].Alpha0;
2257  FFinComb = FMotor->getLeyQuemadoBD()[0].Wiebes[FMotor->getLeyQuemadoBD()[0].Wiebes.size() - 1].Alpha0 +
2258  FMotor->getLeyQuemadoBD()[0].Wiebes[FMotor->getLeyQuemadoBD()[0].Wiebes.size() - 1].IncAlpha;
2259  } else {
2260 
2261  std::vector<double> Dist;
2262 
2263  Dist.resize(FMotor->getLeyQuemadoBD().size());
2264 
2265  for(Uint i = 0; i < FMotor->getLeyQuemadoBD().size(); i++) {
2266  if(FMotor->getLeyQuemadoBD()[i].Wiebes.size() == 4) {
2267  k = 1; // Cuando hay 4 wiebes(piloto,premezcla,difusion y cola)
2268  } else {
2269  k = 0; // Cuando hay 3 wiebes(premezcla,difusion y cola)
2270  }
2271  distReg = pow2((FRegInt - FMotor->getLeyQuemadoBD()[i].n) / FMotor->getLQRegMax());
2272  distMf = pow2((FMfint - FMotor->getLeyQuemadoBD()[i].mf) / FMotor->getLQMfMax());
2273  distMa = pow2((FMaint - FMotor->getLeyQuemadoBD()[i].ma) / FMotor->getLQMaMax());
2274  b = distReg + distMf + distMa;
2275 
2276  if(b < 1e-15)
2277  b = 1e-15;
2278  Dist[i] = sqrt(b);
2279  if(i == 0) {
2280  DistMax = Dist[i];
2281  DistMin = Dist[i];
2282  } else {
2283  if(Dist[i] < DistMin)
2284  DistMin = Dist[i];
2285  else if(Dist[i] > DistMax)
2286  DistMax = Dist[i];
2287  }
2288 
2289  }
2290  for(Uint i = 0; i < FMotor->getLeyQuemadoBD().size(); i++) {
2291  Weight = pow4(((1 / Dist[i]) - (1 / DistMax)) / ((1 / DistMin) - (1 / DistMax)));
2292  Numerador += FMotor->getLeyQuemadoBD()[i].Wiebes[k].Alpha0 * Weight;
2293  Denominador += Weight;
2294  }
2295 
2296  // Media ponderada
2297  Ang01 = Numerador / Denominador;
2298 
2299  // Inicializacion de los parametros.
2300  FIniComb = Ang01;
2301  FFinComb = Ang01;
2302 
2303  // Busqueda del begining y el fin de la combustion
2304  double Finaliza = 0.;
2305 
2306  for(Uint i = 0; i < FMotor->getLeyQuemadoBD().size(); i++) {
2307 
2308  if(FMotor->getLeyQuemadoBD()[i].Wiebes.size() == 4) {
2309  k = 1; // Cuando hay 4 wiebes(piloto,premezcla,difusion y cola)
2310  } else {
2311  k = 0; // Cuando hay 3 wiebes(premezcla,difusion y cola)
2312  }
2313  FAngDesplazado[i] = Ang01 - FMotor->getLeyQuemadoBD()[i].Wiebes[k].Alpha0;
2314  /* Comentado por SHC para avanzar
2315  for (Uint j = 0; j < FMotor->getLeyQuemadoBD()[i].Wiebes.size(); j++) {
2316  FMotor->getLeyQuemadoBD()[i].Wiebes[j].Inicia = FMotor->getLeyQuemadoBD()[i].Wiebes[j]
2317  .Alpha0 + FAngDesplazado[i];
2318  }
2319  */
2320 
2321  if(FMotor->getLeyQuemadoBD()[i].Wiebes[0].Inicia < FIniComb) {
2322  FIniComb = FMotor->getLeyQuemadoBD()[i].Wiebes[0].Inicia;
2323  }
2324 
2325  Finaliza = FMotor->getLeyQuemadoBD()[i].Wiebes[FMotor->getLeyQuemadoBD()[i].Wiebes.size() - 1].Inicia +
2326  FMotor->getLeyQuemadoBD()[i].Wiebes[FMotor->getLeyQuemadoBD()[i].Wiebes.size() - 1].IncAlpha;
2327 
2328  if(Finaliza > FFinComb) {
2329  FFinComb = Finaliza;
2330  }
2331  }
2332  }
2333  }
2334  } catch(exception & N) {
2335  std::cout << "ERROR: AnguloInicioCombustion en el cilindro: " << FNumeroCilindro << std::endl;
2336  std::cout << "Tipo de error: " << N.what() << std::endl;
2337  throw Exception(N.what());
2338  }
2339 }
2340 
2341 // ---------------------------------------------------------------------------
2342 // ---------------------------------------------------------------------------
2343 
2344 double TCilindro::CalculaCalorLiberado(double x) {
2345  try {
2346  double Result = 0.;
2347  double distReg = 0;
2348  double distMf = 0;
2349  double distMa = 0;
2350  double Numerador = 0;
2351  double Denominador = 0;
2352  double dist = 0., e = 0., b = 0., ley = 0., DistMax = 0., DistMin = 0., Weight = 0.;
2353 
2354  if(FMotor->getLeyQuemadoBD().size() == 1) {
2355  Result = fql(x, 0);
2356  } else {
2357  std::vector<double> Dist;
2358  std::vector<double> LeyFQL;
2359 
2360  Dist.resize(FMotor->getLeyQuemadoBD().size());
2361  LeyFQL.resize(FMotor->getLeyQuemadoBD().size());
2362 
2363  for(Uint i = 0; i < FMotor->getLeyQuemadoBD().size(); i++) {
2364  distReg = pow2((FRegInt - FMotor->getLeyQuemadoBD()[i].n) / FMotor->getLQRegMax());
2365  distMf = pow2((FMfint - FMotor->getLeyQuemadoBD()[i].mf) / FMotor->getLQMfMax());
2366  /* : kg/cc */
2367  distMa = pow2((FMaint - FMotor->getLeyQuemadoBD()[i].ma) / FMotor->getLQMaMax());
2368  /* : kg/cc */
2369  // dist=pow(distReg+distMf+distMa,0.5);
2370  b = distReg + distMf + distMa;
2371 
2372  if(b < 1e-15)
2373  b = 1e-15;
2374  Dist[i] = sqrt(b);
2375  if(i == 0) {
2376  DistMax = Dist[i];
2377  DistMin = Dist[i];
2378  } else {
2379  if(Dist[i] < DistMin)
2380  DistMin = Dist[i];
2381  else if(Dist[i] > DistMax)
2382  DistMax = Dist[i];
2383  }
2384  // if(dist<1e-8)
2385  // dist=1e-8;
2386  // e=2+1/dist;
2387  // dist = pow( b,e);
2388  LeyFQL[i] = fql(x, i);
2389  if(LeyFQL[i] > 1.)
2390  printf("WARNING: Ley n. %d > 1. en %lf\n", i, x);
2391  // Numerador+=ley/dist;
2392  // Denominador+=1./dist;
2393  }
2394  for(Uint i = 0; i < FMotor->getLeyQuemadoBD().size(); i++) {
2395  Weight = pow4(((1 / Dist[i]) - (1 / DistMax)) / ((1 / DistMin) - (1 / DistMax)));
2396  Numerador += LeyFQL[i] * Weight;
2397  Denominador += Weight;
2398  }
2399  Result = Numerador / Denominador;
2400  }
2401  return Result;
2402  } catch(exception & N) {
2403  std::cout << "ERROR: CalculaCalorLiberado en cilindro: " << FNumeroCilindro << std::endl;
2404  std::cout << "Tipo de error: " << N.what() << std::endl;
2405  throw Exception(N.what());
2406  }
2407 }
2408 
2409 // ---------------------------------------------------------------------------
2410 // ---------------------------------------------------------------------------
2411 
2412 double TCilindro::fql(double x, int ley) {
2413 
2414  try {
2415  double ret_val = 0., wiebe = 0.;
2416 
2417  for(Uint k = 0; k < FMotor->getLeyQuemadoBD()[ley].Wiebes.size(); ++k) {
2418  wiebe = fun_wiebe(x, ley, k);
2419  ret_val += wiebe * FMotor->getLeyQuemadoBD()[ley].Wiebes[k].Beta;
2420  }
2421 
2422  return ret_val;
2423 
2424  } catch(exception & N) {
2425  std::cout << "ERROR: TCilindro::fql en cilindro: " << FNumeroCilindro << std::endl;
2426  std::cout << "Tipo de error: " << N.what() << std::endl;
2427  throw Exception(N.what());
2428  }
2429 }
2430 
2431 // ---------------------------------------------------------------------------
2432 // ---------------------------------------------------------------------------
2433 
2434 double TCilindro::fun_wiebe(double x, int ley, int wiebe) {
2435  try {
2436  double ret_val = 0., xx = 0., xxx = 0.;
2437 
2438  if(x <= FMotor->getLeyQuemadoBD()[ley].Wiebes[wiebe].Inicia) {
2439  ret_val = 0.;
2440  } else {
2441  xx = (x - FMotor->getLeyQuemadoBD()[ley].Wiebes[wiebe].Inicia) / FMotor->getLeyQuemadoBD()[ley].Wiebes[wiebe].IncAlpha;
2442  xxx = pow(xx, FMotor->getLeyQuemadoBD()[ley].Wiebes[wiebe].m + 1);
2443  if((xxx * FMotor->getLeyQuemadoBD()[ley].Wiebes[wiebe].C) > 10.) {
2444  ret_val = 1.;
2445  } else {
2446  ret_val = 1. - 1. / exp(xxx * FMotor->getLeyQuemadoBD()[ley].Wiebes[wiebe].C);
2447  }
2448  }
2449  return ret_val;
2450  } catch(exception & N) {
2451  std::cout << "ERROR: TCilindro:fun_wiebe en cilindro: " << FNumeroCilindro << std::endl;
2452  std::cout << "Tipo de error: " << N.what() << std::endl;
2453  throw Exception(N.what());
2454  }
2455 }
2456 
2457 // ----------------------------------------------------------------------------
2458 // ----------------------------------------------------------------------------
2459 
2460 double TCilindro::FuncionGamma(double T, double X) {
2461  try {
2462  // T - Temperature en kelvin.
2463  // X - Tanto por uno de gases quemados.
2464  double a = 0., b = 0., c = 0., T00 = 0., cv = 0., Result = 0.;
2465 
2466  T00 = T / 100. - 2.73;
2467  if(fabs(X) < 1e-100 || X < 0.)
2468  X = 0.;
2469  a = 46.4 * pow(X, 0.93) + 489.6;
2470  b = 3.36 * pow(X, 0.8) + 7.768;
2471  c = 0.485 * pow075(X) + 0.0975;
2472 
2473  cv = (a + 2. * b * T00 - 3. * c * pow2(T00)) * 1.455;
2474  if(cv <= 700.) {
2475  cv = 700.;
2476  }
2477  Result = __R::Air / cv + 1.;
2478  return Result;
2479 
2480  } catch(exception & N) {
2481  std::cout << "ERROR: TCilindro::FuncionGamma en cilindro: " << FNumeroCilindro << std::endl;
2482  std::cout << "Tipo de error: " << N.what() << std::endl;
2483  throw Exception(N.what());
2484  }
2485 }
2486 
2487 // ---------------------------------------------------------------------------
2488 // ---------------------------------------------------------------------------
2489 
2490 void TCilindro::CalculaTemperaturasPared() {
2491  double *TPAnt = NULL;
2492 
2493  try {
2494  double ViscGas = 0., ViscPared = 0., Vel = 0., Re = 0., Cond = 0., hExt = 0.;
2495  double Fo = 0., Bii = 0., Bie = 0.;
2496  double hi2 = 0., hi3 = 0., ho1 = 0., ho2 = 0.;
2497  // NUMERO DE NODOS IGUAL A 3
2498  TPAnt = new double[3];
2499 
2500  FTiempoCiclo += FDeltaT;
2501 
2502  // ---------------------------------------------------//
2503  // CILINDRO //
2504  // ---------------------------------------------------//
2505 
2506  ViscGas = 3.27e-7;
2507  ViscPared = 1.8e-7;
2508  Vel = 5.64268e-7 * FMotor->getRegimen() / 60. * FMotor->getParPotMax() / FMotor->getGeometria().NCilin / pow(
2509  FMotor->getGeometria().Carrera, 2.);
2510  Re = Vel * FMotor->getGeometria().Carrera / 2.3 / ViscGas;
2511  Cond = 0.67;
2512  hExt = 0.023 * (1 + 24.2 / pow(2.3, 0.7) / pow025(Re)) * pow(Re, 0.8) * cbrt(1.98) * pow(ViscGas / ViscPared,
2513  0.14) * Cond / (FMotor->getGeometria().Carrera / 2.3);
2514 
2515  Fo = (FMotor->getParedCilindro().Conductividad / FMotor->getParedCilindro().Density /
2516  FMotor->getParedCilindro().CalorEspecifico) * FDeltaT / (pow2(FMotor->getParedCilindro().Espesor) / 4.);
2517  Bii = Fh * FMotor->getParedCilindro().Espesor / 2. / FMotor->getParedCilindro().Conductividad;
2518  Bie = hExt * FMotor->getParedCilindro().Espesor / 2. / FMotor->getParedCilindro().Conductividad;
2519 
2520  for(int i = 0; i < 3; i++) {
2521  TPAnt[i] = __units::degCToK(FTempPared[i].Cylinder);
2522  }
2523 
2524  if(Fo > 0.5 || Fo * (1 + Bii) > 0.5 || Fo * (1 + Bie) > 0.5) {
2525  std::cout << "WARNING: Condiciones de calculo inestables para la trans. de calor en el cilindro: " << FNumeroCilindro <<
2526  std::endl;
2527  }
2528 
2529  if(FMotor->getCalculoPared() == nmConInercia && FMotor->getTheta() / 720. > FMotor->getNumCiclosSinInerciaTermica()) {
2530  FTempPared[2].Cylinder = __units::KTodegC(2 * Fo * (TPAnt[1] + Bie * __units::degCToK(
2531  FMotor->getTempRefrigerante())) + (1 - 2 * Fo - 2 * Bie * Fo) * TPAnt[2]);
2532  FTempPared[1].Cylinder = __units::KTodegC(Fo * (TPAnt[0] + TPAnt[2]) + (1 - 2 * Fo) * TPAnt[1]);
2533  FTempPared[0].Cylinder = __units::KTodegC(2 * Fo * (TPAnt[1] + Bii * __units::degCToK(FTemperature)) +
2534  (1 - 2 * Fo - 2 * Bii * Fo) * TPAnt[0]);
2535 
2536  } else if(FMotor->getCalculoPared() == nmSinInercia
2537  || FMotor->getTheta() / 720. <= FMotor->getNumCiclosSinInerciaTermica()) {
2538  FTempPared[2].Cylinder = __units::KTodegC(2 * Fo * (TPAnt[1] + Bie * __units::degCToK(
2539  FMotor->getTempRefrigerante())) + (1 - 2 * Fo - 2 * Bie * Fo) * TPAnt[2]);
2540  FTempPared[1].Cylinder = __units::KTodegC(Fo * (TPAnt[0] + TPAnt[2]) + (1 - 2 * Fo) * TPAnt[1]);
2541  FTempPared[0].Cylinder = __units::KTodegC(2 * Fo * (TPAnt[1] + Bii * __units::degCToK(FTemperature)) +
2542  (1 - 2 * Fo - 2 * Bii * Fo) * TPAnt[0]);
2543 
2544  if(Fh > 0.) {
2545  hi2 = 1. / (1. / Fh + FMotor->getParedCilindro().Espesor / FMotor->getParedCilindro().Conductividad / 2.);
2546  hi3 = 1. / (1. / Fh + FMotor->getParedCilindro().Espesor / FMotor->getParedCilindro().Conductividad);
2547  FTempPared[0].CilindroSUMup += hi3 * __units::degCToK(FTemperature) * FDeltaT;
2548  FTempPared[0].CilindroSUMdown += hi3 * FDeltaT;
2549  FTempPared[1].CilindroSUMup += hi2 * __units::degCToK(FTemperature) * FDeltaT;
2550  FTempPared[1].CilindroSUMdown += hi2 * FDeltaT;
2551  FTempPared[2].CilindroSUMup += Fh * __units::degCToK(FTemperature) * FDeltaT;
2552  FTempPared[2].CilindroSUMdown += Fh * FDeltaT;
2553  }
2554  if(FAnguloActual < FAnguloAnterior && FNumeroCiclo > 1) {
2555  ho2 = 1 / (1 / hExt + FMotor->getParedCilindro().Espesor / FMotor->getParedCilindro().Conductividad / 2.);
2556  ho1 = 1 / (1 / hExt + FMotor->getParedCilindro().Espesor / FMotor->getParedCilindro().Conductividad);
2557  FTempPared[2].Cylinder = __units::KTodegC(
2558  (FTiempoCiclo * hExt * __units::degCToK(FMotor->getTempRefrigerante()) + FTempPared[2].CilindroSUMup) /
2559  (FTiempoCiclo * hExt + FTempPared[2].CilindroSUMdown));
2560  FTempPared[1].Cylinder = __units::KTodegC(
2561  (FTiempoCiclo * ho2 * __units::degCToK(FMotor->getTempRefrigerante()) + FTempPared[1].CilindroSUMup) /
2562  (FTiempoCiclo * ho2 + FTempPared[1].CilindroSUMdown));
2563  FTempPared[0].Cylinder = __units::KTodegC(
2564  (FTiempoCiclo * ho1 * __units::degCToK(FMotor->getTempRefrigerante()) + FTempPared[0].CilindroSUMup) /
2565  (FTiempoCiclo * ho1 + FTempPared[0].CilindroSUMdown));
2566  for(int i = 0; i < 3; i++) {
2567  FTempPared[i].CilindroSUMup = 0.;
2568  FTempPared[i].CilindroSUMdown = 0.;
2569  }
2570  }
2571 
2572  }
2573 
2574  // ---------------------------------------------------//
2575  // PISTON //
2576  // ---------------------------------------------------//
2577 
2578  // SE HAN COMENTADO LOS CALCULOS IDENTICOS AL CILINDRO PARA AHORRAR TIEMPO DE CALCULO
2579  // ViscGas=3.27e-7;
2580  // ViscPared=1.8e-7;
2581  // Vel=5.64268e-7*FMotor->PutRegimen(5.64268e-7*FMotor->getRegimen()/60.*FMotor->getParPotMax()/FMotor->getGeometria().NCilin/pow(FMotor->getGeometria().Carrera,2.));
2582  // Re=Vel*FMotor->getGeometria().Carrera/2.3/ViscGas;
2583  // Cond=0.67;
2584  // hExt=0.023*(1+24.2/pow(2.3,0.7)/pow(Re,0.25))*pow(Re,0.8)*pow(1.98,0.33)*pow(ViscGas/ViscPared,0.14)
2585  // *Cond/(FMotor->getGeometria().Carrera/2.3);
2586 
2587  Fo = (FMotor->getParedPiston().Conductividad / FMotor->getParedPiston().Density /
2588  FMotor->getParedPiston().CalorEspecifico) * FDeltaT / (pow2(FMotor->getParedPiston().Espesor) / 4.);
2589  Bii = Fh * FMotor->getParedPiston().Espesor / 2. / FMotor->getParedPiston().Conductividad;
2590  Bie = hExt * FMotor->getParedPiston().Espesor / 2. / FMotor->getParedPiston().Conductividad;
2591 
2592  for(int i = 0; i < 3; i++) {
2593  TPAnt[i] = __units::degCToK(FTempPared[i].Piston);
2594  }
2595 
2596  if(Fo > 0.5 || Fo * (1 + Bii) > 0.5 || Fo * (1 + Bie) > 0.5) {
2597  std::cout << "WARNING: Condiciones de calculo inestables para la trans. de calor del piston en el cilindro: " <<
2598  FNumeroCilindro << std::endl;
2599  }
2600 
2601  if(FMotor->getCalculoPared() == nmConInercia && FMotor->getTheta() / 720. > FMotor->getNumCiclosSinInerciaTermica()) {
2602  FTempPared[2].Piston = __units::KTodegC(2 * Fo * (TPAnt[1] + Bie * __units::degCToK(FMotor->getTempRefrigerante())) +
2603  (1 - 2 * Fo - 2 * Bie * Fo) * TPAnt[2]);
2604  FTempPared[1].Piston = __units::KTodegC(Fo * (TPAnt[0] + TPAnt[2]) + (1 - 2 * Fo) * TPAnt[1]);
2605  FTempPared[0].Piston = __units::KTodegC(2 * Fo * (TPAnt[1] + Bii * __units::degCToK(FTemperature)) +
2606  (1 - 2 * Fo - 2 * Bii * Fo) * TPAnt[0]);
2607 
2608  } else if(FMotor->getCalculoPared() == nmSinInercia
2609  || FMotor->getTheta() / 720. <= FMotor->getNumCiclosSinInerciaTermica()) {
2610  FTempPared[2].Piston = __units::KTodegC(2 * Fo * (TPAnt[1] + Bie * __units::degCToK(FMotor->getTempRefrigerante())) +
2611  (1 - 2 * Fo - 2 * Bie * Fo) * TPAnt[2]);
2612  FTempPared[1].Piston = __units::KTodegC(Fo * (TPAnt[0] + TPAnt[2]) + (1 - 2 * Fo) * TPAnt[1]);
2613  FTempPared[0].Piston = __units::KTodegC(2 * Fo * (TPAnt[1] + Bii * __units::degCToK(FTemperature)) +
2614  (1 - 2 * Fo - 2 * Bii * Fo) * TPAnt[0]);
2615 
2616  if(Fh > 0.) {
2617  hi2 = 1. / (1. / Fh + FMotor->getParedPiston().Espesor / FMotor->getParedPiston().Conductividad / 2.);
2618  hi3 = 1. / (1. / Fh + FMotor->getParedPiston().Espesor / FMotor->getParedPiston().Conductividad);
2619  FTempPared[0].PistonSUMup += hi3 * __units::degCToK(FTemperature) * FDeltaT;
2620  FTempPared[0].PistonSUMdown += hi3 * FDeltaT;
2621  FTempPared[1].PistonSUMup += hi2 * __units::degCToK(FTemperature) * FDeltaT;
2622  FTempPared[1].PistonSUMdown += hi2 * FDeltaT;
2623  FTempPared[2].PistonSUMup += Fh * __units::degCToK(FTemperature) * FDeltaT;
2624  FTempPared[2].PistonSUMdown += Fh * FDeltaT;
2625  }
2626  if(FAnguloActual < FAnguloAnterior && FNumeroCiclo > 1) {
2627  ho2 = 1 / (1 / hExt + FMotor->getParedPiston().Espesor / FMotor->getParedPiston().Conductividad / 2.);
2628  ho1 = 1 / (1 / hExt + FMotor->getParedPiston().Espesor / FMotor->getParedPiston().Conductividad);
2629  FTempPared[2].Piston = __units::KTodegC(
2630  (FTiempoCiclo * hExt * __units::degCToK(FMotor->getTempRefrigerante()) + FTempPared[2].PistonSUMup) /
2631  (FTiempoCiclo * hExt + FTempPared[2].PistonSUMdown));
2632  FTempPared[1].Piston = __units::KTodegC(
2633  (FTiempoCiclo * ho2 * __units::degCToK(FMotor->getTempRefrigerante()) + FTempPared[1].PistonSUMup) /
2634  (FTiempoCiclo * ho2 + FTempPared[1].PistonSUMdown));
2635  FTempPared[0].Piston = __units::KTodegC(
2636  (FTiempoCiclo * ho1 * __units::degCToK(FMotor->getTempRefrigerante()) + FTempPared[0].PistonSUMup) /
2637  (FTiempoCiclo * ho1 + FTempPared[0].PistonSUMdown));
2638  for(int i = 0; i < 3; i++) {
2639  FTempPared[i].PistonSUMup = 0.;
2640  FTempPared[i].PistonSUMdown = 0.;
2641  }
2642  }
2643  }
2644 
2645  // ---------------------------------------------------//
2646  // CULATA //
2647  // ---------------------------------------------------//
2648 
2649  // SE HAN COMENTADO LOS CALCULOS IDENTICOS AL CILINDRO PARA AHORRAR TIEMPO DE CALCULO
2650  // ViscGas=3.27e-7;
2651  // ViscPared=1.8e-7;
2652  // Cond=0.67;
2653  Vel = 5.64268e-7 * FMotor->getRegimen() / 60. * FMotor->getParPotMax() / FMotor->getGeometria().NCilin / pow(
2654  1.1 * FMotor->getGeometria().Diametro, 2.);
2655  Re = Vel * FMotor->getGeometria().Carrera / 2.3 / ViscGas;
2656  hExt = 0.023 * (1 + 24.2 / pow(2.3, 0.7) / pow025(Re)) * pow(Re, 0.8) * cbrt(1.98) * pow(ViscGas / ViscPared,
2657  0.14) * Cond / (1.1 * FMotor->getGeometria().Diametro / 2.3);
2658 
2659  Fo = (FMotor->getParedCulata().Conductividad / FMotor->getParedCulata().Density /
2660  FMotor->getParedCulata().CalorEspecifico) * FDeltaT / (pow2(FMotor->getParedCulata().Espesor) / 4.);
2661  Bii = Fh * FMotor->getParedCulata().Espesor / 2. / FMotor->getParedCulata().Conductividad;
2662  Bie = hExt * FMotor->getParedCulata().Espesor / 2. / FMotor->getParedCulata().Conductividad;
2663 
2664  for(int i = 0; i < 3; i++) {
2665  TPAnt[i] = __units::degCToK(FTempPared[i].Culata);
2666  }
2667 
2668  if(Fo > 0.5 || Fo * (1 + Bii) > 0.5 || Fo * (1 + Bie) > 0.5) {
2669  std::cout << "WARNING: Condiciones de calculo inestables para la trans. de calor de la culata en el cilindro: " <<
2670  FNumeroCilindro << std::endl;
2671  }
2672 
2673  if(FMotor->getCalculoPared() == nmConInercia && FMotor->getTheta() / 720. > FMotor->getNumCiclosSinInerciaTermica()) {
2674  FTempPared[2].Culata = __units::KTodegC(2 * Fo * (TPAnt[1] + Bie * __units::degCToK(FMotor->getTempRefrigerante())) +
2675  (1 - 2 * Fo - 2 * Bie * Fo) * TPAnt[2]);
2676  FTempPared[1].Culata = __units::KTodegC(Fo * (TPAnt[0] + TPAnt[2]) + (1 - 2 * Fo) * TPAnt[1]);
2677  FTempPared[0].Culata = __units::KTodegC(2 * Fo * (TPAnt[1] + Bii * __units::degCToK(FTemperature)) +
2678  (1 - 2 * Fo - 2 * Bii * Fo) * TPAnt[0]);
2679 
2680  } else if(FMotor->getCalculoPared() == nmSinInercia
2681  || FMotor->getTheta() / 720. <= FMotor->getNumCiclosSinInerciaTermica()) {
2682  FTempPared[2].Culata = __units::KTodegC(2 * Fo * (TPAnt[1] + Bie * __units::degCToK(FMotor->getTempRefrigerante())) +
2683  (1 - 2 * Fo - 2 * Bie * Fo) * TPAnt[2]);
2684  FTempPared[1].Culata = __units::KTodegC(Fo * (TPAnt[0] + TPAnt[2]) + (1 - 2 * Fo) * TPAnt[1]);
2685  FTempPared[0].Culata = __units::KTodegC(2 * Fo * (TPAnt[1] + Bii * __units::degCToK(FTemperature)) +
2686  (1 - 2 * Fo - 2 * Bii * Fo) * TPAnt[0]);
2687 
2688  if(Fh > 0.) {
2689  hi2 = 1. / (1. / Fh + FMotor->getParedCulata().Espesor / FMotor->getParedCulata().Conductividad / 2.);
2690  hi3 = 1. / (1. / Fh + FMotor->getParedCulata().Espesor / FMotor->getParedCulata().Conductividad);
2691  FTempPared[0].CulataSUMup += hi3 * __units::degCToK(FTemperature) * FDeltaT;
2692  FTempPared[0].CulataSUMdown += hi3 * FDeltaT;
2693  FTempPared[1].CulataSUMup += hi2 * __units::degCToK(FTemperature) * FDeltaT;
2694  FTempPared[1].CulataSUMdown += hi2 * FDeltaT;
2695  FTempPared[2].CulataSUMup += Fh * __units::degCToK(FTemperature) * FDeltaT;
2696  FTempPared[2].CulataSUMdown += Fh * FDeltaT;
2697  }
2698  if(FAnguloActual < FAnguloAnterior && FNumeroCiclo > 1) {
2699  ho2 = 1 / (1 / hExt + FMotor->getParedCulata().Espesor / FMotor->getParedCulata().Conductividad / 2.);
2700  ho1 = 1 / (1 / hExt + FMotor->getParedCulata().Espesor / FMotor->getParedCulata().Conductividad);
2701  FTempPared[2].Culata = __units::KTodegC(
2702  (FTiempoCiclo * hExt * __units::degCToK(FMotor->getTempRefrigerante()) + FTempPared[2].CulataSUMup) /
2703  (FTiempoCiclo * hExt + FTempPared[2].CulataSUMdown));
2704  FTempPared[1].Culata = __units::KTodegC(
2705  (FTiempoCiclo * ho2 * __units::degCToK(FMotor->getTempRefrigerante()) + FTempPared[1].CulataSUMup) /
2706  (FTiempoCiclo * ho2 + FTempPared[1].CulataSUMdown));
2707  FTempPared[0].Culata = __units::KTodegC(
2708  (FTiempoCiclo * ho1 * __units::degCToK(FMotor->getTempRefrigerante()) + FTempPared[0].CulataSUMup) /
2709  (FTiempoCiclo * ho1 + FTempPared[0].CulataSUMdown));
2710  for(int i = 0; i < 3; i++) {
2711  FTempPared[i].CulataSUMup = 0.;
2712  FTempPared[i].CulataSUMdown = 0.;
2713  }
2714  FTiempoCiclo = 0.;
2715  }
2716  }
2717 
2718  if(TPAnt != NULL)
2719  delete TPAnt;
2720 
2721  } catch(exception & N) {
2722  if(TPAnt != NULL)
2723  delete TPAnt;
2724  std::cout << "ERROR: TCilindro::CalculaTemperaturasPared en cilindro: " << FNumeroCilindro << std::endl;
2725  std::cout << "Tipo de error: " << N.what() << std::endl;
2726  throw Exception(N.what());
2727  }
2728 }
2729 
2730 // ---------------------------------------------------------------------------
2731 // ---------------------------------------------------------------------------
2732 
2733 void TCilindro::CalculaFuelMEP(double MasaAire) {
2734 
2735  FMasaFuel = fabs(MasaAire) * FMotor->getDosadoInicial() * FDosadoEstequiometrico;
2736  FMotor->setMasaFuel(FMasaFuel);
2737 
2738 }
2739 
2740 // ---------------------------------------------------------------------------
2741 // ---------------------------------------------------------------------------
2742 
2744 // try {
2745 //
2746 // FMasaFuel = valor;
2747 //
2748 // }
2749 // catch(Exception & N) {
2750 // std::cout << "ERROR: TCilindro::PutMasaFuel en el cilindro: " << FNumeroCilindro << std::endl;
2751 // std::cout << "Tipo de error: " << N.what() << std::endl;
2752 // throw Exception(N.what());
2753 // }
2754 // }
2755 
2756 // ---------------------------------------------------------------------------
2757 // ---------------------------------------------------------------------------
2758 
2759 // void TCilindro::PutPresionInyeccion(double valor) {
2760 // try {
2761 //
2762 // FMotor->getInjectionSys().InjectPressure = valor;
2763 //
2764 // }
2765 // catch(Exception & N) {
2766 // std::cout << "ERROR: TCilindro::PutPresionInyeccion en el cilindro: " << FNumeroCilindro << std::endl;
2767 // std::cout << "Tipo de error: " << N.what() << std::endl;
2768 // throw Exception(N.what());
2769 // }
2770 // }
2771 
2772 // ---------------------------------------------------------------------------
2773 // ---------------------------------------------------------------------------
2774 
2775 // void TCilindro::PutNumeroInyecciones(int valor) {
2776 // try {
2777 //
2778 // FIN = valor;
2779 //
2780 // }
2781 // catch(Exception & N) {
2782 // std::cout << "ERROR: TCilindro::PutNumeroInyecciones en el cilindro: " << FNumeroCilindro <<
2783 // std::endl;
2784 // std::cout << "Tipo de error: " << N.what() << std::endl;
2785 // throw Exception(N.what());
2786 // }
2787 // }
2788 
2789 // ---------------------------------------------------------------------------
2790 // ---------------------------------------------------------------------------
2791 
2792 // void TCilindro::PutInicioComb(double valor) {
2793 // try {
2794 //
2795 // FIniComb = valor;
2796 //
2797 // }
2798 // catch(Exception & N) {
2799 // std::cout << "ERROR: TCilindro::PutInicioComb en el cilindro: " << FNumeroCilindro << std::endl;
2800 // std::cout << "Tipo de error: " << N.what() << std::endl;
2801 // throw Exception(N.what());
2802 // }
2803 // }
2804 
2805 // ---------------------------------------------------------------------------
2806 // ---------------------------------------------------------------------------
2807 
2808 // void TCilindro::PutFinComb(double valor) {
2809 // try {
2810 //
2811 // FFinComb = valor;
2812 //
2813 // }
2814 // catch(Exception & N) {
2815 // std::cout << "ERROR: TCilindro::PutFinComb en el cilindro: " << FNumeroCilindro << std::endl;
2816 // std::cout << "Tipo de error: " << N.what() << std::endl;
2817 // throw Exception(N.what());
2818 // }
2819 // }
2820 
2821 // ---------------------------------------------------------------------------
2822 // ---------------------------------------------------------------------------
2823 
2824 // void TCilindro::PutFQL(double valor) {
2825 // try {
2826 //
2827 // FCalor.FQL = valor;
2828 //
2829 // }
2830 // catch(Exception & N) {
2831 // std::cout << "ERROR: TCilindro::PutFQL en el cilindro: " << FNumeroCilindro << std::endl;
2832 // std::cout << "Tipo de error: " << N.what() << std::endl;
2833 // throw Exception(N.what());
2834 // }
2835 // }
2836 
2837 // ---------------------------------------------------------------------------
2838 // ---------------------------------------------------------------------------
2839 
2840 // void TCilindro::PutModComb(bool valor) {
2841 // try {
2842 //
2843 // FModComb = valor;
2844 //
2845 // }
2846 // catch(Exception & N) {
2847 // std::cout << "ERROR: TCilindro::PutModComb en el cilindro: " << FNumeroCilindro << std::endl;
2848 // std::cout << "Tipo de error: " << N.what() << std::endl;
2849 // throw Exception(N.what());
2850 // }
2851 // }
2852 
2853 // ---------------------------------------------------------------------------
2854 // ---------------------------------------------------------------------------
2855 
2856 void TCilindro::DefineCombustion() {
2857  try {
2858  if(FMotor->getACT()) {
2859  FCalcComb = nmACT;
2860  if(FModComb) {
2861  std::cout << "WARNING: Se pretende calcular la combution mediante ACT y mediante" << std::endl;
2862  std::cout << " calculo externo. Se calculara unicamente con ACT." << std::endl << std::endl;
2863  }
2864  } else {
2865  if(FModComb) {
2866  FCalcComb = nmEXT;
2867  } else {
2868  FCalcComb = nmFQL;
2869  }
2870  }
2871  } catch(exception & N) {
2872  std::cout << "ERROR: TCilindro::PutModComb en el cilindro: " << FNumeroCilindro << std::endl;
2873  std::cout << "Tipo de error: " << N.what() << std::endl;
2874  throw Exception(N.what());
2875  }
2876 }
2877 
2878 // ---------------------------------------------------------------------------
2879 // ---------------------------------------------------------------------------
2880 
2882 // try {
2883 //
2884 // FCalculadoPaso = valor;
2885 //
2886 // }
2887 // catch(Exception & N) {
2888 // std::cout << "ERROR: TCilindro::PutCalculadoPaso en el cilindro: " << FNumeroCilindro << std::endl;
2889 // std::cout << "Tipo de error: " << N.what() << std::endl;
2890 // throw Exception(N.what());
2891 // }
2892 // }
2893 
2894 // ---------------------------------------------------------------------------
2895 // ---------------------------------------------------------------------------
2896 
2897 // void TCilindro::PutHayDLL(bool valor) {
2898 // try {
2899 //
2900 // FHaydll = valor;
2901 //
2902 // }
2903 // catch(Exception & N) {
2904 // std::cout << "ERROR: TCilindro::PutHayDLL en el cilindro: " << FNumeroCilindro << std::endl;
2905 // std::cout << "Tipo de error: " << N.what() << std::endl;
2906 // throw Exception(N.what());
2907 // }
2908 // }
2909 
2910 // ---------------------------------------------------------------------------
2911 // ---------------------------------------------------------------------------
2912 double TCilindro::CalculaCTorbAdmProm() {
2913  try {
2914  double retval = 0.;
2915  double CTorbSum = 0.;
2916 
2917  for(int i = 0; i < FNumeroUnionesAdm; i++) {
2918  if(dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getValvula()->getTypeOfValve() == nmValvula4T) {
2919  CTorbSum += dynamic_cast<TValvula4T*>(dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getValvula())->getCTorbMed();
2920  }
2921  }
2922 
2923  retval = CTorbSum / FNumeroUnionesAdm;
2924 
2925  return retval;
2926 
2927  } catch(exception & N) {
2928  std::cout << "ERROR: TCilindro::CalculaCTorbAdmProm en el cilindro: " << FNumeroCilindro << std::endl;
2929  std::cout << "Tipo de error: " << N.what() << std::endl;
2930  throw Exception(N.what());
2931  }
2932 }
2933 
2934 // ---------------------------------------------------------------------------
2935 // ---------------------------------------------------------------------------
2936 
2937 double TCilindro::CalculaCm() {
2938  try {
2939  return 2 * FMotor->getRegimen() * FMotor->getGeometria().Carrera / 60.;
2940  } catch(exception & N) {
2941  std::cout << "ERROR: TCilindro::CalculaCm en el cilindro: " << FNumeroCilindro << std::endl;
2942  std::cout << "Tipo de error: " << N.what() << std::endl;
2943  throw Exception(N.what());
2944  }
2945 }
2946 
2947 // ---------------------------------------------------------------------------
2948 // ---------------------------------------------------------------------------
2949 
2950 void TCilindro::CalculoNIT() {
2951  try {
2952  double arriba = 0., massflow = 0.;
2953 
2954  // kp=1007.+(0.155+1.46/FAFR)*FTemperature;
2955  if(FMotor->getSpeciesModel() == nmCalculoSimple) {
2956  FCpMezcla = FCvMezcla + FRMezcla;
2957  }
2958  arriba = -FRMezcla / FCpMezcla;
2959  FNIT = FCpMezcla * __units::degCToK(FTemperature) * (1 - pow(FPressure, arriba));
2960  massflow = 0.;
2961  for(int j = 0; j < FNumeroUnionesEsc; ++j) {
2962  massflow += dynamic_cast<TCCCilindro*>(FCCValvulaEsc[j])->getMassflow();
2963  FValvEsc[j].NIT = FNIT * dynamic_cast<TCCCilindro*>(FCCValvulaEsc[j])->getMassflow();
2964  FValvEsc[j].NITSUM += FValvEsc[j].NIT * FDeltaT;
2965  // NIT medio en cada valvula
2966  }
2967  FNIT = FNIT * massflow;
2968 
2969  } catch(exception & N) {
2970  std::cout << "ERROR: TCilindro::CalculoNIT en el cilindro: " << FNumeroCilindro << std::endl;
2971  std::cout << "Tipo de error: " << N.what() << std::endl;
2972  throw Exception(N.what());
2973  }
2974 }
2975 
2976 // ------------------------------------------------------------------------------
2977 // ------------------------------------------------------------------------------
2978 
2979 void TCilindro::CalculaMomentoAngular() {
2980  try {
2981  for(int i = 0; i < FNumeroUnionesAdm; i++) {
2982  FMomentoAngularAdm += dynamic_cast<TCCCilindro*>(FCCValvulaAdm[i])->getMomento();
2983  }
2984  for(int i = 0; i < FNumeroUnionesEsc; i++) {
2985  FMomentoAngularEsc += dynamic_cast<TCCCilindro*>(FCCValvulaEsc[i])->getMomento();
2986  }
2987 
2988  FMomentoAngular = (FMomentoAngularAdm + FMomentoAngularEsc) * FDeltaT;
2989  /* . Se multiplica por el tiempo */
2990 
2991  } catch(exception & N) {
2992  std::cout << "ERROR: TCilindro::CalculaMomentoAngular en el cilindro: " << FNumeroCilindro << std::endl;
2993  std::cout << "Tipo de error: " << N.what() << std::endl;
2994  throw Exception(N.what());
2995  }
2996 }
2997 
2998 // ------------------------------------------------------------------------------
2999 // ------------------------------------------------------------------------------
3000 
3001 void TCilindro::SalidaGeneralCilindros() {
3002  try {
3003  if(FNumVarMed > 0) {
3004  printf("\n \n \n");
3005  std::cout << "INFO:----------------------------------------------" << std::endl;
3006  std::cout << "INFO: CYLINDER RESULTS" << std::endl;
3007  std::cout << "INFO:----------------------------------------------" << std::endl;
3008  std::cout << "INFO: Cylinder number " << FNumeroCilindro << " Cycle number " << FMotor->getCiclo() << std::endl;
3009  std::cout << "INFO:_________________________________________" << std::endl;
3010  if(FResMediosCilindro.RendVolumetrico)
3011  std::cout << "INFO: Volumetric efficiency intake manifold (refered to pipe n. " <<
3012  FMotor->getTuboRendVol()->getNumeroTubo() << "): " << FResMediosCilindro.RendVolumetricoMED << " (-)" << std::endl;
3013  if(FResMediosCilindro.TrabajoNeto)
3014  std::cout << "INFO: Net work: " << FResMediosCilindro.TrabajoNetoMED << " (J)" << std::endl;
3015  if(FResMediosCilindro.PresionMediaNeta)
3016  std::cout << "INFO: Net mean effective pressure: " << FResMediosCilindro.PresionMediaNetaMED << " (bar)" << std::endl;
3017  if(FResMediosCilindro.TrabajoBombeo)
3018  std::cout << "INFO: Pumping work: " << FResMediosCilindro.TrabajoBombeoMED << " (J)" << std::endl;
3019  if(FResMediosCilindro.PresionMediaBombeo)
3020  std::cout << "INFO: Pumping mean effective pressure: " << FResMediosCilindro.PresionMediaBombeoMED << " (bar)" <<
3021  std::endl;
3022  if(FResMediosCilindro.MasaAdmision)
3023  std::cout << "INFO: Intake air mass: " << FResMediosCilindro.MasaAdmisionMED << " (kg/cc)" << std::endl;
3024  if(FResMediosCilindro.MasaEscape)
3025  std::cout << "INFO: Exhaust air mass: " << FResMediosCilindro.MasaEscapeMED << " (kg/cc)" << std::endl;
3026  if(FResMediosCilindro.NITMedio)
3027  std::cout << "INFO: TIP in the cylinder: " << FResMediosCilindro.NITMedioMED << " (W)" << std::endl;
3028  if(FResMediosCilindro.CalorCombustion)
3029  std::cout << "INFO: Heat released: " << FResMediosCilindro.CalorCombustionMED << " (J)" << std::endl;
3030  if(FResMediosCilindro.CalorCilindro)
3031  std::cout << "INFO: Heat transfer to cylinder liner wall: " << FResMediosCilindro.CalorCilindroMED << " (J)" <<
3032  std::endl;
3033  if(FResMediosCilindro.CalorCulata)
3034  std::cout << "INFO: Heat trasnfer to cylinder head wall: " << FResMediosCilindro.CalorCulataMED << " (J)" <<
3035  std::endl;
3036  if(FResMediosCilindro.CalorPiston)
3037  std::cout << "INFO: Heat trasnfer to piston: " << FResMediosCilindro.CalorPistonMED << " (J)" << std::endl;
3038  if(FResMediosCilindro.TemperaturaMedia)
3039  std::cout << "INFO: Mean cycle temperature: " << FResMediosCilindro.TemperaturaMediaMED << " (C)" << std::endl;
3040  if(FResMediosCilindro.Swirl)
3041  std::cout << "INFO: Swirl at T.D.C.: " << FResMediosCilindro.SwirlMED << " (-)" << std::endl;
3042  if(FResMediosCilindro.MasaAtrapada)
3043  std::cout << "INFO: Trapped mass: " << FResMediosCilindro.MasaAtrapadaMED << " (kg/cc)" << std::endl;
3044  }
3045 
3046  } catch(exception & N) {
3047  std::cout << "ERROR: TCilindro::SalidaGeneralCilindros en el cilindro: " << FNumeroCilindro << std::endl;
3048  std::cout << "Tipo de error: " << N.what() << std::endl;
3049  throw Exception(N.what());
3050  }
3051 }
3052 
3053 // ---------------------------------------------------------------------------
3054 // ---------------------------------------------------------------------------
3055 
3056 void TCilindro::CalculaVariablesResultados() {
3057  try {
3058  if(FResMediosCilindro.Swirl || FResInstantCilindro.MomentoAngularEsc || FResInstantCilindro.MomentoAngularEsc) {
3059  CalculaMomentoAngular();
3060  }
3061  if(FResInstantCilindro.NIT || FResMediosCilindro.NITMedio) {
3062  CalculoNIT();
3063  }
3064  if(FResMediosCilindro.Swirl) {
3065  CalculaSWIRL();
3066  }
3067 
3068  } catch(exception & N) {
3069  std::cout << "ERROR: TCilindro::CalculaMomentoAngular en el cilindro: " << FNumeroCilindro << std::endl;
3070  std::cout << "Tipo de error: " << N.what() << std::endl;
3071  throw Exception(N.what());
3072  }
3073 }
3074 
3075 // ---------------------------------------------------------------------------
3076 // ---------------------------------------------------------------------------
3077 
3078 void TCilindro::CalculaSWIRL() {
3079  try {
3080  double wctcc = 0.;
3081 
3082  wctcc = __cons::Pi_4 * pow2(FMotor->getGeometria().DiametroBowl) * FMotor->getGeometria().AlturaBowl;
3083  wctcc = (pow2(FMotor->getGeometria().Diametro) * (FMotor->getGeometria().VCC - wctcc) + pow2(
3084  FMotor->getGeometria().DiametroBowl) * wctcc) / FMotor->getGeometria().VCC / 8.;
3085 
3086  FWoma = FMomentoAngular / pow2(wctcc);
3087  FSwirl = FWoma / __units::RPMToRad_s(FMotor->getRegimen());
3088 
3089  FSwirlSUM += FSwirl * FDeltaT;
3090 
3091  } catch(exception & N) {
3092  std::cout << "ERROR: TCilindro::CalculaSWIRL en el Bloque Engine. " << std::endl;
3093  std::cout << "Tipo de error: " << N.what() << std::endl;
3094  throw Exception(N.what());
3095  }
3096 }
3097 
3098 // ------------------------------------------------------------------------------
3099 // ------------------------------------------------------------------------------
3100 
3101 TCondicionContorno* TCilindro::GetCCValvulaAdm(int i) {
3102  try {
3103  return FCCValvulaAdm[i];
3104  } catch(exception & N) {
3105  std::cout << "ERROR: TCilindro::GetCCValvulaAdm en el cilindro: " << FNumeroCilindro << std::endl;
3106  std::cout << "Tipo de error: " << N.what() << std::endl;
3107  throw Exception(N.what());
3108  }
3109 }
3110 
3111 // ---------------------------------------------------------------------------
3112 // ---------------------------------------------------------------------------
3113 
3114 TCondicionContorno* TCilindro::GetCCValvulaEsc(int i) {
3115  try {
3116  return FCCValvulaEsc[i];
3117  } catch(exception & N) {
3118  std::cout << "ERROR: TCilindro::GetCCValvulaEsc en el cilindro: " << FNumeroCilindro << std::endl;
3119  std::cout << "Tipo de error: " << N.what() << std::endl;
3120  throw Exception(N.what());
3121  }
3122 }
3123 
3124 // ---------------------------------------------------------------------------
3125 // ---------------------------------------------------------------------------
3126 
3127 double TCilindro::GetAireFresco() {
3128  try {
3129  double ret_val = 0.;
3130  ret_val = FComposicionCicloCerrado[2];
3131  return ret_val;
3132 
3133  } catch(exception & N) {
3134  std::cout << "ERROR: TCilindro::GetAireFresco en la condicion de contorno: " << FNumeroCilindro << std::endl;
3135  std::cout << "Tipo de error: " << N.what() << std::endl;
3136  throw Exception(N.what());
3137  }
3138 }
3139 // ---------------------------------------------------------------------------
3140 // ---------------------------------------------------------------------------
3141 
3142 double TCilindro::GetComposicionSaliente(int i) {
3143  try {
3144  return FComposicionSaliente[i];
3145  } catch(exception & N) {
3146  std::cout << "ERROR: TCilindro::GetComposicionSaliente en la condicion de contorno: " << FNumeroCilindro << std::endl;
3147  std::cout << "Tipo de error: " << N.what() << std::endl;
3148  throw Exception(N.what());
3149  }
3150 }
3151 
3152 void TCilindro::PutPresionInyeccion(double valor) {
3153 
3154  stInjectionSys bar;
3155  bar = FMotor->getInjectionSys();
3156  bar.InjectPressure = valor;
3157 
3159  // FMotor->getInjectionSys().InjectPressure = valor;
3161 }
3162 
3163 void TCilindro::AsignMfController(TController **Controller) {
3164  if(FMfControlled)
3165  FMfController = Controller[FMfControllerID - 1];
3166 }
3167 
3168 // ---------------------------------------------------------------------------
3169 // ---------------------------------------------------------------------------
3170 
3171 #pragma package(smart_init)
stEspecies
Definition: Globales.h:297
stInjectionSys
Definition: Globales.h:997
pow075
T pow075(T x)
Returns x to the power of 0.75.
Definition: Math_wam.h:153
Uint
unsigned int Uint
Unsigned integer.
Definition: Math_wam.h:69
TController
Definition: TController.h:37
stTemperaturasPared
Definition: Globales.h:1183
pow025
T pow025(T x)
Returns x to the power of 0.25.
Definition: Math_wam.h:127
TCondicionContorno
Definition: TCondicionContorno.h:54
stValvulasCilindro
Definition: Globales.h:1377
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
pow4
T pow4(T x)
Returns x to the power of 4.
Definition: Math_wam.h:114
TCCCilindro
Foo.
Definition: TCCCilindro.h:46
TLumbrera
Definition: TLumbrera.h:45
TTubo.h
TBloqueMotor
Definition: TBloqueMotor.h:43
pow2
T pow2(T x)
Returns x to the power of 2.
Definition: Math_wam.h:88
TTubo::getNumeroTubo
int getNumeroTubo() const
Gets the pipe id.
Definition: TTubo.cpp:5464