45 #define LOOK_FORWARD_SPEED_DIVIDER 14. 47 #define LOOK_FORWARD_FAR 15. 48 #define LOOK_FORWARD_NEAR 5. 53 #define JAM_FACTOR2 1. 61 myChangeProbability(0),
62 myLeadingBlockerLength(0), myLeftSpace(0) {}
72 const std::pair<MSVehicle*, double>& leader,
73 const std::pair<MSVehicle*, double>& neighLead,
74 const std::pair<MSVehicle*, double>& neighFollow,
76 const std::vector<MSVehicle::LaneQ>& preb,
80 return (laneOffset == -1 ?
81 wantsChangeToRight(msgPass, blocked, leader, neighLead, neighFollow, neighLane, preb, lastBlocked, firstBlocked)
82 :
wantsChangeToLeft(msgPass, blocked, leader, neighLead, neighFollow, neighLane, preb, lastBlocked, firstBlocked));
90 const std::pair<MSVehicle*, double>& leader,
91 const std::pair<MSVehicle*, double>& neighLead,
92 const std::pair<MSVehicle*, double>& neighFollow,
94 const std::vector<MSVehicle::LaneQ>& preb,
99 int bestLaneOffset = 0;
100 double currentDist = 0;
101 double neighDist = 0;
102 double neighExtDist = 0;
103 double currExtDist = 0;
110 for (
int p = 0; p < (int) preb.size(); ++p) {
111 if (preb[p].lane == prebLane && p > 0) {
114 currentDist = curr.
length;
116 neighDist = preb[p - 1].length;
117 neighExtDist = preb[p - 1].lane->getLength();
118 best = preb[p + bestLaneOffset];
127 if (leader.first != 0
144 if ((*lastBlocked) != 0) {
180 if (neighLead.second > 0 && neighLead.second > leader.second) {
186 if (neighLead.first != 0 && (neighLead.first->getLaneChangeModel().getOwnState()&
LCA_LEFT) != 0) {
204 double maxJam =
MAX2(preb[currIdx - 1].occupation, preb[currIdx].occupation);
217 if (currExtDist > neighExtDist && (neighLeftPlace * 2. < rv)) {
233 (
currentDistAllows(neighDist, bestLaneOffset, rv) || neighDist >= currentDist)) {
253 if (neighLead.first == 0) {
259 if (leader.first == 0) {
268 if (thisLaneVSafe - neighLaneVSafe > 5. / 3.6) {
280 vmax -= (double)(5. / 2.6);
281 if (neighLaneVSafe >= vmax) {
297 const std::pair<MSVehicle*, double>& leader,
298 const std::pair<MSVehicle*, double>& neighLead,
299 const std::pair<MSVehicle*, double>& neighFollow,
301 const std::vector<MSVehicle::LaneQ>& preb,
306 int bestLaneOffset = 0;
307 double currentDist = 0;
308 double neighDist = 0;
309 double neighExtDist = 0;
310 double currExtDist = 0;
317 for (
int p = 0; p < (int) preb.size(); ++p) {
318 if (preb[p].lane == prebLane) {
321 currentDist = curr.
length;
323 neighDist = preb[p + 1].length;
324 neighExtDist = preb[p + 1].lane->getLength();
325 best = preb[p + bestLaneOffset];
334 if (leader.first != 0
351 if ((*lastBlocked) != 0) {
387 if (neighLead.second > 0 && neighLead.second > leader.second) {
393 if (neighLead.first != 0 && (neighLead.first->getLaneChangeModel().getOwnState()&
LCA_RIGHT) != 0) {
411 double maxJam =
MAX2(preb[currIdx + 1].occupation, preb[currIdx].occupation);
424 if (currExtDist > neighExtDist && (neighLeftPlace * 2. < lv)) {
449 (
currentDistAllows(neighDist, bestLaneOffset, lv) || neighDist >= currentDist)) {
467 if (neighLead.first == 0) {
473 if (leader.first == 0) {
481 if (thisLaneVSafe > neighLaneVSafe) {
504 double MAGIC_offset = 1.;
514 return MAX2(min, safe);
526 double nVSafe = wanted;
528 for (std::vector<double>::const_iterator i =
myVSafes.begin(); i !=
myVSafes.end(); ++i) {
530 if (v >= min && v <= max) {
531 nVSafe =
MIN2(v, nVSafe);
546 return (min + wanted) / (double) 2.0;
549 return (max + wanted) / (double) 2.0;
551 return (min + wanted) / (double) 2.0;
562 return (min + wanted) / (double) 2.0;
575 return (max + wanted) / (double) 2.0;
581 return (min + wanted) / (double) 2.0;
612 const std::pair<MSVehicle*, double>& neighLead,
613 const std::pair<MSVehicle*, double>& neighFollow) {
615 assert(neighFollow.first != 0);
630 if (neighLead.first != 0 && neighLead.second > 0) {
double getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
double getVehicleMaxSpeed(const SUMOVehicle *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
double myChangeProbability
MSEdge & getEdge() const
Returns the lane's edge.
Representation of a vehicle in the micro simulation.
The action is done to help someone else.
MSLane * getLane() const
Returns the lane the vehicle is on.
int bestLaneOffset
The (signed) number of lanes to be crossed to get to the lane which allows to continue the drive...
virtual double followSpeed(const MSVehicle *const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel) const =0
Computes the vehicle's follow speed (no dawdling)
The car-following model abstraction.
double getPositionOnLane() const
Get the vehicle's position along the lane.
virtual void prepareStep()
void * informNeighFollower(void *info, MSVehicle *sender)
Informs the follower on the desired lane.
virtual double maxNextSpeed(double speed, const MSVehicle *const veh) const
Returns the maximum speed given the current speed.
const std::vector< MSLane * > & getLanes() const
Returns this edge's lanes.
bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist)
double getLength() const
Returns the lane's length.
virtual double patchSpeed(const double min, const double wanted, const double max, const MSCFModel &cfModel)
Called to adapt the speed in order to allow a lane change.
virtual bool predInteraction(const std::pair< MSVehicle *, double > &leader)
MSLCM_DK2008(MSVehicle &v)
double length
The overall length which may be driven when using this lane without a lane change.
The action is due to the wish to be faster (tactical lc)
#define UNUSED_PARAMETER(x)
virtual int wantsChangeToRight(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, const std::pair< MSVehicle *, double > &leader, const std::pair< MSVehicle *, double > &neighLead, const std::pair< MSVehicle *, double > &neighFollow, const MSLane &neighLane, const std::vector< MSVehicle::LaneQ > &preb, MSVehicle **lastBlocked, MSVehicle **firstBlocked)
Called to examine whether the vehicle wants to change to right This method gets the information about...
Needs to stay on the current lane.
A class responsible for exchanging messages between cars involved in lane-change interaction.
MSLane * lane
The described lane.
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
blocked in all directions
The action is urgent (to be defined by lc-model)
virtual int wantsChangeToLeft(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, const std::pair< MSVehicle *, double > &leader, const std::pair< MSVehicle *, double > &neighLead, const std::pair< MSVehicle *, double > &neighFollow, const MSLane &neighLane, const std::vector< MSVehicle::LaneQ > &preb, MSVehicle **lastBlocked, MSVehicle **firstBlocked)
Called to examine whether the vehicle wants to change to left This method gets the information about ...
double getSpeedLimit() const
Returns the lane's maximum allowed speed.
double getMaxSpeed() const
Get vehicle's maximum speed [m/s].
The action is needed to follow the route (navigational lc)
A structure representing the best lanes for continuing the current route starting at 'lane'...
#define LOOK_FORWARD_SPEED_DIVIDER
double getMinGap() const
Get the free space in front of vehicles of this class.
double getMaxDecel() const
Get the vehicle type's maximal comfortable deceleration [m/s^2].
bool amBlockingFollowerPlusNB()
int myOwnState
The current state of the vehicle.
bool isInternal() const
return whether this edge is an internal edge
int wantsChange(int laneOffset, MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, const std::pair< MSVehicle *, double > &leader, const std::pair< MSVehicle *, double > &neighLead, const std::pair< MSVehicle *, double > &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...
MSVehicle & myVehicle
The vehicle this lane-changer belongs to.
void * informNeighLeader(void *info, MSVehicle *sender)
Informs the leader on the desired lane.
double occupation
The overall vehicle sum on consecutive lanes which can be passed without a lane change.
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
bool currentDistAllows(double dist, int laneOffset, double lookForwardDist)
double myLeadingBlockerLength
std::vector< double > myVSafes
virtual void prepareStep()
const double SUMO_const_haltingSpeed
the speed threshold at which vehicles are considered as halting
std::pair< double, int > Info
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)
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
double getSpeed() const
Returns the vehicle's current speed.
#define LOOK_FORWARD_NEAR
Representation of a lane in the micro simulation.
const MSCFModel & myCarFollowModel
The vehicle's car following model.
virtual void * inform(void *info, MSVehicle *sender)
void informBlocker(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int &blocked, int dir, const std::pair< MSVehicle *, double > &neighLead, const std::pair< MSVehicle *, double > &neighFollow)
Interface for lane-change models.
virtual double stopSpeed(const MSVehicle *const veh, const double speed, double gap) const =0
Computes the vehicle's safe speed for approaching a non-moving obstacle (no dawdling) ...
virtual bool congested(const MSVehicle *const neighLeader)