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.
68 #define LOOK_AHEAD_MIN_SPEED (SUMOReal)0.0
69 #define LOOK_AHEAD_SPEED_MEMORY (SUMOReal)0.9
70 #define LOOK_AHEAD_SPEED_DECREMENT 6.
72 #define HELP_DECEL_FACTOR (SUMOReal)1.0
74 #define HELP_OVERTAKE (SUMOReal)(10.0 / 3.6)
75 #define MIN_FALLBEHIND (SUMOReal)(14.0 / 3.6)
77 #define KEEP_RIGHT_HEADWAY (SUMOReal)2.0
79 #define URGENCY (SUMOReal)2.0
81 #define ROUNDABOUT_DIST_BONUS (SUMOReal)80.0
89 mySpeedGainProbability(0),
90 myKeepRightProbability(0),
91 myLeadingBlockerLength(0),
106 const std::pair<MSVehicle*, SUMOReal>& leader,
107 const std::pair<MSVehicle*, SUMOReal>& neighLead,
108 const std::pair<MSVehicle*, SUMOReal>& neighFollow,
110 const std::vector<MSVehicle::LaneQ>& preb,
113 const int result =
_wantsChange(laneOffset, msgPass, blocked, leader, neighLead, neighFollow, neighLane, preb, lastBlocked, firstBlocked);
140 return MAX2(min, safe);
147 for (std::vector<SUMOReal>::const_iterator i =
myVSafes.begin(); i !=
myVSafes.end(); ++i) {
149 if (v >= min && v <= max) {
150 nVSafe =
MIN2(v, nVSafe);
165 return (max + wanted) / (
SUMOReal) 2.0;
169 return (min + wanted) / (
SUMOReal) 2.0;
172 return (max + wanted) / (
SUMOReal) 2.0;
180 return (max + wanted) / (
SUMOReal) 2.0;
207 const std::pair<MSVehicle*, SUMOReal>& neighLead,
211 for (std::vector<SUMOReal>::const_iterator i =
myVSafes.begin(); i !=
myVSafes.end(); ++i) {
214 plannedSpeed =
MIN2(plannedSpeed, v);
218 assert(neighLead.first != 0);
222 const SUMOReal overtakeDist = (neighLead.second
234 || dv * remainingSeconds < overtakeDist) {
257 }
else if (neighLead.first != 0) {
265 return MIN2(targetSpeed, plannedSpeed);
277 const std::pair<MSVehicle*, SUMOReal>& neighFollow,
281 assert(neighFollow.first != 0);
287 if ((neededGap - neighFollow.second) / remainingSeconds < (plannedSpeed - nv->
getSpeed())) {
305 const SUMOReal dv = plannedSpeed - neighNewSpeed1s;
307 const SUMOReal decelGap = neighFollow.second + dv;
309 if (decelGap > 0 && decelGap >= secureGap) {
315 }
else if (dv > 0 && dv * remainingSeconds > (secureGap - decelGap +
POSITION_EPS)) {
332 const SUMOReal overtakeDist = (neighFollow.second
338 const SUMOReal needDV = overtakeDist / remainingSeconds;
382 const std::pair<MSVehicle*, SUMOReal>& leader,
383 const std::pair<MSVehicle*, SUMOReal>& neighLead,
384 const std::pair<MSVehicle*, SUMOReal>& neighFollow,
386 const std::vector<MSVehicle::LaneQ>& preb,
389 assert(laneOffset == 1 || laneOffset == -1);
393 int bestLaneOffset = 0;
402 for (
int p = 0; p < (
int) preb.size(); ++p) {
403 if (preb[p].lane == prebLane && p + laneOffset >= 0) {
404 assert(p + laneOffset < (
int)preb.size());
406 neigh = preb[p + laneOffset];
407 currentDist = curr.
length;
409 bestLaneOffset = curr.bestLaneOffset;
410 if (bestLaneOffset == 0 && preb[p + laneOffset].bestLaneOffset == 0) {
411 bestLaneOffset = laneOffset;
413 best = preb[p + bestLaneOffset];
419 const bool right = (laneOffset == -1);
423 const bool changeToBest = (right && bestLaneOffset < 0) || (!right && bestLaneOffset > 0);
428 if (lastBlocked != firstBlocked) {
460 int roundaboutEdgesAhead = 0;
462 if ((*it) != 0 && (*it)->getEdge().isRoundabout()) {
463 roundaboutEdgesAhead += 1;
464 }
else if (roundaboutEdgesAhead > 0) {
469 int roundaboutEdgesAheadNeigh = 0;
471 if ((*it) != 0 && (*it)->getEdge().isRoundabout()) {
472 roundaboutEdgesAheadNeigh += 1;
473 }
else if (roundaboutEdgesAheadNeigh > 0) {
478 if (roundaboutEdgesAhead > 1) {
484 const SUMOReal maxJam =
MAX2(preb[currIdx + laneOffset].occupation, preb[currIdx].occupation);
512 }
else if (bestLaneOffset == 0 && (neighLeftPlace * 2. < laDist)) {
522 if ((ret & lcaCounter) != 0) {
534 if (changeToBest &&
abs(bestLaneOffset) > 1) {
542 if (*firstBlocked != neighLead.first) {
549 const SUMOReal plannedSpeed =
informLeader(msgPass, blocked, myLca, neighLead, remainingSeconds);
550 if (plannedSpeed >= 0) {
552 informFollower(msgPass, blocked, myLca, neighFollow, remainingSeconds, plannedSpeed);
558 if (roundaboutEdgesAhead > 1) {
606 if (neighLead.first == 0) {
611 &
myVehicle,
myVehicle.
getSpeed(), neighLead.second, neighLead.first->getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel()));
613 if (leader.first == 0) {
625 if (thisLaneVSafe - neighLaneVSafe > 5. / 3.6) {
649 if (thisLaneVSafe > neighLaneVSafe) {
664 && (right ? mySpeedGainProbability < 0 : mySpeedGainProbability > 0)) {
686 if ((*blocked) != 0) {
698 (*blocked)->getCarFollowModel().getMaxDecel()));
void saveBlockerLength(MSVehicle *blocker, int lcaCounter)
save space for vehicles which need to counter-lane-change
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)
The car-following model abstraction.
SUMOReal myKeepRightProbability
a value for tracking the probability of following the/"Rechtsfahrgebot" (never a positive value) ...
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 (in s)
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
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)
SUMOReal brakeGap(const SUMOReal speed) const
Returns the distance the vehicle needs to halt including driver's reaction time.
void keepRight(MSVehicle *neigh)
updated myKeepRightProbability and mySpeedGainProbability if the right neighbours are faster ...
SUMOReal myLeadingBlockerLength
SUMOReal getMinGap() const
Get the free space in front of vehicles of this class.
SUMOReal myLookAheadSpeed
#define LOOK_AHEAD_SPEED_MEMORY
int slowDownForBlocked(MSVehicle **blocked, int state)
compute useful slowdowns for blocked vehicles
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) ...
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
The action is due to the wish to be faster (tactical lc)