41 #ifdef CHECK_MEMORY_LEAKS
43 #endif // CHECK_MEMORY_LEAKS
46 #ifdef DEBUG_VEHICLE_GUI_SELECTION
58 #define LOOK_FORWARD_SPEED_DIVIDER (SUMOReal)14.
64 #define LOOK_FORWARD_RIGHT (SUMOReal)10.
65 #define LOOK_FORWARD_LEFT (SUMOReal)20.
67 #define JAM_FACTOR (SUMOReal)1.
70 #define LCA_RIGHT_IMPATIENCE (SUMOReal)-1.
71 #define CUT_IN_LEFT_SPEED_THRESHOLD (SUMOReal)27.
72 #define MAX_ONRAMP_LENGTH (SUMOReal)200.
74 #define LOOK_AHEAD_MIN_SPEED (SUMOReal)0.0
75 #define LOOK_AHEAD_SPEED_MEMORY (SUMOReal)0.9
76 #define LOOK_AHEAD_SPEED_DECREMENT 6.
78 #define HELP_DECEL_FACTOR (SUMOReal)1.0
80 #define HELP_OVERTAKE (SUMOReal)(10.0 / 3.6)
81 #define MIN_FALLBEHIND (SUMOReal)(14.0 / 3.6)
83 #define KEEP_RIGHT_HEADWAY (SUMOReal)2.0
85 #define URGENCY (SUMOReal)2.0
87 #define ROUNDABOUT_DIST_BONUS (SUMOReal)100.0
89 #define CHANGE_PROB_THRESHOLD_RIGHT (SUMOReal)2.0
90 #define CHANGE_PROB_THRESHOLD_LEFT (SUMOReal)0.2
91 #define KEEP_RIGHT_TIME (SUMOReal)5.0 // the number of seconds after which a vehicle should move to the right lane
92 #define KEEP_RIGHT_ACCEPTANCE (SUMOReal)7.0 // calibration factor for determining the desire to keep right
94 #define RELGAIN_NORMALIZATION_MIN_SPEED (SUMOReal)10.0
96 #define TURN_LANE_DIST (SUMOReal)200.0 // the distance at which a lane leading elsewhere is considered to be a turn-lane that must be avoided
103 #define DEBUG_COND false
108 return v == 0 ?
"NULL" : v->
getID();
117 mySpeedGainProbability(0),
118 myKeepRightProbability(0),
119 myLeadingBlockerLength(0),
134 const std::pair<MSVehicle*, SUMOReal>& leader,
135 const std::pair<MSVehicle*, SUMOReal>& neighLead,
136 const std::pair<MSVehicle*, SUMOReal>& neighFollow,
138 const std::vector<MSVehicle::LaneQ>& preb,
149 <<
" considerChangeTo=" << (laneOffset == -1 ?
"right" :
"left")
153 const int result =
_wantsChange(laneOffset, msgPass, blocked, leader, neighLead, neighFollow, neighLane, preb, lastBlocked, firstBlocked);
158 <<
" wantsChangeTo=" << (laneOffset == -1 ?
"right" :
"left")
165 << ((result &
LCA_TRACI) ?
" (traci)" :
"")
182 const std::string patched = (wanted != newSpeed ?
" patched=" +
toString(newSpeed) :
"");
188 <<
" wanted=" << wanted
219 std::cout << time <<
" veh=" <<
myVehicle.
getID() <<
" slowing down for leading blocker, safe=" << safe << (safe +
NUMERICAL_EPS < min ?
" (not enough)" :
"") <<
"\n";
221 return MAX2(min, safe);
228 for (std::vector<SUMOReal>::const_iterator i =
myVSafes.begin(); i !=
myVSafes.end(); ++i) {
230 if (v >= min && v <= max) {
231 nVSafe =
MIN2(v, nVSafe);
234 std::cout << time <<
" veh=" <<
myVehicle.
getID() <<
" got nVSafe=" << nVSafe <<
"\n";
239 std::cout << time <<
" veh=" <<
myVehicle.
getID() <<
" ignoring low nVSafe=" << v <<
" min=" << min <<
"\n";
243 std::cout << time <<
" veh=" <<
myVehicle.
getID() <<
" ignoring high nVSafe=" << v <<
" max=" << max <<
"\n";
251 std::cout << time <<
" veh=" <<
myVehicle.
getID() <<
" got vSafe\n";
262 std::cout << time <<
" veh=" <<
myVehicle.
getID() <<
" LCA_WANTS_LANECHANGE (strat, no vSafe)\n";
264 return (max + wanted) / (
SUMOReal) 2.0;
269 std::cout << time <<
" veh=" <<
myVehicle.
getID() <<
" LCA_BLOCKED_BY_LEADER (coop)\n";
271 return (min + wanted) / (
SUMOReal) 2.0;
275 std::cout << time <<
" veh=" <<
myVehicle.
getID() <<
" LCA_BLOCKED_BY_FOLLOWER (coop)\n";
277 return (max + wanted) / (
SUMOReal) 2.0;
319 std::cout << time <<
" veh=" <<
myVehicle.
getID() <<
" LCA_AMBLOCKINGLEADER\n";
321 return (max + wanted) / (
SUMOReal) 2.0;
326 std::cout << time <<
" veh=" <<
myVehicle.
getID() <<
" LCA_AMBLOCKINGFOLLOWER_DONTBRAKE\n";
347 if (pinfo->first >= 0) {
355 <<
" informedBy=" << sender->
getID()
356 <<
" info=" << pinfo->second
357 <<
" vSafe=" << pinfo->first
369 const std::pair<MSVehicle*, SUMOReal>& neighLead,
373 for (std::vector<SUMOReal>::const_iterator i =
myVSafes.begin(); i !=
myVSafes.end(); ++i) {
376 plannedSpeed =
MIN2(plannedSpeed, v);
380 std::cout <<
" informLeader speed=" <<
myVehicle.
getSpeed() <<
" planned=" << plannedSpeed <<
"\n";
384 assert(neighLead.first != 0);
386 if (
gDebugFlag2) std::cout <<
" blocked by leader nv=" << nv->
getID() <<
" nvSpeed=" << nv->
getSpeed() <<
" needGap="
390 const SUMOReal overtakeDist = (neighLead.second
402 || dv * remainingSeconds < overtakeDist) {
416 <<
" cannot overtake leader nv=" << nv->
getID()
418 <<
" remainingSeconds=" << remainingSeconds
419 <<
" targetSpeed=" << targetSpeed
420 <<
" nextSpeed=" << nextSpeed
429 <<
" cannot overtake fast leader nv=" << nv->
getID()
431 <<
" remainingSeconds=" << remainingSeconds
432 <<
" targetSpeed=" << targetSpeed
441 <<
" wants to overtake leader nv=" << nv->
getID()
443 <<
" remainingSeconds=" << remainingSeconds
444 <<
" currentGap=" << neighLead.second
446 <<
" overtakeDist=" << overtakeDist
453 }
else if (neighLead.first != 0) {
462 std::cout <<
" not blocked by leader nv=" << nv->
getID()
464 <<
" gap=" << neighLead.second
465 <<
" nextGap=" << neighLead.second - dv
467 <<
" targetSpeed=" << targetSpeed
470 return MIN2(targetSpeed, plannedSpeed);
482 const std::pair<MSVehicle*, SUMOReal>& neighFollow,
486 assert(neighFollow.first != 0);
488 if (
gDebugFlag2) std::cout <<
" blocked by follower nv=" << nv->
getID() <<
" nvSpeed=" << nv->
getSpeed() <<
" needGap="
494 if ((neededGap - neighFollow.second) / remainingSeconds < (plannedSpeed - nv->
getSpeed())) {
496 std::cout <<
" wants to cut in before nv=" << nv->
getID() <<
" without any help neededGap=" << neededGap <<
"\n";
515 const SUMOReal dv = plannedSpeed - neighNewSpeed1s;
517 const SUMOReal decelGap = neighFollow.second + dv;
522 <<
" egoNV=" << plannedSpeed
523 <<
" nvNewSpeed=" << neighNewSpeed
524 <<
" nvNewSpeed1s=" << neighNewSpeed1s
525 <<
" deltaGap=" << dv
526 <<
" decelGap=" << decelGap
527 <<
" secGap=" << secureGap
530 if (decelGap > 0 && decelGap >= secureGap) {
537 std::cout <<
" wants to cut in before nv=" << nv->
getID()
538 <<
" vsafe=" << vsafe
542 }
else if (dv > 0 && dv * remainingSeconds > (secureGap - decelGap +
POSITION_EPS)) {
546 std::cout <<
" wants to cut in before nv=" << nv->
getID() <<
" (eventually)\n";
552 std::cout <<
" wants to cut in before nv=" << nv->
getID() <<
" (nv cannot overtake right)\n";
566 std::cout <<
" wants right follower to slow down a bit\n";
570 std::cout <<
" wants to cut in before right follower nv=" << nv->
getID() <<
" (eventually)\n";
578 const SUMOReal overtakeDist = (neighFollow.second
584 const SUMOReal needDV = overtakeDist / remainingSeconds;
591 <<
" wants to be overtaken by=" << nv->
getID()
592 <<
" overtakeDist=" << overtakeDist
594 <<
" vhelp=" << vhelp
595 <<
" needDV=" << needDV
600 }
else if (neighFollow.first != 0) {
607 std::cout <<
" wants to cut in before non-blocking follower nv=" << nv->
getID() <<
"\n";
650 const std::pair<MSVehicle*, SUMOReal>& leader,
651 const std::pair<MSVehicle*, SUMOReal>& neighLead,
652 const std::pair<MSVehicle*, SUMOReal>& neighFollow,
654 const std::vector<MSVehicle::LaneQ>& preb,
657 assert(laneOffset == 1 || laneOffset == -1);
661 int bestLaneOffset = 0;
670 for (
int p = 0; p < (int) preb.size(); ++p) {
671 if (preb[p].lane == prebLane && p + laneOffset >= 0) {
672 assert(p + laneOffset < (
int)preb.size());
674 neigh = preb[p + laneOffset];
675 currentDist = curr.
length;
677 bestLaneOffset = curr.bestLaneOffset;
679 if (bestLaneOffset == 0 && preb[p + laneOffset].bestLaneOffset == 0) {
683 <<
" bestLaneOffsetOld=" << bestLaneOffset
684 <<
" bestLaneOffsetNew=" << laneOffset
687 bestLaneOffset = laneOffset;
689 best = preb[p + bestLaneOffset];
695 const bool right = (laneOffset == -1);
700 const bool changeToBest = (right && bestLaneOffset < 0) || (!right && bestLaneOffset > 0);
724 <<
" firstBlocked=" <<
tryID(*firstBlocked)
725 <<
" lastBlocked=" <<
tryID(*lastBlocked)
726 <<
" neighLead=" <<
tryID(neighLead.first)
727 <<
" neighLeadGap=" << neighLead.second
728 <<
" neighFollow=" <<
tryID(neighFollow.first)
729 <<
" neighFollowGap=" << neighFollow.second
735 if (lastBlocked != firstBlocked) {
774 int roundaboutEdgesAhead = 0;
776 if ((*it) != 0 && (*it)->getEdge().isRoundabout()) {
777 roundaboutEdgesAhead += 1;
778 }
else if (roundaboutEdgesAhead > 0) {
783 int roundaboutEdgesAheadNeigh = 0;
785 if ((*it) != 0 && (*it)->getEdge().isRoundabout()) {
786 roundaboutEdgesAheadNeigh += 1;
787 }
else if (roundaboutEdgesAheadNeigh > 0) {
792 if (roundaboutEdgesAhead > 1) {
796 if (roundaboutEdgesAhead > 0) {
798 std::cout <<
" roundaboutEdgesAhead=" << roundaboutEdgesAhead <<
" roundaboutEdgesAheadNeigh=" << roundaboutEdgesAheadNeigh <<
"\n";
804 const SUMOReal maxJam =
MAX2(preb[currIdx + laneOffset].occupation, preb[currIdx].occupation);
811 <<
" laDist=" << laDist
812 <<
" currentDist=" << currentDist
813 <<
" usableDist=" << usableDist
814 <<
" bestLaneOffset=" << bestLaneOffset
815 <<
" best.length=" << best.
length
816 <<
" maxJam=" << maxJam
817 <<
" neighLeftPlace=" << neighLeftPlace
840 <<
" avoid overtaking on the right nv=" << nv->
getID()
843 <<
" plannedSpeed=" <<
myVSafes.back()
857 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" could not change back and forth in time (1) neighLeftPlace=" << neighLeftPlace <<
"\n";
860 }
else if (bestLaneOffset == 0 && (neighLeftPlace * 2. < laDist)) {
866 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" could not change back and forth in time (2) neighLeftPlace=" << neighLeftPlace <<
"\n";
869 }
else if (bestLaneOffset == 0
870 && (leader.first == 0 || !leader.first->isStopped())
872 && roundaboutEdgesAhead == 0
878 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" does not want to leave the bestLane (neighDist=" << neighDist <<
")\n";
888 if ((ret & lcaCounter) != 0) {
893 std::cout <<
" retAfterInfluence=" << ret <<
"\n";
903 if (changeToBest &&
abs(bestLaneOffset) > 1) {
906 std::cout <<
" reserving space for unseen blockers\n";
914 if (*firstBlocked != neighLead.first) {
921 const SUMOReal plannedSpeed =
informLeader(msgPass, blocked, myLca, neighLead, remainingSeconds);
922 if (plannedSpeed >= 0) {
924 informFollower(msgPass, blocked, myLca, neighFollow, remainingSeconds, plannedSpeed);
931 <<
" remainingSeconds=" << remainingSeconds
932 <<
" plannedSpeed=" << plannedSpeed
939 if (roundaboutEdgesAhead > 1) {
957 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" does not want to get stranded on the on-ramp of a highway\n";
982 <<
" wantsChangeToHelp=" << (right ?
"right" :
"left")
984 << (((
myOwnState & myLcaCounter) != 0) ?
" (counter)" :
"")
1009 if (neighLead.first == 0) {
1014 &
myVehicle,
myVehicle.
getSpeed(), neighLead.second, neighLead.first->getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel()));
1016 if (leader.first == 0) {
1024 thisLaneVSafe =
MIN2(thisLaneVSafe, vMax);
1025 neighLaneVSafe =
MIN2(neighLaneVSafe, vMax);
1026 const SUMOReal relativeGain = (neighLaneVSafe - thisLaneVSafe) /
MAX2(neighLaneVSafe,
1031 if (thisLaneVSafe - 5 / 3.6 > neighLaneVSafe) {
1045 SUMOReal fullSpeedDrivingSeconds =
MIN2(acceptanceTime, fullSpeedGap / vMax);
1046 if (neighLead.first != 0 && neighLead.first->getSpeed() < vMax) {
1049 vMax, neighLead.first->getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel())));
1050 fullSpeedDrivingSeconds =
MIN2(fullSpeedDrivingSeconds, fullSpeedGap / (vMax - neighLead.first->getSpeed()));
1061 <<
" neighDist=" << neighDist
1063 <<
" leaderSpeed=" << (neighLead.first == 0 ? -1 : neighLead.first->getSpeed())
1065 myVehicle.
getSpeed(), neighLead.first->getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel()))
1066 <<
" acceptanceTime=" << acceptanceTime
1067 <<
" fullSpeedGap=" << fullSpeedGap
1068 <<
" fullSpeedDrivingSeconds=" << fullSpeedDrivingSeconds
1069 <<
" dProb=" << deltaProb
1085 <<
" thisLaneVSafe=" << thisLaneVSafe
1086 <<
" neighLaneVSafe=" << neighLaneVSafe
1087 <<
" relativeGain=" << relativeGain
1088 <<
" blocked=" << blocked
1101 if (thisLaneVSafe > neighLaneVSafe) {
1128 && (right ? mySpeedGainProbability < 0 : mySpeedGainProbability > 0)) {
1140 <<
" thisLaneVSafe=" << thisLaneVSafe
1141 <<
" neighLaneVSafe=" << neighLaneVSafe
1151 if ((*blocked) != 0) {
1156 <<
" blocked=" <<
tryID(*blocked)
1175 (*blocked)->getCarFollowModel().getMaxDecel()));
1189 <<
" saveBlockerLength blocker=" <<
tryID(blocker)
1203 <<
" blocker=" <<
tryID(blocker)
1213 <<
" blocker=" <<
tryID(blocker)
1215 <<
" potential=" << potential
void * inform(void *info, MSVehicle *sender)
#define LOOK_AHEAD_MIN_SPEED
bool gDebugFlag1
global utility flags for debugging
int _wantsChange(int laneOffset, MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, const std::pair< MSVehicle *, SUMOReal > &leader, const std::pair< MSVehicle *, SUMOReal > &neighLead, const std::pair< MSVehicle *, SUMOReal > &neighFollow, const MSLane &neighLane, const std::vector< MSVehicle::LaneQ > &preb, MSVehicle **lastBlocked, MSVehicle **firstBlocked)
helper function for doing the actual work
MSEdge & getEdge() const
Returns the lane's edge.
#define CHANGE_PROB_THRESHOLD_LEFT
Representation of a vehicle in the micro simulation.
SUMOReal getMaxSpeed() const
Get vehicle's maximum speed [m/s].
int slowDownForBlocked(MSVehicle **blocked, int state)
compute useful slowdowns for blocked vehicles
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
bool currentDistAllows(SUMOReal dist, int laneOffset, SUMOReal lookForwardDist)
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
The action is done to help someone else.
SUMOReal getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
int bestLaneOffset
The (signed) number of lanes to be crossed to get to the lane which allows to continue the drive...
virtual SUMOReal followSpeed(const MSVehicle *const veh, SUMOReal speed, SUMOReal gap2pred, SUMOReal predSpeed, SUMOReal predMaxDecel) const =0
Computes the vehicle's follow speed (no dawdling)
SUMOReal myLeadingBlockerLength
The car-following model abstraction.
void * informNeighFollower(void *info, MSVehicle *sender)
Informs the follower on the desired lane.
SUMOReal getLength() const
Get vehicle's length [m].
int wantsChange(int laneOffset, MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, const std::pair< MSVehicle *, SUMOReal > &leader, const std::pair< MSVehicle *, SUMOReal > &neighLead, const std::pair< MSVehicle *, SUMOReal > &neighFollow, const MSLane &neighLane, const std::vector< MSVehicle::LaneQ > &preb, MSVehicle **lastBlocked, MSVehicle **firstBlocked)
Called to examine whether the vehicle wants to change using the given laneOffset. This method gets th...
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
MSLCM_JE2013(MSVehicle &v)
std::vector< SUMOReal > myVSafes
SUMOReal getSecureGap(const SUMOReal speed, const SUMOReal leaderSpeed, const SUMOReal leaderMaxDecel) const
Returns the minimum gap to reserve if the leader is braking at maximum.
void initLastLaneChangeOffset(int dir)
SUMOReal getPositionOnLane() const
Get the vehicle's position along the lane.
The action is due to a TraCI request.
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
SUMOReal length
The overall length which may be driven when using this lane without a lane change.
The action is urgent (to be defined by lc-model)
MSAbstractLaneChangeModel & getLaneChangeModel()
void informFollower(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, int dir, const std::pair< MSVehicle *, SUMOReal > &neighFollow, SUMOReal remainingSeconds, SUMOReal plannedSpeed)
decide whether we will try cut in before the follower or allow to be overtaken
#define LCA_RIGHT_IMPATIENCE
std::pair< SUMOReal, int > Info
information regarding save velocity (unused) and state flags of the ego vehicle
static bool myAllowOvertakingRight
whether overtaking on the right is permitted
A class responsible for exchanging messages between cars involved in lane-change interaction.
const std::string & getID() const
Returns the id.
bool cancelRequest(int state)
whether the influencer cancels the given request
SUMOReal brakeGap(const SUMOReal speed) const
Returns the distance the vehicle needs to halt including driver's reaction time.
#define CUT_IN_LEFT_SPEED_THRESHOLD
SUMOReal mySpeedGainProbability
a value for tracking the probability that a change to the offset with the same sign is beneficial ...
SUMOReal getMinGap() const
Get the free space in front of vehicles of this class.
#define RELGAIN_NORMALIZATION_MIN_SPEED
#define LOOK_FORWARD_RIGHT
bool amBlockingFollowerPlusNB()
SUMOReal informLeader(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, int dir, const std::pair< MSVehicle *, SUMOReal > &neighLead, SUMOReal remainingSeconds)
SUMOReal _patchSpeed(const SUMOReal min, const SUMOReal wanted, const SUMOReal max, const MSCFModel &cfModel)
void saveBlockerLength(MSVehicle *blocker, int lcaCounter)
save space for vehicles which need to counter-lane-change
#define MAX_ONRAMP_LENGTH
virtual SUMOReal stopSpeed(const MSVehicle *const veh, const SUMOReal speed, SUMOReal gap2pred) const =0
Computes the vehicle's safe speed for approaching a non-moving obstacle (no dawdling) ...
SUMOReal getSpeedLimit() const
Returns the lane's maximum allowed speed.
std::string tryID(const MSVehicle *v)
A structure representing the best lanes for continuing the route.
SUMOReal getMaxDecel() const
Get the vehicle type's maximum deceleration [m/s^2].
SUMOReal changeRequestRemainingSeconds(const SUMOTime currentTime) const
Return the remaining number of seconds of the current laneTimeLine assuming one exists.
int myOwnState
The current state of the vehicle.
std::string toString(const T &t, std::streamsize accuracy=OUTPUT_ACCURACY)
virtual void saveBlockerLength(SUMOReal length)
reserve space at the end of the lane to avoid dead locks
#define HELP_DECEL_FACTOR
MSVehicle & myVehicle
The vehicle this lane-changer belongs to.
void * informNeighLeader(void *info, MSVehicle *sender)
Informs the leader on the desired lane.
The action is needed to follow the route (navigational lc)
EdgeBasicFunction getPurpose() const
Returns the edge type (EdgeBasicFunction)
Influencer & getInfluencer()
Returns the velocity/lane influencer.
SUMOReal myKeepRightProbability
#define LOOK_AHEAD_SPEED_MEMORY
#define ROUNDABOUT_DIST_BONUS
SUMOReal occupation
The overall vehicle sum on consecutive lanes which can be passed without a lane change.
#define CHANGE_PROB_THRESHOLD_RIGHT
std::vector< MSLane * > bestContinuations
Consecutive lane that can be followed without a lane change (contribute to length and occupation) ...
SUMOReal myLookAheadSpeed
The action is due to the default of keeping right "Rechtsfahrgebot".
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
const SUMOReal SUMO_const_haltingSpeed
the speed threshold at which vehicles are considered as halting
Needs to stay on the current lane.
SUMOReal getSpeed() const
Returns the vehicle's current speed.
SUMOReal getWaitingSeconds() const
Returns the number of seconds waited (speed was lesser than 0.1m/s)
#define KEEP_RIGHT_ACCEPTANCE
#define LOOK_FORWARD_LEFT
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
SUMOReal getVehicleMaxSpeed(const SUMOVehicle *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
MSLane * getLane() const
Returns the lane the vehicle is on.
int influenceChangeDecision(int state)
allow TraCI to influence a lane change decision
The edge is an internal edge.
Representation of a lane in the micro simulation.
const MSCFModel & myCarFollowModel
The vehicle's car following model.
bool currentDistDisallows(SUMOReal dist, int laneOffset, SUMOReal lookForwardDist)
Interface for lane-change models.
int getBestLaneOffset() const
returns the current offset from the best lane
SUMOReal patchSpeed(const SUMOReal min, const SUMOReal wanted, const SUMOReal max, const MSCFModel &cfModel)
Called to adapt the speed in order to allow a lane change.
const std::string & getID() const
Returns the name of the vehicle.
The action is due to the wish to be faster (tactical lc)