Eclipse SUMO - Simulation of Urban MObility
V5/cs/CEP.cs
Go to the documentation of this file.
1 #define FLEET
2 using System;
3 using System.Collections.Generic;
4 using System.Linq;
5 using System.Text;
6 using System.Threading.Tasks;
7 
8 namespace PHEMlightdll
9 {
10  public class CEP
11  {
12  #region Constructor
13  public CEP(VEHPHEMLightJSON.VEH Vehicle,
14  List<string> headerLineFCvalues,
15  List<List<double>> matrixFCvalues,
16  List<string> headerLinePollutants,
17  List<List<double>> matrixPollutants,
18  List<double> idlingFCvalues,
19  List<double> idlingPollutants)
20  {
21  _resistanceF0 = Vehicle.RollingResData.Fr0.Value;
22  _resistanceF1 = Vehicle.RollingResData.Fr1.Value;
23  _resistanceF2 = Vehicle.RollingResData.Fr2.Value;
24  _resistanceF3 = Vehicle.RollingResData.Fr3.Value;
25  _resistanceF4 = Vehicle.RollingResData.Fr4.Value;
26  _cWValue = Vehicle.VehicleData.Cw.Value;
27  _crossSectionalArea = Vehicle.VehicleData.A.Value;
28  _massVehicle = Vehicle.VehicleData.Mass.Value;
29  _vehicleLoading = Vehicle.VehicleData.Loading.Value;
30  _vehicleMassRot = Vehicle.VehicleData.RedMassWheel.Value;
31  CalcType = Vehicle.VehicleData.CalcType;
32  switch (CalcType)
33  {
34  case "Conv":
35  RatedPower = Vehicle.EngineData.ICEData.Prated.Value;
36  _engineRatedSpeed = Vehicle.EngineData.ICEData.nrated.Value;
37  _engineIdlingSpeed = Vehicle.EngineData.ICEData.Idling.Value;
38  break;
39  case "HEV":
40  // Power von beiden zusammen Rest bezogen auf ICE
41  RatedPower = Vehicle.EngineData.ICEData.Prated.Value + Vehicle.EngineData.EMData.Prated.Value;
42  _engineRatedSpeed = Vehicle.EngineData.ICEData.nrated.Value;
43  _engineIdlingSpeed = Vehicle.EngineData.ICEData.Idling.Value;
44  break;
45  case "BEV":
46  RatedPower = Vehicle.EngineData.EMData.Prated.Value;
47  _engineRatedSpeed = Vehicle.EngineData.EMData.nrated.Value;
48  _engineIdlingSpeed = 0;
49  break;
50  }
51 
52  _effectiveWheelDiameter = Vehicle.VehicleData.WheelDiameter.Value;
53  HeavyVehicle = Vehicle.VehicleData.MassType == Constants.HeavyVehicle;
54  FuelType = Vehicle.VehicleData.FuelType;
55  _axleRatio = Vehicle.TransmissionData.AxelRatio.Value;
56  _auxPower = Vehicle.AuxiliariesData.Pauxnorm.Value;
57 
58  _pNormV0 = Vehicle.FLDData.P_n_max_v0.Value / 3.6;
59  _pNormP0 = Vehicle.FLDData.P_n_max_p0.Value;
60  _pNormV1 = Vehicle.FLDData.P_n_max_v1.Value / 3.6;
61  _pNormP1 = Vehicle.FLDData.P_n_max_p1.Value;
62 
63  // Init pollutant identifiers, unit and measures
64  List<string> FCvaluesIdentifier = new List<string>();
65  List<List<double>> FCvaluesMeasures = new List<List<double>>();
66  List<List<double>> normalizedFCvaluesMeasures = new List<List<double>>();
67  for (int i = 0; i < headerLineFCvalues.Count; i++)
68  {
69  FCvaluesIdentifier.Add(headerLineFCvalues[i]);
70  FCvaluesMeasures.Add(new List<double>());
71  normalizedFCvaluesMeasures.Add(new List<double>());
72  }
73 
74  // Init pollutant identifiers, unit and measures
75  List<string> pollutantIdentifier = new List<string>();
76  List<List<double>> pollutantMeasures = new List<List<double>>();
77  List<List<double>> normalizedPollutantMeasures = new List<List<double>>();
78  for (int i = 0; i < headerLinePollutants.Count; i++)
79  {
80  pollutantIdentifier.Add(headerLinePollutants[i]);
81  pollutantMeasures.Add(new List<double>());
82  normalizedPollutantMeasures.Add(new List<double>());
83  }
84 
85  // Assigning values for speed rotational table
86  _speedPatternRotational = new List<double>();
87  for (int i = 0; i < Vehicle.TransmissionData.Transm["Speed"].Count; i++)
88  _speedPatternRotational.Add(Vehicle.TransmissionData.Transm["Speed"][i] / 3.6);
89 
90  _gearTransmissionCurve = Vehicle.TransmissionData.Transm["GearRatio"];
91  _speedCurveRotational = Vehicle.TransmissionData.Transm["RotMassF"];
92 
93  // Assigning values for drag table
94  _nNormTable = Vehicle.FLDData.DragCurve["n_norm"];
95  _dragNormTable = Vehicle.FLDData.DragCurve["pe_drag_norm"];
96 
97  // Looping through matrix and assigning values for FC values
98  _powerPatternFCvalues = new List<double>();
99  _normalizedPowerPatternFCvalues = new List<double>();
100 
101  int headerFCCount = headerLineFCvalues.Count;
102  for (int i = 0; i < matrixFCvalues.Count; i++)
103  {
104  for (int j = 0; j < matrixFCvalues[i].Count; j++)
105  {
106  if (matrixFCvalues[i].Count != headerFCCount + 1)
107  return;
108 
109  if (j == 0)
110  {
111  _normalizedPowerPatternFCvalues.Add(matrixFCvalues[i][j]);
112  _powerPatternFCvalues.Add(matrixFCvalues[i][j] * RatedPower);
113  }
114  else
115  {
116  FCvaluesMeasures[j - 1].Add(matrixFCvalues[i][j] * RatedPower);
117  normalizedFCvaluesMeasures[j - 1].Add(matrixFCvalues[i][j]);
118  }
119  }
120  }
121 
122  _cepCurveFCvalues = new Dictionary<string, List<double>>();
123  _idlingValueFCvalues = new Dictionary<string, double>();
124  _normedCepCurveFCvalues = new Dictionary<string, List<double>>();
125 
126  for (int i = 0; i < headerLineFCvalues.Count; i++)
127  {
128  _cepCurveFCvalues.Add(FCvaluesIdentifier[i], FCvaluesMeasures[i]);
129  _normedCepCurveFCvalues.Add(FCvaluesIdentifier[i], normalizedFCvaluesMeasures[i]);
130  _idlingValueFCvalues.Add(FCvaluesIdentifier[i], idlingFCvalues[i] * RatedPower);
131  }
132 
133  // looping through matrix and assigning values for pollutants
134  double pollutantMultiplyer = 1;
135  DrivingPower = NormalizingPower = CalcPower(Constants.NORMALIZING_SPEED, Constants.NORMALIZING_ACCELARATION, 0, (CalcType == "HEV" | CalcType == "BEV"));
136  if (HeavyVehicle)
137  {
138  NormalizingPower = RatedPower;
139  NormalizingType = eNormalizingType.RatedPower;
140  pollutantMultiplyer = RatedPower;
141  }
142  else
143  {
144  NormalizingPower = DrivingPower;
145  NormalizingType = eNormalizingType.DrivingPower;
146  }
147 
148  _powerPatternPollutants = new List<double>();
149  _normailzedPowerPatternPollutants = new List<double>();
150  _cepNormalizedCurvePollutants = new Dictionary<string, List<double>>();
151 
152  int headerCount = headerLinePollutants.Count;
153  for (int i = 0; i < matrixPollutants.Count; i++)
154  {
155  for (int j = 0; j < matrixPollutants[i].Count; j++)
156  {
157  if (matrixPollutants[i].Count != headerCount + 1)
158  return;
159 
160  if (j == 0)
161  {
162  _normailzedPowerPatternPollutants.Add(matrixPollutants[i][j]);
163  _powerPatternPollutants.Add(matrixPollutants[i][j] * NormalizingPower);
164  }
165  else
166  {
167  pollutantMeasures[j - 1].Add(matrixPollutants[i][j] * pollutantMultiplyer);
168  normalizedPollutantMeasures[j - 1].Add(matrixPollutants[i][j]);
169  }
170  }
171  }
172 
173  _cepCurvePollutants = new Dictionary<string, List<double>>();
174  _idlingValuesPollutants = new Dictionary<string, double>();
175 
176  for (int i = 0; i < headerLinePollutants.Count; i++)
177  {
178  _cepCurvePollutants.Add(pollutantIdentifier[i], pollutantMeasures[i]);
179  _cepNormalizedCurvePollutants.Add(pollutantIdentifier[i], normalizedPollutantMeasures[i]);
180  _idlingValuesPollutants.Add(pollutantIdentifier[i], idlingPollutants[i] * pollutantMultiplyer);
181  }
182 
183  _FleetMix = new Dictionary<string, double>();
184  _FleetMix.Add(Constants.strGasoline, 0);
185  _FleetMix.Add(Constants.strDiesel, 0);
186  _FleetMix.Add(Constants.strCNG, 0);
187  _FleetMix.Add(Constants.strLPG, 0);
188  }
189  #endregion
190 
191  #if FLEET
192  #region ConstrutorForFleetmix
193  private CEP(bool heavyVehicle,
194  double vehicleMass,
195  double vehicleLoading,
196  double vehicleMassRot,
197  double crossArea,
198  double cWValue,
199  double f0,
200  double f1,
201  double f2,
202  double f3,
203  double f4,
204  double axleRatio,
205  double auxPower,
206  double ratedPower,
207  double engineIdlingSpeed,
208  double engineRatedSpeed,
209  double effictiveWheelDiameter,
210  double pNormV0,
211  double pNormP0,
212  double pNormV1,
213  double pNormP1)
214  {
215  _resistanceF0 = f0;
216  _resistanceF1 = f1;
217  _resistanceF2 = f2;
218  _resistanceF3 = f3;
219  _resistanceF4 = f4;
220  _cWValue = cWValue;
221  _crossSectionalArea = crossArea;
222  _massVehicle = vehicleMass;
223  _vehicleLoading = vehicleLoading;
224  _vehicleMassRot = vehicleMassRot;
225  RatedPower = ratedPower;
226  _engineIdlingSpeed = engineIdlingSpeed;
227  _engineRatedSpeed = engineRatedSpeed;
228  _effectiveWheelDiameter = effictiveWheelDiameter;
229 
230  _axleRatio = axleRatio;
231  _auxPower = auxPower;
232 
233  _pNormV0 = pNormV0;
234  _pNormP0 = pNormP0;
235  _pNormV1 = pNormV1;
236  _pNormP1 = pNormP1;
237 
238  HeavyVehicle = heavyVehicle;
239  }
240  #endregion
241  #endif
242 
243  public bool HeavyVehicle { get; }
244  public string FuelType { get; private set; }
245  public string CalcType { get; private set; }
246 
247  #region NormalizingType
248  public enum eNormalizingType
249  {
250  RatedPower,
251  DrivingPower
252  }
253 
254  public eNormalizingType NormalizingType { get; private set; }
255  #endregion
256 
257  public double RatedPower { get; set; }
258  public double NormalizingPower { get; private set; }
259  public double DrivingPower { get; set; }
260 
261  #region Private Members
262  protected double _massVehicle;
263  protected double _vehicleLoading;
264  protected double _vehicleMassRot;
265  protected double _crossSectionalArea;
266  protected double _cWValue;
267  protected double _resistanceF0;
268  protected double _resistanceF1;
269  protected double _resistanceF2;
270  protected double _resistanceF3;
271  protected double _resistanceF4;
272  protected double _axleRatio;
273  protected double _auxPower;
274  protected double _pNormV0;
275  protected double _pNormP0;
276  protected double _pNormV1;
277  protected double _pNormP1;
278 
279  protected double _engineRatedSpeed;
280  protected double _engineIdlingSpeed;
281  protected double _effectiveWheelDiameter;
282 
283  protected List<double> _speedPatternRotational;
284  protected List<double> _powerPatternFCvalues;
285  protected List<double> _normalizedPowerPatternFCvalues;
286  protected List<double> _normailzedPowerPatternPollutants;
287  protected List<double> _powerPatternPollutants;
288 
289  protected Dictionary<string, List<double>> _cepCurveFCvalues;
290  protected Dictionary<string, List<double>> _normedCepCurveFCvalues;
291  protected List<double> _gearTransmissionCurve;
292  protected List<double> _speedCurveRotational;
293  protected Dictionary<string, List<double>> _cepCurvePollutants;
294  protected Dictionary<string, List<double>> _cepNormalizedCurvePollutants;
295  protected Dictionary<string, double> _FleetMix;
296  protected Dictionary<string, double> _idlingValueFCvalues;
297  protected Dictionary<string, double> _idlingValuesPollutants;
298 
299  protected List<double> _nNormTable;
300  protected List<double> _dragNormTable;
301  #endregion
302 
303  #region CalcPower
304  public double CalcPower(double speed, double acc, double gradient, bool HBEV)
305  {
306  //Declaration
307  double power = 0;
308  double rotFactor = GetRotationalCoeffecient(speed);
309  double powerAux = (_auxPower * RatedPower);
310 
311  //Calculate the power
312  power += (_massVehicle + _vehicleLoading) * Constants.GRAVITY_CONST * (_resistanceF0 + _resistanceF1 * speed + _resistanceF4 * Math.Pow(speed, 4)) * speed;
313  power += (_crossSectionalArea * _cWValue * Constants.AIR_DENSITY_CONST / 2) * Math.Pow(speed, 3);
314  power += (_massVehicle * rotFactor + _vehicleMassRot + _vehicleLoading) * acc * speed;
315  power += (_massVehicle + _vehicleLoading) * Constants.GRAVITY_CONST * gradient * 0.01 * speed;
316  power /= 1000;
317  power /= Constants._DRIVE_TRAIN_EFFICIENCY;
318  if (!HBEV)
319  power += powerAux;
320 
321  //Return result
322  return power;
323  }
324 
325  public double CalcWheelPower(double speed, double acc, double gradient)
326  {
327  //Declaration
328  double power = 0;
329  double rotFactor = GetRotationalCoeffecient(speed);
330 
331  //Calculate the power
332  power += (_massVehicle + _vehicleLoading) * Constants.GRAVITY_CONST * (_resistanceF0 + _resistanceF1 * speed + _resistanceF4 * Math.Pow(speed, 4)) * speed;
333  power += (_crossSectionalArea * _cWValue * Constants.AIR_DENSITY_CONST / 2) * Math.Pow(speed, 3);
334  power += (_massVehicle * rotFactor + _vehicleMassRot + _vehicleLoading) * acc * speed;
335  power += (_massVehicle + _vehicleLoading) * Constants.GRAVITY_CONST * gradient * 0.01 * speed;
336  power /= 1000;
337 
338  //Return result
339  return power;
340  }
341  #endregion
342 
343  #region CalcEngPower
344  public double CalcEngPower(double power)
345  {
346  if (power < _powerPatternFCvalues.First()) return _powerPatternFCvalues.First();
347  if (power > _powerPatternFCvalues.Last()) return _powerPatternFCvalues.Last();
348 
349  return power;
350  }
351  #endregion
352 
353  #region GetEmission
354  public Dictionary<string, double> GetAllEmission(double power, double speed, Helpers VehicleClass, bool SetZero = false)
355  {
356  //Declaration
357  Dictionary<string, double> Emi = new Dictionary<string, double>();
358 
359  if (!SetZero)
360  {
361  //FC values
362  foreach (string id in _cepCurveFCvalues.Keys)
363  {
364  if (id.ToUpper() == "FC_EL" & VehicleClass.pClass == Constants.strBEV)
365  Emi.Add(id.ToUpper(), GetEmission(id, power, speed, VehicleClass) + _auxPower * RatedPower);
366  else
367  Emi.Add(id.ToUpper(), GetEmission(id, power, speed, VehicleClass));
368  }
369 
370  //Emission
371  foreach (string id in _cepCurvePollutants.Keys)
372  {
373  if (VehicleClass.pClass != Constants.strBEV)
374  {
375  Emi.Add(id.ToUpper(), GetEmission(id, power, speed, VehicleClass));
376  }
377  else
378  {
379  //If BEV set all emissions to 0
380  Emi.Add(id.ToUpper(), 0);
381  }
382  }
383 
384  if (!Emi.ContainsKey("CO2"))
385  {
386  if (Emi.ContainsKey("FC") & Emi.ContainsKey("CO") & Emi.ContainsKey("HC") & VehicleClass.pClass != Constants.strBEV)
387  Emi.Add("CO2", GetCO2Emission(Emi["FC"], Emi["CO"], Emi["HC"], VehicleClass));
388  else
389  Emi.Add("CO2", 0);
390  }
391  }
392  else
393  {
394  foreach (string id in _cepCurveFCvalues.Keys)
395  {
396  if (VehicleClass.pClass == "Mix" & id.ToUpper() == "FC_EL")
397  Emi.Add(id, GetEmission(id, power, speed, VehicleClass));
398  else
399  Emi.Add(id.ToUpper(), 0);
400  }
401 
402  foreach (string id in _cepCurvePollutants.Keys)
403  {
404  Emi.Add(id.ToUpper(), 0);
405  }
406  if (!Emi.ContainsKey("CO2")) Emi.Add("CO2", 0);
407  }
408 
409  //Return value
410  return Emi;
411  }
412 
413  private double GetEmission(string pollutant, double power, double speed, Helpers VehicleClass)
414  {
415  //Declaration
416  List<double> emissionCurve = new List<double>();
417  List<double> powerPattern = new List<double>();
418 
419  // bisection search to find correct position in power pattern
420  int upperIndex;
421  int lowerIndex;
422 
423  if (Math.Abs(speed) <= Constants.ZERO_SPEED_ACCURACY)
424  {
425  if (!_cepCurvePollutants.ContainsKey(pollutant) & !_cepCurveFCvalues.ContainsKey(pollutant))
426  {
427  VehicleClass.ErrMsg = "Emission pollutant or fuel value " + pollutant + " not found!";
428  return 0;
429  }
430 
431  if (_cepCurveFCvalues.ContainsKey(pollutant))
432  return _idlingValueFCvalues[pollutant];
433  else if (_cepCurvePollutants.ContainsKey(pollutant))
434  return _idlingValuesPollutants[pollutant];
435  }
436 
437  if (!_cepCurvePollutants.ContainsKey(pollutant) & !_cepCurveFCvalues.ContainsKey(pollutant))
438  {
439  VehicleClass.ErrMsg = "Emission pollutant or fuel value " + pollutant + " not found!";
440  return 0;
441  }
442 
443  if (_cepCurveFCvalues.ContainsKey(pollutant))
444  {
445  emissionCurve = _cepCurveFCvalues[pollutant];
446  powerPattern = _powerPatternFCvalues;
447  }
448  else if (_cepCurvePollutants.ContainsKey(pollutant))
449  {
450  emissionCurve = _cepCurvePollutants[pollutant];
451  powerPattern = _powerPatternPollutants;
452  }
453 
454  if (emissionCurve.Count == 0)
455  {
456  VehicleClass.ErrMsg = "Empty emission curve for " + pollutant + " found!";
457  return 0;
458  }
459  if (emissionCurve.Count == 1)
460  {
461  return emissionCurve[0];
462  }
463 
464  // in case that the demanded power is smaller than the first entry (smallest) in the power pattern the first is returned (should never happen)
465  if (power <= powerPattern.First())
466  {
467  return emissionCurve[0];
468  }
469 
470  // if power bigger than all entries in power pattern return the last (should never happen)
471  if (power >= powerPattern.Last())
472  {
473  return emissionCurve.Last();
474  }
475 
476  FindLowerUpperInPattern(out lowerIndex, out upperIndex, powerPattern, power);
477  return Interpolate(power, powerPattern[lowerIndex], powerPattern[upperIndex], emissionCurve[lowerIndex], emissionCurve[upperIndex]);
478  }
479  #endregion
480 
481 #if FLEET
482  #region GetNormedEmission
483  private double GetNormedEmission(string pollutant, double power, double speed, Helpers VehicleClass)
484  {
485  //Declaration
486  List<double> emissionCurve = new List<double>();
487  List<double> powerPattern = new List<double>();
488 
489  // bisection search to find correct position in power pattern
490  int upperIndex;
491  int lowerIndex;
492 
493  if (!_cepCurvePollutants.ContainsKey(pollutant) & !_cepCurveFCvalues.ContainsKey(pollutant))
494  {
495  VehicleClass.ErrMsg = "Emission pollutant or fuel value " + pollutant + " not found!";
496  return 0;
497  }
498 
499  if (_cepCurveFCvalues.ContainsKey(pollutant))
500  {
501  emissionCurve = _normedCepCurveFCvalues[pollutant];
502  powerPattern = _normalizedPowerPatternFCvalues;
503  }
504  else if (_cepCurvePollutants.ContainsKey(pollutant))
505  {
506  emissionCurve = _cepNormalizedCurvePollutants[pollutant];
507  powerPattern = _normailzedPowerPatternPollutants;
508  }
509 
510  if (emissionCurve.Count == 0)
511  {
512  VehicleClass.ErrMsg = "Empty emission curve for " + pollutant + " found!";
513  return 0;
514  }
515  if (emissionCurve.Count == 1)
516  {
517  return emissionCurve[0];
518  }
519  // in case that the demanded power is smaller than the first entry (smallest) in the power pattern the first is returned (should never happen)
520  if (power <= powerPattern.First())
521  {
522  return emissionCurve[0];
523  }
524 
525  // if power bigger than all entries in power pattern the last is returned (should never happen)
526  if (power >= powerPattern.Last())
527  {
528  return emissionCurve.Last();
529  }
530 
531  FindLowerUpperInPattern(out lowerIndex, out upperIndex, powerPattern, power);
532  return Interpolate(power, powerPattern[lowerIndex], powerPattern[upperIndex], emissionCurve[lowerIndex], emissionCurve[upperIndex]);
533  }
534  #endregion
535  #endif
536 
537  #region GetCO2Emission
538  public double GetCO2Emission(double _FC, double _CO, double _HC, Helpers VehicleClass)
539  {
540  //Declaration
541  double fCBr, fCHC, fCCO, fCCO2;
542 
543  fCBr = 0;
544  fCHC = 0;
545  fCCO = 0;
546  fCCO2 = 0;
547 
548  if (FuelType != "Mix")
549  {
550  if (!GetfcVals(FuelType, ref fCBr, ref fCHC, ref fCCO, ref fCCO2, VehicleClass))
551  return 0;
552  }
553  else
554  {
555  if (!CalcfCValMix(ref fCBr, ref fCHC, ref fCCO, ref fCCO2, VehicleClass))
556  return 0;
557  }
558 
559  return (_FC * fCBr - _CO * fCCO - _HC * fCHC) / fCCO2;
560  }
561 
562  //Calculate the weighted fuel factor values for Fleetmix
563  private bool CalcfCValMix(ref double _fCBr, ref double _fCHC, ref double _fCCO, ref double _fCCO2, Helpers VehicleClass)
564  {
565  //Declaration
566  double Sum = 0;
567  double sumfCBr, sumfCHC, sumfCCO, sumfCCO2;
568 
569  //Initialise
570  sumfCBr = 0;
571  sumfCHC = 0;
572  sumfCCO = 0;
573  sumfCCO2 = 0;
574 
575  //calculate the sum
576  foreach (string id in _FleetMix.Keys)
577  {
578  Sum += _FleetMix[id];
579  }
580 
581  //Calculate the weighted fuel factors
582  if (Sum <= 0)
583  {
584  VehicleClass.ErrMsg = "All propolsion types in the fleetshares file are not known!";
585  return false;
586  }
587  else
588  {
589  foreach (string id in _FleetMix.Keys)
590  {
591  if (!GetfcVals(id, ref _fCBr, ref _fCHC, ref _fCCO, ref _fCCO2, VehicleClass))
592  {
593  return false;
594  }
595  else
596  {
597  sumfCBr += _fCBr * _FleetMix[id] / Sum;
598  sumfCHC += _fCHC * _FleetMix[id] / Sum;
599  sumfCCO += _fCCO * _FleetMix[id] / Sum;
600  sumfCCO2 += _fCCO2 * _FleetMix[id] / Sum;
601  }
602  }
603  }
604  //Result values
605  _fCBr = sumfCBr;
606  _fCHC = sumfCHC;
607  _fCCO = sumfCCO;
608  _fCCO2 = sumfCCO2;
609  return true;
610  }
611 
612  // Get the fuel factor values
613  private bool GetfcVals(string _fuelTypex, ref double _fCBr, ref double _fCHC, ref double _fCCO, ref double _fCCO2, Helpers VehicleClass)
614  {
615  _fCHC = 0.866;
616  _fCCO = 0.429;
617  _fCCO2 = 0.273;
618 
619  switch (_fuelTypex)
620  {
621  case Constants.strGasoline:
622  _fCBr = 0.865;
623  break;
624  case Constants.strDiesel:
625  _fCBr = 0.863;
626  break;
627  case Constants.strCNG:
628  _fCBr = 0.693;
629  _fCHC = 0.803;
630  break;
631  case Constants.strLPG:
632  _fCBr = 0.825;
633  _fCHC = 0.825;
634  break;
635  default:
636  VehicleClass.ErrMsg = "The propolsion type is not known! (" + FuelType + ")";
637  return false;
638  }
639  return true;
640  }
641  #endregion
642 
643  #region GetDecelCoast
644  public double GetDecelCoast(double speed, double acc, double gradient)
645  {
646  //Declaration
647  int upperIndex;
648  int lowerIndex;
649 
650  if (speed < Constants.SPEED_DCEL_MIN)
651  {
652  return speed / Constants.SPEED_DCEL_MIN * GetDecelCoast(Constants.SPEED_DCEL_MIN, acc, gradient);
653  }
654 
655  double rotCoeff = GetRotationalCoeffecient(speed);
656  FindLowerUpperInPattern(out lowerIndex, out upperIndex, _speedPatternRotational, speed);
657  double iGear = Interpolate(speed,
658  _speedPatternRotational[lowerIndex],
659  _speedPatternRotational[upperIndex],
660  _gearTransmissionCurve[lowerIndex],
661  _gearTransmissionCurve[upperIndex]);
662 
663  double iTot = iGear * _axleRatio;
664 
665  double n = (30 * speed * iTot) / ((_effectiveWheelDiameter / 2) * Math.PI);
666  double nNorm = (n - _engineIdlingSpeed) / (_engineRatedSpeed - _engineIdlingSpeed);
667 
668  FindLowerUpperInPattern(out lowerIndex, out upperIndex, _nNormTable, nNorm);
669 
670  double fMot = 0;
671 
672  if (speed >= 10e-2)
673  {
674  fMot = (-Interpolate(nNorm,
675  _nNormTable[lowerIndex],
676  _nNormTable[upperIndex],
677  _dragNormTable[lowerIndex],
678  _dragNormTable[upperIndex]) * RatedPower * 1000 / speed) / Constants.DRIVE_TRAIN_EFFICIENCY;
679  }
680 
681  double fRoll = (_resistanceF0
682  + _resistanceF1 * speed
683  + Math.Pow(_resistanceF2 * speed, 2)
684  + Math.Pow(_resistanceF3 * speed, 3)
685  + Math.Pow(_resistanceF4 * speed, 4)) * (_massVehicle + _vehicleLoading) * Constants.GRAVITY_CONST;
686 
687  double fAir = _cWValue * _crossSectionalArea * Constants.AIR_DENSITY_CONST * 0.5 * Math.Pow(speed, 2);
688 
689  double fGrad = (_massVehicle + _vehicleLoading) * Constants.GRAVITY_CONST * gradient / 100;
690 
691  return -(fMot + fRoll + fAir + fGrad) / ((_massVehicle + _vehicleLoading) * rotCoeff);
692  }
693  #endregion
694 
695  #region GetRotationalCoeffecient
696  public double GetRotationalCoeffecient(double speed)
697  {
698  //Declaration
699  int upperIndex;
700  int lowerIndex;
701 
702  FindLowerUpperInPattern(out lowerIndex, out upperIndex, _speedPatternRotational, speed);
703  return Interpolate(speed,
704  _speedPatternRotational[lowerIndex],
705  _speedPatternRotational[upperIndex],
706  _speedCurveRotational[lowerIndex],
707  _speedCurveRotational[upperIndex]);
708  }
709  #endregion
710 
711  #if FLEET
712  #region GetGearCoeffecient
713  public double GetGearCoeffecient(double speed)
714  {
715  //Declaration
716  int upperIndex;
717  int lowerIndex;
718 
719  FindLowerUpperInPattern(out lowerIndex, out upperIndex, _speedPatternRotational, speed);
720  return Interpolate(speed,
721  _speedPatternRotational[lowerIndex],
722  _speedPatternRotational[upperIndex],
723  _gearTransmissionCurve[lowerIndex],
724  _gearTransmissionCurve[upperIndex]);
725  }
726  #endregion
727 
728  #region GetDragCoeffecient
729  public double GetDragCoeffecient(double nNorm)
730  {
731  //Declaration
732  int upperIndex;
733  int lowerIndex;
734 
735  FindLowerUpperInPattern(out lowerIndex, out upperIndex, _nNormTable, nNorm);
736  return Interpolate(nNorm,
737  _nNormTable[lowerIndex],
738  _nNormTable[upperIndex],
739  _dragNormTable[lowerIndex],
740  _dragNormTable[upperIndex]);
741  }
742  #endregion
743  #endif
744 
745  #region FindLowerUpperInPattern
746  private void FindLowerUpperInPattern(out int lowerIndex, out int upperIndex, List<double> pattern, double value)
747  {
748  lowerIndex = 0;
749  upperIndex = 0;
750 
751  if (value <= pattern.First())
752  {
753  lowerIndex = 0;
754  upperIndex = 0;
755  return;
756  }
757 
758  if (value >= pattern.Last())
759  {
760  lowerIndex = pattern.Count - 1;
761  upperIndex = pattern.Count - 1;
762  return;
763  }
764 
765  // bisection search to find correct position in power pattern
766  int middleIndex = (pattern.Count - 1) / 2;
767  upperIndex = pattern.Count - 1;
768  lowerIndex = 0;
769 
770  while (upperIndex - lowerIndex > 1)
771  {
772  if (pattern[middleIndex] == value)
773  {
774  lowerIndex = middleIndex;
775  upperIndex = middleIndex;
776  return;
777  }
778  else if (pattern[middleIndex] < value)
779  {
780  lowerIndex = middleIndex;
781  middleIndex = (upperIndex - lowerIndex) / 2 + lowerIndex;
782  }
783  else
784  {
785  upperIndex = middleIndex;
786  middleIndex = (upperIndex - lowerIndex) / 2 + lowerIndex;
787  }
788  }
789 
790  if (pattern[lowerIndex] <= value && value < pattern[upperIndex])
791  {
792  return;
793  }
794  }
795  #endregion
796 
797  #region Interpolate
798  private double Interpolate(double px, double p1, double p2, double e1, double e2)
799  {
800  if (p2 == p1)
801  return e1;
802 
803  return e1 + (px - p1) / (p2 - p1) * (e2 - e1);
804  }
805  #endregion
806 
807  #region GetMaxAccel
808  public double GetMaxAccel(double speed, double gradient, bool HBEV)
809  {
810  double rotFactor = GetRotationalCoeffecient(speed);
811  double pMaxForAcc = GetPMaxNorm(speed) * RatedPower - CalcPower(speed, 0, gradient, HBEV);
812 
813  return (pMaxForAcc * 1000) / ((_massVehicle * rotFactor + _vehicleMassRot + _vehicleLoading) * speed);
814  }
815  #endregion
816 
817  #region GetPMaxNorm
818  private double GetPMaxNorm(double speed)
819  {
820  // Linear function between v0 and v1, constant elsewhere
821  if (speed <= _pNormV0)
822  return _pNormP0;
823  else if (speed >= _pNormV1)
824  return _pNormP1;
825  else
826  {
827  return Interpolate(speed, _pNormV0, _pNormV1, _pNormP0, _pNormP1);
828  }
829  }
830  #endregion
831 
832  //--------------------------------------------------------------------------------------------------
833  // Operators for fleetmix
834  //--------------------------------------------------------------------------------------------------
835 
836  #if FLEET
837  #region AddRangeCeps
838  public static CEP AddRangeCeps(CEP[] cps, Helpers Helper)
839  {
840  #region SingleValues
841  CEP newCEP = new CEP(cps.Select(p => p.HeavyVehicle ? 1 : 0).Sum() > 0,
842  cps.Select(p => p._massVehicle).Sum(),
843  cps.Select(p => p._vehicleLoading).Sum(),
844  cps.Select(p => p._vehicleMassRot).Sum(),
845  cps.Select(p => p._crossSectionalArea).Sum(),
846  cps.Select(p => p._cWValue).Sum(),
847  cps.Select(p => p._resistanceF0).Sum(),
848  cps.Select(p => p._resistanceF1).Sum(),
849  cps.Select(p => p._resistanceF2).Sum(),
850  cps.Select(p => p._resistanceF3).Sum(),
851  cps.Select(p => p._resistanceF4).Sum(),
852  cps.Select(p => p._axleRatio).Sum(),
853  cps.Select(p => p._auxPower).Sum(),
854  cps.Select(p => p.RatedPower).Sum(),
855  cps.Select(p => p._engineIdlingSpeed).Sum(),
856  cps.Select(p => p._engineRatedSpeed).Sum(),
857  cps.Select(p => p._effectiveWheelDiameter).Sum(),
858  cps.Select(p => p._pNormV0).Sum(),
859  cps.Select(p => p._pNormP0).Sum(),
860  cps.Select(p => p._pNormV1).Sum(),
861  cps.Select(p => p._pNormP1).Sum());
862 
863  #region Fleetmix and Fueltype
864  if (cps.Select(p => p.FuelType).Min() == cps.Select(p => p.FuelType).Max())
865  newCEP.FuelType = cps.First().FuelType;
866  else
867  newCEP.FuelType = "Mix";
868 
869  newCEP._FleetMix = new Dictionary<string, double>();
870  foreach (string id in cps.First()._FleetMix.Keys)
871  {
872  newCEP._FleetMix.Add(id, cps.Select(p => p._FleetMix[id]).Sum());
873  }
874  #endregion
875  #endregion
876 
877  #region SpeedRotationalTable
878  double minSpeedRotational = cps.Select(p => p._speedPatternRotational.First()).Min();
879  double maxSpeedRotational = cps.Select(p => p._speedPatternRotational.Last()).Max();
880 
881  newCEP._speedPatternRotational
882  = CreatePattern(minSpeedRotational,
883  maxSpeedRotational,
884  Constants.SPEED_ROTATIONAL_INCREMENT);
885 
886  newCEP._speedCurveRotational = new List<double>();
887  newCEP._gearTransmissionCurve = new List<double>();
888 
889  for (int i = 0; i < newCEP._speedPatternRotational.Count; i++)
890  {
891  newCEP._speedCurveRotational.Add(cps.Select(p => p.GetRotationalCoeffecient(newCEP._speedPatternRotational[i])).Sum());
892 
893  newCEP._gearTransmissionCurve.Add(cps.Select(p => p.GetGearCoeffecient(newCEP._speedPatternRotational[i])).Sum());
894  }
895  #endregion
896 
897  #region NormalizingPower
898  newCEP.DrivingPower = newCEP.CalcPower(Constants.NORMALIZING_SPEED, Constants.NORMALIZING_ACCELARATION, 0, (Helper.pClass == Constants.strBEV | Helper.uClass == Constants.strHybrid));
899 
900  if (newCEP.HeavyVehicle)
901  {
902  newCEP.NormalizingPower = newCEP.RatedPower;
903  newCEP.NormalizingType = eNormalizingType.RatedPower;
904  }
905  else
906  {
907  newCEP.NormalizingPower = newCEP.DrivingPower;
908  newCEP.NormalizingType = eNormalizingType.DrivingPower;
909  }
910  #endregion
911 
912  #region FC
913  double minNormPowerPatternFC = cps.Select(p => p._normalizedPowerPatternFCvalues.First()).Min();
914  double maxNormPowerPatternFC = cps.Select(p => p._normalizedPowerPatternFCvalues.Last()).Max();
915 
916  newCEP._normalizedPowerPatternFCvalues
917  = CreatePattern(minNormPowerPatternFC,
918  maxNormPowerPatternFC,
919  Constants.POWER_FC_INCREMENT);
920 
921  newCEP._cepCurveFCvalues = new Dictionary<string, List<double>>();
922  newCEP._normedCepCurveFCvalues = new Dictionary<string, List<double>>();
923  newCEP._powerPatternFCvalues = new List<double>();
924 
925  foreach (string id in cps.First()._cepCurveFCvalues.Keys)
926  {
927  newCEP._cepCurveFCvalues.Add(id, new List<double>());
928  newCEP._normedCepCurveFCvalues.Add(id, new List<double>());
929  }
930 
931  for (int i = 0; i < newCEP._normalizedPowerPatternFCvalues.Count; i++)
932  {
933  foreach (string id in newCEP._cepCurveFCvalues.Keys)
934  {
935  double newCepVal = cps.Select(p => p.GetNormedEmission(id, newCEP._normalizedPowerPatternFCvalues[i], double.MaxValue, Helper)).Sum();
936  newCEP._cepCurveFCvalues[id].Add(newCepVal * newCEP.RatedPower);
937  newCEP._normedCepCurveFCvalues[id].Add(newCepVal);
938  }
939  newCEP._powerPatternFCvalues.Add(newCEP._normalizedPowerPatternFCvalues[i] * newCEP.RatedPower);
940  }
941  #endregion
942 
943  #region Pollutants
944  double minNormPowerPattern = cps.Select(p => p._normailzedPowerPatternPollutants.First()).Min();
945  double maxNormPowerPattern = cps.Select(p => p._normailzedPowerPatternPollutants.Last()).Max();
946 
947  newCEP._normailzedPowerPatternPollutants
948  = CreatePattern(minNormPowerPattern,
949  maxNormPowerPattern,
950  Constants.POWER_POLLUTANT_INCREMENT);
951 
952  newCEP._cepCurvePollutants = new Dictionary<string, List<double>>();
953  newCEP._cepNormalizedCurvePollutants = new Dictionary<string, List<double>>();
954  newCEP._powerPatternPollutants = new List<double>();
955 
956  foreach (string id in cps.First()._cepCurvePollutants.Keys)
957  {
958  newCEP._cepCurvePollutants.Add(id, new List<double>());
959  newCEP._cepNormalizedCurvePollutants.Add(id, new List<double>());
960  }
961 
962  for (int i = 0; i < newCEP._normailzedPowerPatternPollutants.Count; i++)
963  {
964  foreach (string id in newCEP._cepCurvePollutants.Keys)
965  {
966  if (newCEP.NormalizingType == eNormalizingType.RatedPower)
967  {
968  double newCepVal = cps.Select(p => p.GetNormedEmission(id, newCEP._normailzedPowerPatternPollutants[i], double.MaxValue, Helper)).Sum();
969  newCEP._cepCurvePollutants[id].Add(newCepVal * newCEP.RatedPower);
970  newCEP._cepNormalizedCurvePollutants[id].Add(newCepVal);
971  }
972  else
973  {
974  newCEP._cepCurvePollutants[id].Add(cps.Select(p => p.GetEmission(id, newCEP._normailzedPowerPatternPollutants[i] * p.NormalizingPower, double.MaxValue, Helper)).Sum());
975  newCEP._cepNormalizedCurvePollutants[id].Add(cps.Select(p => p.GetNormedEmission(id, newCEP._normailzedPowerPatternPollutants[i], double.MaxValue, Helper)).Sum());
976  }
977  }
978  newCEP._powerPatternPollutants.Add(newCEP._normailzedPowerPatternPollutants[i] * newCEP.NormalizingPower);
979  }
980  #endregion
981 
982  #region IdlingValues
983  newCEP._idlingValueFCvalues = new Dictionary<string, double>();
984  newCEP._idlingValuesPollutants = new Dictionary<string, double>();
985 
986  foreach (string id in cps.First()._idlingValueFCvalues.Keys)
987  {
988  newCEP._idlingValueFCvalues.Add(id, cps.Select(p => p._idlingValueFCvalues[id]).Sum());
989  }
990 
991  foreach (string id in cps.First()._idlingValuesPollutants.Keys)
992  {
993  newCEP._idlingValuesPollutants.Add(id, cps.Select(p => p._idlingValuesPollutants[id]).Sum());
994  }
995  #endregion
996 
997  #region TragTable
998  double minTragTable = cps.Select(p => p._nNormTable.First()).Min();
999  double maxTragTable = cps.Select(p => p._nNormTable.Last()).Max();
1000 
1001  newCEP._nNormTable
1002  = CreatePattern(minTragTable,
1003  maxTragTable,
1004  Constants.NNORM_INCREMENT);
1005 
1006  newCEP._dragNormTable = new List<double>();
1007 
1008  for (int i = 0; i < newCEP._nNormTable.Count; i++)
1009  {
1010  newCEP._dragNormTable.Add(cps.Select(p => p.GetDragCoeffecient(newCEP._nNormTable[i])).Sum());
1011  }
1012  #endregion
1013  return newCEP;
1014  }
1015  #endregion
1016 
1017  #region Operator *
1018  public static CEP operator *(CEP cp1, double d)
1019  {
1020  #region SingleValues
1021  CEP newCEP = new CEP(cp1.HeavyVehicle,
1022  d * cp1._massVehicle,
1023  d * cp1._vehicleLoading,
1024  d * cp1._vehicleMassRot,
1025  d * cp1._crossSectionalArea,
1026  d * cp1._cWValue,
1027  d * cp1._resistanceF0,
1028  d * cp1._resistanceF1,
1029  d * cp1._resistanceF2,
1030  d * cp1._resistanceF3,
1031  d * cp1._resistanceF4,
1032  d * cp1._axleRatio,
1033  d * cp1._auxPower,
1034  d * cp1.RatedPower,
1035  d * cp1._engineIdlingSpeed,
1036  d * cp1._engineRatedSpeed,
1037  d * cp1._effectiveWheelDiameter,
1038  d * cp1._pNormV0,
1039  d * cp1._pNormP0,
1040  d * cp1._pNormV1,
1041  d * cp1._pNormP1);
1042 
1043  #region Fleetmix and Fueltype
1044  newCEP.FuelType = cp1.FuelType;
1045  newCEP._FleetMix = new Dictionary<string, double>();
1046  foreach (string id in cp1._FleetMix.Keys)
1047  {
1048  if (newCEP.FuelType == id)
1049  newCEP._FleetMix.Add(newCEP.FuelType, d);
1050  else
1051  newCEP._FleetMix.Add(id, 0);
1052  }
1053  #endregion
1054  #endregion
1055 
1056  #region SpeedRotationalTable
1057  newCEP._speedPatternRotational = new List<double>(cp1._speedPatternRotational);
1058  newCEP._speedCurveRotational = new List<double>(cp1._speedCurveRotational.Select(p => p * d));
1059  newCEP._gearTransmissionCurve = new List<double>(cp1._gearTransmissionCurve.Select(p => p * d));
1060  #endregion
1061 
1062  #region NormalizingPower
1063  newCEP.DrivingPower = newCEP.CalcPower(Constants.NORMALIZING_SPEED, Constants.NORMALIZING_ACCELARATION, 0, (cp1.CalcType == "HEV" | cp1.CalcType == "BEV"));
1064 
1065  if (newCEP.HeavyVehicle)
1066  {
1067  newCEP.NormalizingPower = newCEP.RatedPower;
1068  newCEP.NormalizingType = eNormalizingType.RatedPower;
1069  }
1070  else
1071  {
1072  newCEP.NormalizingPower = newCEP.DrivingPower;
1073  newCEP.NormalizingType = eNormalizingType.DrivingPower;
1074  }
1075  #endregion
1076 
1077  #region FC
1078  newCEP._powerPatternFCvalues = new List<double>(cp1._powerPatternFCvalues.Select(p => p * d));
1079  newCEP._normalizedPowerPatternFCvalues = new List<double>(cp1._normalizedPowerPatternFCvalues);
1080  newCEP._cepCurveFCvalues = new Dictionary<string, List<double>>();
1081  newCEP._normedCepCurveFCvalues = new Dictionary<string, List<double>>();
1082 
1083  foreach (string id in cp1._cepCurveFCvalues.Keys)
1084  {
1085  newCEP._cepCurveFCvalues.Add(id, new List<double>(cp1._cepCurveFCvalues[id].Select(p => p * d)));
1086  newCEP._normedCepCurveFCvalues.Add(id, new List<double>(cp1._normedCepCurveFCvalues[id].Select(p => p * d)));
1087  }
1088  #endregion
1089 
1090  #region Pollutants
1091  newCEP._powerPatternPollutants = new List<double>(cp1._normailzedPowerPatternPollutants.Select(p => p * newCEP.NormalizingPower));
1092  newCEP._normailzedPowerPatternPollutants = new List<double>(cp1._normailzedPowerPatternPollutants);
1093  newCEP._cepCurvePollutants = new Dictionary<string, List<double>>();
1094  newCEP._cepNormalizedCurvePollutants = new Dictionary<string, List<double>>();
1095 
1096  foreach (string id in cp1._cepCurvePollutants.Keys)
1097  {
1098  newCEP._cepCurvePollutants.Add(id, new List<double>(cp1._cepCurvePollutants[id].Select(p => p * d)));
1099  newCEP._cepNormalizedCurvePollutants.Add(id, new List<double>(cp1._cepNormalizedCurvePollutants[id].Select(p => p * d)));
1100  }
1101  #endregion
1102 
1103  #region IdlingValues
1104  newCEP._idlingValueFCvalues = new Dictionary<string, double>();
1105  newCEP._idlingValuesPollutants = new Dictionary<string, double>();
1106 
1107  foreach (string id in cp1._idlingValueFCvalues.Keys)
1108  {
1109  newCEP._idlingValueFCvalues.Add(id,
1110  cp1._idlingValueFCvalues[id] * d);
1111  }
1112 
1113  foreach (string id in cp1._idlingValuesPollutants.Keys)
1114  {
1115  newCEP._idlingValuesPollutants.Add(id,
1116  cp1._idlingValuesPollutants[id] * d);
1117  }
1118  #endregion
1119 
1120  #region DragTable
1121  newCEP._nNormTable = new List<double>(cp1._nNormTable);
1122  newCEP._dragNormTable = new List<double>(cp1._dragNormTable.Select(p => p * d));
1123  #endregion
1124  return newCEP;
1125  }
1126  #endregion
1127 
1128  #region CreatePattern
1129  static public List<double> CreatePattern(double min, double max, double increment)
1130  {
1131  //Declaration
1132  List<double> pattern = new List<double>();
1133  double actualMin = min;
1134  double actualMax = max;
1135 
1136  if (min < 0)
1137  actualMin = Math.Ceiling(min / increment) * increment;
1138  else
1139  actualMin = Math.Floor(min / increment) * increment;
1140 
1141  if (max < 0)
1142  actualMax = Math.Floor(max / increment) * increment;
1143  else
1144  actualMax = Math.Ceiling(max / increment) * increment;
1145 
1146  double curVal = actualMin;
1147 
1148  while (curVal <= actualMax)
1149  {
1150  pattern.Add(curVal);
1151  curVal += increment;
1152  }
1153  return pattern;
1154  }
1155  #endregion
1156 
1157  #region CheckClass
1158  public static bool CheckClass(CEP[] cps)
1159  {
1160  return cps.Select(p => p.HeavyVehicle ? 1 : 0).Min() == cps.Select(p => p.HeavyVehicle ? 1 : 0).Max();
1161  }
1162  #endregion
1163  #endif
1164  }
1165 }
PHEMlightdll::CEP._cepCurveFCvalues
Dictionary< string, List< double > > _cepCurveFCvalues
Definition: V5/cs/CEP.cs:289
PHEMlightdll::CEP::_powerPatternPollutants
std::vector< double > _powerPatternPollutants
Definition: cpp/CEP.h:116
PHEMlightdll::CEP::_dragNormTable
std::vector< double > _dragNormTable
Definition: cpp/CEP.h:128
PHEMlightdll::CEP.GetGearCoeffecient
double GetGearCoeffecient(double speed)
Definition: V5/cs/CEP.cs:713
PHEMlightdll::CEP.GetAllEmission
Dictionary< string, double > GetAllEmission(double power, double speed, Helpers VehicleClass, bool SetZero=false)
Definition: V5/cs/CEP.cs:354
PHEMlightdll::CEP::_pNormP1
double _pNormP1
Definition: cpp/CEP.h:106
PHEMlightdll::CEP::GetPMaxNorm
double GetPMaxNorm(double speed)
Definition: cpp/CEP.cpp:427
PHEMlightdll::CEP::CEP
CEP(bool heavyVehicle, double vehicleMass, double vehicleLoading, double vehicleMassRot, double crossArea, double cWValue, double f0, double f1, double f2, double f3, double f4, double axleRatio, std::vector< double > &transmissionGearRatios, double auxPower, double ratedPower, double engineIdlingSpeed, double engineRatedSpeed, double effictiveWheelDiameter, double pNormV0, double pNormP0, double pNormV1, double pNormP1, const std::string &vehicelFuelType, std::vector< std::vector< double > > &matrixFC, std::vector< std::string > &headerLinePollutants, std::vector< std::vector< double > > &matrixPollutants, std::vector< std::vector< double > > &matrixSpeedRotational, std::vector< std::vector< double > > &normedDragTable, double idlingFC, std::vector< double > &idlingPollutants)
Definition: cpp/CEP.cpp:32
PHEMlightdll::CEP._normalizedPowerPatternFCvalues
List< double > _normalizedPowerPatternFCvalues
Definition: V5/cs/CEP.cs:285
PHEMlightdll::CEP::_nNormTable
std::vector< double > _nNormTable
Definition: cpp/CEP.h:127
PHEMlightdll::CEP::_pNormP0
double _pNormP0
Definition: cpp/CEP.h:104
PHEMlightdll::CEP.GetEmission
double GetEmission(string pollutant, double power, double speed, Helpers VehicleClass)
Definition: V5/cs/CEP.cs:413
PHEMlightdll::CEP::_effectiveWheelDiameter
double _effectiveWheelDiameter
Definition: cpp/CEP.h:110
PHEMlightdll::CEP.GetDragCoeffecient
double GetDragCoeffecient(double nNorm)
Definition: V5/cs/CEP.cs:729
PHEMlightdll::CEP._normedCepCurveFCvalues
Dictionary< string, List< double > > _normedCepCurveFCvalues
Definition: V5/cs/CEP.cs:290
PHEMlightdll::CEP::_axleRatio
double _axleRatio
Definition: cpp/CEP.h:101
PHEMlightdll::CEP::_cepNormalizedCurvePollutants
std::map< std::string, std::vector< double > > _cepNormalizedCurvePollutants
Definition: cpp/CEP.h:123
PHEMlightdll::CEP::_idlingValuesPollutants
std::map< std::string, double > _idlingValuesPollutants
Definition: cpp/CEP.h:125
PHEMlightdll::CEP::_vehicleLoading
double _vehicleLoading
Definition: cpp/CEP.h:92
PHEMlightdll::CEP.AddRangeCeps
static CEP AddRangeCeps(CEP[] cps, Helpers Helper)
Definition: V5/cs/CEP.cs:838
PHEMlightdll::CEP::_speedPatternRotational
std::vector< double > _speedPatternRotational
Definition: cpp/CEP.h:112
PHEMlightdll::CEP._FleetMix
Dictionary< string, double > _FleetMix
Definition: V5/cs/CEP.cs:295
PHEMlightdll::CEP.CalcWheelPower
double CalcWheelPower(double speed, double acc, double gradient)
Definition: V5/cs/CEP.cs:325
PHEMlightdll::CEP.GetNormedEmission
double GetNormedEmission(string pollutant, double power, double speed, Helpers VehicleClass)
Definition: V5/cs/CEP.cs:483
PHEMlightdll::CEP.CEP
CEP(VEHPHEMLightJSON.VEH Vehicle, List< string > headerLineFCvalues, List< List< double >> matrixFCvalues, List< string > headerLinePollutants, List< List< double >> matrixPollutants, List< double > idlingFCvalues, List< double > idlingPollutants)
Definition: V5/cs/CEP.cs:13
PHEMlightdll::CEP.GetfcVals
bool GetfcVals(string _fuelTypex, ref double _fCBr, ref double _fCHC, ref double _fCCO, ref double _fCCO2, Helpers VehicleClass)
Definition: V5/cs/CEP.cs:613
PHEMlightdll::CEP::_resistanceF2
double _resistanceF2
Definition: cpp/CEP.h:98
PHEMlightdll::CEP::_resistanceF3
double _resistanceF3
Definition: cpp/CEP.h:99
PHEMlightdll::CEP.GetMaxAccel
double GetMaxAccel(double speed, double gradient, bool HBEV)
Definition: V5/cs/CEP.cs:808
PHEMlightdll::CEP::_pNormV1
double _pNormV1
Definition: cpp/CEP.h:105
PHEMlightdll::CEP::_cWValue
double _cWValue
Definition: cpp/CEP.h:95
PHEMlightdll::CEP.operator*
static CEP operator*(CEP cp1, double d)
Definition: dll_code/CEP.cs:921
PHEMlightdll::CEP::_normailzedPowerPatternPollutants
std::vector< double > _normailzedPowerPatternPollutants
Definition: cpp/CEP.h:115
PHEMlightdll::CEP::_crossSectionalArea
double _crossSectionalArea
Definition: cpp/CEP.h:94
PHEMlightdll::CEP::_auxPower
double _auxPower
Definition: cpp/CEP.h:102
PHEMlightdll::CEP::FindLowerUpperInPattern
void FindLowerUpperInPattern(int &lowerIndex, int &upperIndex, std::vector< double > &pattern, double value)
Definition: cpp/CEP.cpp:370
PHEMlightdll::CEP::_gearTransmissionCurve
std::vector< double > _gearTransmissionCurve
Definition: cpp/CEP.h:120
PHEMlightdll::CEP.GetCO2Emission
double GetCO2Emission(double _FC, double _CO, double _HC, Helpers VehicleClass)
Definition: V5/cs/CEP.cs:538
PHEMlightdll::CEP._powerPatternFCvalues
List< double > _powerPatternFCvalues
Definition: V5/cs/CEP.cs:284
PHEMlightdll::CEP::GetRotationalCoeffecient
double GetRotationalCoeffecient(double speed)
Definition: cpp/CEP.cpp:361
PHEMlightdll::CEP.CalcEngPower
double CalcEngPower(double power)
Definition: V5/cs/CEP.cs:344
PHEMlightdll::CEP::GetEmission
double GetEmission(const std::string &pollutant, double power, double speed, Helpers *VehicleClass)
Definition: cpp/CEP.cpp:230
PHEMlightdll::CEP::_speedCurveRotational
std::vector< double > _speedCurveRotational
Definition: cpp/CEP.h:121
PHEMlightdll::CEP.FindLowerUpperInPattern
void FindLowerUpperInPattern(out int lowerIndex, out int upperIndex, List< double > pattern, double value)
Definition: V5/cs/CEP.cs:746
PHEMlightdll::CEP::_resistanceF4
double _resistanceF4
Definition: cpp/CEP.h:100
PHEMlightdll::CEP._idlingValueFCvalues
Dictionary< string, double > _idlingValueFCvalues
Definition: V5/cs/CEP.cs:296
PHEMlightdll::CEP.CreatePattern
static List< double > CreatePattern(double min, double max, double increment)
Definition: dll_code/CEP.cs:1010
PHEMlightdll::CEP::_resistanceF0
double _resistanceF0
Definition: cpp/CEP.h:96
PHEMlightdll::CEP::CalcPower
double CalcPower(double speed, double acc, double gradient)
Definition: cpp/CEP.cpp:200
PHEMlightdll::CEP::GetCO2Emission
double GetCO2Emission(double _FC, double _CO, double _HC, Helpers *VehicleClass)
Definition: cpp/CEP.cpp:291
PHEMlightdll::CEP::_pNormV0
double _pNormV0
Definition: cpp/CEP.h:103
PHEMlightdll::CEP.CheckClass
static bool CheckClass(CEP[] cps)
Definition: V5/cs/CEP.cs:1158
PHEMlightdll::CEP::Interpolate
double Interpolate(double px, double p1, double p2, double e1, double e2)
Definition: cpp/CEP.cpp:412
PHEMlightdll::CEP::_engineIdlingSpeed
double _engineIdlingSpeed
Definition: cpp/CEP.h:109
PHEMlightdll::CEP.CalcfCValMix
bool CalcfCValMix(ref double _fCBr, ref double _fCHC, ref double _fCCO, ref double _fCCO2, Helpers VehicleClass)
Definition: V5/cs/CEP.cs:563
PHEMlightdll::CEP::_engineRatedSpeed
double _engineRatedSpeed
Definition: cpp/CEP.h:108
PHEMlightdll::CEP::_cepCurvePollutants
std::map< std::string, std::vector< double > > _cepCurvePollutants
Definition: cpp/CEP.h:122
PHEMlightdll::CEP::_massVehicle
double _massVehicle
Definition: cpp/CEP.h:91
PHEMlightdll::CEP.CEP
CEP(bool heavyVehicle, double vehicleMass, double vehicleLoading, double vehicleMassRot, double crossArea, double cWValue, double f0, double f1, double f2, double f3, double f4, double axleRatio, double auxPower, double ratedPower, double engineIdlingSpeed, double engineRatedSpeed, double effictiveWheelDiameter, double pNormV0, double pNormP0, double pNormV1, double pNormP1)
Definition: V5/cs/CEP.cs:193
PHEMlightdll::CEP.CalcPower
double CalcPower(double speed, double acc, double gradient, bool HBEV)
Definition: V5/cs/CEP.cs:304
PHEMlightdll::CEP.GetDecelCoast
double GetDecelCoast(double speed, double acc, double gradient)
Definition: V5/cs/CEP.cs:644
PHEMlightdll::CEP::_resistanceF1
double _resistanceF1
Definition: cpp/CEP.h:97
PHEMlightdll::CEP::_vehicleMassRot
double _vehicleMassRot
Definition: cpp/CEP.h:93
PHEMlightdll::Constants::strBEV
static const std::string strBEV
Definition: cpp/Constants.h:63
PHEMlightdll::Constants::AIR_DENSITY_CONST
static const double AIR_DENSITY_CONST
Definition: cpp/Constants.h:35
PHEMlightdll::Constants::SPEED_DCEL_MIN
static const double SPEED_DCEL_MIN
Definition: cpp/Constants.h:38
PHEMlightdll::Constants::strLPG
static const std::string strLPG
Definition: cpp/Constants.h:61
PHEMlightdll::Constants::ZERO_SPEED_ACCURACY
static const double ZERO_SPEED_ACCURACY
Definition: cpp/Constants.h:39
PHEMlightdll::Constants::GRAVITY_CONST
static const double GRAVITY_CONST
Definition: cpp/Constants.h:34
PHEMlightdll::Constants::strDiesel
static const std::string strDiesel
Definition: cpp/Constants.h:59
PHEMlightdll::Constants.SPEED_ROTATIONAL_INCREMENT
const double SPEED_ROTATIONAL_INCREMENT
Definition: dll_code/Constants.cs:24
PHEMlightdll::Constants::HeavyVehicle
static const std::string HeavyVehicle
Definition: cpp/Constants.h:44
PHEMlightdll::Constants.POWER_POLLUTANT_INCREMENT
const double POWER_POLLUTANT_INCREMENT
Definition: dll_code/Constants.cs:26
PHEMlightdll::Constants::NORMALIZING_ACCELARATION
static const double NORMALIZING_ACCELARATION
Definition: cpp/Constants.h:37
PHEMlightdll::Constants._DRIVE_TRAIN_EFFICIENCY
static double _DRIVE_TRAIN_EFFICIENCY
Definition: dll_code/Constants.cs:73
PHEMlightdll::Constants::strHybrid
static const std::string strHybrid
Definition: cpp/Constants.h:62
PHEMlightdll::Constants::strGasoline
static const std::string strGasoline
Definition: cpp/Constants.h:58
PHEMlightdll::Constants::strCNG
static const std::string strCNG
Definition: cpp/Constants.h:60
PHEMlightdll::Constants::NORMALIZING_SPEED
static const double NORMALIZING_SPEED
Definition: cpp/Constants.h:36
PHEMlightdll::Constants.DRIVE_TRAIN_EFFICIENCY
static double DRIVE_TRAIN_EFFICIENCY
Definition: dll_code/Constants.cs:75
Vehicle
C++ TraCI client API implementation.
Definition: Vehicle.h:34