39 #define LOOK_FORWARD_SPEED_DIVIDER 14. 41 #define LOOK_FORWARD_FAR 15. 42 #define LOOK_FORWARD_NEAR 5. 47 #define JAM_FACTOR2 1. 55 myChangeProbability(0),
56 myLeadingBlockerLength(0), myLeftSpace(0) {}
66 const std::pair<MSVehicle*, double>& leader,
67 const std::pair<MSVehicle*, double>& neighLead,
68 const std::pair<MSVehicle*, double>& neighFollow,
70 const std::vector<MSVehicle::LaneQ>& preb,
74 return (laneOffset == -1 ?
75 wantsChangeToRight(msgPass, blocked, leader, neighLead, neighFollow, neighLane, preb, lastBlocked, firstBlocked)
76 :
wantsChangeToLeft(msgPass, blocked, leader, neighLead, neighFollow, neighLane, preb, lastBlocked, firstBlocked));
84 const std::pair<MSVehicle*, double>& leader,
85 const std::pair<MSVehicle*, double>& neighLead,
86 const std::pair<MSVehicle*, double>& neighFollow,
88 const std::vector<MSVehicle::LaneQ>& preb,
93 int bestLaneOffset = 0;
94 double currentDist = 0;
96 double neighExtDist = 0;
97 double currExtDist = 0;
104 for (
int p = 0; p < (int) preb.size(); ++p) {
105 if (preb[p].lane == prebLane && p > 0) {
108 currentDist = curr.
length;
110 neighDist = preb[p - 1].length;
111 neighExtDist = preb[p - 1].lane->getLength();
112 best = preb[p + bestLaneOffset];
121 if (leader.first != 0
138 if ((*lastBlocked) !=
nullptr) {
148 (*lastBlocked) =
nullptr;
174 if (neighLead.second > 0 && neighLead.second > leader.second) {
180 if (neighLead.first != 0 && (neighLead.first->getLaneChangeModel().getOwnState()&
LCA_LEFT) != 0) {
198 double maxJam =
MAX2(preb[currIdx - 1].occupation, preb[currIdx].occupation);
211 if (currExtDist > neighExtDist && (neighLeftPlace * 2. < rv)) {
227 (
currentDistAllows(neighDist, bestLaneOffset, rv) || neighDist >= currentDist)) {
247 if (neighLead.first == 0) {
253 if (leader.first == 0) {
262 if (thisLaneVSafe - neighLaneVSafe > 5. / 3.6) {
274 vmax -= (double)(5. / 2.6);
275 if (neighLaneVSafe >= vmax) {
291 const std::pair<MSVehicle*, double>& leader,
292 const std::pair<MSVehicle*, double>& neighLead,
293 const std::pair<MSVehicle*, double>& neighFollow,
295 const std::vector<MSVehicle::LaneQ>& preb,
300 int bestLaneOffset = 0;
301 double currentDist = 0;
302 double neighDist = 0;
303 double neighExtDist = 0;
304 double currExtDist = 0;
311 for (
int p = 0; p < (int) preb.size(); ++p) {
312 if (preb[p].lane == prebLane) {
315 currentDist = curr.
length;
317 neighDist = preb[p + 1].length;
318 neighExtDist = preb[p + 1].lane->getLength();
319 best = preb[p + bestLaneOffset];
328 if (leader.first != 0
345 if ((*lastBlocked) !=
nullptr) {
355 (*lastBlocked) =
nullptr;
381 if (neighLead.second > 0 && neighLead.second > leader.second) {
387 if (neighLead.first != 0 && (neighLead.first->getLaneChangeModel().getOwnState()&
LCA_RIGHT) != 0) {
405 double maxJam =
MAX2(preb[currIdx + 1].occupation, preb[currIdx].occupation);
418 if (currExtDist > neighExtDist && (neighLeftPlace * 2. < lv)) {
443 (
currentDistAllows(neighDist, bestLaneOffset, lv) || neighDist >= currentDist)) {
461 if (neighLead.first == 0) {
467 if (leader.first == 0) {
475 if (thisLaneVSafe > neighLaneVSafe) {
498 double MAGIC_offset = 1.;
508 return MAX2(min, safe);
520 double nVSafe = wanted;
522 for (std::vector<double>::const_iterator i =
myVSafes.begin(); i !=
myVSafes.end(); ++i) {
524 if (v >= min && v <= max) {
525 nVSafe =
MIN2(v, nVSafe);
540 return (min + wanted) / (double) 2.0;
543 return (max + wanted) / (double) 2.0;
545 return (min + wanted) / (double) 2.0;
556 return (min + wanted) / (double) 2.0;
569 return (max + wanted) / (double) 2.0;
575 return (min + wanted) / (double) 2.0;
606 const std::pair<MSVehicle*, double>& neighLead,
607 const std::pair<MSVehicle*, double>& neighFollow) {
609 assert(neighFollow.first != 0);
624 if (neighLead.first != 0 && neighLead.second > 0) {
double getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
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...
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 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)
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
const MSLinkCont & getLinkCont() const
returns the container with all links !!!
double getSpeed() const
Returns the vehicle's current speed.
virtual double followSpeed(const MSVehicle *const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle *const pred=0) const =0
Computes the vehicle's follow speed (no dawdling)
#define LOOK_FORWARD_NEAR
Representation of a lane in the micro simulation.
const MSCFModel & myCarFollowModel
The vehicle's car following model.
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
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)