44 #define LOOK_FORWARD (double)10.
46 #define JAM_FACTOR (double)1.
48 #define LCA_RIGHT_IMPATIENCE (double)-1.
49 #define CUT_IN_LEFT_SPEED_THRESHOLD (double)27.
51 #define LOOK_AHEAD_MIN_SPEED 0.0
52 #define LOOK_AHEAD_SPEED_MEMORY 0.9
54 #define HELP_DECEL_FACTOR (double)1.0
56 #define HELP_OVERTAKE (double)(10.0 / 3.6)
57 #define MIN_FALLBEHIND (double)(7.0 / 3.6)
60 #define OVERTAKE_RIGHT_THRESHOLD (double)(5/3.6)
62 #define RELGAIN_NORMALIZATION_MIN_SPEED (double)10.0
63 #define URGENCY (double)2.0
64 #define OPPOSITE_URGENCY (double)5.0
66 #define KEEP_RIGHT_TIME (double)5.0 // the number of seconds after which a vehicle should move to the right lane
67 #define KEEP_RIGHT_ACCEPTANCE (double)7.0 // calibration factor for determining the desire to keep right
69 #define ROUNDABOUT_DIST_FACTOR (double)10.0 // Must be >=1.0, serves an alternative way of decreasing sense lc-urgency by multiplying the distance along the next roundabout
71 #define KEEP_RIGHT_HEADWAY (double)2.0
72 #define MAX_ONRAMP_LENGTH (double)200.
73 #define TURN_LANE_DIST (double)200.0 // the distance at which a lane leading elsewhere is considered to be a turn-lane that must be avoided
75 #define LC_RESOLUTION_SPEED_LAT (double)0.5 // the lateral speed (in m/s) for a standing vehicle which was unable to finish a continuous LC in time (in case mySpeedLatStanding==0), see #3771
76 #define LC_ASSUMED_DECEL (double)1.0 // the minimal constant deceleration assumed to estimate the duration of a continuous lane-change at its initiation.
78 #define REACT_TO_STOPPED_DISTANCE 100
93 #define DEBUG_COND (myVehicle.isSelected())
101 mySpeedGainProbability(0),
102 myKeepRightProbability(0),
103 myLeadingBlockerLength(0),
117 #ifdef DEBUG_CONSTRUCTOR
153 const std::pair<MSVehicle*, double>& leader,
154 const std::pair<MSVehicle*, double>& neighLead,
155 const std::pair<MSVehicle*, double>& neighFollow,
157 const std::vector<MSVehicle::LaneQ>& preb,
161 #ifdef DEBUG_WANTS_CHANGE
163 std::cout <<
"\nWANTS_CHANGE\n" <<
SIMTIME
170 <<
" considerChangeTo=" << (laneOffset == -1 ?
"right" :
"left")
175 const int result =
_wantsChange(laneOffset, msgPass, blocked, leader, neighLead, neighFollow, neighLane, preb, lastBlocked, firstBlocked);
177 #ifdef DEBUG_WANTS_CHANGE
190 #ifdef DEBUG_PATCH_SPEED
192 std::cout <<
"\nPATCH_SPEED\n"
199 <<
" wanted=" << wanted
206 const double newSpeed =
_patchSpeed(
MAX2(min, 0.0), wanted, max, cfModel);
208 #ifdef DEBUG_PATCH_SPEED
210 const std::string patched = (wanted != newSpeed ?
" patched=" +
toString(newSpeed) :
"");
223 #ifdef DEBUG_PATCH_SPEED
230 <<
" wanted=" << wanted << std::endl;
235 double MAGIC_offset = 1.;
239 #ifdef DEBUG_PATCH_SPEED
250 #ifdef DEBUG_PATCH_SPEED
252 std::cout <<
SIMTIME <<
" veh=" <<
myVehicle.
getID() <<
" slowing down for leading blocker, safe=" << safe << (safe +
NUMERICAL_EPS < min ?
" (not enough)" :
"") <<
"\n";
255 return MAX2(min, safe);
260 double nVSafe = wanted;
274 nVSafe =
MIN2(v * coopWeight + (1 - coopWeight) * wanted, nVSafe);
276 #ifdef DEBUG_PATCH_SPEED
283 #ifdef DEBUG_PATCH_SPEED
285 std::cout <<
SIMTIME <<
" veh=" <<
myVehicle.
getID() <<
" ignoring low nVSafe=" << v <<
" min=" << min <<
"\n";
289 #ifdef DEBUG_PATCH_SPEED
291 std::cout <<
SIMTIME <<
" veh=" <<
myVehicle.
getID() <<
" ignoring high nVSafe=" << v <<
" max=" << max <<
"\n";
299 #ifdef DEBUG_PATCH_SPEED
312 #ifdef DEBUG_PATCH_SPEED
317 return (max + wanted) / (double) 2.0;
321 #ifdef DEBUG_PATCH_SPEED
327 return (
MAX2(0., min) + wanted) / (double) 2.0;
333 #ifdef DEBUG_PATCH_SPEED
338 return (max + wanted) / (double) 2.0;
379 #ifdef DEBUG_PATCH_SPEED
384 return (max + wanted) / (double) 2.0;
388 #ifdef DEBUG_PATCH_SPEED
416 #ifdef DEBUG_INFORMED
420 <<
" informedBy=" << sender->
getID()
421 <<
" info=" << pinfo->second
422 <<
" vSafe=" << pinfo->first
434 double overtakeDist = (gap
439 return MAX2(overtakeDist, 0.);
447 const std::pair<MSVehicle*, double>& neighLead,
448 double remainingSeconds) {
457 #ifdef DEBUG_INFORMER
459 std::cout <<
"\nINFORM_LEADER"
464 const MSVehicle*
const nv = neighLead.first;
472 neighNextGap = neighLead.second +
SPEED2DIST(neighNextSpeed - plannedSpeed);
477 #ifdef DEBUG_INFORMER
479 std::cout <<
" blocked by leader nv=" << nv->
getID() <<
" nvSpeed=" << nv->
getSpeed() <<
" needGap="
486 const double dv = plannedSpeed - nv->
getSpeed();
489 overtakeTime = overtakeDist / dv;
492 overtakeTime = remainingSeconds + 1;
495 #ifdef DEBUG_INFORMER
498 <<
"\nnv = " << nv->
getID()
499 <<
"\nplannedSpeed = " << plannedSpeed
500 <<
"\nleaderSpeed = " << nv->
getSpeed()
502 <<
"\nremainingSeconds = " << remainingSeconds
503 <<
"\novertakeDist = " << overtakeDist
504 <<
"\novertakeTime = " << overtakeTime
519 && !(
isOpposite() && neighLead.second < 0 && neighLead.first->isStopped())) {
524 const double targetSpeed =
MAX2(
533 #ifdef DEBUG_INFORMER
536 <<
" cannot overtake leader nv=" << nv->
getID()
540 <<
" overtakeDist=" << overtakeDist
541 <<
" overtakeTime=" << overtakeTime
542 <<
" remainingSeconds=" << remainingSeconds
543 <<
" currentGap=" << neighLead.second
545 <<
" neighNextSpeed=" << neighNextSpeed
546 <<
" neighNextGap=" << neighNextGap
547 <<
" targetSpeed=" << targetSpeed
548 <<
" nextSpeed=" << nextSpeed
556 #ifdef DEBUG_INFORMER
559 <<
" cannot overtake fast leader nv=" << nv->
getID()
563 <<
" overtakeDist=" << overtakeDist
565 <<
" overtakeTime=" << overtakeTime
566 <<
" remainingSeconds=" << remainingSeconds
567 <<
" currentGap=" << neighLead.second
568 <<
" targetSpeed=" << targetSpeed
577 #ifdef DEBUG_INFORMER
580 <<
" wants to overtake leader nv=" << nv->
getID()
582 <<
" overtakeDist=" << overtakeDist
583 <<
" remainingSeconds=" << remainingSeconds
584 <<
" overtakeTime=" << overtakeTime
585 <<
" currentGap=" << neighLead.second
595 const double targetSpeed =
MAX2(
599 #ifdef DEBUG_INFORMER
601 std::cout <<
" not blocked by leader nv=" << nv->
getID()
603 <<
" gap=" << neighLead.second
604 <<
" neighNextSpeed=" << neighNextSpeed
605 <<
" neighNextGap=" << neighNextGap
607 <<
" targetSpeed=" << targetSpeed
611 return MIN2(targetSpeed, plannedSpeed);
619 const std::pair<MSVehicle*, double>& neighFollow,
620 double remainingSeconds,
621 double plannedSpeed) {
626 #ifdef DEBUG_INFORMER
628 std::cout <<
"\nINFORM_FOLLOWER"
634 #ifdef DEBUG_INFORMER
636 std::cout <<
" blocked by follower nv=" << nv->
getID() <<
" nvSpeed=" << nv->
getSpeed() <<
" needGap="
644 if ((neededGap - neighFollow.second) / remainingSeconds < (
MAX2(plannedSpeed, 0.) - nv->
getSpeed())) {
645 #ifdef DEBUG_INFORMER
647 std::cout <<
" wants to cut in before nv=" << nv->
getID() <<
" without any help." <<
"\nneededGap = " << neededGap <<
"\n";
667 double neighNewSpeed;
669 double neighNewSpeed1s;
679 dv = plannedSpeed - neighNewSpeed1s;
686 decelGap = neighFollow.second + dv;
693 neighNewSpeed1s = nv->
getSpeed() - helpDecel;
705 #ifdef DEBUG_INFORMER
709 <<
" plannedSpeed=" << plannedSpeed
710 <<
" threshold=" << onRampThreshold
711 <<
" neighNewSpeed=" << neighNewSpeed
712 <<
" neighNewSpeed1s=" << neighNewSpeed1s
714 <<
" gap=" << neighFollow.second
715 <<
" decelGap=" << decelGap
716 <<
" secureGap=" << secureGap
723 && neighNewSpeed1s < onRampThreshold) {
727 if (decelGap > 0 && decelGap >= secureGap) {
735 double vsafe, vsafe1;
744 assert(vsafe <= vsafe1);
755 #ifdef DEBUG_INFORMER
757 std::cout <<
"nextGap=" << nextGap <<
" (without help decel) \n";
765 MAX2(0., plannedSpeed),
773 nv->
getSpeed(), plannedAccel, -decel2,
783 MAX2(0., plannedSpeed),
788 #ifdef DEBUG_INFORMER
790 std::cout <<
"nextGap=" << nextGap
791 <<
" (with vsafe1 and help decel) \nvsafe1=" << vsafe1
792 <<
" vsafe=" << vsafe
801 if (nextGap < nextSecureGap) {
803 vsafe = neighNewSpeed;
806 #ifdef DEBUG_INFORMER
808 std::cout <<
"nextGap=" << nextGap
809 <<
" minNextSecureGap=" << nextSecureGap
810 <<
" vsafe=" << vsafe <<
"\n";
818 #ifdef DEBUG_INFORMER
820 std::cout <<
" wants to cut in before nv=" << nv->
getID()
821 <<
" vsafe1=" << vsafe1 <<
" vsafe=" << vsafe
847 #ifdef DEBUG_INFORMER
849 std::cout <<
" wants to cut in before nv=" << nv->
getID() <<
" (eventually)\n";
856 #ifdef DEBUG_INFORMER
858 std::cout <<
" wants to cut in before nv=" << nv->
getID() <<
" (nv cannot overtake right)\n";
877 #ifdef DEBUG_INFORMER
881 std::cout <<
" wants right follower to slow down a bit\n";
888 #ifdef DEBUG_INFORMER
891 std::cout <<
" wants to cut in before right follower nv=" << nv->
getID() <<
" (eventually)\n";
913 if (gapAfterRemainingSecs >= secureGapAfterRemainingSecs) {
914 #ifdef DEBUG_INFORMER
916 std::cout <<
" wants to cut in before follower nv=" << nv->
getID() <<
" (eventually)\n";
929 #ifdef DEBUG_INFORMER
933 <<
" informs follower " << nv->
getID()
934 <<
" vhelp=" << vhelp
943 const double needDV = overtakeDist / remainingSeconds;
947 #ifdef DEBUG_INFORMER
951 <<
" wants to be overtaken by=" << nv->
getID()
952 <<
" overtakeDist=" << overtakeDist
954 <<
" vhelp=" << vhelp
955 <<
" needDV=" << needDV
964 double vsafe, vsafe1;
978 double anticipationTime = 1.;
989 if (anticipatedGap > secureGap) {
996 if (anticipatedGap < secureGap) {
1007 #ifdef DEBUG_INFORMER
1009 std::cout <<
" wants to cut in before non-blocking follower nv=" << nv->
getID() <<
"\n";
1064 const std::pair<MSVehicle*, double>& leader,
1065 const std::pair<MSVehicle*, double>& neighLead,
1066 const std::pair<MSVehicle*, double>& neighFollow,
1068 const std::vector<MSVehicle::LaneQ>& preb,
1071 assert(laneOffset == 1 || laneOffset == -1);
1075 int bestLaneOffset = 0;
1080 double currentDist = 0;
1081 double neighDist = 0;
1090 const int prebOffset = (checkOpposite ? 0 : laneOffset);
1091 for (
int p = 0; p < (int) preb.size(); ++p) {
1092 if (preb[p].lane == prebLane && p + laneOffset >= 0) {
1093 assert(p + prebOffset < (
int)preb.size());
1095 neigh = preb[p + prebOffset];
1096 currentDist = curr.
length;
1097 neighDist = neigh.
length;
1098 bestLaneOffset = curr.bestLaneOffset;
1099 if (bestLaneOffset == 0 && preb[p + prebOffset].bestLaneOffset == 0) {
1100 #ifdef DEBUG_WANTS_CHANGE
1104 <<
" bestLaneOffsetOld=" << bestLaneOffset
1105 <<
" bestLaneOffsetNew=" << laneOffset
1109 bestLaneOffset = prebOffset;
1111 best = preb[p + bestLaneOffset];
1117 const bool right = (laneOffset == -1);
1119 neigh = preb[preb.size() - 1];
1122 bestLaneOffset = -1;
1124 neighDist = neigh.
length;
1125 currentDist = curr.
length;
1127 double driveToNextStop = -std::numeric_limits<double>::max();
1135 #ifdef DEBUG_WANTS_CHANGE
1140 <<
" stopPos=" << stopPos
1141 <<
" currentDist=" << currentDist
1142 <<
" neighDist=" << neighDist
1146 currentDist =
MAX2(currentDist, stopPos);
1147 neighDist =
MAX2(neighDist, stopPos);
1153 const bool changeToBest = (right && bestLaneOffset < 0) || (!right && bestLaneOffset > 0);
1159 if (lastBlocked != firstBlocked) {
1163 #ifdef DEBUG_WANTS_CHANGE
1172 <<
" leaderGap=" << leader.second
1174 <<
" neighLeadGap=" << neighLead.second
1176 <<
" neighFollowGap=" << neighFollow.second
1199 assert(memoryFactor > 0.);
1207 if (bestLaneOffset == 0 && leader.first != 0 && leader.first->isStopped() && leader.second < (currentDist - posOnLane)) {
1212 + leader.first->getVehicleType().getLengthWithGap()
1214 }
else if (bestLaneOffset == laneOffset && neighLead.first != 0 && neighLead.first->isStopped() && neighLead.second < (currentDist - posOnLane)) {
1217 + neighLead.first->getVehicleType().getLengthWithGap()
1218 + neighLead.second);
1233 currentDist += roundaboutBonus;
1234 neighDist += roundaboutBonus;
1238 const double maxJam =
MAX2(preb[currIdx + prebOffset].occupation, preb[currIdx].occupation);
1239 const double neighLeftPlace =
MAX2((
double) 0, neighDist - posOnLane - maxJam);
1242 double thisLaneVSafe = vMax;
1248 #ifdef DEBUG_WANTS_CHANGE
1253 <<
" laDist=" << laDist
1254 <<
" currentDist=" << currentDist
1255 <<
" usableDist=" << usableDist
1256 <<
" bestLaneOffset=" << bestLaneOffset
1258 <<
" best.length=" << best.
length
1259 <<
"\n roundaboutBonus=" << roundaboutBonus
1260 <<
" maxJam=" << maxJam
1261 <<
" neighDist=" << neighDist
1262 <<
" neighLeftPlace=" << neighLeftPlace
1267 bool changeLeftToAvoidOvertakeRight =
false;
1274 if (neighLead.first != 0 && checkOverTakeRight && !right) {
1286 if (vSafeFollow >= vMaxDecel) {
1287 vSafe = vSafeFollow;
1289 vSafe =
MAX2(vMaxDecel, vStayBehind);
1294 thisLaneVSafe =
MIN2(thisLaneVSafe, vSafe);
1297 const double deltaGapFuture = deltaV * 8;
1300 if (vSafeFuture < vSafe) {
1301 const double relativeGain = deltaV /
MAX2(vMax,
1304 changeLeftToAvoidOvertakeRight =
true;
1306 #ifdef DEBUG_WANTS_CHANGE
1309 <<
" avoid overtaking on the right nv=" << nv->
getID()
1310 <<
" deltaV=" << deltaV
1319 const double overtakeDist = (leader.first == 0 ? -1 :
1323 &&
MIN2(neighDist, currentDist) - posOnLane > overtakeDist
1325 && (!checkOverTakeRight || !right)
1326 && (neighLead.first == 0 || !neighLead.first->isStopped()
1328 || neighLead.second > overtakeDist)) {
1331 #ifdef DEBUG_WANTS_CHANGE
1333 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" overtake stopped leader=" << leader.first->getID()
1334 <<
" overtakeDist=" << overtakeDist
1335 <<
" remaining=" <<
MIN2(neighDist, currentDist) - posOnLane
1340 }
else if (!changeToBest && (
currentDistDisallows(neighLeftPlace, abs(bestLaneOffset) + 2, laDist))) {
1347 #ifdef DEBUG_WANTS_CHANGE
1349 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" could not change back and forth in time (1) neighLeftPlace=" << neighLeftPlace <<
"\n";
1353 }
else if (bestLaneOffset == 0 && (neighLeftPlace * 2. < laDist)) {
1358 #ifdef DEBUG_WANTS_CHANGE
1360 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" could not change back and forth in time (2) neighLeftPlace=" << neighLeftPlace <<
"\n";
1364 }
else if (bestLaneOffset == 0
1365 && (leader.first == 0 || !leader.first->isStopped())
1367 && roundaboutBonus == 0
1373 #ifdef DEBUG_WANTS_CHANGE
1375 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" does not want to leave the bestLane (neighDist=" << neighDist <<
")\n";
1382 #ifdef DEBUG_WANTS_CHANGE
1390 if ((ret & lcaCounter) != 0) {
1394 #ifdef DEBUG_WANTS_CHANGE
1396 std::cout <<
" retAfterInfluence=" << ret <<
"\n";
1407 if (changeToBest && abs(bestLaneOffset) > 1) {
1410 #ifdef DEBUG_WANTS_CHANGE
1412 std::cout <<
" reserving space for unseen blockers myLeadingBlockerLength=" <<
myLeadingBlockerLength <<
"\n";
1420 if (*firstBlocked != neighLead.first) {
1424 const int remainingLanes =
MAX2(1, abs(bestLaneOffset));
1426 const double remainingSeconds = ((ret &
LCA_TRACI) == 0 ?
1430 const double plannedSpeed =
informLeader(msgPass, blocked, myLca, neighLead, remainingSeconds);
1435 informFollower(msgPass, blocked, myLca, neighFollow, remainingSeconds, plannedSpeed);
1438 #ifdef DEBUG_WANTS_CHANGE
1443 <<
" remainingSeconds=" << remainingSeconds
1444 <<
" plannedSpeed=" << plannedSpeed
1452 const double inconvenience =
MIN2((
double)1.0, (laneOffset < 0
1459 if (roundaboutBonus > 0) {
1461 #ifdef DEBUG_WANTS_CHANGE
1465 <<
" roundaboutBonus=" << roundaboutBonus
1495 #ifdef DEBUG_WANTS_CHANGE
1497 std::cout <<
" veh=" <<
myVehicle.
getID() <<
" does not want to get stranded on the on-ramp of a highway\n";
1517 && (!speedGainInconvenient)
1519 && (changeToBest ||
currentDistAllows(neighDist, abs(bestLaneOffset) + 1, laDist))) {
1522 #ifdef DEBUG_COOPERATE
1526 <<
" wantsChangeToHelp=" << (right ?
"right" :
"left")
1528 << (((
myOwnState & myLca) == 0) ?
" (counter)" :
"")
1557 const bool acceleratingLeader = (neighLead.first != 0 && neighLead.first->getAcceleration() > 0)
1558 || (leader.first != 0 && leader.first->getAcceleration() > 0);
1560 if (acceleratingLeader) {
1567 if (neighLead.first == 0) {
1571 &
myVehicle, correctedSpeed, neighLead.second, neighLead.first->
getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel()));
1573 if (leader.first == 0) {
1577 &
myVehicle, correctedSpeed, leader.second, leader.first->
getSpeed(), leader.first->getCarFollowModel().getMaxDecel()));
1580 if (neighLead.first == 0) {
1584 neighLead.first->getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel(),
true));
1586 if (leader.first == 0) {
1590 leader.first->getSpeed(), leader.first->getCarFollowModel().getMaxDecel(),
true));
1600 const double relativeGain = (neighLaneVSafe - thisLaneVSafe) /
MAX2(neighLaneVSafe,
1603 #ifdef DEBUG_WANTS_CHANGE
1607 <<
" currentDist=" << currentDist
1608 <<
" neighDist=" << neighDist
1609 <<
" thisVSafe=" << thisLaneVSafe
1610 <<
" neighVSafe=" << neighLaneVSafe
1611 <<
" relGain=" <<
toString(relativeGain, 8)
1618 if (thisLaneVSafe - 5 / 3.6 > neighLaneVSafe) {
1635 if (mySpeedGainProbability < 0 || relativeGain > 0) {
1644 double fullSpeedDrivingSeconds =
MIN2(acceptanceTime, fullSpeedGap / vMax);
1645 if (neighLead.first != 0 && neighLead.first->getSpeed() < vMax) {
1646 fullSpeedGap =
MAX2(0.,
MIN2(fullSpeedGap,
1648 vMax, neighLead.first->
getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel())));
1649 fullSpeedDrivingSeconds =
MIN2(fullSpeedDrivingSeconds, fullSpeedGap / (vMax - neighLead.first->getSpeed()));
1652 if (checkOverTakeRight && leader.first != 0
1653 && leader.first->getLane()->getVehicleMaxSpeed(leader.first) < vMax) {
1654 fullSpeedGap =
MIN2(fullSpeedGap, leader.second);
1655 fullSpeedDrivingSeconds =
MIN2(fullSpeedDrivingSeconds, fullSpeedGap / (vMax - leader.first->getSpeed()));
1656 const double relativeGain = (vMax - leader.first->getLane()->getVehicleMaxSpeed(leader.first)) /
MAX2(vMax,
1665 #ifdef DEBUG_WANTS_CHANGE
1670 <<
" neighDist=" << neighDist
1672 <<
" leaderSpeed=" << (neighLead.first == 0 ? -1 : neighLead.first->getSpeed())
1674 myVehicle.
getSpeed(), neighLead.first->getSpeed(), neighLead.first->getCarFollowModel().getMaxDecel()))
1675 <<
" acceptanceTime=" << acceptanceTime
1676 <<
" fullSpeedGap=" << fullSpeedGap
1677 <<
" fullSpeedDrivingSeconds=" << fullSpeedDrivingSeconds
1678 <<
" dProb=" << deltaProb
1691 #ifdef DEBUG_WANTS_CHANGE
1697 <<
" thisLaneVSafe=" << thisLaneVSafe
1698 <<
" neighLaneVSafe=" << neighLaneVSafe
1699 <<
" relativeGain=" << relativeGain
1700 <<
" blocked=" << blocked
1714 if (thisLaneVSafe > neighLaneVSafe) {
1719 }
else if (thisLaneVSafe == neighLaneVSafe) {
1737 #ifdef DEBUG_WANTS_CHANGE
1743 <<
" thisLaneVSafe=" << thisLaneVSafe
1744 <<
" neighLaneVSafe=" << neighLaneVSafe
1745 <<
" relativeGain=" << relativeGain
1746 <<
" blocked=" << blocked
1752 && (relativeGain >
NUMERICAL_EPS || changeLeftToAvoidOvertakeRight)
1762 && relativeGain >= 0
1763 && (right ? mySpeedGainProbability < 0 : mySpeedGainProbability > 0)) {
1770 #ifdef DEBUG_WANTS_CHANGE
1776 <<
" thisLaneVSafe=" << thisLaneVSafe
1777 <<
" neighLaneVSafe=" << neighLaneVSafe
1793 int roundaboutJunctionsAhead = 0;
1794 bool enteredRoundabout =
false;
1800 if (lane ==
nullptr) {
1805 #ifdef DEBUG_WANTS_CHANGE
1807 std::cout <<
" noBonus: inner does not continue (lane=" << lane->
getID() <<
")\n";
1814 #ifdef DEBUG_WANTS_CHANGE
1816 std::cout <<
" noBonus: seen=" << seen <<
" (lane=" << lane->
getID() <<
")\n";
1823 enteredRoundabout =
true;
1825 roundaboutJunctionsAhead++;
1827 }
else if (enteredRoundabout) {
1834 if (roundaboutJunctionsAhead < 2) {
1840 double occupancyOuter = 0;
1841 double occupancyInner = 0;
1842 double distanceInRoundabout = 0;
1843 MSLane* prevNormal =
nullptr;
1844 MSLane* prevInner =
nullptr;
1845 enteredRoundabout =
false;
1848 if (lane ==
nullptr) {
1852 enteredRoundabout =
true;
1853 }
else if (enteredRoundabout) {
1858 if (prevNormal !=
nullptr) {
1860 if (link->getLane() == lane) {
1861 via = link->getViaLane();
1865 if (enteredRoundabout) {
1866 distanceInRoundabout += lane->
getLength();
1867 if (via !=
nullptr) {
1868 distanceInRoundabout += via->
getLength();
1877 std::cout <<
" lane=" << lane->
getID() <<
" occ=" << lane->
getBruttoVehLenSum() <<
" discount=" << upstreamDiscount <<
" outer=" << occupancyOuter <<
"\n";
1879 if (via !=
nullptr) {
1882 std::cout <<
" via=" << via->
getID() <<
" occ=" << via->
getBruttoVehLenSum() <<
" outer=" << occupancyOuter <<
"\n";
1889 std::cout <<
" inner=" << innerLane->
getID() <<
" occ=" << innerLane->
getBruttoVehLenSum() <<
" discount=" << upstreamDiscount <<
" inner=" << occupancyInner <<
"\n";
1891 if (prevInner !=
nullptr) {
1893 if (link->getLane() == innerLane && link->getViaLane() !=
nullptr) {
1894 occupancyInner += link->getViaLane()->getBruttoVehLenSum();
1896 std::cout <<
" innerVia=" << link->getViaLane()->getID() <<
" occ=" << link->getViaLane()->getBruttoVehLenSum() <<
" inner=" << occupancyInner <<
"\n";
1901 prevInner = innerLane;
1905 #ifdef DEBUG_WANTS_CHANGE
1907 std::cout <<
" distanceInRoundabout=" << distanceInRoundabout
1908 <<
" roundaboutJunctionsAhead=" << roundaboutJunctionsAhead
1909 <<
" occupancyInner=" << occupancyInner
1910 <<
" occupancyOuter=" << occupancyOuter
1915 const double maxOccupancy =
MAX2(occupancyInner, occupancyOuter);
1916 if (maxOccupancy == 0) {
1921 const double bonus = roundaboutJunctionsAhead * 7.5;
1922 const double relativeJam = (occupancyOuter - occupancyInner + bonus) / (maxOccupancy + bonus);
1924 const double jamFactor =
MAX2(0.0, relativeJam);
1926 #ifdef DEBUG_WANTS_CHANGE
1928 std::cout <<
" relativeJam=" << relativeJam
1929 <<
" jamFactor=" << jamFactor
1930 <<
" distanceBonus=" << result
1941 if ((*blocked) !=
nullptr) {
1943 #ifdef DEBUG_SLOW_DOWN
1967 (*blocked)->getCarFollowModel().getMaxDecel()));
1970 #ifdef DEBUG_SLOW_DOWN
1974 <<
" slowing down for"
1996 #ifdef DEBUG_SAVE_BLOCKER_LENGTH
2012 #ifdef DEBUG_SAVE_BLOCKER_LENGTH
2024 #ifdef DEBUG_SAVE_BLOCKER_LENGTH
2030 <<
" potential=" << potential
2043 #ifdef DEBUG_WANTS_CHANGE
2045 std::cout <<
SIMTIME <<
" adapt to pedestrians on lane=" << lane->
getID() <<
"\n";
2051 if (leader.first != 0) {
2053 v =
MIN2(v, stopSpeed);
2054 #ifdef DEBUG_WANTS_CHANGE
2056 std::cout <<
SIMTIME <<
" pedLeader=" << leader.first->getID() <<
" dist=" << leader.second <<
" v=" << v <<
"\n";
2077 return MAX2(-speedBound,
MIN2(speedBound,
2093 return myOppositeParam <= 0 ? std::numeric_limits<double>::max() : 1 /
myOppositeParam;