Eclipse SUMO - Simulation of Urban MObility
MSCFModel_CACC.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-2020 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 /****************************************************************************/
19 // CACC car-following model based on [1], [2].
20 // [1] Milanes, V., and S. E. Shladover. Handling Cut-In Vehicles in Strings
21 // of Cooperative Adaptive Cruise Control Vehicles. Journal of Intelligent
22 // Transportation Systems, Vol. 20, No. 2, 2015, pp. 178-191.
23 // [2] Xiao, L., M. Wang and B. van Arem. Realistic Car-Following Models for
24 // Microscopic Simulation of Adaptive and Cooperative Adaptive Cruise
25 // Control Vehicles. Transportation Research Record: Journal of the
26 // Transportation Research Board, No. 2623, 2017. (DOI: 10.3141/2623-01).
27 /****************************************************************************/
28 #include <config.h>
29 
30 #include <stdio.h>
31 #include <iostream>
32 
33 #include "MSCFModel_CACC.h"
34 #include <microsim/MSVehicle.h>
35 #include <microsim/MSLane.h>
37 #include <utils/common/SUMOTime.h>
40 #include <math.h>
41 #include <microsim/MSNet.h>
42 
43 // ===========================================================================
44 // debug flags
45 // ===========================================================================
46 #define DEBUG_CACC 0
47 #define DEBUG_CACC_INSERTION_FOLLOW_SPEED 0
48 #define DEBUG_CACC_SECURE_GAP 0
49 #define DEBUG_COND (veh->isSelected())
50 //#define DEBUG_COND (veh->getID() == "flow.0")
51 //#define DEBUG_COND (veh->getID() == "CVflowToC2.11")
52 
53 
54 // ===========================================================================
55 // defaults
56 // ===========================================================================
57 #define DEFAULT_SC_GAIN_CACC -0.4
58 #define DEFAULT_GCC_GAIN_GAP_CACC 0.005
59 #define DEFAULT_GCC_GAIN_GAP_DOT_CACC 0.05
60 #define DEFAULT_GC_GAIN_GAP_CACC 0.45
61 #define DEFAULT_GC_GAIN_GAP_DOT_CACC 0.0125
62 #define DEFAULT_CA_GAIN_GAP_CACC 0.45
63 #define DEFAULT_CA_GAIN_GAP_DOT_CACC 0.05
64 #define DEFAULT_HEADWAYTIME_ACC 1.0
65 
66 // override followSpeed when deemed unsafe by the given margin (the value was selected to reduce the number of necessary interventions)
67 #define DEFAULT_EMERGENCY_OVERRIDE_THRESHOLD 2.0
68 
69 std::map<std::string, MSCFModel_CACC::CommunicationsOverrideMode> MSCFModel_CACC::CommunicationsOverrideModeMap = {
70  {"0", CACC_NO_OVERRIDE},
71  {"1", CACC_MODE_NO_LEADER},
72  {"2", CACC_MODE_LEADER_NO_CAV},
73  {"3", CACC_MODE_LEADER_CAV}
74 };
75 
76 std::map<MSCFModel_CACC::VehicleMode, std::string> MSCFModel_CACC::VehicleModeNames = {
77  {CC_MODE, "CC"},
78  {ACC_MODE, "ACC"},
79  {CACC_GAP_CLOSING_MODE, "CACC_GAP_CL"},
80  {CACC_GAP_MODE, "CACC_GAP"},
81  {CACC_COLLISION_AVOIDANCE_MODE, "CACC_CA"}
82 };
83 
84 // ===========================================================================
85 // method definitions
86 // ===========================================================================
88  MSCFModel(vtype), acc_CFM(MSCFModel_ACC(vtype)),
89  mySpeedControlGain(vtype->getParameter().getCFParam(SUMO_ATTR_SC_GAIN_CACC, DEFAULT_SC_GAIN_CACC)),
90  myGapClosingControlGainGap(vtype->getParameter().getCFParam(SUMO_ATTR_GCC_GAIN_GAP_CACC, DEFAULT_GCC_GAIN_GAP_CACC)),
91  myGapClosingControlGainGapDot(vtype->getParameter().getCFParam(SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC, DEFAULT_GCC_GAIN_GAP_DOT_CACC)),
92  myGapControlGainGap(vtype->getParameter().getCFParam(SUMO_ATTR_GC_GAIN_GAP_CACC, DEFAULT_GC_GAIN_GAP_CACC)),
93  myGapControlGainGapDot(vtype->getParameter().getCFParam(SUMO_ATTR_GC_GAIN_GAP_DOT_CACC, DEFAULT_GC_GAIN_GAP_DOT_CACC)),
94  myCollisionAvoidanceGainGap(vtype->getParameter().getCFParam(SUMO_ATTR_CA_GAIN_GAP_CACC, DEFAULT_CA_GAIN_GAP_CACC)),
95  myCollisionAvoidanceGainGapDot(vtype->getParameter().getCFParam(SUMO_ATTR_CA_GAIN_GAP_DOT_CACC, DEFAULT_CA_GAIN_GAP_DOT_CACC)),
96  myHeadwayTimeACC(vtype->getParameter().getCFParam(SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC, DEFAULT_HEADWAYTIME_ACC)) {
99 }
100 
102 
103 double
104 MSCFModel_CACC::freeSpeed(const MSVehicle* const veh, double speed, double seen, double maxSpeed, const bool onInsertion) const {
105  // set "caccVehicleMode" parameter to default value
106  if (!MSGlobals::gComputeLC) {
107  const_cast<SUMOVehicleParameter&>(veh->getParameter()).setParameter("caccVehicleMode", VehicleModeNames[CC_MODE]);
108  }
109  return MSCFModel::freeSpeed(veh, speed, seen, maxSpeed, onInsertion);
110 }
111 
112 double
113 MSCFModel_CACC::followSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred) const {
114 
115  const double desSpeed = veh->getLane()->getVehicleMaxSpeed(veh);
116  const double vCACC = _v(veh, pred, gap2pred, speed, predSpeed, desSpeed, true);
117  const double vSafe = maximumSafeFollowSpeed(gap2pred, speed, predSpeed, predMaxDecel);
118 
119 #if DEBUG_CACC == 1
120  if (DEBUG_COND) {
121  std::cout << SIMTIME << " veh=" << veh->getID() << " pred=" << Named::getIDSecure(pred)
122  << " v=" << speed << " vL=" << predSpeed << " gap=" << gap2pred
123  << " predDecel=" << predMaxDecel << " vCACC=" << vCACC << " vSafe=" << vSafe << "\n";
124  }
125 #else
126  UNUSED_PARAMETER(pred);
127 #endif
128  const double speedOverride = MIN2(DEFAULT_EMERGENCY_OVERRIDE_THRESHOLD, gap2pred);
129  if (vSafe + speedOverride < vCACC) {
130 #if DEBUG_CACC == 1
131  if (DEBUG_COND) {
132  std::cout << "Apply Safe speed, override=" << speedOverride << "\n";
133  }
134 #endif
135  return vSafe + speedOverride;
136  }
137  return vCACC;
138 }
139 
140 double
141 MSCFModel_CACC::stopSpeed(const MSVehicle* const veh, const double speed, double gap) const {
142 
143  // NOTE: This allows return of smaller values than minNextSpeed().
144  // Only relevant for the ballistic update: We give the argument headway=TS, to assure that
145  // the stopping position is approached with a uniform deceleration also for tau!=TS.
146  return MIN2(maximumSafeStopSpeed(gap, speed, false, veh->getActionStepLengthSecs()), maxNextSpeed(speed, veh));
147 }
148 
149 double
150 MSCFModel_CACC::getSecureGap(const MSVehicle* const veh, const MSVehicle* const pred, const double speed, const double leaderSpeed, const double leaderMaxDecel) const {
151  // Accel in gap mode should vanish:
152  double desSpacing;
153  if (pred->getCarFollowModel().getModelID() != SUMO_TAG_CF_CACC) {
154  // 0 = myGapControlGainSpeed * (leaderSpeed - speed) + myGapControlGainSpace * (g - myHeadwayTime * speed);
155  // <=> myGapControlGainSpace * g = - myGapControlGainSpeed * (leaderSpeed - speed) + myGapControlGainSpace * myHeadwayTime * speed;
156  // <=> g = - myGapControlGainSpeed * (leaderSpeed - speed) / myGapControlGainSpace + myHeadwayTime * speed;
157  desSpacing = acc_CFM.myGapControlGainSpeed * (speed - leaderSpeed) / acc_CFM.myGapControlGainSpace + myHeadwayTimeACC * speed; // MSCFModel_ACC::accelGapControl
158  } else {
159  desSpacing = myHeadwayTime * speed; // speedGapControl
160  }
161  const double desSpacingDefault = MSCFModel::getSecureGap(veh, pred, speed, leaderSpeed, leaderMaxDecel);
162 #if DEBUG_CACC_SECURE_GAP == 1
163  std::cout << SIMTIME << "MSCFModel_ACC::getSecureGap speed=" << speed << " leaderSpeed=" << leaderSpeed
164  << " desSpacing=" << desSpacing << " desSpacingDefault=" << desSpacingDefault << "\n";
165 #endif
166  return MAX2(desSpacing, desSpacingDefault);
167 }
168 
169 
170 double
171 MSCFModel_CACC::insertionFollowSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred) const {
172 #if DEBUG_CACC_INSERTION_FOLLOW_SPEED == 1
173  if (DEBUG_COND) {
174  std::cout << "MSCFModel_ACC::insertionFollowSpeed(), speed=" << speed << " gap2pred=" << gap2pred << " predSpeed=" << predSpeed << "\n";
175  }
176 #endif
177  // iterate to find a stationary value for
178  // speed = followSpeed(v, speed, gap2pred, predSpeed, predMaxDecel, nullptr)
179  const int max_iter = 50;
180  int n_iter = 0;
181  const double tol = 0.1;
182  double damping = 0.8;
183 
184  double res = speed;
185  while (n_iter < max_iter) {
186  // proposed acceleration
187  const double vCACC = _v(veh, pred, gap2pred, res, predSpeed, speed, true);
188  const double vSafe = maximumSafeFollowSpeed(gap2pred, res, predSpeed, predMaxDecel, true);
189  const double a = MIN2(vCACC, vSafe) - res;
190  res = res + damping * a;
191 #if DEBUG_CACC_INSERTION_FOLLOW_SPEED == 1
192  if (DEBUG_COND) {
193  std::cout << " n_iter=" << n_iter << " vSafe=" << vSafe << " vCACC=" << vCACC << " a=" << a << " damping=" << damping << " res=" << res << std::endl;
194  }
195 #endif
196  damping *= 0.9;
197  if (fabs(a) < tol) {
198  break;
199  } else {
200  n_iter++;
201  }
202  }
203  return res;
204 }
205 
206 
207 
208 
210 double
211 MSCFModel_CACC::interactionGap(const MSVehicle* const /* veh */, double /* vL */) const {
212  /*maximum radar range is CACC is enabled*/
213  return 250;
214 }
215 
216 
217 std::string
218 MSCFModel_CACC::getParameter(const MSVehicle* veh, const std::string& key) const {
220 
221  if (key.compare("caccCommunicationsOverrideMode") == 0) {
223  }
224 
225  return "";
226 }
227 
228 
229 void
230 MSCFModel_CACC::setParameter(MSVehicle* veh, const std::string& key, const std::string& value) const {
232 
233  try {
234  if (key.compare("caccCommunicationsOverrideMode") == 0) {
236  }
237  } catch (NumberFormatException&) {
238  throw InvalidArgument("Invalid value '" + value + "' for parameter '" + key + "' for vehicle '" + veh->getID() + "'");
239  }
240 }
241 
242 
243 double
244 MSCFModel_CACC::speedSpeedControl(const double speed, double vErr, VehicleMode& vehMode) const {
245  // Speed control law
246  vehMode = CC_MODE;
247  double sclAccel = mySpeedControlGain * vErr;
248  double newSpeed = speed + ACCEL2SPEED(sclAccel);
249  return newSpeed;
250 }
251 
252 double
253 MSCFModel_CACC::speedGapControl(const MSVehicle* const veh, const double gap2pred,
254  const double speed, const double predSpeed, const double desSpeed, double vErr,
255  const MSVehicle* const pred, VehicleMode& vehMode) const {
256  // Gap control law
257  double newSpeed = 0.0;
258 
259  if (pred != nullptr) {
260  if (pred->getCarFollowModel().getModelID() != SUMO_TAG_CF_CACC) {
261  vehMode = ACC_MODE;
262  newSpeed = acc_CFM._v(veh, gap2pred, speed, predSpeed, desSpeed, true);
263 #if DEBUG_CACC == 1
264  if (DEBUG_COND) {
265  std::cout << " acc control mode" << std::endl;
266  }
267 #endif
268  } else {
269 #if DEBUG_CACC == 1
270  if (DEBUG_COND) {
271  std::cout << " CACC control mode" << std::endl;
272  }
273 #endif
274  double desSpacing = myHeadwayTime * speed;
275  double gap = gap2pred - veh->getVehicleType().getMinGap();
276  double spacingErr = gap - desSpacing;
277  double accel = veh->getAcceleration();
278  double spacingErr1 = predSpeed - speed + myHeadwayTime * accel;
279 
280  if ((spacingErr > 0 && spacingErr < 0.2) && (vErr < 0.1)) {
281  // gap mode
282  //newSpeed = speed + 0.45 * spacingErr + 0.0125 *spacingErr1;
283 #if DEBUG_CACC == 1
284  if (DEBUG_COND) {
285  std::cout << " applying gap control" << std::endl;
286  }
287 #endif
288  newSpeed = speed + myGapControlGainGap * spacingErr + myGapControlGainGapDot * spacingErr1;
289 
290  vehMode = CACC_GAP_MODE;
291  } else if (spacingErr < 0) {
292  // collision avoidance mode
293  //newSpeed = speed + 0.45 * spacingErr + 0.05 *spacingErr1;
294 #if DEBUG_CACC == 1
295  if (DEBUG_COND) {
296  std::cout << " applying collision avoidance err=" << spacingErr << " err1=" << spacingErr1 << "\n";
297  }
298 #endif
299  newSpeed = speed + myCollisionAvoidanceGainGap * spacingErr + myCollisionAvoidanceGainGapDot * spacingErr1;
301  } else {
302  // gap closing mode
303 #if DEBUG_CACC == 1
304  if (DEBUG_COND) {
305  std::cout << " applying gap closing" << std::endl;
306  }
307 #endif
308  newSpeed = speed + myGapClosingControlGainGap * spacingErr + myGapClosingControlGainGapDot * spacingErr1;
309 
310  vehMode = CACC_GAP_CLOSING_MODE;
311  }
312  }
313  } else {
314  /* no leader */
315 #if DEBUG_CACC == 1
316  if (DEBUG_COND) {
317  std::cout << " no leader" << std::endl;
318  }
319 #endif
320  newSpeed = speedSpeedControl(speed, vErr, vehMode);
321  }
322 
323  return newSpeed;
324 }
325 
326 double
327 MSCFModel_CACC::_v(const MSVehicle* const veh, const MSVehicle* const pred, const double gap2pred, const double speed,
328  const double predSpeed, const double desSpeed, const bool /* respectMinGap */) const {
329  double newSpeed = 0.0;
330  VehicleMode vehMode = CC_MODE;
331 
332 #if DEBUG_CACC == 1
333  if (DEBUG_COND) {
334  std::cout << SIMTIME << " MSCFModel_CACC::_v() for veh '" << veh->getID()
335  << " gap=" << gap2pred << " speed=" << speed << " predSpeed=" << predSpeed
336  << " desSpeed=" << desSpeed << std::endl;
337  }
338 #endif
339 
340  /* Velocity error */
341  double vErr = speed - desSpeed;
342  bool setControlMode = false;
346  setControlMode = true;
347  }
348 
350 
351  if (commMode == CACC_NO_OVERRIDE) { // old CACC logic (rely on time gap from predecessor)
352  double time_gap = gap2pred / speed;
353 
354  if (time_gap > 2) {
355 #if DEBUG_CACC == 1
356  if (DEBUG_COND) {
357  std::cout << " applying speedControl" << std::endl;
358  }
359 #endif
360  // Find acceleration - Speed control law
361  newSpeed = speedSpeedControl(speed, vErr, vehMode);
362  // Set cl to vehicle parameters
363  if (setControlMode) {
364  vars->CACC_ControlMode = 0;
365  }
366  } else if (time_gap < 1.5) {
367  // Find acceleration - Gap control law
368 #if DEBUG_CACC == 1
369  if (DEBUG_COND) {
370  std::cout << " speedGapControl" << std::endl;
371  }
372 #endif
373 
374  newSpeed = speedGapControl(veh, gap2pred, speed, predSpeed, desSpeed, vErr, pred, vehMode);
375  // Set cl to vehicle parameters
376  if (setControlMode) {
377  vars->CACC_ControlMode = 1;
378  }
379  } else {
380  // Follow previous applied law
381  int cm = vars->CACC_ControlMode;
382  if (!cm) {
383  // CACC_ControlMode = speed control
384 
385 #if DEBUG_CACC == 1
386  if (DEBUG_COND) {
387  std::cout << " applying speedControl (previous)" << std::endl;
388  }
389 #endif
390  newSpeed = speedSpeedControl(speed, vErr, vehMode);
391  } else {
392  // CACC_ControlMode = gap control
393 #if DEBUG_CACC == 1
394  if (DEBUG_COND) {
395  std::cout << " previous speedGapControl (previous)" << std::endl;
396  }
397 #endif
398  newSpeed = speedGapControl(veh, gap2pred, speed, predSpeed, desSpeed, vErr, pred, vehMode);
399  }
400  }
401  } else if (commMode == CACC_MODE_NO_LEADER) {
402  newSpeed = speedSpeedControl(speed, vErr, vehMode);
403  } else if (commMode == CACC_MODE_LEADER_NO_CAV) {
404  newSpeed = acc_CFM._v(veh, gap2pred, speed, predSpeed, desSpeed, true);
405  vehMode = ACC_MODE;
406  } else if (commMode == CACC_MODE_LEADER_CAV) {
407  double desSpacing = myHeadwayTime * speed;
408  double gap = gap2pred - veh->getVehicleType().getMinGap();
409  double spacingErr = gap - desSpacing;
410  double accel = veh->getAcceleration();
411  double spacingErr1 = predSpeed - speed + myHeadwayTime * accel;
412 
413  if ((spacingErr > 0 && spacingErr < 0.2) && (vErr < 0.1)) {
414  // gap mode
415  //newSpeed = speed + 0.45 * spacingErr + 0.0125 *spacingErr1;
416  newSpeed = speed + myGapControlGainGap * spacingErr + myGapControlGainGapDot * spacingErr1;
417  vehMode = CACC_GAP_MODE;
418  } else if (spacingErr < 0) {
419  // collision avoidance mode
420  //newSpeed = speed + 0.45 * spacingErr + 0.05 *spacingErr1;
421  newSpeed = speed + myCollisionAvoidanceGainGap * spacingErr + myCollisionAvoidanceGainGapDot * spacingErr1;
423  } else {
424  // gap closing mode
425  newSpeed = speed + myGapClosingControlGainGap * spacingErr + myGapClosingControlGainGapDot * spacingErr1;
426  vehMode = CACC_GAP_CLOSING_MODE;
427  }
428  }
429 
430  if (setControlMode && !MSGlobals::gComputeLC) {
431  const_cast<SUMOVehicleParameter&>(veh->getParameter()).setParameter("caccVehicleMode", VehicleModeNames[vehMode]);
432  }
433 
434  //std::cout << veh->getID() << " commMode: " << commMode << ", caccVehicleMode: " << VehicleModeNames[vehMode]
435  // << ", gap2pred: " << gap2pred << ", newSpeed: " << newSpeed << std::endl;
436 
437 #if DEBUG_CACC == 1
438  if (DEBUG_COND) {
439  std::cout << " result: accel=" << SPEED2ACCEL(newSpeed - speed) << " newSpeed=" << newSpeed << std::endl;
440  }
441 #endif
442 
443  return MAX2(0., newSpeed);
444 }
445 
446 
447 
448 MSCFModel*
450  return new MSCFModel_CACC(vtype);
451 }
452 
#define DEFAULT_GC_GAIN_GAP_DOT_CACC
#define DEFAULT_CA_GAIN_GAP_DOT_CACC
#define DEFAULT_SC_GAIN_CACC
#define DEFAULT_GC_GAIN_GAP_CACC
#define DEFAULT_HEADWAYTIME_ACC
#define DEFAULT_CA_GAIN_GAP_CACC
#define DEFAULT_EMERGENCY_OVERRIDE_THRESHOLD
#define DEBUG_COND
#define DEFAULT_GCC_GAIN_GAP_CACC
#define DEFAULT_GCC_GAIN_GAP_DOT_CACC
#define ACCEL2SPEED(x)
Definition: SUMOTime.h:49
#define SIMTIME
Definition: SUMOTime.h:60
#define SPEED2ACCEL(x)
Definition: SUMOTime.h:51
@ SUMO_TAG_CF_CACC
@ SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC
@ SUMO_ATTR_CA_GAIN_GAP_CACC
@ SUMO_ATTR_GC_GAIN_GAP_DOT_CACC
@ SUMO_ATTR_CA_GAIN_GAP_DOT_CACC
@ SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC
@ SUMO_ATTR_GC_GAIN_GAP_CACC
@ SUMO_ATTR_COLLISION_MINGAP_FACTOR
@ SUMO_ATTR_GCC_GAIN_GAP_CACC
@ SUMO_ATTR_SC_GAIN_CACC
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:29
T MIN2(T a, T b)
Definition: StdDefs.h:73
T MAX2(T a, T b)
Definition: StdDefs.h:79
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:44
const SUMOVehicleParameter & getParameter() const
Returns the vehicle's parameter (including departure definition)
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
The ACC car-following model.
Definition: MSCFModel_ACC.h:47
double myGapControlGainSpace
double myGapControlGainSpeed
double _v(const MSVehicle *const veh, const double gap2pred, const double mySpeed, const double predSpeed, const double desSpeed, const bool respectMinGap=true) const
CommunicationsOverrideMode CACC_CommunicationsOverrideMode
int CACC_ControlMode
The vehicle's CACC precious time step gap error.
virtual std::string getParameter(const MSVehicle *veh, const std::string &key) const
try to get the given parameter for this carFollowingModel
double stopSpeed(const MSVehicle *const veh, const double speed, double gap2pred) const
Computes the vehicle's safe speed for approaching a non-moving obstacle (no dawdling)
MSCFModel_ACC acc_CFM
double getSecureGap(const MSVehicle *const veh, const MSVehicle *const pred, const double speed, const double leaderSpeed, const double leaderMaxDecel) const
Returns the a gap such that the gap mode acceleration of the follower is zero.
MSCFModel_CACC(const MSVehicleType *vtype)
Constructor.
double myGapControlGainGap
virtual void setParameter(MSVehicle *veh, const std::string &key, const std::string &value) const
try to set the given parameter for this carFollowingModel
double myGapClosingControlGainGap
MSCFModel * duplicate(const MSVehicleType *vtype) const
Duplicates the car-following model.
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)
double speedSpeedControl(const double speed, double vErr, VehicleMode &vehMode) const
double _v(const MSVehicle *const veh, const MSVehicle *const pred, const double gap2pred, const double mySpeed, const double predSpeed, const double desSpeed, const bool respectMinGap=true) const
double insertionFollowSpeed(const MSVehicle *const v, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle *const pred=0) const
Computes the vehicle's acceptable speed at insertion.
double myGapClosingControlGainGapDot
static std::map< std::string, CommunicationsOverrideMode > CommunicationsOverrideModeMap
double mySpeedControlGain
double myCollisionAvoidanceGainGapDot
double speedGapControl(const MSVehicle *const veh, const double gap2pred, const double speed, const double predSpeed, const double desSpeed, double vErr, const MSVehicle *const pred, VehicleMode &vehMode) const
double myHeadwayTimeACC
double myGapControlGainGapDot
~MSCFModel_CACC()
Destructor.
VehicleMode
Vehicle mode (default is CACC) Switch to ACC mode if CACC_ControlMode = 1 (gap control mode) and lead...
static std::map< VehicleMode, std::string > VehicleModeNames
Vehicle mode name map.
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.
double myCollisionAvoidanceGainGap
double interactionGap(const MSVehicle *const, double vL) const
Returns the maximum gap at which an interaction between both vehicles occurs.
The car-following model abstraction.
Definition: MSCFModel.h:55
virtual double maxNextSpeed(double speed, const MSVehicle *const veh) const
Returns the maximum speed given the current speed.
Definition: MSCFModel.cpp:237
virtual double getSecureGap(const MSVehicle *const, const MSVehicle *const, const double speed, const double leaderSpeed, const double leaderMaxDecel) const
Returns the minimum gap to reserve if the leader is braking at maximum (>=0)
Definition: MSCFModel.h:328
virtual void setHeadwayTime(double headwayTime)
Sets a new value for desired headway [s].
Definition: MSCFModel.h:506
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.
Definition: MSCFModel.cpp:266
double maximumSafeFollowSpeed(double gap, double egoSpeed, double predSpeed, double predMaxDecel, bool onInsertion=false) const
Returns the maximum safe velocity for following the given leader.
Definition: MSCFModel.cpp:855
double maximumSafeStopSpeed(double gap, double currentSpeed, bool onInsertion=false, double headway=-1) const
Returns the maximum next velocity for stopping within gap.
Definition: MSCFModel.cpp:710
double myCollisionMinGapFactor
The factor of minGap that must be maintained to avoid a collision event.
Definition: MSCFModel.h:625
virtual int getModelID() const =0
Returns the model's ID; the XML-Tag number is used.
double myHeadwayTime
The driver's desired time headway (aka reaction time tau) [s].
Definition: MSCFModel.h:628
static bool gComputeLC
whether the simulationLoop is in the lane changing phase
Definition: MSGlobals.h:112
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: MSLane.h:517
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:171
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:313
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77
double getActionStepLengthSecs() const
Returns the vehicle's action step length in secs, i.e. the interval between two action points.
Definition: MSVehicle.h:502
double getAcceleration() const
Returns the vehicle's acceleration in m/s (this is computed as the last step's mean acceleration in c...
Definition: MSVehicle.h:483
MSCFModel::VehicleVariables * getCarFollowVariables() const
Returns the vehicle's car following model variables.
Definition: MSVehicle.h:947
const MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:550
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
Definition: MSVehicle.h:930
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:66
const std::string & getID() const
Returns the id.
Definition: Named.h:73
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.
Structure representing possible vehicle parameter.