Eclipse SUMO - Simulation of Urban MObility
Loading...
Searching...
No Matches
MSLCM_SL2015.h
Go to the documentation of this file.
1/****************************************************************************/
2// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3// Copyright (C) 2013-2024 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
19// A lane change model for heterogeneous traffic (based on sub-lanes)
20/****************************************************************************/
21#pragma once
22#include <config.h>
23
25#include <vector>
26
27
28// ===========================================================================
29// class definitions
30// ===========================================================================
36public:
37
39
40 virtual ~MSLCM_SL2015();
41
43 LaneChangeModel getModelID() const override {
45 }
46
49
58 int wantsChangeSublane(int laneOffset,
59 LaneChangeAction alternatives,
60 const MSLeaderDistanceInfo& leaders,
61 const MSLeaderDistanceInfo& followers,
62 const MSLeaderDistanceInfo& blockers,
63 const MSLeaderDistanceInfo& neighLeaders,
64 const MSLeaderDistanceInfo& neighFollowers,
65 const MSLeaderDistanceInfo& neighBlockers,
66 const MSLane& neighLane,
67 const std::vector<MSVehicle::LaneQ>& preb,
68 MSVehicle** lastBlocked,
69 MSVehicle** firstBlocked,
70 double& latDist, double& maneuverDist, int& blocked) override;
71
79 int wantsChange(
80 int laneOffset,
81 MSAbstractLaneChangeModel::MSLCMessager& msgPass, int blocked,
82 const std::pair<MSVehicle*, double>& leader,
83 const std::pair<MSVehicle*, double>& follower,
84 const std::pair<MSVehicle*, double>& neighLead,
85 const std::pair<MSVehicle*, double>& neighFollow,
86 const MSLane& neighLane,
87 const std::vector<MSVehicle::LaneQ>& preb,
88 MSVehicle** lastBlocked,
89 MSVehicle** firstBlocked) override;
90
91 void* inform(void* info, MSVehicle* sender) override;
92
103 double patchSpeed(const double min, const double wanted, const double max,
104 const MSCFModel& cfModel) override;
105
106 void changed() override;
107
108 void resetState() override;
109
110 double getSafetyFactor() const override;
111
112 double getOppositeSafetyFactor() const override;
113
114 void prepareStep() override;
115
116 double getExtraReservation(int bestLaneOffset) const override;
117
119 bool debugVehicle() const override;
120
121 void setOwnState(const int state) override;
122
125 virtual void updateSafeLatDist(const double travelledLatDist) override;
126
128 std::string getParameter(const std::string& key) const override;
129
131 void setParameter(const std::string& key, const std::string& value) override;
132
135 double computeSpeedLat(double latDist, double& maneuverDist, bool urgent) const override;
136
138
139protected:
141 double _patchSpeed(double min, const double wanted, double max,
142 const MSCFModel& cfModel);
143
146 int laneOffset,
147 LaneChangeAction alternatives,
148 const MSLeaderDistanceInfo& leaders,
149 const MSLeaderDistanceInfo& followers,
150 const MSLeaderDistanceInfo& blockers,
151 const MSLeaderDistanceInfo& neighLeaders,
152 const MSLeaderDistanceInfo& neighFollowers,
153 const MSLeaderDistanceInfo& neighBlockers,
154 const MSLane& neighLane,
155 const std::vector<MSVehicle::LaneQ>& preb,
156 MSVehicle** lastBlocked,
157 MSVehicle** firstBlocked,
158 double& latDist, double& maneuverDist, int& blocked);
159
160
161 /* @brief decide whether we will overtake or follow blocking leaders
162 * and inform them accordingly (see informLeader)
163 * If we decide to follow, myVSafes will be extended
164 * returns the planned speed if following or -1 if overtaking */
165 double informLeaders(int blocked, int dir,
166 const std::vector<CLeaderDist>& blockers,
167 double remainingSeconds);
168
170 void informFollowers(int blocked, int dir,
171 const std::vector<CLeaderDist>& blockers,
172 double remainingSeconds,
173 double plannedSpeed);
174
175 /* @brief decide whether we will overtake or follow a blocking leader
176 * and inform it accordingly
177 * If we decide to follow, myVSafes will be extended
178 * returns the planned speed if following or -1 if overtaking */
179 double informLeader(int blocked, int dir,
180 const CLeaderDist& neighLead,
181 double remainingSeconds);
182
184 void informFollower(int blocked, int dir,
185 const CLeaderDist& neighFollow,
186 double remainingSeconds,
187 double plannedSpeed);
188
189
191 int slowDownForBlocked(MSVehicle** blocked, int state);
192
194 bool saveBlockerLength(double length, double foeLeftSpace) override;
195
197 bool outsideEdge() const;
198
199 inline bool amBlockingLeader() {
200 return (myOwnState & LCA_AMBLOCKINGLEADER) != 0;
201 }
202 inline bool amBlockingFollower() {
203 return (myOwnState & LCA_AMBLOCKINGFOLLOWER) != 0;
204 }
205 inline bool amBlockingFollowerNB() {
207 }
211 inline bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist) {
212 return dist / (abs(laneOffset)) < lookForwardDist;
213 }
214 inline bool currentDistAllows(double dist, int laneOffset, double lookForwardDist) {
215 return dist / abs(laneOffset) > lookForwardDist;
216 }
217
218
220 typedef std::pair<double, int> Info;
221
223 void updateExpectedSublaneSpeeds(const MSLeaderDistanceInfo& ahead, int sublaneOffset, int laneIndex) override;
224
226 StateAndDist decideDirection(StateAndDist sd1, StateAndDist sd2) const override;
227
229 static int lowest_bit(int changeReason);
230
231protected:
232
234 void msg(const CLeaderDist& cld, double speed, int state);
235
237 int computeSublaneShift(const MSEdge* prevEdge, const MSEdge* curEdge);
238
241
242 bool tieBrakeLeader(const MSVehicle* veh) const;
243
246
248 int checkBlocking(const MSLane& neighLane, double& latDist, double maneuverDist, int laneOffset,
249 const MSLeaderDistanceInfo& leaders,
250 const MSLeaderDistanceInfo& followers,
251 const MSLeaderDistanceInfo& blockers,
252 const MSLeaderDistanceInfo& neighLeaders,
253 const MSLeaderDistanceInfo& neighFollowers,
254 const MSLeaderDistanceInfo& neighBlockers,
255 std::vector<CLeaderDist>* collectLeadBlockers = 0,
256 std::vector<CLeaderDist>* collectFollowBlockers = 0,
257 bool keepLatGapManeuver = false,
258 double gapFactor = 0,
259 int* retBlockedFully = 0);
260
262 int checkBlockingVehicles(const MSVehicle* ego, const MSLeaderDistanceInfo& vehicles,
263 int laneOffset, double latDist, double foeOffset, bool leaders,
264 double& safeLatGapRight, double& safeLatGapLeft,
265 std::vector<CLeaderDist>* collectBlockers = 0) const;
266
268 static bool overlap(double right, double left, double right2, double left2);
269
271 static LaneChangeAction getLCA(int state, double latDist);
272
275 int checkStrategicChange(int ret,
276 const MSLane& neighLane,
277 int laneOffset,
278 const MSLeaderDistanceInfo& leaders,
279 const MSLeaderDistanceInfo& neighLeaders,
280 const MSVehicle::LaneQ& curr,
281 const MSVehicle::LaneQ& neigh,
282 const MSVehicle::LaneQ& best,
283 int bestLaneOffset,
284 bool changeToBest,
285 double currentDist,
286 double neighDist,
287 double laDist,
288 double roundaboutBonus,
289 double latLaneDist,
290 bool checkOpposite,
291 double& latDist
292 );
293
294
295 bool mustOvertakeStopped(const MSLane& neighLane, const MSLeaderDistanceInfo& leaders, const MSLeaderDistanceInfo& neighLead,
296 double posOnLane, double neighDist, bool right, double latLaneDist, double& currentDist, double& latDist);
297
299 int keepLatGap(int state,
300 const MSLeaderDistanceInfo& leaders,
301 const MSLeaderDistanceInfo& followers,
302 const MSLeaderDistanceInfo& blockers,
303 const MSLeaderDistanceInfo& neighLeaders,
304 const MSLeaderDistanceInfo& neighFollowers,
305 const MSLeaderDistanceInfo& neighBlockers,
306 const MSLane& neighLane,
307 int laneOffset,
308 double& latDist,
309 double& maneuverDist,
310 int& blocked);
311
312
314 void updateGaps(const MSLeaderDistanceInfo& others, double foeOffset, double oldCenter, double gapFactor,
315 double& surplusGapRight, double& surplusGapLeft, bool saveMinGap = false, double netOverlap = 0,
316 double latDist = 0,
317 std::vector<CLeaderDist>* collectBlockers = 0);
318
320 double computeGapFactor(int state) const;
321
323 double getWidth() const;
324
326 void updateCFRelated(const MSLeaderDistanceInfo& vehicles, double foeOffset, bool leaders);
327
332
334 void commitManoeuvre(int blocked, int blockedFully,
335 const MSLeaderDistanceInfo& leaders,
336 const MSLeaderDistanceInfo& neighLeaders,
337 const MSLane& neighLane,
338 double maneuverDist);
339
341 double commitFollowSpeed(double speed, double latDist, double secondsToLeaveLane, const MSLeaderDistanceInfo& leaders, double foeOffset) const;
342
344 double forecastAverageSpeed(double vSafe, double vMax, double gap, double vLeader) const;
345
347 double computeSpeedGain(double latDistSublane, double defaultNextSpeed) const;
348
350 double getPosLat();
351
353 double getLateralDrift();
354
356 double getLeftBorder(bool checkOpposite = true) const;
357
359 double getVehicleCenter() const;
360
362 double getNeighRight(const MSLane& neighLane) const;
363
364 /* @brief check whether vehicle speed is appropriate for the intended maneuver distance
365 * (rather than doing an orthogonal slide) */
366 bool preventSliding(double maneuverDist) const;
367
369 inline bool wantsKeepRight(double keepRightProb) const;
370
372 bool isBidi(const MSLane* lane) const;
373
375 double emergencySpeedLat(double speedLat) const;
376
377protected:
382
383 /* @brief a value for tracking the probability of following the/"Rechtsfahrgebot"
384 * A larger negative value indicates higher probability for moving to the
385 * right (as in mySpeedGainProbability) */
387
390
391 /*@brief the speed to use when computing the look-ahead distance for
392 * determining urgency of strategic lane changes */
394
396 std::vector<double> myExpectedSublaneSpeeds;
397
400
403
406
410
412 std::set<const MSVehicle*> myCFRelated;
414
416
423 // @brief minimum lateral gap
425 // @brief willingness to encroach on other vehicles laterally (pushing them around)
426 double myPushy;
427 // @brief willingness to undercut longitudinal safe gaps
429 // @brief dynamic component of willingness for longitudinal gap reduction
432 // @brief time to reach maximum impatience in seconds
434 // @brief lateral acceleration
436 // @brief distance to turn at which alignment should be adjusted to the turn direction
438 // @brief the factor by which the lookahead distance to the left differs from the lookahead to the right
440 // @brief the factor by which the speedGain-threshold for the leftdiffers from the threshold for the right
442 // @brief lane discipline factor
444 // @brief lookahead for speedGain in seconds
446 // @brief the minimum time to spent driving without lane change after a speed-gain change
448 // @brief bonus factor staying on the inside of multi-lane roundabout
450 // @brief factor for cooperative speed adjustment
452 // time for unrestricted driving on the right to accept keepRight change
454 // @brief speed difference factor for overtaking the leader on the neighbor lane before changing to that lane
457
459
460 // @brief threshold value for changing to the right
462 // @brief threshold value for changing to the left
464 // @brief threshold value for accepting speed loss to achieve desired sublane alignment
466
467 // @brief state of lane keeping imperfection
470
471};
std::pair< const MSVehicle *, double > CLeaderDist
LatAlignmentDefinition
Possible ways to choose the lateral alignment, i.e., how vehicles align themselves within their lane.
LaneChangeAction
The state of a vehicle's lane-change behavior.
@ LCA_AMBLOCKINGLEADER
@ LCA_AMBLOCKINGFOLLOWER_DONTBRAKE
@ LCA_AMBLOCKINGFOLLOWER
A class responsible for exchanging messages between cars involved in lane-change interaction.
Interface for lane-change models.
int myOwnState
The current state of the vehicle.
MSVehicle & myVehicle
The vehicle this lane-changer belongs to.
The car-following model abstraction.
Definition MSCFModel.h:55
A road/street connecting two junctions.
Definition MSEdge.h:77
static double gLateralResolution
Definition MSGlobals.h:100
A lane change model developed by J. Erdmann.
double mySafeLatDistRight
the lateral distance the vehicle can safely move in the currently considered direction
static bool overlap(double right, double left, double right2, double left2)
return whether the given intervals overlap
double _patchSpeed(double min, const double wanted, double max, const MSCFModel &cfModel)
double informLeaders(int blocked, int dir, const std::vector< CLeaderDist > &blockers, double remainingSeconds)
double myRoundaboutBonus
void commitManoeuvre(int blocked, int blockedFully, const MSLeaderDistanceInfo &leaders, const MSLeaderDistanceInfo &neighLeaders, const MSLane &neighLane, double maneuverDist)
commit to lane change maneuver potentially overriding safe speed
std::set< const MSVehicle * > myCFRelated
set of vehicles that are in a car-following relationship with ego (leader of followers)
void prepareStep() override
double myKeepRightProbability
double myMinImpatience
double commitFollowSpeed(double speed, double latDist, double secondsToLeaveLane, const MSLeaderDistanceInfo &leaders, double foeOffset) const
compute speed when committing to an urgent change that is safe in regard to leading vehicles
double getLeftBorder(bool checkOpposite=true) const
return current edge width optionally extended by opposite direction lane width
double myChangeProbThresholdRight
double informLeader(int blocked, int dir, const CLeaderDist &neighLead, double remainingSeconds)
double mySafeLatDistLeft
double getSublaneWidth()
return the current sublane width (and return a sensible value when running without sublanes)
int computeSublaneShift(const MSEdge *prevEdge, const MSEdge *curEdge)
compute shift so that prevSublane + shift = newSublane
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 ...
double getSafetyFactor() const override
return factor for modifying the safety constraints of the car-following model
double myCooperativeSpeed
double computeSpeedLat(double latDist, double &maneuverDist, bool urgent) const override
decides the next lateral speed depending on the remaining lane change distance to be covered and upda...
std::vector< double > myExpectedSublaneSpeeds
expected travel speeds on all sublanes on the current edge(!)
double getWidth() const
return the width of this vehicle (padded for numerical stability)
bool myCanChangeFully
whether the current lane changing maneuver can be finished in a single step
void changed() 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) override
Called to examine whether the vehicle wants to change using the given laneOffset (this is a wrapper a...
double myLaneDiscipline
bool outsideEdge() const
whether the ego vehicle is driving outside edgebounds
bool myDontBrake
flag to prevent speed adaptation by slowing down
std::string getParameter(const std::string &key) const override
try to retrieve the given parameter from this device. Throw exception for unsupported key
bool wantsKeepRight(double keepRightProb) const
check against thresholds
bool amBlockingFollower()
double forecastAverageSpeed(double vSafe, double vMax, double gap, double vLeader) const
estimate average speed over mySpeedGainLookahead time
LaneChangeModel getModelID() const override
Returns the model's id.
void updateCFRelated(const MSLeaderDistanceInfo &vehicles, double foeOffset, bool leaders)
find leaders/followers that are already in a car-following relationship with ego
bool debugVehicle() const override
whether the current vehicles shall be debugged
double myAccelLat
int wantsChangeSublane(int laneOffset, LaneChangeAction alternatives, const MSLeaderDistanceInfo &leaders, const MSLeaderDistanceInfo &followers, const MSLeaderDistanceInfo &blockers, const MSLeaderDistanceInfo &neighLeaders, const MSLeaderDistanceInfo &neighFollowers, const MSLeaderDistanceInfo &neighBlockers, const MSLane &neighLane, const std::vector< MSVehicle::LaneQ > &preb, MSVehicle **lastBlocked, MSVehicle **firstBlocked, double &latDist, double &maneuverDist, int &blocked) override
Called to examine whether the vehicle wants to change with the given laneOffset (using the sublane mo...
LatAlignmentDefinition getDesiredAlignment() const override
double mySpeedGainProbabilityRight
a value for tracking the probability that a change to the right is beneficial
double myLookAheadSpeed
int slowDownForBlocked(MSVehicle **blocked, int state)
compute useful slowdowns for blocked vehicles
void initDerivedParameters()
init cached parameters derived directly from model parameters
int keepLatGap(int state, const MSLeaderDistanceInfo &leaders, const MSLeaderDistanceInfo &followers, const MSLeaderDistanceInfo &blockers, const MSLeaderDistanceInfo &neighLeaders, const MSLeaderDistanceInfo &neighFollowers, const MSLeaderDistanceInfo &neighBlockers, const MSLane &neighLane, int laneOffset, double &latDist, double &maneuverDist, int &blocked)
check whether lateral gap requirements are met override the current maneuver if necessary
bool tieBrakeLeader(const MSVehicle *veh) const
bool currentDistAllows(double dist, int laneOffset, double lookForwardDist)
CLeaderDist getLongest(const MSLeaderDistanceInfo &ldi) const
get the longest vehicle in the given info
double myCooperativeParam
double getNeighRight(const MSLane &neighLane) const
return the right offset of the neighboring lane relative to the current edge
double computeSpeedGain(double latDistSublane, double defaultNextSpeed) const
compute speedGain when moving by the given amount
double emergencySpeedLat(double speedLat) const
avoid unsafe lateral speed (overruling lcAccelLat)
double myKeepRightAcceptanceTime
double mySigmaState
void updateGaps(const MSLeaderDistanceInfo &others, double foeOffset, double oldCenter, double gapFactor, double &surplusGapRight, double &surplusGapLeft, bool saveMinGap=false, double netOverlap=0, double latDist=0, std::vector< CLeaderDist > *collectBlockers=0)
check remaining lateral gaps for the given foe vehicles and optionally update minimum lateral gaps
double mySpeedGainParam
virtual void updateSafeLatDist(const double travelledLatDist) override
Updates the value of safe lateral distances (mySafeLatDistLeft and mySafeLatDistRight) during maneuve...
const MSEdge * myLastEdge
expected travel speeds on all sublanes on the current edge(!)
double getOppositeSafetyFactor() const override
return factor for modifying the safety constraints for opposite-diretction overtaking of the car-foll...
int checkStrategicChange(int ret, const MSLane &neighLane, int laneOffset, const MSLeaderDistanceInfo &leaders, const MSLeaderDistanceInfo &neighLeaders, const MSVehicle::LaneQ &curr, const MSVehicle::LaneQ &neigh, const MSVehicle::LaneQ &best, int bestLaneOffset, bool changeToBest, double currentDist, double neighDist, double laDist, double roundaboutBonus, double latLaneDist, bool checkOpposite, double &latDist)
compute strategic lane change actions TODO: Better documentation, refs #2
StateAndDist decideDirection(StateAndDist sd1, StateAndDist sd2) const override
decide in which direction to move in case both directions are desirable
double myImpatience
double myOppositeParam
double myLeftSpace
std::pair< double, int > Info
information regarding save velocity (unused) and state flags of the ego vehicle
void msg(const CLeaderDist &cld, double speed, int state)
send a speed recommendation to the given vehicle
double mySpeedGainRemainTime
double myLookaheadLeft
int checkBlocking(const MSLane &neighLane, double &latDist, double maneuverDist, int laneOffset, const MSLeaderDistanceInfo &leaders, const MSLeaderDistanceInfo &followers, const MSLeaderDistanceInfo &blockers, const MSLeaderDistanceInfo &neighLeaders, const MSLeaderDistanceInfo &neighFollowers, const MSLeaderDistanceInfo &neighBlockers, std::vector< CLeaderDist > *collectLeadBlockers=0, std::vector< CLeaderDist > *collectFollowBlockers=0, bool keepLatGapManeuver=false, double gapFactor=0, int *retBlockedFully=0)
restrict latDist to permissible speed and determine blocking state depending on that distance
bool amBlockingLeader()
double myStrategicParam
double getVehicleCenter() const
return vehicle position relative to the current edge (extend by another virtual lane for opposite-dir...
int _wantsChangeSublane(int laneOffset, LaneChangeAction alternatives, const MSLeaderDistanceInfo &leaders, const MSLeaderDistanceInfo &followers, const MSLeaderDistanceInfo &blockers, const MSLeaderDistanceInfo &neighLeaders, const MSLeaderDistanceInfo &neighFollowers, const MSLeaderDistanceInfo &neighBlockers, const MSLane &neighLane, const std::vector< MSVehicle::LaneQ > &preb, MSVehicle **lastBlocked, MSVehicle **firstBlocked, double &latDist, double &maneuverDist, int &blocked)
helper function for doing the actual work
double getLateralDrift()
get lateral drift for the current step
double computeGapFactor(int state) const
compute the gap factor for the given state
double getPosLat()
get lateral position of this vehicle
bool preventSliding(double maneuverDist) const
bool isBidi(const MSLane *lane) const
check whether lane is an upcoming bidi lane
bool mustOvertakeStopped(const MSLane &neighLane, const MSLeaderDistanceInfo &leaders, const MSLeaderDistanceInfo &neighLead, double posOnLane, double neighDist, bool right, double latLaneDist, double &currentDist, double &latDist)
void * inform(void *info, MSVehicle *sender) override
double myMinGapLat
void informFollower(int blocked, int dir, const CLeaderDist &neighFollow, double remainingSeconds, double plannedSpeed)
decide whether we will try cut in before the follower or allow to be overtaken
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
bool saveBlockerLength(double length, double foeLeftSpace) override
reserve space at the end of the lane to avoid dead locks
double myOvertakeDeltaSpeedFactor
double myTurnAlignmentDist
double myLeadingBlockerLength
void setOwnState(const int state) override
int checkBlockingVehicles(const MSVehicle *ego, const MSLeaderDistanceInfo &vehicles, int laneOffset, double latDist, double foeOffset, bool leaders, double &safeLatGapRight, double &safeLatGapLeft, std::vector< CLeaderDist > *collectBlockers=0) const
check whether any of the vehicles overlaps with ego
void informFollowers(int blocked, int dir, const std::vector< CLeaderDist > &blockers, double remainingSeconds, double plannedSpeed)
call informFollower for multiple followers
double mySpeedGainLookahead
virtual ~MSLCM_SL2015()
double mySpeedLossProbThreshold
void resetState() override
bool myCFRelatedReady
double mySpeedGainProbabilityLeft
a value for tracking the probability that a change to the left is beneficial
bool amBlockingFollowerNB()
double myAssertive
double mySpeedGainRight
static LaneChangeAction getLCA(int state, double latDist)
compute lane change action from desired lateral distance
double myChangeProbThresholdLeft
void updateExpectedSublaneSpeeds(const MSLeaderDistanceInfo &ahead, int sublaneOffset, int laneIndex) override
update expected speeds for each sublane of the current edge
bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist)
double getExtraReservation(int bestLaneOffset) const override
reserve extra space for unseen blockers when more tnan one lane change is required
double myTimeToImpatience
static int lowest_bit(int changeReason)
return the most important change reason
static CLeaderDist getSlowest(const MSLeaderDistanceInfo &ldi)
get the slowest vehicle in the given info
bool amBlockingFollowerPlusNB()
double myKeepRightParam
double mySublaneParam
Representation of a lane in the micro simulation.
Definition MSLane.h:84
double getWidth() const
Returns the lane's width.
Definition MSLane.h:635
saves leader/follower vehicles and their distances relative to an ego vehicle
Representation of a vehicle in the micro simulation.
Definition MSVehicle.h:77
const MSLane * getLane() const
Returns the lane the vehicle is on.
Definition MSVehicle.h:581
A structure representing the best lanes for continuing the current route starting at 'lane'.
Definition MSVehicle.h:857