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-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 /****************************************************************************/
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)),
97  myApplyDriverstate(vtype->getParameter().getCFParam(SUMO_ATTR_APPLYDRIVERSTATE, 0)) {
100 }
101 
103 
104 double
105 MSCFModel_CACC::freeSpeed(const MSVehicle* const veh, double speed, double seen, double maxSpeed, const bool onInsertion) const {
106  // set "caccVehicleMode" parameter to default value
107  if (!MSGlobals::gComputeLC) {
108  const_cast<SUMOVehicleParameter&>(veh->getParameter()).setParameter("caccVehicleMode", VehicleModeNames[CC_MODE]);
109  }
110  return MSCFModel::freeSpeed(veh, speed, seen, maxSpeed, onInsertion);
111 }
112 
113 double
114 MSCFModel_CACC::followSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred) const {
115  if (myApplyDriverstate) {
116  applyHeadwayAndSpeedDifferencePerceptionErrors(veh, speed, gap2pred, predSpeed, predMaxDecel, pred);
117  }
118 
119  const double desSpeed = veh->getLane()->getVehicleMaxSpeed(veh);
120  const double vCACC = _v(veh, pred, gap2pred, speed, predSpeed, desSpeed, true);
121  const double vSafe = maximumSafeFollowSpeed(gap2pred, speed, predSpeed, predMaxDecel);
122 
123 #if DEBUG_CACC == 1
124  if (DEBUG_COND) {
125  std::cout << SIMTIME << " veh=" << veh->getID() << " pred=" << Named::getIDSecure(pred)
126  << " v=" << speed << " vL=" << predSpeed << " gap=" << gap2pred
127  << " predDecel=" << predMaxDecel << " vCACC=" << vCACC << " vSafe=" << vSafe << "\n";
128  }
129 #else
130  UNUSED_PARAMETER(pred);
131 #endif
132  const double speedOverride = MIN2(DEFAULT_EMERGENCY_OVERRIDE_THRESHOLD, gap2pred);
133  if (vSafe + speedOverride < vCACC) {
134 #if DEBUG_CACC == 1
135  if (DEBUG_COND) {
136  std::cout << "Apply Safe speed, override=" << speedOverride << "\n";
137  }
138 #endif
139  return vSafe + speedOverride;
140  }
141  return vCACC;
142 }
143 
144 double
145 MSCFModel_CACC::stopSpeed(const MSVehicle* const veh, const double speed, double gap, double decel) const {
146  if (myApplyDriverstate) {
147  applyHeadwayPerceptionError(veh, speed, gap);
148  }
149 
150  // NOTE: This allows return of smaller values than minNextSpeed().
151  // Only relevant for the ballistic update: We give the argument headway=TS, to assure that
152  // the stopping position is approached with a uniform deceleration also for tau!=TS.
153  return MIN2(maximumSafeStopSpeed(gap, decel, speed, false, veh->getActionStepLengthSecs()), maxNextSpeed(speed, veh));
154 }
155 
156 double
157 MSCFModel_CACC::getSecureGap(const MSVehicle* const veh, const MSVehicle* const pred, const double speed, const double leaderSpeed, const double leaderMaxDecel) const {
158  // Accel in gap mode should vanish:
159  double desSpacing;
160  if (pred->getCarFollowModel().getModelID() != SUMO_TAG_CF_CACC) {
161  // 0 = myGapControlGainSpeed * (leaderSpeed - speed) + myGapControlGainSpace * (g - myHeadwayTime * speed);
162  // <=> myGapControlGainSpace * g = - myGapControlGainSpeed * (leaderSpeed - speed) + myGapControlGainSpace * myHeadwayTime * speed;
163  // <=> g = - myGapControlGainSpeed * (leaderSpeed - speed) / myGapControlGainSpace + myHeadwayTime * speed;
164  desSpacing = acc_CFM.myGapControlGainSpeed * (speed - leaderSpeed) / acc_CFM.myGapControlGainSpace + myHeadwayTimeACC * speed; // MSCFModel_ACC::accelGapControl
165  } else {
166  desSpacing = myHeadwayTime * speed; // speedGapControl
167  }
168  const double desSpacingDefault = MSCFModel::getSecureGap(veh, pred, speed, leaderSpeed, leaderMaxDecel);
169 #if DEBUG_CACC_SECURE_GAP == 1
170  std::cout << SIMTIME << "MSCFModel_ACC::getSecureGap speed=" << speed << " leaderSpeed=" << leaderSpeed
171  << " desSpacing=" << desSpacing << " desSpacingDefault=" << desSpacingDefault << "\n";
172 #endif
173  return MAX2(desSpacing, desSpacingDefault);
174 }
175 
176 
177 double
178 MSCFModel_CACC::insertionFollowSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred) const {
179 #if DEBUG_CACC_INSERTION_FOLLOW_SPEED == 1
180  if (DEBUG_COND) {
181  std::cout << "MSCFModel_ACC::insertionFollowSpeed(), speed=" << speed << " gap2pred=" << gap2pred << " predSpeed=" << predSpeed << "\n";
182  }
183 #endif
184  // iterate to find a stationary value for
185  // speed = followSpeed(v, speed, gap2pred, predSpeed, predMaxDecel, nullptr)
186  const int max_iter = 50;
187  int n_iter = 0;
188  const double tol = 0.1;
189  double damping = 0.8;
190 
191  double res = speed;
192  while (n_iter < max_iter) {
193  // proposed acceleration
194  const double vCACC = _v(veh, pred, gap2pred, res, predSpeed, speed, true);
195  const double vSafe = maximumSafeFollowSpeed(gap2pred, res, predSpeed, predMaxDecel, true);
196  const double a = MIN2(vCACC, vSafe) - res;
197  res = res + damping * a;
198 #if DEBUG_CACC_INSERTION_FOLLOW_SPEED == 1
199  if (DEBUG_COND) {
200  std::cout << " n_iter=" << n_iter << " vSafe=" << vSafe << " vCACC=" << vCACC << " a=" << a << " damping=" << damping << " res=" << res << std::endl;
201  }
202 #endif
203  damping *= 0.9;
204  if (fabs(a) < tol) {
205  break;
206  } else {
207  n_iter++;
208  }
209  }
210  return res;
211 }
212 
213 
214 
215 
217 double
218 MSCFModel_CACC::interactionGap(const MSVehicle* const /* veh */, double /* vL */) const {
219  /*maximum radar range is CACC is enabled*/
220  return 250;
221 }
222 
223 
224 std::string
225 MSCFModel_CACC::getParameter(const MSVehicle* veh, const std::string& key) const {
227 
228  if (key.compare("caccCommunicationsOverrideMode") == 0) {
230  }
231 
232  return "";
233 }
234 
235 
236 void
237 MSCFModel_CACC::setParameter(MSVehicle* veh, const std::string& key, const std::string& value) const {
239 
240  try {
241  if (key.compare("caccCommunicationsOverrideMode") == 0) {
243  }
244  } catch (NumberFormatException&) {
245  throw InvalidArgument("Invalid value '" + value + "' for parameter '" + key + "' for vehicle '" + veh->getID() + "'");
246  }
247 }
248 
249 
250 double
251 MSCFModel_CACC::speedSpeedControl(const double speed, double vErr, VehicleMode& vehMode) const {
252  // Speed control law
253  vehMode = CC_MODE;
254  double sclAccel = mySpeedControlGain * vErr;
255  double newSpeed = speed + ACCEL2SPEED(sclAccel);
256  return newSpeed;
257 }
258 
259 double
260 MSCFModel_CACC::speedGapControl(const MSVehicle* const veh, const double gap2pred,
261  const double speed, const double predSpeed, const double desSpeed, double vErr,
262  const MSVehicle* const pred, VehicleMode& vehMode) const {
263  // Gap control law
264  double newSpeed = 0.0;
265 
266  if (pred != nullptr) {
267  if (pred->getCarFollowModel().getModelID() != SUMO_TAG_CF_CACC) {
268  vehMode = ACC_MODE;
269  newSpeed = acc_CFM._v(veh, gap2pred, speed, predSpeed, desSpeed, true);
270 #if DEBUG_CACC == 1
271  if (DEBUG_COND) {
272  std::cout << " acc control mode" << std::endl;
273  }
274 #endif
275  } else {
276 #if DEBUG_CACC == 1
277  if (DEBUG_COND) {
278  std::cout << " CACC control mode" << std::endl;
279  }
280 #endif
281  double desSpacing = myHeadwayTime * speed;
282  double gap = gap2pred - veh->getVehicleType().getMinGap();
283  double spacingErr = gap - desSpacing;
284  double accel = veh->getAcceleration();
285  double spacingErr1 = predSpeed - speed + myHeadwayTime * accel;
286 
287  if ((spacingErr > 0 && spacingErr < 0.2) && (vErr < 0.1)) {
288  // gap mode
289  //newSpeed = speed + 0.45 * spacingErr + 0.0125 *spacingErr1;
290 #if DEBUG_CACC == 1
291  if (DEBUG_COND) {
292  std::cout << " applying gap control" << std::endl;
293  }
294 #endif
295  newSpeed = speed + myGapControlGainGap * spacingErr + myGapControlGainGapDot * spacingErr1;
296 
297  vehMode = CACC_GAP_MODE;
298  } else if (spacingErr < 0) {
299  // collision avoidance mode
300  //newSpeed = speed + 0.45 * spacingErr + 0.05 *spacingErr1;
301 #if DEBUG_CACC == 1
302  if (DEBUG_COND) {
303  std::cout << " applying collision avoidance err=" << spacingErr << " err1=" << spacingErr1 << "\n";
304  }
305 #endif
306  newSpeed = speed + myCollisionAvoidanceGainGap * spacingErr + myCollisionAvoidanceGainGapDot * spacingErr1;
308  } else {
309  // gap closing mode
310 #if DEBUG_CACC == 1
311  if (DEBUG_COND) {
312  std::cout << " applying gap closing err=" << spacingErr << " err1=" << spacingErr1 << " predSpeed=" << predSpeed << " speed=" << speed << " accel=" << accel << "\n";
313  }
314 #endif
315  newSpeed = speed + myGapClosingControlGainGap * spacingErr + myGapClosingControlGainGapDot * spacingErr1;
316 
317  vehMode = CACC_GAP_CLOSING_MODE;
318  }
319  }
320  } else {
321  /* no leader */
322 #if DEBUG_CACC == 1
323  if (DEBUG_COND) {
324  std::cout << " no leader" << std::endl;
325  }
326 #endif
327  newSpeed = speedSpeedControl(speed, vErr, vehMode);
328  }
329 
330  return newSpeed;
331 }
332 
333 double
334 MSCFModel_CACC::_v(const MSVehicle* const veh, const MSVehicle* const pred, const double gap2pred, const double speed,
335  const double predSpeed, const double desSpeed, const bool /* respectMinGap */) const {
336  double newSpeed = 0.0;
337  VehicleMode vehMode = CC_MODE;
338 
339 #if DEBUG_CACC == 1
340  if (DEBUG_COND) {
341  std::cout << SIMTIME << " MSCFModel_CACC::_v() for veh '" << veh->getID()
342  << " gap=" << gap2pred << " speed=" << speed << " predSpeed=" << predSpeed
343  << " desSpeed=" << desSpeed << std::endl;
344  }
345 #endif
346 
347  /* Velocity error */
348  double vErr = speed - desSpeed;
349  bool setControlMode = false;
353  setControlMode = true;
354  }
355 
357 
358  if (commMode == CACC_NO_OVERRIDE) { // old CACC logic (rely on time gap from predecessor)
359  double time_gap = gap2pred / speed;
360 
361  if (time_gap > 2) {
362 #if DEBUG_CACC == 1
363  if (DEBUG_COND) {
364  std::cout << " applying speedControl" << std::endl;
365  }
366 #endif
367  // Find acceleration - Speed control law
368  newSpeed = speedSpeedControl(speed, vErr, vehMode);
369  // Set cl to vehicle parameters
370  if (setControlMode) {
371  vars->CACC_ControlMode = 0;
372  }
373  } else if (time_gap < 1.5) {
374  // Find acceleration - Gap control law
375 #if DEBUG_CACC == 1
376  if (DEBUG_COND) {
377  std::cout << " speedGapControl" << std::endl;
378  }
379 #endif
380 
381  newSpeed = speedGapControl(veh, gap2pred, speed, predSpeed, desSpeed, vErr, pred, vehMode);
382  // Set cl to vehicle parameters
383  if (setControlMode) {
384  vars->CACC_ControlMode = 1;
385  }
386  } else {
387  // Follow previous applied law
388  int cm = vars->CACC_ControlMode;
389  if (!cm) {
390  // CACC_ControlMode = speed control
391 
392 #if DEBUG_CACC == 1
393  if (DEBUG_COND) {
394  std::cout << " applying speedControl (previous)" << std::endl;
395  }
396 #endif
397  newSpeed = speedSpeedControl(speed, vErr, vehMode);
398  } else {
399  // CACC_ControlMode = gap control
400 #if DEBUG_CACC == 1
401  if (DEBUG_COND) {
402  std::cout << " previous speedGapControl (previous)" << std::endl;
403  }
404 #endif
405  newSpeed = speedGapControl(veh, gap2pred, speed, predSpeed, desSpeed, vErr, pred, vehMode);
406  }
407  }
408  } else if (commMode == CACC_MODE_NO_LEADER) {
409  newSpeed = speedSpeedControl(speed, vErr, vehMode);
410  } else if (commMode == CACC_MODE_LEADER_NO_CAV) {
411  newSpeed = acc_CFM._v(veh, gap2pred, speed, predSpeed, desSpeed, true);
412  vehMode = ACC_MODE;
413  } else if (commMode == CACC_MODE_LEADER_CAV) {
414  double desSpacing = myHeadwayTime * speed;
415  double gap = gap2pred - veh->getVehicleType().getMinGap();
416  double spacingErr = gap - desSpacing;
417  double accel = veh->getAcceleration();
418  double spacingErr1 = predSpeed - speed + myHeadwayTime * accel;
419 
420  if ((spacingErr > 0 && spacingErr < 0.2) && (vErr < 0.1)) {
421  // gap mode
422  //newSpeed = speed + 0.45 * spacingErr + 0.0125 *spacingErr1;
423  newSpeed = speed + myGapControlGainGap * spacingErr + myGapControlGainGapDot * spacingErr1;
424  vehMode = CACC_GAP_MODE;
425  } else if (spacingErr < 0) {
426  // collision avoidance mode
427  //newSpeed = speed + 0.45 * spacingErr + 0.05 *spacingErr1;
428  newSpeed = speed + myCollisionAvoidanceGainGap * spacingErr + myCollisionAvoidanceGainGapDot * spacingErr1;
430  } else {
431  // gap closing mode
432  newSpeed = speed + myGapClosingControlGainGap * spacingErr + myGapClosingControlGainGapDot * spacingErr1;
433  vehMode = CACC_GAP_CLOSING_MODE;
434  }
435  }
436 
437  if (setControlMode && !MSGlobals::gComputeLC) {
438  const_cast<SUMOVehicleParameter&>(veh->getParameter()).setParameter("caccVehicleMode", VehicleModeNames[vehMode]);
439  }
440 
441  //std::cout << veh->getID() << " commMode: " << commMode << ", caccVehicleMode: " << VehicleModeNames[vehMode]
442  // << ", gap2pred: " << gap2pred << ", newSpeed: " << newSpeed << std::endl;
443 
444  // newSpeed is meant for step length 0.1 but this would cause extreme
445  // accelerations at lower step length
446  double newSpeedScaled = newSpeed;
447  if (DELTA_T < 100) {
448  const double accel01 = (newSpeed - speed) * 10;
449  newSpeedScaled = speed + ACCEL2SPEED(accel01);
450  }
451 
452 #if DEBUG_CACC == 1
453  if (DEBUG_COND) {
454  std::cout << " result: rawAccel=" << SPEED2ACCEL(newSpeed - speed) << " newSpeed=" << newSpeed << " newSpeedScaled=" << newSpeedScaled << "\n";
455  }
456 #endif
457 
458  return MAX2(0., newSpeedScaled);
459 }
460 
461 
462 
463 MSCFModel*
465  return new MSCFModel_CACC(vtype);
466 }
467 
#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
SUMOTime DELTA_T
Definition: SUMOTime.cpp:37
#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_APPLYDRIVERSTATE
@ SUMO_ATTR_GCC_GAIN_GAP_CACC
@ SUMO_ATTR_SC_GAIN_CACC
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:30
T MIN2(T a, T b)
Definition: StdDefs.h:74
T MAX2(T a, T b)
Definition: StdDefs.h:80
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:46
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
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
double myApplyDriverstate
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 stopSpeed(const MSVehicle *const veh, const double speed, double gap2pred, double decel) const
Computes the vehicle's safe speed for approaching a non-moving obstacle (no dawdling)
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:351
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
virtual void setHeadwayTime(double headwayTime)
Sets a new value for desired headway [s].
Definition: MSCFModel.h:529
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 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
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 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:861
double myCollisionMinGapFactor
The factor of minGap that must be maintained to avoid a collision event.
Definition: MSCFModel.h:653
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:656
static bool gComputeLC
whether the simulationLoop is in the lane changing phase
Definition: MSGlobals.h:127
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: MSLane.h:519
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:174
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:318
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
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:485
MSCFModel::VehicleVariables * getCarFollowVariables() const
Returns the vehicle's car following model variables.
Definition: MSVehicle.h:934
const MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:552
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
Definition: MSVehicle.h:917
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.
Structure representing possible vehicle parameter.