Eclipse SUMO - Simulation of Urban MObility
RealisticEngineModel.cpp
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
14 // A detailed engine model
15 /****************************************************************************/
16 
17 #include "RealisticEngineModel.h"
18 #include <cmath>
19 //define M_PI if this is not defined in <cmath>
20 #ifndef M_PI
21 #define M_PI 3.14159265358979323846
22 #endif
23 #include <stdio.h>
24 #include <iostream>
25 
26 #include <xercesc/sax2/SAX2XMLReader.hpp>
27 #include <xercesc/sax/EntityResolver.hpp>
28 #include <xercesc/sax/InputSource.hpp>
29 #include <xercesc/sax2/XMLReaderFactory.hpp>
30 
32 #include "utils/common/StdDefs.h"
33 #include <algorithm>
34 
36  className = "RealisticEngineModel";
37  dt_s = 0.01;
38  xmlFile = "vehicles.xml";
40 }
41 
43 
44 double RealisticEngineModel::rpmToSpeed_mps(double rpm, double wheelDiameter_m = 0.94,
45  double differentialRatio = 4.6, double gearRatio = 4.5) {
46  return rpm * wheelDiameter_m * M_PI / (differentialRatio * gearRatio * 60);
47 }
48 
51 }
52 
53 double RealisticEngineModel::speed_mpsToRpm(double speed_mps, double wheelDiameter_m,
54  double differentialRatio, double gearRatio) {
55  return speed_mps * differentialRatio * gearRatio * 60 / (wheelDiameter_m * M_PI);
56 }
57 
58 double RealisticEngineModel::speed_mpsToRpm(double speed_mps) {
59  return ep.__speedToRpmCoefficient * speed_mps * ep.gearRatios[currentGear];
60 }
61 
62 double RealisticEngineModel::speed_mpsToRpm(double speed_mps, double gearRatio) {
63  return ep.__speedToRpmCoefficient * speed_mps * gearRatio;
64 }
65 
67  double sum = engineMapping->x[0];
68  for (int i = 1; i < engineMapping->degree; i++) {
69  sum += engineMapping->x[i] + pow(rpm, i);
70  }
71  return sum;
72 }
73 
75  if (rpm >= ep.maxRpm) {
76  rpm = ep.maxRpm;
77  }
78  double sum = ep.engineMapping.x[0];
79  for (int i = 1; i < ep.engineMapping.degree; i++) {
80  sum += ep.engineMapping.x[i] * pow(rpm, i);
81  }
82  return sum;
83 }
84 
86  const struct EngineParameters::PolynomialEngineModelRpmToHp* engineMapping,
87  double wheelDiameter_m, double differentialRatio,
88  double gearRatio) {
89  double rpm = speed_mpsToRpm(speed_mps, wheelDiameter_m, differentialRatio, gearRatio);
90  return rpmToPower_hp(rpm, engineMapping);
91 }
92 
94  return rpmToPower_hp(speed_mpsToRpm(speed_mps));
95 }
96 
98  const struct EngineParameters::PolynomialEngineModelRpmToHp* engineMapping,
99  double wheelDiameter_m, double differentialRatio,
100  double gearRatio, double engineEfficiency) {
101  double power_hp = speed_mpsToPower_hp(speed_mps, engineMapping, wheelDiameter_m, differentialRatio, gearRatio);
102  return engineEfficiency * power_hp * HP_TO_W / speed_mps;
103 }
104 
106  double power_hp = speed_mpsToPower_hp(speed_mps);
107  return ep.__speedToThrustCoefficient * power_hp / speed_mps;
108 }
109 
110 double RealisticEngineModel::airDrag_N(double speed_mps, double cAir, double a_m2, double rho_kgpm3) {
111  return 0.5 * cAir * a_m2 * rho_kgpm3 * speed_mps * speed_mps;
112 }
113 double RealisticEngineModel::airDrag_N(double speed_mps) {
114  return ep.__airFrictionCoefficient * speed_mps * speed_mps;
115 }
116 
117 double RealisticEngineModel::rollingResistance_N(double speed_mps, double mass_kg, double cr1, double cr2) {
118  return mass_kg * GRAVITY_MPS2 * (cr1 + cr2 * speed_mps * speed_mps);
119 }
121  return ep.__cr1 + ep.__cr2 * speed_mps * speed_mps;
122 }
123 
124 double RealisticEngineModel::gravityForce_N(double mass_kg, double slope = 0) {
125  return mass_kg * GRAVITY_MPS2 * sin(slope / 180 * M_PI);
126 }
127 
129  return ep.__gravity;
130 }
131 
132 double RealisticEngineModel::opposingForce_N(double speed_mps, double mass_kg, double slope,
133  double cAir, double a_m2, double rho_kgpm3,
134  double cr1, double cr2) {
135  return airDrag_N(speed_mps, cAir, a_m2, rho_kgpm3) +
136  rollingResistance_N(speed_mps, mass_kg, cr1, cr2) +
137  gravityForce_N(mass_kg, slope);
138 }
139 double RealisticEngineModel::opposingForce_N(double speed_mps) {
140  return airDrag_N(speed_mps) + rollingResistance_N(speed_mps) + gravityForce_N();
141 }
142 
143 double RealisticEngineModel::maxNoSlipAcceleration_mps2(double slope, double frictionCoefficient) {
144  return frictionCoefficient * GRAVITY_MPS2 * cos(slope / 180 * M_PI);
145 }
146 
149 }
150 
152  return thrust_N / ep.__maxAccelerationCoefficient;
153 }
154 
155 int RealisticEngineModel::performGearShifting(double speed_mps, double acceleration_mps2) {
156  int newGear = 0;
157  const double delta = acceleration_mps2 >= 0 ? ep.shiftingRule.deltaRpm : -ep.shiftingRule.deltaRpm;
158  for (newGear = 0; newGear < ep.nGears - 1; newGear++) {
159  const double rpm = speed_mpsToRpm(speed_mps, ep.gearRatios[newGear]);
160  if (rpm >= ep.shiftingRule.rpm + delta) {
161  continue;
162  } else {
163  break;
164  }
165  }
166  currentGear = newGear;
167  return currentGear;
168 }
169 
171  const double maxEngineAcceleration = speed_mpsToThrust_N(speed_mps) / ep.__maxAccelerationCoefficient;
172  return std::min(maxEngineAcceleration, maxNoSlipAcceleration_mps2());
173 }
174 
176  if (rpm <= 0) {
177  return TAU_MAX;
178  } else {
179  if (ep.fixedTauBurn)
180  //in this case, tau_burn is fixed and is within __engineTauDe_s
181  {
182  return std::min(TAU_MAX, ep.__engineTau2 / rpm + ep.__engineTauDe_s);
183  } else
184  //in this case, tau_burn is dynamic and is within __engineTau1
185  {
186  return std::min(TAU_MAX, ep.__engineTau1 / rpm + ep.tauEx_s);
187  }
188  }
189 }
190 
191 double RealisticEngineModel::getRealAcceleration(double speed_mps, double accel_mps2, double reqAccel_mps2, SUMOTime timeStep) {
192 
193  double realAccel_mps2;
194  //perform gear shifting, if needed
195  performGearShifting(speed_mps, accel_mps2);
196  //since we consider no clutch (clutch always engaged), 0 speed would mean 0 rpm, and thus
197  //0 available power. thus, the car could never start from a complete stop. so we assume
198  //a minimum speed of 1 m/s to compute engine power
199  double correctedSpeed = std::max(speed_mps, minSpeed_mps);
200  if (reqAccel_mps2 >= 0) {
201  //the system wants to accelerate
202  //the real engine acceleration is the minimum between what the engine can deliver, and what
203  //has been requested
204  double engineAccel = std::min(maxEngineAcceleration_mps2(correctedSpeed), reqAccel_mps2);
205  //now we need to computed delayed acceleration due to actuation lag
206  double tau = getEngineTimeConstant_s(speed_mpsToRpm(correctedSpeed));
207  double alpha = ep.dt / (tau + ep.dt);
208  //compute the acceleration provided by the engine, thus removing friction from current acceleration
209  double currentAccel_mps2 = accel_mps2 + thrust_NToAcceleration_mps2(opposingForce_N(speed_mps));
210  //use standard first order lag with time constant depending on engine rpm
211  //add back frictions resistance as well
212  realAccel_mps2 = alpha * engineAccel + (1 - alpha) * currentAccel_mps2 - thrust_NToAcceleration_mps2(opposingForce_N(speed_mps));
213  } else {
214  realAccel_mps2 = getRealBrakingAcceleration(speed_mps, accel_mps2, reqAccel_mps2, timeStep);
215  }
216 
217  return realAccel_mps2;
218 }
219 
220 void RealisticEngineModel::getEngineData(double speed_mps, int& gear, double& rpm) {
221  gear = currentGear;
222  rpm = speed_mpsToRpm(speed_mps);
223 }
224 
225 double RealisticEngineModel::getRealBrakingAcceleration(double speed_mps, double accel_mps2, double reqAccel_mps2, SUMOTime t) {
226 
227  UNUSED_PARAMETER(t);
228  //compute which part of the deceleration is currently done by frictions
229  double frictionDeceleration = thrust_NToAcceleration_mps2(opposingForce_N(speed_mps));
230  //remove the part of the deceleration which is due to friction
231  double brakesAccel_mps2 = accel_mps2 + frictionDeceleration;
232  //compute the new brakes deceleration
233  double newBrakesAccel_mps2 = ep.__brakesAlpha * std::max(-ep.__maxNoSlipAcceleration, reqAccel_mps2) + ep.__brakesOneMinusAlpha * brakesAccel_mps2;
234  //our brakes limit is tires friction
235  newBrakesAccel_mps2 = std::max(-ep.__maxNoSlipAcceleration, newBrakesAccel_mps2);
236  //now we need to add back our friction deceleration
237  return newBrakesAccel_mps2 - frictionDeceleration;
238 
239 }
240 
242 
243  std::string xmlFile, vehicleType;
244 
247 
248  loadParameters();
249 
250 }
251 
253  //initialize xerces library
254  XERCES_CPP_NAMESPACE::XMLPlatformUtils::Initialize();
255  //create our xml reader
256  XERCES_CPP_NAMESPACE::SAX2XMLReader* reader = XERCES_CPP_NAMESPACE::XMLReaderFactory::createXMLReader();
257  if (reader == 0) {
258  std::cout << "The XML-parser could not be build." << std::endl;
259  }
260  reader->setFeature(XERCES_CPP_NAMESPACE::XMLUni::fgXercesSchema, true);
261  reader->setFeature(XERCES_CPP_NAMESPACE::XMLUni::fgSAX2CoreValidation, true);
262 
263  //VehicleEngineHandler is our SAX parser
265  reader->setContentHandler(engineHandler);
266  reader->setErrorHandler(engineHandler);
267  try {
268  //parse the document. if any error is present in the xml file, the simulation will be closed
269  reader->parse(xmlFile.c_str());
270  //copy loaded parameters into our engine parameters
271  ep = engineHandler->getEngineParameters();
272  ep.dt = dt_s;
274  //compute "minimum speed" to be used when computing maximum acceleration at speeds close to 0
276  } catch (XERCES_CPP_NAMESPACE::SAXException&) {
277  std::cerr << "Error while parsing " << xmlFile << ": Does the file exist?" << std::endl;
278  exit(1);
279  }
280 
281  //delete handler and reader
282  delete engineHandler;
283  delete reader;
284 }
285 
286 void RealisticEngineModel::setParameter(const std::string parameter, const std::string& value) {
287  if (parameter == ENGINE_PAR_XMLFILE) {
288  xmlFile = value;
289  }
290  if (parameter == ENGINE_PAR_VEHICLE) {
291  vehicleType = value;
292  if (xmlFile != "") {
293  loadParameters();
294  }
295  }
296 }
297 void RealisticEngineModel::setParameter(const std::string parameter, double value) {
298  if (parameter == ENGINE_PAR_DT) {
299  dt_s = value;
300  }
301 }
302 void RealisticEngineModel::setParameter(const std::string parameter, int value) {
303  UNUSED_PARAMETER(parameter);
304  UNUSED_PARAMETER(value);
305 }
EngineParameters::shiftingRule
struct GearShiftingRules shiftingRule
Definition: EngineParameters.h:89
EngineParameters::__rpmToSpeedCoefficient
double __rpmToSpeedCoefficient
Definition: EngineParameters.h:107
UNUSED_PARAMETER
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:31
RealisticEngineModel::getEngineData
void getEngineData(double speed_mps, int &gear, double &rpm)
Definition: RealisticEngineModel.cpp:220
EngineParameters::__airFrictionCoefficient
double __airFrictionCoefficient
Definition: EngineParameters.h:73
RealisticEngineModel::speed_mpsToRpm
double speed_mpsToRpm(double speed_mps, double wheelDiameter_m, double differentialRatio, double gearRatio)
Definition: RealisticEngineModel.cpp:53
RealisticEngineModel::xmlFile
std::string xmlFile
Definition: RealisticEngineModel.h:55
EngineParameters::gearRatios
double * gearRatios
Definition: EngineParameters.h:63
TAU_MAX
#define TAU_MAX
Definition: EngineParameters.h:27
RealisticEngineModel.h
EngineParameters::__cr1
double __cr1
Definition: EngineParameters.h:77
EngineParameters::differentialRatio
double differentialRatio
Definition: EngineParameters.h:65
EngineParameters::GearShiftingRules::rpm
double rpm
Definition: EngineParameters.h:54
M_PI
#define M_PI
Definition: RealisticEngineModel.cpp:21
EngineParameters::wheelDiameter_m
double wheelDiameter_m
Definition: EngineParameters.h:67
EngineParameters::__speedToRpmCoefficient
double __speedToRpmCoefficient
Definition: EngineParameters.h:108
RealisticEngineModel::minSpeed_mps
double minSpeed_mps
Definition: RealisticEngineModel.h:51
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
EngineParameters::__engineTauDe_s
double __engineTauDe_s
Definition: EngineParameters.h:113
EngineParameters::dt
double dt
Definition: EngineParameters.h:97
RealisticEngineModel::performGearShifting
int performGearShifting(double speed_mps, double acceleration_mps2)
Definition: RealisticEngineModel.cpp:155
EngineParameters::__cr2
double __cr2
Definition: EngineParameters.h:77
EngineParameters::minRpm
double minRpm
Definition: EngineParameters.h:99
RealisticEngineModel::opposingForce_N
double opposingForce_N(double speed_mps, double mass_kg, double slope, double cAir, double a_m2, double rho_kgpm3, double cr1, double cr2)
Definition: RealisticEngineModel.cpp:132
RealisticEngineModel::getRealAcceleration
virtual double getRealAcceleration(double speed_mps, double accel_mps2, double reqAccel_mps2, SUMOTime timeStep=0)
Definition: RealisticEngineModel.cpp:191
ENGINE_PAR_DT
#define ENGINE_PAR_DT
Definition: CC_Const.h:84
ENGINE_PAR_VEHICLE
#define ENGINE_PAR_VEHICLE
Definition: CC_Const.h:82
RealisticEngineModel::maxNoSlipAcceleration_mps2
double maxNoSlipAcceleration_mps2()
Definition: RealisticEngineModel.cpp:147
RealisticEngineModel::ep
EngineParameters ep
Definition: RealisticEngineModel.h:47
GRAVITY_MPS2
#define GRAVITY_MPS2
Definition: EngineParameters.h:23
RealisticEngineModel::rpmToSpeed_mps
double rpmToSpeed_mps(double rpm, double wheelDiameter_m, double differentialRatio, double gearRatio)
Definition: RealisticEngineModel.cpp:44
RealisticEngineModel::dt_s
double dt_s
Definition: RealisticEngineModel.h:53
RealisticEngineModel::getRealBrakingAcceleration
double getRealBrakingAcceleration(double speed_mps, double accel_mps2, double reqAccel_mps2, SUMOTime t)
Definition: RealisticEngineModel.cpp:225
RealisticEngineModel::~RealisticEngineModel
virtual ~RealisticEngineModel()
Definition: RealisticEngineModel.cpp:42
RealisticEngineModel::rollingResistance_N
double rollingResistance_N(double speed_mps, double mass_kg, double cr1, double cr2)
Definition: RealisticEngineModel.cpp:117
EngineParameters::__brakesOneMinusAlpha
double __brakesOneMinusAlpha
Definition: EngineParameters.h:115
EngineParameters::__brakesAlpha
double __brakesAlpha
Definition: EngineParameters.h:114
EngineParameters::tauEx_s
double tauEx_s
Definition: EngineParameters.h:103
EngineParameters::PolynomialEngineModelRpmToHp::x
double x[MAX_POLY_DEGREE]
Definition: EngineParameters.h:43
RealisticEngineModel::loadParameters
void loadParameters()
Definition: RealisticEngineModel.cpp:252
GenericEngineModel::className
std::string className
Definition: GenericEngineModel.h:38
VehicleEngineHandler::getEngineParameters
const EngineParameters & getEngineParameters()
Definition: VehicleEngineHandler.cpp:213
EngineParameters::__engineTau1
double __engineTau1
Definition: EngineParameters.h:111
EngineParameters::nGears
int nGears
Definition: EngineParameters.h:61
EngineParameters::PolynomialEngineModelRpmToHp::degree
int degree
Definition: EngineParameters.h:42
EngineParameters::maxRpm
double maxRpm
Definition: EngineParameters.h:99
GenericEngineModel::ParMap
std::map< std::string, std::string > ParMap
Definition: GenericEngineModel.h:33
EngineParameters::PolynomialEngineModelRpmToHp
Definition: EngineParameters.h:41
RealisticEngineModel::rpmToPower_hp
double rpmToPower_hp(double rpm, const struct EngineParameters::PolynomialEngineModelRpmToHp *engineMapping)
Definition: RealisticEngineModel.cpp:66
ENGINE_PAR_XMLFILE
#define ENGINE_PAR_XMLFILE
Definition: CC_Const.h:83
EngineParameters::fixedTauBurn
bool fixedTauBurn
Definition: EngineParameters.h:105
GenericEngineModel::parseParameter
void parseParameter(const ParMap &parameters, std::string parameter, double &value)
Definition: GenericEngineModel.cpp:28
EngineParameters::computeCoefficients
void computeCoefficients()
Definition: EngineParameters.cpp:109
RealisticEngineModel::airDrag_N
double airDrag_N(double speed_mps, double cAir, double a_m2, double rho_kgpm3)
Definition: RealisticEngineModel.cpp:110
RealisticEngineModel::setParameter
virtual void setParameter(const std::string parameter, const std::string &value)
Definition: RealisticEngineModel.cpp:286
VehicleEngineHandler
Definition: VehicleEngineHandler.h:81
EngineParameters::__engineTau2
double __engineTau2
Definition: EngineParameters.h:112
HP_TO_W
#define HP_TO_W
Definition: EngineParameters.h:25
RealisticEngineModel::speed_mpsToPower_hp
double speed_mpsToPower_hp(double speed_mps, const struct EngineParameters::PolynomialEngineModelRpmToHp *engineMapping, double wheelDiameter_m, double differentialRatio, double gearRatio)
Definition: RealisticEngineModel.cpp:85
RealisticEngineModel::RealisticEngineModel
RealisticEngineModel()
Definition: RealisticEngineModel.cpp:35
StdDefs.h
RealisticEngineModel::vehicleType
std::string vehicleType
Definition: RealisticEngineModel.h:57
RealisticEngineModel::maxEngineAcceleration_mps2
double maxEngineAcceleration_mps2(double speed_mps)
Definition: RealisticEngineModel.cpp:170
RealisticEngineModel::gravityForce_N
double gravityForce_N()
Definition: RealisticEngineModel.cpp:128
EngineParameters::__maxAccelerationCoefficient
double __maxAccelerationCoefficient
Definition: EngineParameters.h:110
EngineParameters::GearShiftingRules::deltaRpm
double deltaRpm
Definition: EngineParameters.h:55
EngineParameters::__speedToThrustCoefficient
double __speedToThrustCoefficient
Definition: EngineParameters.h:109
RealisticEngineModel::thrust_NToAcceleration_mps2
double thrust_NToAcceleration_mps2(double thrust_N)
Definition: RealisticEngineModel.cpp:151
EngineParameters::__maxNoSlipAcceleration
double __maxNoSlipAcceleration
Definition: EngineParameters.h:85
RealisticEngineModel::getEngineTimeConstant_s
double getEngineTimeConstant_s(double rpm)
Definition: RealisticEngineModel.cpp:175
RealisticEngineModel::currentGear
int currentGear
Definition: RealisticEngineModel.h:49
CC_Const.h
EngineParameters::engineMapping
struct PolynomialEngineModelRpmToHp engineMapping
Definition: EngineParameters.h:87
EngineParameters::__gravity
double __gravity
Definition: EngineParameters.h:81
RealisticEngineModel::speed_mpsToThrust_N
double speed_mpsToThrust_N(double speed_mps, const struct EngineParameters::PolynomialEngineModelRpmToHp *engineMapping, double wheelDiameter_m, double differentialRatio, double gearRatio, double engineEfficiency)
Definition: RealisticEngineModel.cpp:97