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-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 /****************************************************************************/
15 // CACC car-following model based on [1], [2].
16 // [1] Milanes, V., and S. E. Shladover. Handling Cut-In Vehicles in Strings
17 // of Cooperative Adaptive Cruise Control Vehicles. Journal of Intelligent
18 // Transportation Systems, Vol. 20, No. 2, 2015, pp. 178-191.
19 // [2] Xiao, L., M. Wang and B. van Arem. Realistic Car-Following Models for
20 // Microscopic Simulation of Adaptive and Cooperative Adaptive Cruise
21 // Control Vehicles. Transportation Research Record: Journal of the
22 // Transportation Research Board, No. 2623, 2017. (DOI: 10.3141/2623-01).
23 /****************************************************************************/
24 
25 // ===========================================================================
26 // included modules
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>
39 #include <math.h>
40 #include <microsim/MSNet.h>
41 
42 // ===========================================================================
43 // debug flags
44 // ===========================================================================
45 #define DEBUG_CACC 0
46 #define DEBUG_CACC_INSERTION_FOLLOW_SPEED 0
47 #define DEBUG_CACC_SECURE_GAP 0
48 #define DEBUG_COND (veh->isSelected())
49 //#define DEBUG_COND (veh->getID() == "flow.0")
50 //#define DEBUG_COND (veh->getID() == "CVflowToC2.11")
51 
52 
53 // ===========================================================================
54 // defaults
55 // ===========================================================================
56 #define DEFAULT_SC_GAIN_CACC -0.4
57 #define DEFAULT_GCC_GAIN_GAP_CACC 0.005
58 #define DEFAULT_GCC_GAIN_GAP_DOT_CACC 0.05
59 #define DEFAULT_GC_GAIN_GAP_CACC 0.45
60 #define DEFAULT_GC_GAIN_GAP_DOT_CACC 0.0125
61 #define DEFAULT_CA_GAIN_GAP_CACC 0.45
62 #define DEFAULT_CA_GAIN_GAP_DOT_CACC 0.05
63 #define DEFAULT_HEADWAYTIME_ACC 1.0
64 
65 // override followSpeed when deemed unsafe by the given margin (the value was selected to reduce the number of necessary interventions)
66 #define DEFAULT_EMERGENCY_OVERRIDE_THRESHOLD 2.0
67 
68 
69 // ===========================================================================
70 // method definitions
71 // ===========================================================================
73  MSCFModel(vtype), acc_CFM(MSCFModel_ACC(vtype)),
74  mySpeedControlGain(vtype->getParameter().getCFParam(SUMO_ATTR_SC_GAIN_CACC, DEFAULT_SC_GAIN_CACC)),
75  myGapClosingControlGainGap(vtype->getParameter().getCFParam(SUMO_ATTR_GCC_GAIN_GAP_CACC, DEFAULT_GCC_GAIN_GAP_CACC)),
76  myGapClosingControlGainGapDot(vtype->getParameter().getCFParam(SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC, DEFAULT_GCC_GAIN_GAP_DOT_CACC)),
77  myGapControlGainGap(vtype->getParameter().getCFParam(SUMO_ATTR_GC_GAIN_GAP_CACC, DEFAULT_GC_GAIN_GAP_CACC)),
78  myGapControlGainGapDot(vtype->getParameter().getCFParam(SUMO_ATTR_GC_GAIN_GAP_DOT_CACC, DEFAULT_GC_GAIN_GAP_DOT_CACC)),
79  myCollisionAvoidanceGainGap(vtype->getParameter().getCFParam(SUMO_ATTR_CA_GAIN_GAP_CACC, DEFAULT_CA_GAIN_GAP_CACC)),
80  myCollisionAvoidanceGainGapDot(vtype->getParameter().getCFParam(SUMO_ATTR_CA_GAIN_GAP_DOT_CACC, DEFAULT_CA_GAIN_GAP_DOT_CACC)),
81  myHeadwayTimeACC(vtype->getParameter().getCFParam(SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC, DEFAULT_HEADWAYTIME_ACC)) {
84 }
85 
87 
88 
89 double
90 MSCFModel_CACC::followSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred) const {
91 
92  const double desSpeed = veh->getLane()->getVehicleMaxSpeed(veh);
93  const double vCACC = _v(veh, pred, gap2pred, speed, predSpeed, desSpeed, true);
94  //gDebugFlag1 = DEBUG_COND;
95  const double vSafe = maximumSafeFollowSpeed(gap2pred, speed, predSpeed, predMaxDecel);
96  //gDebugFlag1 = false;
97 #if DEBUG_CACC == 1
98  if (DEBUG_COND) {
99  std::cout << SIMTIME << " veh=" << veh->getID() << " pred=" << Named::getIDSecure(pred)
100  << " v=" << speed << " vL=" << predSpeed << " gap=" << gap2pred
101  << " predDecel=" << predMaxDecel << " vCACC=" << vCACC << " vSafe=" << vSafe << "\n";
102  }
103 #else
104  UNUSED_PARAMETER(pred);
105 #endif
106  const double speedOverride = MIN2(DEFAULT_EMERGENCY_OVERRIDE_THRESHOLD, gap2pred);
107  if (vSafe + speedOverride < vCACC) {
108 #if DEBUG_CACC == 1
109  if (DEBUG_COND) {
110  std::cout << "Apply Safe speed, override=" << speedOverride << "\n";
111  }
112 #endif
113  return vSafe + speedOverride;
114  }
115  return vCACC;
116 }
117 
118 double
119 MSCFModel_CACC::stopSpeed(const MSVehicle* const veh, const double speed, double gap) const {
120 
121  // NOTE: This allows return of smaller values than minNextSpeed().
122  // Only relevant for the ballistic update: We give the argument headway=TS, to assure that
123  // the stopping position is approached with a uniform deceleration also for tau!=TS.
124  return MIN2(maximumSafeStopSpeed(gap, speed, false, veh->getActionStepLengthSecs()), maxNextSpeed(speed, veh));
125 }
126 
127 double
128 MSCFModel_CACC::getSecureGap(const double speed, const double leaderSpeed, const double leaderMaxDecel) const {
129  // Accel in gap mode should vanish:
130  // 0 = myGapControlGainSpeed * (leaderSpeed - speed) + myGapControlGainSpace * (g - myHeadwayTime * speed);
131  // <=> myGapControlGainSpace * g = - myGapControlGainSpeed * (leaderSpeed - speed) + myGapControlGainSpace * myHeadwayTime * speed;
132  // <=> g = - myGapControlGainSpeed * (leaderSpeed - speed) / myGapControlGainSpace + myHeadwayTime * speed;
133  const double desSpacing = myHeadwayTime * speed; // speedGapControl
134  const double desSpacingACC = acc_CFM.myGapControlGainSpeed * (speed - leaderSpeed) / acc_CFM.myGapControlGainSpace + myHeadwayTime * speed; // MSCFModel_ACC::accelGapControl
135 #if DEBUG_CACC_SECURE_GAP == 1
136  std::cout << SIMTIME << "MSCFModel_ACC::getSecureGap speed=" << speed << " leaderSpeed=" << leaderSpeed << " desSpacing=" << desSpacing << " desSpacingACC=" << desSpacingACC << "\n";
137 #endif
138  return MAX3(desSpacing, desSpacingACC, MSCFModel::getSecureGap(speed, leaderSpeed, leaderMaxDecel));
139 }
140 
141 double
142 MSCFModel_CACC::insertionFollowSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred) const {
143 #if DEBUG_CACC_INSERTION_FOLLOW_SPEED == 1
144  if (DEBUG_COND) {
145  std::cout << "MSCFModel_ACC::insertionFollowSpeed(), speed=" << speed << " gap2pred=" << gap2pred << " predSpeed=" << predSpeed << "\n";
146  }
147 #endif
148  // iterate to find a stationary value for
149  // speed = followSpeed(v, speed, gap2pred, predSpeed, predMaxDecel, nullptr)
150  const int max_iter = 50;
151  int n_iter = 0;
152  const double tol = 0.1;
153  double damping = 0.8;
154 
155  double res = speed;
156  while (n_iter < max_iter) {
157  // proposed acceleration
158  const double vCACC = _v(veh, pred, gap2pred, res, predSpeed, speed, true);
159  const double vSafe = maximumSafeFollowSpeed(gap2pred, res, predSpeed, predMaxDecel, true);
160  const double a = MIN2(vCACC, vSafe) - res;
161  res = res + damping * a;
162 #if DEBUG_CACC_INSERTION_FOLLOW_SPEED == 1
163  if (DEBUG_COND) {
164  std::cout << " n_iter=" << n_iter << " vSafe=" << vSafe << " vCACC=" << vCACC << " a=" << a << " damping=" << damping << " res=" << res << std::endl;
165  }
166 #endif
167  damping *= 0.9;
168  if (fabs(a) < tol) {
169  break;
170  } else {
171  n_iter++;
172  }
173  }
174  return res;
175 }
176 
177 
178 
179 
181 double
182 MSCFModel_CACC::interactionGap(const MSVehicle* const /* veh */, double /* vL */) const {
183  /*maximum radar range is CACC is enabled*/
184  return 250;
185 }
186 
187 double MSCFModel_CACC::speedSpeedContol(const double speed, double vErr) const {
188  // Speed control law
189  double sclAccel = mySpeedControlGain * vErr;
190  double newSpeed = speed + ACCEL2SPEED(sclAccel);
191  return newSpeed;
192 }
193 
194 double MSCFModel_CACC::speedGapControl(const MSVehicle* const veh, const double gap2pred,
195  const double speed, const double predSpeed, const double desSpeed, double vErr,
196  const MSVehicle* const pred) const {
197  // Gap control law
198  double newSpeed = 0.0;
199 
200  if (pred != nullptr) {
201  if (pred->getCarFollowModel().getModelID() != SUMO_TAG_CF_CACC) {
202  //ACC control mode
203  newSpeed = acc_CFM._v(veh, gap2pred, speed, predSpeed, desSpeed, true);
204 #if DEBUG_CACC == 1
205  if (DEBUG_COND) {
206  std::cout << " acc control mode" << std::endl;
207  }
208 #endif
209 
210  } else {
211  //CACC control mode
212 #if DEBUG_CACC == 1
213  if (DEBUG_COND) {
214  std::cout << " CACC control mode" << std::endl;
215  }
216 #endif
217  double desSpacing = myHeadwayTime * speed;
218  double gap = gap2pred - veh->getVehicleType().getMinGap();
219  double spacingErr = gap - desSpacing;
220  double accel = veh->getAcceleration();
221  double spacingErr1 = predSpeed - speed + myHeadwayTime * accel;
222 
223  if ((spacingErr > 0 && spacingErr < 0.2) && (vErr < 0.1)) {
224  // gap mode
225  //newSpeed = speed + 0.45 * spacingErr + 0.0125 *spacingErr1;
226 #if DEBUG_CACC == 1
227  if (DEBUG_COND) {
228  std::cout << " applying gap control" << std::endl;
229  }
230 #endif
231  newSpeed = speed + myGapControlGainGap * spacingErr + myGapControlGainGapDot * spacingErr1;
232  } else if (spacingErr < 0) {
233  // collision avoidance mode
234  //newSpeed = speed + 0.45 * spacingErr + 0.05 *spacingErr1;
235 #if DEBUG_CACC == 1
236  if (DEBUG_COND) {
237  std::cout << " applying collision avoidance err=" << spacingErr << " err1=" << spacingErr1 << "\n";
238  }
239 #endif
240  newSpeed = speed + myCollisionAvoidanceGainGap * spacingErr + myCollisionAvoidanceGainGapDot * spacingErr1;
241  } else {
242  // gap closing mode
243 #if DEBUG_CACC == 1
244  if (DEBUG_COND) {
245  std::cout << " applying gap closing" << std::endl;
246  }
247 #endif
248  newSpeed = speed + myGapClosingControlGainGap * spacingErr + myGapClosingControlGainGapDot * spacingErr1;
249  }
250  }
251 
252  } else { /* no leader */
253 #if DEBUG_CACC == 1
254  if (DEBUG_COND) {
255  std::cout << " no leader" << std::endl;
256  }
257 #endif
258  newSpeed = speedSpeedContol(speed, vErr);
259  }
260 
261  return newSpeed;
262 
263 }
264 
265 double
266 MSCFModel_CACC::_v(const MSVehicle* const veh, const MSVehicle* const pred, const double gap2pred, const double speed,
267  const double predSpeed, const double desSpeed, const bool /* respectMinGap */) const {
268  double newSpeed = 0.0;
269 
270 #if DEBUG_CACC == 1
271  if (DEBUG_COND) {
272  std::cout << SIMTIME << " MSCFModel_CACC::_v() for veh '" << veh->getID()
273  << " gap=" << gap2pred << " speed=" << speed << " predSpeed=" << predSpeed
274  << " desSpeed=" << desSpeed << std::endl;
275  }
276 #endif
277 
278  /* Velocity error */
279  double vErr = speed - desSpeed;
280  int setControlMode = 0;
284  setControlMode = 1;
285  }
286 
287  double time_gap = gap2pred / speed;
288  if (time_gap > 2) {
289 #if DEBUG_CACC == 1
290  if (DEBUG_COND) {
291  std::cout << " applying speedControl" << std::endl;
292  }
293 #endif
294  // Find acceleration - Speed control law
295  newSpeed = speedSpeedContol(speed, vErr);
296  // Set cl to vehicle parameters
297  if (setControlMode) {
298  vars->CACC_ControlMode = 0;
299  }
300  } else if (time_gap < 1.5) {
301  // Find acceleration - Gap control law
302 #if DEBUG_CACC == 1
303  if (DEBUG_COND) {
304  std::cout << " speedGapControl" << std::endl;
305  }
306 #endif
307  newSpeed = speedGapControl(veh, gap2pred, speed, predSpeed, desSpeed, vErr, pred);
308  // Set cl to vehicle parameters
309  if (setControlMode) {
310  vars->CACC_ControlMode = 1;
311  }
312  } else {
313  // Follow previous applied law
314  int cm = vars->CACC_ControlMode;
315  if (!cm) {
316 
317 #if DEBUG_CACC == 1
318  if (DEBUG_COND) {
319  std::cout << " applying speedControl (previous)" << std::endl;
320  }
321 #endif
322  newSpeed = speedSpeedContol(speed, vErr);
323  } else {
324 #if DEBUG_CACC == 1
325  if (DEBUG_COND) {
326  std::cout << " previous speedGapControl (previous)" << std::endl;
327  }
328 #endif
329  newSpeed = speedGapControl(veh, gap2pred, speed, predSpeed, desSpeed, vErr, pred);
330  }
331  }
332 
333 #if DEBUG_CACC == 1
334  if (DEBUG_COND) std::cout << " result: accel=" << SPEED2ACCEL(newSpeed - speed) {
335  << " newSpeed=" << newSpeed << std::endl;
336  }
337 #endif
338 
339  return MAX2(0., newSpeed);
340 }
341 
342 
343 
344 MSCFModel*
346  return new MSCFModel_CACC(vtype);
347 }
348 
MSVehicleType
The car-following model and parameter.
Definition: MSVehicleType.h:66
UNUSED_PARAMETER
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:32
MIN2
T MIN2(T a, T b)
Definition: StdDefs.h:74
MSCFModel_CACC::myGapControlGainGap
double myGapControlGainGap
Definition: MSCFModel_CACC.h:163
SUMO_ATTR_GC_GAIN_GAP_CACC
Definition: SUMOXMLDefinitions.h:573
MSCFModel::maximumSafeFollowSpeed
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:857
DEFAULT_GC_GAIN_GAP_CACC
#define DEFAULT_GC_GAIN_GAP_CACC
Definition: MSCFModel_CACC.cpp:59
DEFAULT_EMERGENCY_OVERRIDE_THRESHOLD
#define DEFAULT_EMERGENCY_OVERRIDE_THRESHOLD
Definition: MSCFModel_CACC.cpp:66
MSCFModel_CACC::insertionFollowSpeed
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.
Definition: MSCFModel_CACC.cpp:142
MSCFModel_CACC::stopSpeed
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)
Definition: MSCFModel_CACC.cpp:119
SUMOTime.h
MSNet.h
MSCFModel_CACC::duplicate
MSCFModel * duplicate(const MSVehicleType *vtype) const
Duplicates the car-following model.
Definition: MSCFModel_CACC.cpp:345
MSCFModel_ACC::_v
double _v(const MSVehicle *const veh, const double gap2pred, const double mySpeed, const double predSpeed, const double desSpeed, const bool respectMinGap=true) const
Definition: MSCFModel_ACC.cpp:204
DEFAULT_GCC_GAIN_GAP_DOT_CACC
#define DEFAULT_GCC_GAIN_GAP_DOT_CACC
Definition: MSCFModel_CACC.cpp:58
MSCFModel::maxNextSpeed
virtual double maxNextSpeed(double speed, const MSVehicle *const veh) const
Returns the maximum speed given the current speed.
Definition: MSCFModel.cpp:239
MSCFModel_CACC::CACCVehicleVariables
Definition: MSCFModel_CACC.h:140
SUMO_TAG_CF_CACC
Definition: SUMOXMLDefinitions.h:289
ACCEL2SPEED
#define ACCEL2SPEED(x)
Definition: SUMOTime.h:53
DEFAULT_CA_GAIN_GAP_DOT_CACC
#define DEFAULT_CA_GAIN_GAP_DOT_CACC
Definition: MSCFModel_CACC.cpp:62
SPEED2ACCEL
#define SPEED2ACCEL(x)
Definition: SUMOTime.h:55
MSCFModel_CACC::CACCVehicleVariables::lastUpdateTime
SUMOTime lastUpdateTime
Definition: MSCFModel_CACC.h:145
SUMO_ATTR_GC_GAIN_GAP_DOT_CACC
Definition: SUMOXMLDefinitions.h:574
MSCFModel_CACC::myGapClosingControlGainGapDot
double myGapClosingControlGainGapDot
Definition: MSCFModel_CACC.h:162
MSCFModel_CACC::followSpeed
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)
Definition: MSCFModel_CACC.cpp:90
MAX3
T MAX3(T a, T b, T c)
Definition: StdDefs.h:94
MSCFModel_CACC::myHeadwayTimeACC
double myHeadwayTimeACC
Definition: MSCFModel_CACC.h:167
MSVehicle::getCarFollowVariables
MSCFModel::VehicleVariables * getCarFollowVariables() const
Returns the vehicle's car following model variables.
Definition: MSVehicle.h:911
MSCFModel_CACC::myGapControlGainGapDot
double myGapControlGainGapDot
Definition: MSCFModel_CACC.h:164
MSVehicle::getCarFollowModel
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
Definition: MSVehicle.h:894
MSCFModel::setHeadwayTime
virtual void setHeadwayTime(double headwayTime)
Sets a new value for desired headway [s].
Definition: MSCFModel.h:506
MSCFModel_ACC::myGapControlGainSpace
double myGapControlGainSpace
Definition: MSCFModel_ACC.h:161
MSCFModel_CACC::mySpeedControlGain
double mySpeedControlGain
Definition: MSCFModel_CACC.h:160
MSVehicle.h
MSCFModel_CACC::myCollisionAvoidanceGainGapDot
double myCollisionAvoidanceGainGapDot
Definition: MSCFModel_CACC.h:166
MSCFModel_CACC::getSecureGap
double getSecureGap(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.
Definition: MSCFModel_CACC.cpp:128
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:80
MSCFModel_CACC::acc_CFM
MSCFModel_ACC acc_CFM
Definition: MSCFModel_CACC.h:159
SIMTIME
#define SIMTIME
Definition: SUMOTime.h:64
SUMO_ATTR_COLLISION_MINGAP_FACTOR
Definition: SUMOXMLDefinitions.h:461
DEBUG_CACC_SECURE_GAP
#define DEBUG_CACC_SECURE_GAP
Definition: MSCFModel_CACC.cpp:47
MSVehicle::getActionStepLengthSecs
double getActionStepLengthSecs() const
Returns the vehicle's action step length in secs, i.e. the interval between two action points.
Definition: MSVehicle.h:513
DEFAULT_CA_GAIN_GAP_CACC
#define DEFAULT_CA_GAIN_GAP_CACC
Definition: MSCFModel_CACC.cpp:61
SUMO_ATTR_GCC_GAIN_GAP_CACC
Definition: SUMOXMLDefinitions.h:571
SUMO_ATTR_SC_GAIN_CACC
Definition: SUMOXMLDefinitions.h:570
MSNet::getCurrentTimeStep
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
Definition: MSNet.h:284
MSCFModel::maximumSafeStopSpeed
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:712
MSCFModel::myHeadwayTime
double myHeadwayTime
The driver's desired time headway (aka reaction time tau) [s].
Definition: MSCFModel.h:628
MSCFModel_CACC::CACCVehicleVariables::CACC_ControlMode
int CACC_ControlMode
The vehicle's CACC precious time step gap error.
Definition: MSCFModel_CACC.h:144
SUMO_ATTR_CA_GAIN_GAP_CACC
Definition: SUMOXMLDefinitions.h:575
MSCFModel_CACC::myCollisionAvoidanceGainGap
double myCollisionAvoidanceGainGap
Definition: MSCFModel_CACC.h:165
MSCFModel_ACC
The ACC car-following model.
Definition: MSCFModel_ACC.h:49
MSVehicleType::getMinGap
double getMinGap() const
Get the free space in front of vehicles of this class.
Definition: MSVehicleType.h:126
SUMOVTypeParameter::getCFParam
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.
Definition: SUMOVTypeParameter.cpp:406
MSBaseVehicle::getVehicleType
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
Definition: MSBaseVehicle.h:118
MSCFModel_CACC::speedSpeedContol
double speedSpeedContol(const double speed, double vErr) const
Definition: MSCFModel_CACC.cpp:187
DEFAULT_SC_GAIN_CACC
#define DEFAULT_SC_GAIN_CACC
Definition: MSCFModel_CACC.cpp:56
MSVehicle::getLane
MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:561
MSCFModel_ACC::myGapControlGainSpeed
double myGapControlGainSpeed
Definition: MSCFModel_ACC.h:160
SUMO_ATTR_GCC_GAIN_GAP_DOT_CACC
Definition: SUMOXMLDefinitions.h:572
MSCFModel_CACC::_v
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
Definition: MSCFModel_CACC.cpp:266
MSCFModel::myCollisionMinGapFactor
double myCollisionMinGapFactor
The factor of minGap that must be maintained to avoid a collision event.
Definition: MSCFModel.h:625
SUMO_ATTR_CA_GAIN_GAP_DOT_CACC
Definition: SUMOXMLDefinitions.h:576
MSCFModel::getSecureGap
virtual double getSecureGap(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
MSNet::getInstance
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
Definition: MSNet.cpp:168
DEFAULT_HEADWAYTIME_ACC
#define DEFAULT_HEADWAYTIME_ACC
Definition: MSCFModel_CACC.cpp:63
MSVehicleType::getParameter
const SUMOVTypeParameter & getParameter() const
Definition: MSVehicleType.h:556
MSBaseVehicle::getID
const std::string & getID() const
Returns the name of the vehicle.
Definition: MSBaseVehicle.cpp:137
MSVehicle::getAcceleration
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:494
MSCFModel
The car-following model abstraction.
Definition: MSCFModel.h:57
MSCFModel_CACC.h
config.h
Named::getIDSecure
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:70
RandHelper.h
SUMO_ATTR_HEADWAY_TIME_CACC_TO_ACC
Definition: SUMOXMLDefinitions.h:577
MSCFModel_CACC::MSCFModel_CACC
MSCFModel_CACC(const MSVehicleType *vtype)
Constructor.
Definition: MSCFModel_CACC.cpp:72
DEBUG_COND
#define DEBUG_COND
Definition: MSCFModel_CACC.cpp:48
DEFAULT_GCC_GAIN_GAP_CACC
#define DEFAULT_GCC_GAIN_GAP_CACC
Definition: MSCFModel_CACC.cpp:57
MSCFModel::getModelID
virtual int getModelID() const =0
Returns the model's ID; the XML-Tag number is used.
MSLane.h
MSLane::getVehicleMaxSpeed
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
Definition: MSLane.h:519
MSCFModel_CACC::interactionGap
double interactionGap(const MSVehicle *const, double vL) const
Returns the maximum gap at which an interaction between both vehicles occurs.
Definition: MSCFModel_CACC.cpp:182
MSCFModel_CACC::myGapClosingControlGainGap
double myGapClosingControlGainGap
Definition: MSCFModel_CACC.h:161
MSAbstractLaneChangeModel.h
MSCFModel_CACC::~MSCFModel_CACC
~MSCFModel_CACC()
Destructor.
Definition: MSCFModel_CACC.cpp:86
DEFAULT_GC_GAIN_GAP_DOT_CACC
#define DEFAULT_GC_GAIN_GAP_DOT_CACC
Definition: MSCFModel_CACC.cpp:60
MSCFModel_CACC::speedGapControl
double speedGapControl(const MSVehicle *const veh, const double gap2pred, const double speed, const double predSpeed, const double desSpeed, double vErr, const MSVehicle *const pred) const
Definition: MSCFModel_CACC.cpp:194
MSVehicle
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:80