Eclipse SUMO - Simulation of Urban MObility
MSCFModel_IDM.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-2022 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials are made available under the
5 // terms of the Eclipse Public License 2.0 which is available at
6 // https://www.eclipse.org/legal/epl-2.0/
7 // This Source Code may also be made available under the following Secondary
8 // Licenses when the conditions for such availability set forth in the Eclipse
9 // Public License 2.0 are satisfied: GNU General Public License, version 2
10 // or later which is available at
11 // https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12 // SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13 /****************************************************************************/
20 // The Intelligent Driver Model (IDM) car-following model
21 /****************************************************************************/
22 #include <config.h>
23 
24 #include "MSCFModel_IDM.h"
25 #include <microsim/MSVehicle.h>
26 
27 //#define DEBUG_V
28 //#define DEBUG_INSERTION_SPEED
29 
30 // ===========================================================================
31 // method definitions
32 // ===========================================================================
33 MSCFModel_IDM::MSCFModel_IDM(const MSVehicleType* vtype, bool idmm) :
34  MSCFModel(vtype),
35  myIDMM(idmm),
36  myDelta(idmm ? 4.0 : vtype->getParameter().getCFParam(SUMO_ATTR_CF_IDM_DELTA, 4.)),
37  myAdaptationFactor(idmm ? vtype->getParameter().getCFParam(SUMO_ATTR_CF_IDMM_ADAPT_FACTOR, 1.8) : 1.0),
38  myAdaptationTime(idmm ? vtype->getParameter().getCFParam(SUMO_ATTR_CF_IDMM_ADAPT_TIME, 600.0) : 0.0),
39  myIterations(MAX2(1, int(TS / vtype->getParameter().getCFParam(SUMO_ATTR_CF_IDM_STEPPING, .25) + .5))),
40  myTwoSqrtAccelDecel(double(2 * sqrt(myAccel * myDecel))) {
41  // IDM does not drive very precise and may violate minGap on occasion
43 }
44 
46 
47 
48 double
49 MSCFModel_IDM::finalizeSpeed(MSVehicle* const veh, double vPos) const {
50  const double vNext = MSCFModel::finalizeSpeed(veh, vPos);
51  if (myAdaptationFactor != 1.) {
53  vars->levelOfService += (vNext / veh->getLane()->getVehicleMaxSpeed(veh) - vars->levelOfService) / myAdaptationTime * TS;
54  }
55  return vNext;
56 }
57 
58 
59 double
60 MSCFModel_IDM::freeSpeed(const MSVehicle* const veh, double speed, double seen, double maxSpeed, const bool /*onInsertion*/) const {
61  if (maxSpeed < 0.) {
62  // can occur for ballistic update (in context of driving at red light)
63  return maxSpeed;
64  }
65  const double secGap = getSecureGap(veh, nullptr, maxSpeed, 0, myDecel);
66  double vSafe;
67  if (speed <= maxSpeed) {
68  // accelerate
69  vSafe = _v(veh, 1e6, speed, maxSpeed, veh->getLane()->getVehicleMaxSpeed(veh), false);
70  } else {
71  // decelerate
72  // @note relax gap to avoid emergency braking
73  // @note since the transition point does not move we set the leader speed to 0
74  vSafe = _v(veh, MAX2(seen, secGap), speed, 0, veh->getLane()->getVehicleMaxSpeed(veh), false);
75  }
76  if (seen < secGap) {
77  // avoid overshoot when close to change in speed limit
78  vSafe = MIN2(vSafe, maxSpeed);
79  }
80  //std::cout << SIMTIME << " speed=" << speed << " maxSpeed=" << maxSpeed << " seen=" << seen << " secGap=" << secGap << " vSafe=" << vSafe << "\n";
81  return vSafe;
82 }
83 
84 
85 double
86 MSCFModel_IDM::followSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred) const {
87  applyHeadwayAndSpeedDifferencePerceptionErrors(veh, speed, gap2pred, predSpeed, predMaxDecel, pred);
88 #ifdef DEBUG_V
89  gDebugFlag1 = veh->isSelected();
90 #endif
91  return _v(veh, gap2pred, speed, predSpeed, veh->getLane()->getVehicleMaxSpeed(veh));
92 }
93 
94 
95 double
96 MSCFModel_IDM::insertionFollowSpeed(const MSVehicle* const v, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred) const {
97  // see definition of s in _v()
98  double s = MAX2(0., speed * myHeadwayTime + speed * (speed - predSpeed) / myTwoSqrtAccelDecel);
99  if (gap2pred >= s) {
100  // followSpeed always stays below speed because s*s / (gap2pred * gap2pred) > 0. This would prevent insertion with maximum speed at all distances
101  return speed;
102  } else {
103  // we cannot call follow speed directly because it assumes that 'speed'
104  // is the current speed rather than the desired insertion speed.
105  // If the safe speed is much lower than the desired speed, the
106  // followSpeed function would still return a new speed that involves
107  // reasonable braking rather than the actual safe speed (and cause
108  // emergency braking in a subsequent step)
109  const double speed2 = followSpeed(v, speed, gap2pred, predSpeed, predMaxDecel);
110  const double speed3 = followSpeed(v, speed2, gap2pred, predSpeed, predMaxDecel);
111  if (speed2 - speed3 < 1) {
112  return speed2;
113  } else {
114 #ifdef DEBUG_INSERTION_SPEED
115  std::cout << SIMTIME << " veh=" << v->getID() << " speed=" << speed << " gap2pred=" << gap2pred << " predSpeed=" << predSpeed << " predMaxDecel=" << predMaxDecel << " pred=" << Named::getIDSecure(pred) << " s=" << s << " speed2=" << speed2 << " speed3=" << speed3 << "\n";
116 #endif
117  return insertionFollowSpeed(v, speed2, gap2pred, predSpeed, predMaxDecel, pred);
118  }
119  }
120 }
121 
122 
123 double
124 MSCFModel_IDM::stopSpeed(const MSVehicle* const veh, const double speed, double gap, double decel) const {
125  applyHeadwayPerceptionError(veh, speed, gap);
126  if (gap < 0.01) {
127  return 0;
128  }
129  double result = _v(veh, gap, speed, 0, veh->getLane()->getVehicleMaxSpeed(veh));
130  if (gap > 0 && speed < NUMERICAL_EPS && result < NUMERICAL_EPS) {
131  // ensure that stops can be reached:
132  //std::cout << " switching to krauss: " << veh->getID() << " gap=" << gap << " speed=" << speed << " res1=" << result << " res2=" << maximumSafeStopSpeed(gap, speed, false, veh->getActionStepLengthSecs())<< "\n";
133  result = maximumSafeStopSpeed(gap, decel, speed, false, veh->getActionStepLengthSecs());
134  }
135  //if (result * TS > gap) {
136  // std::cout << "Maximum stop speed exceeded for gap=" << gap << " result=" << result << " veh=" << veh->getID() << " speed=" << speed << " t=" << SIMTIME << "\n";
137  //}
138  return result;
139 }
140 
141 
143 double
144 MSCFModel_IDM::interactionGap(const MSVehicle* const veh, double vL) const {
145  // Resolve the IDM equation to gap. Assume predecessor has
146  // speed != 0 and that vsafe will be the current speed plus acceleration,
147  // i.e that with this gap there will be no interaction.
148  const double acc = myAccel * (1. - pow(veh->getSpeed() / veh->getLane()->getVehicleMaxSpeed(veh), myDelta));
149  const double vNext = veh->getSpeed() + acc;
150  const double gap = (vNext - vL) * (veh->getSpeed() + vL) / (2 * myDecel) + vL;
151 
152  // Don't allow timeHeadWay < deltaT situations.
153  return MAX2(gap, SPEED2DIST(vNext));
154 }
155 
156 double
157 MSCFModel_IDM::getSecureGap(const MSVehicle* const /*veh*/, const MSVehicle* const /*pred*/, const double speed, const double leaderSpeed, const double /*leaderMaxDecel*/) const {
158  const double delta_v = speed - leaderSpeed;
159  return MAX2(0.0, speed * myHeadwayTime + speed * delta_v / myTwoSqrtAccelDecel);
160 }
161 
162 
163 double
164 MSCFModel_IDM::_v(const MSVehicle* const veh, const double gap2pred, const double egoSpeed,
165  const double predSpeed, const double desSpeed, const bool respectMinGap) const {
166 // this is more or less based on http://www.vwi.tu-dresden.de/~treiber/MicroApplet/IDM.html
167 // and http://arxiv.org/abs/cond-mat/0304337
168 // we assume however constant speed for the leader
169  double headwayTime = myHeadwayTime;
170  if (myAdaptationFactor != 1.) {
172  headwayTime *= myAdaptationFactor + vars->levelOfService * (1. - myAdaptationFactor);
173  }
174  double newSpeed = egoSpeed;
175  double gap = gap2pred;
176  if (respectMinGap) {
177  // gap2pred comes with minGap already subtracted so we need to add it here again
178  gap += myType->getMinGap();
179  }
180  for (int i = 0; i < myIterations; i++) {
181  const double delta_v = newSpeed - predSpeed;
182  double s = MAX2(0., newSpeed * headwayTime + newSpeed * delta_v / myTwoSqrtAccelDecel);
183  if (respectMinGap) {
184  s += myType->getMinGap();
185  }
186  gap = MAX2(NUMERICAL_EPS, gap); // avoid singularity
187  const double acc = myAccel * (1. - pow(newSpeed / desSpeed, myDelta) - (s * s) / (gap * gap));
188 #ifdef DEBUG_V
189  if (gDebugFlag1) {
190  std::cout << " gap=" << gap << " t=" << myHeadwayTime << " t2=" << headwayTime << " s=" << s << " pow=" << pow(newSpeed / desSpeed, myDelta) << " gapDecel=" << (s * s) / (gap * gap) << " a=" << acc;
191  }
192 #endif
193  newSpeed = MAX2(0.0, newSpeed + ACCEL2SPEED(acc) / myIterations);
194 #ifdef DEBUG_V
195  if (gDebugFlag1) {
196  std::cout << " v2=" << newSpeed << "\n";
197  }
198 #endif
199  //TODO use more realistic position update which takes accelerated motion into account
200  gap -= MAX2(0., SPEED2DIST(newSpeed - predSpeed) / myIterations);
201  }
202  return MAX2(0., newSpeed);
203 }
204 
205 
206 MSCFModel*
208  return new MSCFModel_IDM(vtype, myIDMM);
209 }
#define SPEED2DIST(x)
Definition: SUMOTime.h:43
#define ACCEL2SPEED(x)
Definition: SUMOTime.h:49
#define TS
Definition: SUMOTime.h:40
#define SIMTIME
Definition: SUMOTime.h:60
@ SUMO_ATTR_CF_IDMM_ADAPT_TIME
@ SUMO_ATTR_CF_IDM_DELTA
@ SUMO_ATTR_CF_IDM_STEPPING
@ SUMO_ATTR_CF_IDMM_ADAPT_FACTOR
@ SUMO_ATTR_COLLISION_MINGAP_FACTOR
bool gDebugFlag1
global utility flags for debugging
Definition: StdDefs.cpp:32
T MIN2(T a, T b)
Definition: StdDefs.h:74
T MAX2(T a, T b)
Definition: StdDefs.h:80
virtual bool isSelected() const
whether this vehicle is selected in the GUI
double levelOfService
state variable for remembering speed deviation history (lambda)
const int myIterations
The number of iterations in speed calculations.
double finalizeSpeed(MSVehicle *const veh, double vPos) const
Applies interaction with stops and lane changing model influences.
~MSCFModel_IDM()
Destructor.
const bool myIDMM
whether the model is IDMM or IDM
double getSecureGap(const MSVehicle *const veh, const MSVehicle *const pred, const double speed, const double leaderSpeed, const double leaderMaxDecel) const
Returns the minimum gap to reserve if the leader is braking at maximum (>=0)
MSCFModel_IDM(const MSVehicleType *vtype, bool idmm)
Constructor.
double insertionFollowSpeed(const MSVehicle *const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle *const pred=0) const
Computes the vehicle's safe speed (no dawdling) This method is used during the insertion stage....
virtual double freeSpeed(const MSVehicle *const veh, double speed, double seen, double maxSpeed, const bool onInsertion=false) const
Computes the vehicle's safe speed without a leader.
const double myAdaptationTime
The IDMM adaptation time tau.
double followSpeed(const MSVehicle *const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle *const pred=0) const
Computes the vehicle's safe speed (no dawdling)
MSCFModel * duplicate(const MSVehicleType *vtype) const
Duplicates the car-following model.
const double myTwoSqrtAccelDecel
A computational shortcut.
const double myAdaptationFactor
The IDMM adaptation factor beta.
const double myDelta
The IDM delta exponent.
double _v(const MSVehicle *const veh, const double gap2pred, const double mySpeed, const double predSpeed, const double desSpeed, const bool respectMinGap=true) const
double interactionGap(const MSVehicle *const, double vL) const
Returns the maximum gap at which an interaction between both vehicles occurs.
double stopSpeed(const MSVehicle *const veh, const double speed, double gap, double decel) const
Computes the vehicle's safe speed for approaching a non-moving obstacle (no dawdling)
The car-following model abstraction.
Definition: MSCFModel.h:55
double maximumSafeStopSpeed(double gap, double decel, double currentSpeed, bool onInsertion=false, double headway=-1) const
Returns the maximum next velocity for stopping within gap.
Definition: MSCFModel.cpp:716
void applyHeadwayPerceptionError(const MSVehicle *const veh, double speed, double &gap) const
Overwrites gap by the perceived value obtained from the vehicle's driver state.
Definition: MSCFModel.cpp:1023
virtual double finalizeSpeed(MSVehicle *const veh, double vPos) const
Applies interaction with stops and lane changing model influences. Called at most once per simulation...
Definition: MSCFModel.cpp:163
void applyHeadwayAndSpeedDifferencePerceptionErrors(const MSVehicle *const veh, double speed, double &gap, double &predSpeed, double predMaxDecel, const MSVehicle *const pred) const
Overwrites gap2pred and predSpeed by the perceived values obtained from the vehicle's driver state,...
Definition: MSCFModel.cpp:987
double myCollisionMinGapFactor
The factor of minGap that must be maintained to avoid a collision event.
Definition: MSCFModel.h:653
double myDecel
The vehicle's maximum deceleration [m/s^2].
Definition: MSCFModel.h:647
double myAccel
The vehicle's maximum acceleration [m/s^2].
Definition: MSCFModel.h:644
const MSVehicleType * myType
The type to which this model definition belongs to.
Definition: MSCFModel.h:641
double myHeadwayTime
The driver's desired time headway (aka reaction time tau) [s].
Definition: MSCFModel.h:656
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: MSLane.h:519
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:75
double getActionStepLengthSecs() const
Returns the vehicle's action step length in secs, i.e. the interval between two action points.
Definition: MSVehicle.h:504
MSCFModel::VehicleVariables * getCarFollowVariables() const
Returns the vehicle's car following model variables.
Definition: MSVehicle.h:934
double getSpeed() const
Returns the vehicle's current speed.
Definition: MSVehicle.h:462
const MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:552
The car-following model and parameter.
Definition: MSVehicleType.h:62
double getMinGap() const
Get the free space in front of vehicles of this class.
const SUMOVTypeParameter & getParameter() const
static std::string getIDSecure(const T *obj, const std::string &fallBack="NULL")
get an identifier for Named-like object which may be Null
Definition: Named.h:67
const std::string & getID() const
Returns the id.
Definition: Named.h:74
double getCFParam(const SumoXMLAttr attr, const double defaultValue) const
Returns the named value from the map, or the default if it is not contained there.