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