42 #ifdef CHECK_MEMORY_LEAKS
44 #endif // CHECK_MEMORY_LEAKS
47 #ifdef DEBUG_VEHICLE_GUI_SELECTION
59 #define LOOK_FORWARD_SPEED_DIVIDER (SUMOReal)14.
61 #define LOOK_FORWARD_RIGHT (SUMOReal)10.
62 #define LOOK_FORWARD_LEFT (SUMOReal)20.
64 #define JAM_FACTOR (SUMOReal)1.
66 #define LCA_RIGHT_IMPATIENCE (SUMOReal)-1.
67 #define CUT_IN_LEFT_SPEED_THRESHOLD (SUMOReal)27.
69 #define LOOK_AHEAD_MIN_SPEED (SUMOReal)0.0
70 #define LOOK_AHEAD_SPEED_MEMORY (SUMOReal)0.9
71 #define LOOK_AHEAD_SPEED_DECREMENT 6.
73 #define HELP_DECEL_FACTOR (SUMOReal)1.0
75 #define HELP_OVERTAKE (SUMOReal)(10.0 / 3.6)
76 #define MIN_FALLBEHIND (SUMOReal)(14.0 / 3.6)
78 #define KEEP_RIGHT_HEADWAY (SUMOReal)2.0
80 #define URGENCY (SUMOReal)2.0
82 #define ROUNDABOUT_DIST_BONUS (SUMOReal)80.0
84 #define CHANGE_PROB_THRESHOLD_RIGHT (SUMOReal)2.0
85 #define CHANGE_PROB_THRESHOLD_LEFT (SUMOReal)0.2
86 #define KEEP_RIGHT_TIME (SUMOReal)5.0 // the number of seconds after which a vehicle should move to the right lane
87 #define KEEP_RIGHT_ACCEPTANCE (SUMOReal)2.0 // calibration factor for determining the desire to keep right
89 #define RELGAIN_NORMALIZATION_MIN_SPEED (SUMOReal)10.0
96 mySpeedGainProbability(0),
97 myKeepRightProbability(0),
98 myLeadingBlockerLength(0),
113 const std::pair<MSVehicle*, SUMOReal>& leader,
114 const std::pair<MSVehicle*, SUMOReal>& neighLead,
115 const std::pair<MSVehicle*, SUMOReal>& neighFollow,
117 const std::vector<MSVehicle::LaneQ>& preb,
120 const int result =
_wantsChange(laneOffset, msgPass, blocked, leader, neighLead, neighFollow, neighLane, preb, lastBlocked, firstBlocked);
147 return MAX2(min, safe);
154 for (std::vector<SUMOReal>::const_iterator i =
myVSafes.begin(); i !=
myVSafes.end(); ++i) {
156 if (v >= min && v <= max) {
157 nVSafe =
MIN2(v, nVSafe);
172 return (max + wanted) / (
SUMOReal) 2.0;
176 return (min + wanted) / (
SUMOReal) 2.0;
179 return (max + wanted) / (
SUMOReal) 2.0;
187 return (max + wanted) / (
SUMOReal) 2.0;
214 const std::pair<MSVehicle*, SUMOReal>& neighLead,
218 for (std::vector<SUMOReal>::const_iterator i =
myVSafes.begin(); i !=
myVSafes.end(); ++i) {
221 plannedSpeed =
MIN2(plannedSpeed, v);
225 assert(neighLead.first != 0);
229 const SUMOReal overtakeDist = (neighLead.second
241 || dv * remainingSeconds < overtakeDist) {
264 }
else if (neighLead.first != 0) {
272 return MIN2(targetSpeed, plannedSpeed);
284 const std::pair<MSVehicle*, SUMOReal>& neighFollow,
288 assert(neighFollow.first != 0);
294 if ((neededGap - neighFollow.second) / remainingSeconds < (plannedSpeed - nv->
getSpeed())) {
312 const SUMOReal dv = plannedSpeed - neighNewSpeed1s;
314 const SUMOReal decelGap = neighFollow.second + dv;
316 if (decelGap > 0 && decelGap >= secureGap) {
322 }
else if (dv > 0 && dv * remainingSeconds > (secureGap - decelGap +
POSITION_EPS)) {
343 const SUMOReal overtakeDist = (neighFollow.second
349 const SUMOReal needDV = overtakeDist / remainingSeconds;
393 const std::pair<MSVehicle*, SUMOReal>& leader,
394 const std::pair<MSVehicle*, SUMOReal>& neighLead,
395 const std::pair<MSVehicle*, SUMOReal>& neighFollow,
397 const std::vector<MSVehicle::LaneQ>& preb,
400 assert(laneOffset == 1 || laneOffset == -1);
404 int bestLaneOffset = 0;
413 for (
int p = 0; p < (
int) preb.size(); ++p) {
414 if (preb[p].lane == prebLane && p + laneOffset >= 0) {
415 assert(p + laneOffset < (
int)preb.size());
417 neigh = preb[p + laneOffset];
418 currentDist = curr.
length;
420 bestLaneOffset = curr.bestLaneOffset;
421 if (bestLaneOffset == 0 && preb[p + laneOffset].bestLaneOffset == 0) {
422 bestLaneOffset = laneOffset;
424 best = preb[p + bestLaneOffset];
430 const bool right = (laneOffset == -1);
434 const bool changeToBest = (right && bestLaneOffset < 0) || (!right && bestLaneOffset > 0);
440 if (lastBlocked != firstBlocked) {
472 int roundaboutEdgesAhead = 0;
474 if ((*it) != 0 && (*it)->getEdge().isRoundabout()) {
475 roundaboutEdgesAhead += 1;
476 }
else if (roundaboutEdgesAhead > 0) {
481 int roundaboutEdgesAheadNeigh = 0;
483 if ((*it) != 0 && (*it)->getEdge().isRoundabout()) {
484 roundaboutEdgesAheadNeigh += 1;
485 }
else if (roundaboutEdgesAheadNeigh > 0) {
490 if (roundaboutEdgesAhead > 1) {
496 const SUMOReal maxJam =
MAX2(preb[currIdx + laneOffset].occupation, preb[currIdx].occupation);
526 }
else if (bestLaneOffset == 0 && (neighLeftPlace * 2. < laDist)) {
536 if ((ret & lcaCounter) != 0) {
548 if (changeToBest &&
abs(bestLaneOffset) > 1) {
556 if (*firstBlocked != neighLead.first) {
563 const SUMOReal plannedSpeed =
informLeader(msgPass, blocked, myLca, neighLead, remainingSeconds);
564 if (plannedSpeed >= 0) {
566 informFollower(msgPass, blocked, myLca, neighFollow, remainingSeconds, plannedSpeed);
572 if (roundaboutEdgesAhead > 1) {
629 if (neighLead.first == 0) {
634 &
myVehicle,
myVehicle.
getSpeed(), neighLead.second, neighLead.first->getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel()));
636 if (leader.first == 0) {
644 thisLaneVSafe =
MIN2(thisLaneVSafe, vMax);
645 neighLaneVSafe =
MIN2(neighLaneVSafe, vMax);
646 const SUMOReal relativeGain = (neighLaneVSafe - thisLaneVSafe) /
MAX2(neighLaneVSafe,
651 if (thisLaneVSafe - 5 / 3.6 > neighLaneVSafe) {
666 SUMOReal fullSpeedDrivingSeconds =
MIN2(acceptanceTime, fullSpeedGap / vMax);
667 if (neighLead.first != 0 && neighLead.first->getSpeed() < vMax) {
670 vMax, neighLead.first->getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel())));
671 fullSpeedDrivingSeconds =
MIN2(fullSpeedDrivingSeconds, fullSpeedGap / (vMax - neighLead.first->getSpeed()));
682 <<
" neighDist=" << neighDist
684 <<
" leaderSpeed=" << (neighLead.first == 0 ? -1 : neighLead.first->getSpeed())
686 myVehicle.
getSpeed(), neighLead.first->getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel()))
687 <<
" acceptanceTime=" << acceptanceTime
688 <<
" fullSpeedGap=" << fullSpeedGap
689 <<
" fullSpeedDrivingSeconds=" << fullSpeedDrivingSeconds
690 <<
" dProb=" << deltaProb
710 if (thisLaneVSafe > neighLaneVSafe) {
728 && (right ? mySpeedGainProbability < 0 : mySpeedGainProbability > 0)) {
743 if ((*blocked) != 0) {
755 (*blocked)->getCarFollowModel().getMaxDecel()));
void saveBlockerLength(MSVehicle *blocker, int lcaCounter)
save space for vehicles which need to counter-lane-change
#define CHANGE_PROB_THRESHOLD_RIGHT
MSEdge & getEdge() const
Returns the lane's edge.
Representation of a vehicle in the micro simulation.
SUMOReal getMaxSpeed() const
Get vehicle's maximum speed [m/s].
MSLCM_LC2013(MSVehicle &v)
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...
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
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.
#define LOOK_FORWARD_RIGHT
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 safe speed (no dawdling)
#define KEEP_RIGHT_ACCEPTANCE
The car-following model abstraction.
SUMOReal myKeepRightProbability
void * informNeighFollower(void *info, MSVehicle *sender)
Informs the follower on the desired lane.
SUMOReal getLength() const
Get vehicle's length [m].
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
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.
SUMOReal getPositionOnLane() const
Get the vehicle's position along the lane.
std::vector< SUMOReal > myVSafes
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)
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
MSAbstractLaneChangeModel & getLaneChangeModel()
#define ROUNDABOUT_DIST_BONUS
static bool myAllowOvertakingRight
whether overtaking on the right is permitted
A class responsible for exchanging messages between cars involved in lane-change interaction.
bool currentDistDisallows(SUMOReal dist, int laneOffset, SUMOReal lookForwardDist)
bool currentDistAllows(SUMOReal dist, int laneOffset, SUMOReal lookForwardDist)
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.
SUMOReal myLeadingBlockerLength
SUMOReal getMinGap() const
Get the free space in front of vehicles of this class.
#define CUT_IN_LEFT_SPEED_THRESHOLD
SUMOReal myLookAheadSpeed
#define LOOK_AHEAD_SPEED_MEMORY
int slowDownForBlocked(MSVehicle **blocked, int state)
compute useful slowdowns for blocked vehicles
#define CHANGE_PROB_THRESHOLD_LEFT
#define RELGAIN_NORMALIZATION_MIN_SPEED
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.
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.
SUMOReal informLeader(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, int dir, const std::pair< MSVehicle *, SUMOReal > &neighLead, SUMOReal remainingSeconds)
virtual void saveBlockerLength(SUMOReal length)
reserve space at the end of the lane to avoid dead locks
std::pair< SUMOReal, int > Info
information regarding save velocity (unused) and state flags of the ego vehicle
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
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.
SUMOTime myLastLaneChangeOffset
information how long ago the vehicle has performed a lane-change
SUMOReal occupation
The overall vehicle sum on consecutive lanes which can be passed without a lane change.
std::vector< MSLane * > bestContinuations
Consecutive lane that can be followed without a lane change (contribute to length and occupation) ...
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 LOOK_FORWARD_LEFT
SUMOReal mySpeedGainProbability
a value for tracking the probability that a change to the offset with the same sign is beneficial ...
bool amBlockingFollowerPlusNB()
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
SUMOReal _patchSpeed(const SUMOReal min, const SUMOReal wanted, const SUMOReal max, const MSCFModel &cfModel)
#define LOOK_AHEAD_MIN_SPEED
#define LCA_RIGHT_IMPATIENCE
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.
void * inform(void *info, MSVehicle *sender)
Representation of a lane in the micro simulation.
const MSCFModel & myCarFollowModel
The vehicle's car following model.
Interface for lane-change models.
int getBestLaneOffset() const
returns the current offset from the best lane
#define HELP_DECEL_FACTOR
const std::string & getID() const
Returns the name of the vehicle.
The action is due to the wish to be faster (tactical lc)