47#define MAGIC_OFFSET 1.
48#define LOOK_FORWARD 10.
52#define LCA_RIGHT_IMPATIENCE -1.
53#define CUT_IN_LEFT_SPEED_THRESHOLD 27.
55#define LOOK_AHEAD_MIN_SPEED 0.0
56#define LOOK_AHEAD_SPEED_MEMORY 0.9
58#define HELP_DECEL_FACTOR 1.0
60#define HELP_OVERTAKE (10.0 / 3.6)
61#define MIN_FALLBEHIND (7.0 / 3.6)
63#define RELGAIN_NORMALIZATION_MIN_SPEED 10.0
65#define OPPOSITE_URGENCY 5.0
67#define KEEP_RIGHT_TIME 5.0
69#define KEEP_RIGHT_HEADWAY 2.0
70#define MAX_ONRAMP_LENGTH 200.
71#define TURN_LANE_DIST 200.0
73#define LC_RESOLUTION_SPEED_LAT 0.5
75#define REACT_TO_STOPPED_DISTANCE 100
76#define BLOCKER_IS_BLOCKED_TIME_THRESHOLD 5
91#define DEBUG_COND (myVehicle.isSelected())
99 mySpeedGainProbability(0),
100 myKeepRightProbability(0),
101 myLeadingBlockerLength(0),
120#ifdef DEBUG_CONSTRUCTOR
161 const std::pair<MSVehicle*, double>& leader,
162 const std::pair<MSVehicle*, double>& follower,
163 const std::pair<MSVehicle*, double>& neighLead,
164 const std::pair<MSVehicle*, double>& neighFollow,
166 const std::vector<MSVehicle::LaneQ>& preb,
170#ifdef DEBUG_WANTS_CHANGE
172 std::cout <<
"\nWANTS_CHANGE\n" <<
SIMTIME
179 <<
" considerChangeTo=" << (laneOffset == -1 ?
"right" :
"left")
184 const int result =
_wantsChange(laneOffset, msgPass, blocked, leader, follower, neighLead, neighFollow, neighLane, preb, lastBlocked, firstBlocked);
186#ifdef DEBUG_WANTS_CHANGE
199#ifdef DEBUG_PATCH_SPEED
201 std::cout <<
"\nPATCH_SPEED\n"
208 <<
" wanted=" << wanted
215 const double newSpeed =
_patchSpeed(
MAX2(min, 0.0), wanted, max, cfModel);
217#ifdef DEBUG_PATCH_SPEED
219 const std::string patched = (wanted != newSpeed ?
" patched=" +
toString(newSpeed) :
"");
232#ifdef DEBUG_PATCH_SPEED
244 double nVSafe = wanted;
249#ifdef DEBUG_PATCH_SPEED
258 max =
MIN2(max,
MAX2(safe, vMinEmergency));
263 if (safe >= vMinEmergency) {
265 min =
MAX2(vMinEmergency, safe);
268#ifdef DEBUG_PATCH_SPEED
270 std::cout <<
SIMTIME <<
" veh=" <<
myVehicle.
getID() <<
" slowing down for leading blocker, safe=" << safe << (safe + NUMERICAL_EPS < min ?
" (not enough)" :
"") <<
"\n";
273 nVSafe =
MAX2(min, safe);
293 nVSafe =
MIN2(v, nVSafe);
295 nVSafe =
MIN2(v * coopWeight + (1 - coopWeight) * wanted, nVSafe);
298#ifdef DEBUG_PATCH_SPEED
300 std::cout <<
SIMTIME <<
" veh=" <<
myVehicle.
getID() <<
" got nVSafe=" << nVSafe <<
" isOwn: " << i.second <<
" rawV=" << v <<
"\n";
305#ifdef DEBUG_PATCH_SPEED
307 std::cout <<
SIMTIME <<
" veh=" <<
myVehicle.
getID() <<
" ignoring low nVSafe=" << v <<
" min=" << min <<
"\n";
311#ifdef DEBUG_PATCH_SPEED
313 std::cout <<
SIMTIME <<
" veh=" <<
myVehicle.
getID() <<
" ignoring high nVSafe=" << v <<
" max=" << max <<
"\n";
321#ifdef DEBUG_PATCH_SPEED
334#ifdef DEBUG_PATCH_SPEED
339 return (max + wanted) / 2.0;
343#ifdef DEBUG_PATCH_SPEED
349 return (
MAX2(0., min) + wanted) / 2.0;
355#ifdef DEBUG_PATCH_SPEED
360 return (max + wanted) / 2.0;
401#ifdef DEBUG_PATCH_SPEED
406 return (max + wanted) / 2.0;
410#ifdef DEBUG_PATCH_SPEED
442 <<
" informedBy=" << sender->
getID()
443 <<
" info=" << pinfo->second
444 <<
" vSafe=" << pinfo->first
456 double overtakeDist = (gap
461 return MAX2(overtakeDist, 0.);
469 const std::pair<MSVehicle*, double>& neighLead,
470 double remainingSeconds) {
473 plannedSpeed =
MIN2(plannedSpeed,
477 const double a = i.first;
484 std::cout <<
"\nINFORM_LEADER"
489 const MSVehicle*
const nv = neighLead.first;
497 neighNextGap = neighLead.second +
SPEED2DIST(neighNextSpeed - plannedSpeed);
508 std::cout <<
" blocked by leader nv=" << nv->
getID() <<
" nvSpeed=" << nv->
getSpeed() <<
" needGap="
515 const double dv = plannedSpeed - nv->
getSpeed();
518 overtakeTime = overtakeDist / dv;
523 overtakeTime = remainingSeconds - 1;
526 overtakeTime = remainingSeconds + 1;
532 <<
"\nnv = " << nv->
getID()
533 <<
"\nplannedSpeed = " << plannedSpeed
534 <<
"\nleaderSpeed = " << nv->
getSpeed()
536 <<
"\nremainingSeconds = " << remainingSeconds
537 <<
"\novertakeDist = " << overtakeDist
538 <<
"\novertakeTime = " << overtakeTime
553 && (!neighLead.first->isStopped() || (
isOpposite() && neighLead.second >= 0))) {
558 const double targetSpeed =
MAX2(
570 <<
" cannot overtake leader nv=" << nv->
getID()
574 <<
" overtakeDist=" << overtakeDist
575 <<
" overtakeTime=" << overtakeTime
576 <<
" remainingSeconds=" << remainingSeconds
577 <<
" currentGap=" << neighLead.second
579 <<
" neighNextSpeed=" << neighNextSpeed
580 <<
" neighNextGap=" << neighNextGap
581 <<
" targetSpeed=" << targetSpeed
582 <<
" nextSpeed=" << nextSpeed
593 <<
" cannot overtake fast leader nv=" << nv->
getID()
597 <<
" overtakeDist=" << overtakeDist
599 <<
" overtakeTime=" << overtakeTime
600 <<
" remainingSeconds=" << remainingSeconds
601 <<
" currentGap=" << neighLead.second
602 <<
" neighNextSpeed=" << neighNextSpeed
603 <<
" neighNextGap=" << neighNextGap
604 <<
" targetSpeed=" << targetSpeed
616 <<
" wants to overtake leader nv=" << nv->
getID()
618 <<
" overtakeDist=" << overtakeDist
619 <<
" remainingSeconds=" << remainingSeconds
620 <<
" overtakeTime=" << overtakeTime
621 <<
" currentGap=" << neighLead.second
634 const double targetSpeed =
MAX2(
640 std::cout <<
" not blocked by leader nv=" << nv->
getID()
642 <<
" gap=" << neighLead.second
643 <<
" neighNextSpeed=" << neighNextSpeed
644 <<
" neighNextGap=" << neighNextGap
646 <<
" targetSpeed=" << targetSpeed
650 return MIN2(targetSpeed, plannedSpeed);
658 const std::pair<MSVehicle*, double>& neighFollow,
659 double remainingSeconds,
660 double plannedSpeed) {
667 std::cout <<
"\nINFORM_FOLLOWER"
679 std::cout <<
" blocked by follower nv=" << nv->
getID() <<
" nvSpeed=" << nv->
getSpeed() <<
" needGap="
687 if ((neededGap - neighFollow.second) / remainingSeconds < (
MAX2(plannedSpeed, 0.) - nv->
getSpeed())) {
690 std::cout <<
" wants to cut in before nv=" << nv->
getID() <<
" without any help." <<
"\nneededGap = " << neededGap <<
"\n";
710 double neighNewSpeed;
712 double neighNewSpeed1s;
722 dv = plannedSpeed - neighNewSpeed1s;
729 decelGap = neighFollow.second + dv;
736 neighNewSpeed1s = nv->
getSpeed() - helpDecel;
752 <<
" plannedSpeed=" << plannedSpeed
753 <<
" threshold=" << onRampThreshold
754 <<
" neighNewSpeed=" << neighNewSpeed
755 <<
" neighNewSpeed1s=" << neighNewSpeed1s
757 <<
" gap=" << neighFollow.second
758 <<
" decelGap=" << decelGap
759 <<
" secureGap=" << secureGap
766 && neighNewSpeed1s < onRampThreshold) {
770 if (decelGap > 0 && decelGap >= secureGap) {
778 double vsafe, vsafe1;
800 std::cout <<
"nextGap=" << nextGap <<
" (without help decel) \n";
808 MAX2(0., plannedSpeed),
816 nv->
getSpeed(), plannedAccel, -decel2,
826 MAX2(0., plannedSpeed),
829 assert(vsafe >= vsafe1 - NUMERICAL_EPS);
833 std::cout <<
"nextGap=" << nextGap
834 <<
" (with vsafe1 and help decel) \nvsafe1=" << vsafe1
835 <<
" vsafe=" << vsafe
844 if (nextGap < nextSecureGap) {
846 vsafe = neighNewSpeed;
851 std::cout <<
"nextGap=" << nextGap
852 <<
" minNextSecureGap=" << nextSecureGap
853 <<
" vsafe=" << vsafe <<
"\n";
863 std::cout <<
" wants to cut in before nv=" << nv->
getID()
864 <<
" vsafe1=" << vsafe1 <<
" vsafe=" << vsafe
892 std::cout <<
" wants to cut in before nv=" << nv->
getID() <<
" (eventually)\n";
901 std::cout <<
" wants to cut in before nv=" << nv->
getID() <<
" (nv cannot overtake right)\n";
924 std::cout <<
" wants right follower to slow down a bit\n";
934 std::cout <<
" wants to cut in before right follower nv=" << nv->
getID() <<
" (eventually)\n";
956 if (gapAfterRemainingSecs >= secureGapAfterRemainingSecs) {
959 std::cout <<
" wants to cut in before follower nv=" << nv->
getID() <<
" (eventually)\n";
976 <<
" informs follower " << nv->
getID()
977 <<
" vhelp=" << vhelp
986 const double needDV = overtakeDist / remainingSeconds;
994 <<
" wants to be overtaken by=" << nv->
getID()
995 <<
" overtakeDist=" << overtakeDist
997 <<
" vhelp=" << vhelp
998 <<
" needDV=" << needDV
1009#ifdef DEBUG_INFORMER
1011 std::cout <<
" wants to cut in before non-blocking follower nv=" << nv->
getID() <<
"\n";
1040 scaledDelta =
MIN2(overlap, maxDist);
1049 deltaPosLat =
MAX2(
MIN2(deltaPosLat, maxDist), -maxDist);
1062 if (bestLaneOffset < -1) {
1064 }
else if (bestLaneOffset > 1) {
1105 const std::pair<MSVehicle*, double>& leader,
1106 const std::pair<MSVehicle*, double>& follower,
1107 const std::pair<MSVehicle*, double>& neighLead,
1108 const std::pair<MSVehicle*, double>& neighFollow,
1110 const std::vector<MSVehicle::LaneQ>& preb,
1113 assert(laneOffset == 1 || laneOffset == -1);
1117 int bestLaneOffset = 0;
1122 double currentDist = 0;
1123 double neighDist = 0;
1136 const int prebOffset = laneOffset;
1137 for (
int p = 0; p < (int) preb.size(); ++p) {
1141 if (preb[p].lane == prebLane && p + laneOffset >= 0) {
1142 assert(p + prebOffset < (
int)preb.size());
1144 neigh = preb[p + prebOffset];
1145 currentDist = curr.
length;
1146 neighDist = neigh.
length;
1148 if (bestLaneOffset == 0 && preb[p + prebOffset].bestLaneOffset == 0 && !checkOpposite) {
1149#ifdef DEBUG_WANTS_CHANGE
1153 <<
" bestLaneOffsetOld=" << bestLaneOffset
1154 <<
" bestLaneOffsetNew=" << laneOffset
1158 bestLaneOffset = prebOffset;
1160 best = preb[p + bestLaneOffset];
1165 assert(curr.
lane !=
nullptr);
1166 assert(neigh.
lane !=
nullptr);
1167 assert(best.
lane !=
nullptr);
1169 const bool right = (laneOffset == -1);
1171 double driveToNextStop = -std::numeric_limits<double>::max();
1179#ifdef DEBUG_WANTS_CHANGE
1184 <<
" stopPos=" << stopPos
1185 <<
" currentDist=" << currentDist
1186 <<
" neighDist=" << neighDist
1190 currentDist =
MAX2(currentDist, stopPos);
1191 neighDist =
MAX2(neighDist, stopPos);
1196 bool changeToBest = (right && bestLaneOffset < 0) || (!right && bestLaneOffset > 0);
1202 if (lastBlocked != firstBlocked) {
1206#ifdef DEBUG_WANTS_CHANGE
1215 <<
" leaderGap=" << leader.second
1217 <<
" followerGap=" << follower.second
1219 <<
" neighLeadGap=" << neighLead.second
1221 <<
" neighFollowGap=" << neighFollow.second
1244 assert(memoryFactor > 0.);
1250 const bool hasStoppedLeader = leader.first != 0 && leader.first->isStopped() && leader.second < (currentDist - posOnLane);
1254 if (bestLaneOffset == 0 && hasBidiLeader) {
1257 }
else if (bestLaneOffset == 0 && hasStoppedLeader) {
1262 + leader.first->getVehicleType().getLengthWithGap()
1264 }
else if (bestLaneOffset == laneOffset && neighLead.first != 0 && (neighLead.first->isStopped() || hasBidiNeighLeader) && neighLead.second < (currentDist - posOnLane)) {
1269 + neighLead.first->getVehicleType().getLengthWithGap()
1270 + neighLead.second);
1271 }
else if (!hasStoppedLeader &&
1273 || hasBidiNeighLeader)) {
1276 changeToBest =
false;
1295 currentDist += roundaboutBonus;
1296 neighDist += roundaboutBonus;
1300 const double maxJam =
MAX2(preb[currIdx + prebOffset].occupation, preb[currIdx].occupation);
1304 double thisLaneVSafe = vMax;
1307 double neighLeftPlace =
MAX2(0.0, neighDist - posOnLane - maxJam);
1308 if (neighLead.first != 0 && neighLead.first->isStopped()) {
1309 neighLeftPlace =
MIN2(neighLeftPlace, neighLead.second);
1312#ifdef DEBUG_WANTS_CHANGE
1317 <<
" laDist=" << laDist
1318 <<
" currentDist=" << currentDist
1319 <<
" usableDist=" << usableDist
1320 <<
" bestLaneOffset=" << bestLaneOffset
1322 <<
" best.length=" << best.
length
1323 <<
"\n roundaboutBonus=" << roundaboutBonus
1324 <<
" maxJam=" << maxJam
1325 <<
" neighDist=" << neighDist
1326 <<
" neighLeftPlace=" << neighLeftPlace
1327 << (hasBidiLeader ?
" bidiLeader" :
"")
1328 << (hasBidiNeighLeader ?
" bidiNeighLeader" :
"")
1333 bool changeLeftToAvoidOvertakeRight =
false;
1340 if (neighLead.first != 0 && checkOverTakeRight && !right) {
1352 if (vSafeFollow >= vMaxDecel) {
1353 vSafe = vSafeFollow;
1355 vSafe =
MAX2(vMaxDecel, vStayBehind);
1360 thisLaneVSafe =
MIN2(thisLaneVSafe, vSafe);
1363 const double deltaGapFuture = deltaV * 8;
1366 if (vSafeFuture < vSafe) {
1367 const double relativeGain = deltaV /
MAX2(vMax,
1370 changeLeftToAvoidOvertakeRight =
true;
1372#ifdef DEBUG_WANTS_CHANGE
1375 <<
" avoid overtaking on the right nv=" << nv->
getID()
1376 <<
" deltaV=" << deltaV
1385 const bool currFreeUntilNeighEnd = leader.first ==
nullptr || neighDist - posOnLane <= leader.second;
1386 const double overtakeDist = (leader.first == 0 || hasBidiLeader ? -1 :
1390 &&
MIN2(neighDist, currentDist) - posOnLane > overtakeDist
1392 && (!checkOverTakeRight || !right)
1394 && (neighLead.first == 0 || !neighLead.first->isStopped()
1396 || neighLead.second > overtakeDist)) {
1399#ifdef DEBUG_WANTS_CHANGE
1401 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" overtake stopped leader=" << leader.first->getID()
1402 <<
" overtakeDist=" << overtakeDist
1403 <<
" remaining=" <<
MIN2(neighDist, currentDist) - posOnLane
1408 }
else if (!changeToBest &&
currentDistDisallows(neighLeftPlace, abs(bestLaneOffset) + 2, laDist) && !hasBidiLeader) {
1415#ifdef DEBUG_WANTS_CHANGE
1417 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" could not change back and forth in time (1) neighLeftPlace=" << neighLeftPlace <<
"\n";
1421 }
else if (bestLaneOffset == 0 && (neighLeftPlace * 2. < laDist)) {
1426#ifdef DEBUG_WANTS_CHANGE
1428 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" could not change back and forth in time (2) neighLeftPlace=" << neighLeftPlace <<
"\n";
1432 }
else if (bestLaneOffset == 0
1433 && (leader.first == 0 || !leader.first->isStopped())
1436 && roundaboutBonus == 0
1445#ifdef DEBUG_WANTS_CHANGE
1447 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" does not want to leave the bestLane (neighDist=" << neighDist <<
")\n";
1454#ifdef DEBUG_WANTS_CHANGE
1462 if ((ret & lcaCounter) != 0) {
1466#ifdef DEBUG_WANTS_CHANGE
1481 if (changeToBest && abs(bestLaneOffset) > 1) {
1484#ifdef DEBUG_WANTS_CHANGE
1486 std::cout <<
" reserving space for unseen blockers myLeadingBlockerLength=" <<
myLeadingBlockerLength <<
"\n";
1495 if (*firstBlocked != neighLead.first) {
1498#ifdef DEBUG_SAVE_BLOCKER_LENGTH
1500 std::cout <<
SIMTIME <<
" canReserve=" << canReserve <<
" canContinue=" << canContinue <<
"\n";
1509 const int remainingLanes =
MAX2(1, abs(bestLaneOffset));
1511 const double remainingSeconds = ((ret &
LCA_TRACI) == 0 ?
1515 if (!hasBidiNeighLeader) {
1516 const double plannedSpeed =
informLeader(msgPass, blocked, myLca, neighLead, remainingSeconds);
1522 if (!hasBidiNeighFollower) {
1523 informFollower(msgPass, blocked, myLca, neighFollow, remainingSeconds, plannedSpeed);
1526#ifdef DEBUG_WANTS_CHANGE
1531 <<
" remainingSeconds=" << remainingSeconds
1532 <<
" plannedSpeed=" << plannedSpeed
1537#ifdef DEBUG_WANTS_CHANGE
1542 <<
" remainingSeconds=" << remainingSeconds
1543 <<
" hasBidiNeighLeader\n";
1556 const bool acceleratingLeader = (neighLead.first != 0 && neighLead.first->getAcceleration() > 0)
1557 || (leader.first != 0 && leader.first->getAcceleration() > 0);
1568 double inconvenience = laneOffset < 0
1572 const double relSpeedDiff = thisLaneVSafe == 0 ? 0 : (thisLaneVSafe - neighLaneVSafe) /
MAX2(thisLaneVSafe, neighLaneVSafe);
1573 inconvenience =
MAX2(relSpeedDiff, inconvenience);
1574 inconvenience =
MIN2(1.0, inconvenience);
1578#ifdef DEBUG_WANTS_CHANGE
1583 <<
" neighSpeedFactor=" << (thisLaneVSafe / neighLaneVSafe - 1)
1584 <<
" inconvenience=" << inconvenience
1585 <<
" speedInconv=" << speedGainInconvenient
1586 <<
" occInconv=" << neighOccupancyInconvenient
1592 if (roundaboutBonus > 0) {
1594#ifdef DEBUG_WANTS_CHANGE
1598 <<
" roundaboutBonus=" << roundaboutBonus
1628#ifdef DEBUG_WANTS_CHANGE
1630 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" does not want to get stranded on the on-ramp of a highway\n";
1650 && (!speedGainInconvenient)
1652 && (changeToBest ||
currentDistAllows(neighDist, abs(bestLaneOffset) + 1, laDist))) {
1655#ifdef DEBUG_COOPERATE
1659 <<
" wantsChangeToHelp=" << (right ?
"right" :
"left")
1661 << (((
myOwnState & myLca) == 0) ?
" (counter)" :
"")
1692 const double relativeGain = (neighLaneVSafe - thisLaneVSafe) /
MAX2(neighLaneVSafe,
1695#ifdef DEBUG_WANTS_CHANGE
1699 <<
" currentDist=" << currentDist
1700 <<
" neighDist=" << neighDist
1701 <<
" thisVSafe=" << thisLaneVSafe
1702 <<
" neighVSafe=" << neighLaneVSafe
1703 <<
" relGain=" <<
toString(relativeGain, 8)
1710 if (thisLaneVSafe - 5 / 3.6 > neighLaneVSafe) {
1727 if (mySpeedGainProbability < 0 || relativeGain > 0) {
1733 double acceptanceTime;
1740 if (follower.first !=
nullptr && follower.second < 2 * follower.first->getCarFollowModel().brakeGap(follower.first->getSpeed())) {
1744 const double fRSF = follower.first->getLane()->getVehicleMaxSpeed(follower.first) / follower.first->getLane()->getSpeedLimit();
1745 if (fRSF > roadSpeedFactor) {
1746 acceptanceTime /= fRSF;
1752 double fullSpeedDrivingSeconds =
MIN2(acceptanceTime, fullSpeedGap / vMax);
1753 if (neighLead.first != 0 && neighLead.first->getSpeed() < vMax) {
1754 fullSpeedGap =
MAX2(0.,
MIN2(fullSpeedGap,
1756 vMax, neighLead.first->
getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel())));
1757 fullSpeedDrivingSeconds =
MIN2(fullSpeedDrivingSeconds, fullSpeedGap / (vMax - neighLead.first->getSpeed()));
1760 if (checkOverTakeRight && leader.first != 0
1761 && leader.first->getLane()->getVehicleMaxSpeed(leader.first) < vMax) {
1762 fullSpeedGap =
MIN2(fullSpeedGap, leader.second);
1763 fullSpeedDrivingSeconds =
MIN2(fullSpeedDrivingSeconds, fullSpeedGap / (vMax - leader.first->getSpeed()));
1764 const double relGain = (vMax - leader.first->getLane()->getVehicleMaxSpeed(leader.first)) /
MAX2(vMax,
1781#ifdef DEBUG_WANTS_CHANGE
1786 <<
" neighDist=" << neighDist
1788 <<
" leaderSpeed=" << (neighLead.first == 0 ? -1 : neighLead.first->getSpeed())
1790 myVehicle.
getSpeed(), neighLead.first->getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel()))
1791 <<
" acceptanceTime=" << acceptanceTime
1792 <<
" fullSpeedGap=" << fullSpeedGap
1793 <<
" fullSpeedDrivingSeconds=" << fullSpeedDrivingSeconds
1794 <<
" dProb=" << deltaProb
1807#ifdef DEBUG_WANTS_CHANGE
1813 <<
" thisLaneVSafe=" << thisLaneVSafe
1814 <<
" neighLaneVSafe=" << neighLaneVSafe
1815 <<
" relativeGain=" << relativeGain
1816 <<
" blocked=" << blocked
1830 if (thisLaneVSafe > neighLaneVSafe) {
1835 }
else if (thisLaneVSafe == neighLaneVSafe) {
1853#ifdef DEBUG_WANTS_CHANGE
1859 <<
" thisLaneVSafe=" << thisLaneVSafe
1860 <<
" neighLaneVSafe=" << neighLaneVSafe
1861 <<
" relativeGain=" << relativeGain
1862 <<
" blocked=" << blocked
1868 && (relativeGain > NUMERICAL_EPS || changeLeftToAvoidOvertakeRight)
1879 && relativeGain >= 0
1880 && (right ? mySpeedGainProbability < 0 : mySpeedGainProbability > 0)) {
1887#ifdef DEBUG_WANTS_CHANGE
1893 <<
" thisLaneVSafe=" << thisLaneVSafe
1894 <<
" neighLaneVSafe=" << neighLaneVSafe
1905 const MSVehicle* leader = leaderDist.first;
1906 const double gap = leaderDist.second;
1908 if (acceleratingLeader) {
1912 if (leader ==
nullptr) {
1924 if (leader ==
nullptr) {
1935 futureSpeed =
MIN2(vMax, futureSpeed);
1938 const double deltaV = vMax - futureLeaderSpeed;
1939 if (deltaV > 0 && gap > 0) {
1941 const double fullSpeedGap = gap - secGap;
1945 const double gapClosingTime =
MAX2(0.0, fullSpeedGap / deltaV);
1948 futureSpeed =
MIN2(futureSpeed, (gapClosingTime * futureSpeed + (foreCastTime - gapClosingTime) * futureLeaderSpeed) / foreCastTime);
1960 if ((*blocked) !=
nullptr) {
1962#ifdef DEBUG_SLOW_DOWN
1971 if (gap > POSITION_EPS) {
1985 gap - POSITION_EPS, (*blocked)->getSpeed(),
1986 (*blocked)->getCarFollowModel().getMaxDecel()),
false);
1989#ifdef DEBUG_SLOW_DOWN
1993 <<
" slowing down for"
2017#ifdef DEBUG_WANTS_CHANGE
2019 std::cout <<
SIMTIME <<
" adapt to pedestrians on lane=" << lane->
getID() <<
"\n";
2025 if (leader.first != 0) {
2027 v =
MIN2(v, stopSpeed);
2028#ifdef DEBUG_WANTS_CHANGE
2030 std::cout <<
SIMTIME <<
" pedLeader=" << leader.first->getID() <<
" dist=" << leader.second <<
" v=" << v <<
"\n";
2041#ifdef DEBUG_WANTS_CHANGE
2043 std::cout <<
SIMTIME <<
" veh=" <<
myVehicle.
getID() <<
" myLeftSpace=" <<
myLeftSpace <<
" latDist=" << latDist <<
" maneuverDist=" << maneuverDist <<
" result=" << result <<
"\n";
2051 result =
MAX2(-speedBound,
MIN2(speedBound, result));
2064 return myOppositeParam <= 0 ? std::numeric_limits<double>::max() : 1 /
myOppositeParam;
2072#ifdef DEBUG_SAVE_BLOCKER_LENGTH
2074 std::cout <<
SIMTIME <<
" saveBlockerLength veh=" <<
myVehicle.
getID() <<
" canReserve=" << canReserve <<
" myLeftSpace=" <<
myLeftSpace <<
" foeLeftSpace=" << foeLeftSpace <<
"\n";
2130 }
else if (key ==
"speedGainProbabilityRight") {
2132 }
else if (key ==
"speedGainProbabilityLeft") {
2134 }
else if (key ==
"keepRightProbability") {
2136 }
else if (key ==
"lookAheadSpeed") {
2139 }
else if (key ==
"speedGainRP") {
2141 }
else if (key ==
"speedGainLP") {
2143 }
else if (key ==
"keepRightP") {
2199 }
else if (key ==
"speedGainProbabilityRight") {
2201 }
else if (key ==
"speedGainProbabilityLeft") {
2203 }
else if (key ==
"keepRightProbability") {
2205 }
else if (key ==
"lookAheadSpeed") {
#define HELP_DECEL_FACTOR
#define LOOK_AHEAD_MIN_SPEED
#define LCA_RIGHT_IMPATIENCE
#define REACT_TO_STOPPED_DISTANCE
#define RELGAIN_NORMALIZATION_MIN_SPEED
#define CUT_IN_LEFT_SPEED_THRESHOLD
#define MAX_ONRAMP_LENGTH
#define LOOK_AHEAD_SPEED_MEMORY
#define BLOCKER_IS_BLOCKED_TIME_THRESHOLD
#define LC_RESOLUTION_SPEED_LAT
std::pair< const MSPerson *, double > PersonDist
LaneChangeAction
The state of a vehicle's lane-change behavior.
@ LCA_KEEPRIGHT
The action is due to the default of keeping right "Rechtsfahrgebot".
@ LCA_BLOCKED
blocked in all directions
@ LCA_URGENT
The action is urgent (to be defined by lc-model)
@ LCA_STAY
Needs to stay on the current lane.
@ LCA_BLOCKED_BY_LEADER
blocked by leader
@ LCA_AMBLOCKINGFOLLOWER_DONTBRAKE
@ LCA_COOPERATIVE
The action is done to help someone else.
@ LCA_LEFT
Wants go to the left.
@ LCA_STRATEGIC
The action is needed to follow the route (navigational lc)
@ LCA_AMBACKBLOCKER_STANDING
@ LCA_TRACI
The action is due to a TraCI request.
@ LCA_SPEEDGAIN
The action is due to the wish to be faster (tactical lc)
@ LCA_WANTS_LANECHANGE
lane can change
@ LCA_RIGHT
Wants go to the right.
@ LCA_BLOCKED_BY_FOLLOWER
blocker by follower
@ SUMO_ATTR_LCA_COOPERATIVE_SPEED
@ SUMO_ATTR_LCA_ASSERTIVE
@ SUMO_ATTR_LCA_LOOKAHEADLEFT
@ SUMO_ATTR_LCA_SPEEDGAIN_PARAM
@ SUMO_ATTR_LCA_MAXDISTLATSTANDING
@ SUMO_ATTR_LCA_COOPERATIVE_ROUNDABOUT
@ SUMO_ATTR_LCA_SPEEDGAIN_LOOKAHEAD
@ SUMO_ATTR_LCA_MAXSPEEDLATFACTOR
@ SUMO_ATTR_LCA_MAXSPEEDLATSTANDING
@ SUMO_ATTR_LCA_KEEPRIGHT_PARAM
@ SUMO_ATTR_LCA_STRATEGIC_LOOKAHEAD
@ SUMO_ATTR_LCA_COOPERATIVE_PARAM
@ SUMO_ATTR_LCA_OPPOSITE_PARAM
@ SUMO_ATTR_LCA_SPEEDGAIN_REMAIN_TIME
@ SUMO_ATTR_LCA_OVERTAKE_DELTASPEED_FACTOR
@ SUMO_ATTR_LCA_OVERTAKE_RIGHT
@ SUMO_ATTR_LCA_STRATEGIC_PARAM
@ SUMO_ATTR_LCA_KEEPRIGHT_ACCEPTANCE_TIME
@ SUMO_ATTR_LCA_EXPERIMENTAL1
@ SUMO_ATTR_LCA_SPEEDGAINRIGHT
int gPrecision
the precision for floating point outputs
#define UNUSED_PARAMETER(x)
const double SUMO_const_haltingSpeed
the speed threshold at which vehicles are considered as halting
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
A class responsible for exchanging messages between cars involved in lane-change interaction.
void * informNeighFollower(void *info, MSVehicle *sender)
Informs the follower on the desired lane.
void * informNeighLeader(void *info, MSVehicle *sender)
Informs the leader on the desired lane.
Interface for lane-change models.
double getForwardPos() const
get vehicle position relative to the forward direction lane
bool hasBlueLight() const
virtual double computeSpeedLat(double latDist, double &maneuverDist, bool urgent) const
decides the next lateral speed depending on the remaining lane change distance to be covered and upda...
virtual void resetSpeedLat()
int myOwnState
The current state of the vehicle.
virtual void prepareStep()
double myMaxDistLatStanding
static bool myAllowOvertakingRight
whether overtaking on the right is permitted
void addLCSpeedAdvice(const double vSafe, bool ownAdvice=true)
Takes a vSafe (speed advice for speed in the next simulation step), converts it into an acceleration ...
int & getCanceledState(const int dir)
double myMaxSpeedLatFactor
const LaneChangeModel myModel
the type of this model
bool cancelRequest(int state, int laneOffset)
whether the influencer cancels the given request
std::vector< std::pair< double, bool > > myLCAccelerationAdvices
void setSpeedLat(double speedLat)
set the lateral speed and update lateral acceleraton
double myOvertakeRightParam
const MSCFModel & getCarFollowModel() const
The vehicle's car following model.
double myMaxSpeedLatStanding
double myStrategicLookahead
MSVehicle & myVehicle
The vehicle this lane-changer belongs to.
virtual bool avoidOvertakeRight() const
bool isChangingLanes() const
return true if the vehicle currently performs a lane change maneuver
double getImpatience() const
Returns this vehicles impatience.
double getWaitingSeconds() const
Returns the number of seconds waited (speed was lesser than 0.1m/s)
const MSVehicleType & getVehicleType() const
Returns the vehicle's type definition.
bool isStopped() const
Returns whether the vehicle is at a stop.
The car-following model abstraction.
static double gapExtrapolation(const double duration, const double currentGap, double v1, double v2, double a1=0, double a2=0, const double maxV1=std::numeric_limits< double >::max(), const double maxV2=std::numeric_limits< double >::max())
return the resulting gap if, starting with gap currentGap, two vehicles continue with constant accele...
virtual double minNextSpeedEmergency(double speed, const MSVehicle *const veh=0) const
Returns the minimum speed after emergency braking, given the current speed (depends on the numerical ...
virtual double minNextSpeed(double speed, const MSVehicle *const veh=0) const
Returns the minimum speed given the current speed (depends on the numerical update scheme and its ste...
double maximumSafeFollowSpeed(double gap, double egoSpeed, double predSpeed, double predMaxDecel, bool onInsertion=false) const
Returns the maximum safe velocity for following the given leader.
@ LANE_CHANGE
the return value is used for lane change calculations
virtual double getSecureGap(const MSVehicle *const veh, const MSVehicle *const, const double speed, const double leaderSpeed, const double leaderMaxDecel) const
Returns the minimum gap to reserve if the leader is braking at maximum (>=0)
double getMaxAccel() const
Get the vehicle type's maximum acceleration [m/s^2].
double brakeGap(const double speed) const
Returns the distance the vehicle needs to halt including driver's reaction time tau (i....
double maximumSafeStopSpeed(double gap, double decel, double currentSpeed, bool onInsertion=false, double headway=-1, bool relaxEmergency=true) const
Returns the maximum next velocity for stopping within gap.
double getMaxDecel() const
Get the vehicle type's maximal comfortable deceleration [m/s^2].
virtual double getSpeedAfterMaxDecel(double v) const
Returns the velocity after maximum deceleration.
virtual double followSpeed(const MSVehicle *const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle *const pred=0, const CalcReason usage=CalcReason::CURRENT) const =0
Computes the vehicle's follow speed (no dawdling)
double stopSpeed(const MSVehicle *const veh, const double speed, double gap, const CalcReason usage=CalcReason::CURRENT) const
Computes the vehicle's safe speed for approaching a non-moving obstacle (no dawdling)
const std::set< MSTransportable *, ComparatorNumericalIdLess > & getPersons() const
Returns this edge's persons set.
bool hasLaneChanger() const
bool isInternal() const
return whether this edge is an internal edge
static bool gSemiImplicitEulerUpdate
static bool isBidiFollower(const MSVehicle *ego, const MSVehicle *follower)
static bool canSaveBlockerLength(const MSVehicle &veh, double requested, double leftSpace)
static double getSpeedPreservingSecureGap(const MSVehicle &leader, const MSVehicle &follower, double currentGap, double leaderPlannedSpeed)
static double getRoundaboutDistBonus(const MSVehicle &veh, double bonusParam, const MSVehicle::LaneQ &curr, const MSVehicle::LaneQ &neigh, const MSVehicle::LaneQ &best)
static bool isBidiLeader(const MSVehicle *leader, const std::vector< MSLane * > &cont)
static bool updateBlockerLength(const MSVehicle &veh, MSVehicle *blocker, int lcaCounter, double leftSpace, bool reliefConnection, double &leadingBlockerLength)
static bool divergentRoute(const MSVehicle &v1, const MSVehicle &v2)
return whether the vehicles are on the same junction but on divergent paths
bool currentDistAllows(double dist, int laneOffset, double lookForwardDist)
int wantsChange(int laneOffset, MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, const std::pair< MSVehicle *, double > &leader, const std::pair< MSVehicle *, double > &follower, 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) override
Called to examine whether the vehicle wants to change using the given laneOffset. This method gets th...
void informFollower(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, int dir, const std::pair< MSVehicle *, double > &neighFollow, double remainingSeconds, double plannedSpeed)
decide whether we will try cut in before the follower or allow to be overtaken
double computeSpeedLat(double latDist, double &maneuverDist, bool urgent) const override
decides the next lateral speed (for continuous lane changing)
double myOvertakeDeltaSpeedFactor
double getExtraReservation(int bestLaneOffset) const override
reserve extra space for unseen blockers when more tnan one lane change is required
bool debugVehicle() const override
whether the current vehicles shall be debugged
double mySpeedGainLookahead
const double myExperimentalParam1
double patchSpeed(const double min, const double wanted, const double max, const MSCFModel &cfModel) override
Called to adapt the speed in order to allow a lane change. It uses information on LC-related desired ...
void initDerivedParameters()
init cached parameters derived directly from model parameters
double myCooperativeParam
MSLCM_LC2013(MSVehicle &v)
double myChangeProbThresholdRight
double anticipateFollowSpeed(const std::pair< MSVehicle *, double > &leaderDist, double dist, double vMax, bool acceleratingLeader)
anticipate future follow speed for the given leader
std::string getParameter(const std::string &key) const override
try to retrieve the given parameter from this device. Throw exception for unsupported key
void setParameter(const std::string &key, const std::string &value) override
try to set the given parameter for this laneChangeModel. Throw exception for unsupported key
double myCooperativeSpeed
double informLeader(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, int dir, const std::pair< MSVehicle *, double > &neighLead, double remainingSeconds)
double _patchSpeed(double min, const double wanted, double max, const MSCFModel &cfModel)
double myLeadingBlockerLength
std::pair< double, int > Info
information regarding save velocity (unused) and state flags of the ego vehicle
void prepareStep() override
double getSafetyFactor() const override
return factor for modifying the safety constraints of the car-following model
int slowDownForBlocked(MSVehicle **blocked, int state)
compute useful slowdowns for blocked vehicles
bool amBlockingFollowerPlusNB()
double myKeepRightProbability
bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist)
void adaptSpeedToPedestrians(const MSLane *lane, double &v)
react to pedestrians on the given lane
double getOppositeSafetyFactor() const override
return factor for modifying the safety constraints for opposite-diretction overtaking of the car-foll...
void resetState() override
double myKeepRightAcceptanceTime
bool saveBlockerLength(double length, double foeLeftSpace) override
reserve space at the end of the lane to avoid dead locks
double mySpeedGainRemainTime
double mySpeedGainProbability
a value for tracking the probability that a change to the offset with the same sign is beneficial
double myChangeProbThresholdLeft
void * inform(void *info, MSVehicle *sender) override
int _wantsChange(int laneOffset, MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, const std::pair< MSVehicle *, double > &leader, const std::pair< MSVehicle *, double > &follower, 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)
helper function for doing the actual work
static double overtakeDistance(const MSVehicle *follower, const MSVehicle *leader, const double gap, double followerSpeed=INVALID_SPEED, double leaderSpeed=INVALID_SPEED)
Representation of a lane in the micro simulation.
std::pair< const MSPerson *, double > nextBlocking(double minPos, double minRight, double maxLeft, double stopTime=0, bool bidi=false) const
This is just a wrapper around MSPModel::nextBlocking. You should always check using hasPedestrians be...
bool isAccelLane() const
return whether this lane is an acceleration lane
double getSpeedLimit() const
Returns the lane's maximum allowed speed.
double getLength() const
Returns the lane's length.
double getVehicleMaxSpeed(const SUMOTrafficObject *const veh) const
Returns the lane's maximum speed, given a vehicle's speed limit adaptation.
bool hasPedestrians() const
whether the lane has pedestrians on it
int getIndex() const
Returns the lane's index.
double getBruttoOccupancy() const
Returns the brutto (including minGaps) occupancy of this lane during the last step.
MSLane * getBidiLane() const
retrieve bidirectional lane or nullptr
MSEdge & getEdge() const
Returns the lane's edge.
const MSLane * getNormalPredecessorLane() const
get normal lane leading to this internal lane, for normal lanes, the lane itself is returned
const std::vector< MSLink * > & getLinkCont() const
returns the container with all links !!!
static MSNet * getInstance()
Returns the pointer to the unique instance of MSNet (singleton).
SUMOTime getCurrentTimeStep() const
Returns the current simulation step.
const MSLane * lane
The lane to stop at (microsim only)
double changeRequestRemainingSeconds(const SUMOTime currentTime) const
Return the remaining number of seconds of the current laneTimeLine assuming one exists.
Representation of a vehicle in the micro simulation.
double getActionStepLengthSecs() const
Returns the vehicle's action step length in secs, i.e. the interval between two action points.
int influenceChangeDecision(int state)
allow TraCI to influence a lane change decision
double getMaxSpeedOnLane() const
Returns the maximal speed for the vehicle on its current lane (including speed factor and deviation,...
double nextStopDist() const
return the distance to the next stop or doubleMax if there is none.
double getAcceleration() const
Returns the vehicle's acceleration in m/s (this is computed as the last step's mean acceleration in c...
int getBestLaneOffset() const
const MSLane * getLane() const
Returns the lane the vehicle is on.
double getLastStepDist() const
Get the distance the vehicle covered in the previous timestep.
Influencer & getInfluencer()
double getRightSideOnLane() const
Get the lateral position of the vehicles right side on the lane:
double getLateralPositionOnLane() const
Get the vehicle's lateral position on the lane.
double getSpeed() const
Returns the vehicle's current speed.
const std::vector< LaneQ > & getBestLanes() const
Returns the description of best lanes to use in order to continue the route.
const MSCFModel & getCarFollowModel() const
Returns the vehicle's car following model definition.
double getPositionOnLane() const
Get the vehicle's position along the lane.
double getLateralOverlap() const
return the amount by which the vehicle extends laterally outside it's primary lane
void setLateralPositionOnLane(double posLat)
double getLengthWithGap() const
Get vehicle's length including the minimum gap [m].
double getWidth() const
Get the width which vehicles of this class shall have when being drawn.
double getMinGap() const
Get the free space in front of vehicles of this class.
double getMaxSpeedLat() const
Get vehicle's maximum lateral speed [m/s].
double getLength() const
Get vehicle's length [m].
static std::string getIDSecure(const T *obj, const std::string &fallBack="NULL")
get an identifier for Named-like object which may be Null
const std::string & getID() const
Returns the id.
void step(double dt)
evolve for a time step of length dt.
static double toDouble(const std::string &sData)
converts a string into the double value described by it by calling the char-type converter
A structure representing the best lanes for continuing the current route starting at 'lane'.
double length
The overall length which may be driven when using this lane without a lane change.
std::vector< MSLane * > bestContinuations
MSLane * lane
The described lane.
int bestLaneOffset
The (signed) number of lanes to be crossed to get to the lane which allows to continue the drive.
double occupation
The overall vehicle sum on consecutive lanes which can be passed without a lane change.