Eclipse SUMO - Simulation of Urban MObility
MSLCM_SL2015.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2013-2022 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 // ===========================================================================
36 public:
37 
39 
40  virtual ~MSLCM_SL2015();
41 
43  LaneChangeModel getModelID() const override {
45  }
46 
48  void initDerivedParameters();
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  double getSafetyFactor() const override;
109 
110  double getOppositeSafetyFactor() const override;
111 
112  void prepareStep() override;
113 
115  bool debugVehicle() const override;
116 
117  void setOwnState(const int state) override;
118 
121  virtual void updateSafeLatDist(const double travelledLatDist) override;
122 
124  std::string getParameter(const std::string& key) const override;
125 
127  void setParameter(const std::string& key, const std::string& value) override;
128 
131  double computeSpeedLat(double latDist, double& maneuverDist, bool urgent) const override;
132 
133 protected:
135  double _patchSpeed(const double min, const double wanted, const double max,
136  const MSCFModel& cfModel);
137 
140  int laneOffset,
141  LaneChangeAction alternatives,
142  const MSLeaderDistanceInfo& leaders,
143  const MSLeaderDistanceInfo& followers,
144  const MSLeaderDistanceInfo& blockers,
145  const MSLeaderDistanceInfo& neighLeaders,
146  const MSLeaderDistanceInfo& neighFollowers,
147  const MSLeaderDistanceInfo& neighBlockers,
148  const MSLane& neighLane,
149  const std::vector<MSVehicle::LaneQ>& preb,
150  MSVehicle** lastBlocked,
151  MSVehicle** firstBlocked,
152  double& latDist, double& maneuverDist, int& blocked);
153 
154 
155  /* @brief decide whether we will overtake or follow blocking leaders
156  * and inform them accordingly (see informLeader)
157  * If we decide to follow, myVSafes will be extended
158  * returns the planned speed if following or -1 if overtaking */
159  double informLeaders(int blocked, int dir,
160  const std::vector<CLeaderDist>& blockers,
161  double remainingSeconds);
162 
164  void informFollowers(int blocked, int dir,
165  const std::vector<CLeaderDist>& blockers,
166  double remainingSeconds,
167  double plannedSpeed);
168 
169  /* @brief decide whether we will overtake or follow a blocking leader
170  * and inform it accordingly
171  * If we decide to follow, myVSafes will be extended
172  * returns the planned speed if following or -1 if overtaking */
173  double informLeader(int blocked, int dir,
174  const CLeaderDist& neighLead,
175  double remainingSeconds);
176 
178  void informFollower(int blocked, int dir,
179  const CLeaderDist& neighFollow,
180  double remainingSeconds,
181  double plannedSpeed);
182 
183 
185  int slowDownForBlocked(MSVehicle** blocked, int state);
186 
188  void saveBlockerLength(const MSVehicle* blocker, int lcaCounter);
189 
191  inline void saveBlockerLength(double length) override {
193  };
194 
195  inline bool amBlockingLeader() {
196  return (myOwnState & LCA_AMBLOCKINGLEADER) != 0;
197  }
198  inline bool amBlockingFollower() {
199  return (myOwnState & LCA_AMBLOCKINGFOLLOWER) != 0;
200  }
201  inline bool amBlockingFollowerNB() {
203  }
204  inline bool amBlockingFollowerPlusNB() {
206  }
207  inline bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist) {
208  return dist / (abs(laneOffset)) < lookForwardDist;
209  }
210  inline bool currentDistAllows(double dist, int laneOffset, double lookForwardDist) {
211  return dist / abs(laneOffset) > lookForwardDist;
212  }
213 
214 
216  typedef std::pair<double, int> Info;
217 
224  void addLCSpeedAdvice(const double vSafe);
225 
227  void updateExpectedSublaneSpeeds(const MSLeaderDistanceInfo& ahead, int sublaneOffset, int laneIndex) override;
228 
230  StateAndDist decideDirection(StateAndDist sd1, StateAndDist sd2) const override;
231 
233  static int lowest_bit(int changeReason);
234 
235 protected:
236 
238  void msg(const CLeaderDist& cld, double speed, int state);
239 
241  int computeSublaneShift(const MSEdge* prevEdge, const MSEdge* curEdge);
242 
244  static CLeaderDist getLongest(const MSLeaderDistanceInfo& ldi);
245 
247  static CLeaderDist getSlowest(const MSLeaderDistanceInfo& ldi);
248 
250  int checkBlocking(const MSLane& neighLane, double& latDist, double maneuverDist, int laneOffset,
251  const MSLeaderDistanceInfo& leaders,
252  const MSLeaderDistanceInfo& followers,
253  const MSLeaderDistanceInfo& blockers,
254  const MSLeaderDistanceInfo& neighLeaders,
255  const MSLeaderDistanceInfo& neighFollowers,
256  const MSLeaderDistanceInfo& neighBlockers,
257  std::vector<CLeaderDist>* collectLeadBlockers = 0,
258  std::vector<CLeaderDist>* collectFollowBlockers = 0,
259  bool keepLatGapManeuver = false,
260  double gapFactor = 0,
261  int* retBlockedFully = 0);
262 
264  int checkBlockingVehicles(const MSVehicle* ego, const MSLeaderDistanceInfo& vehicles,
265  double latDist, double foeOffset, bool leaders, LaneChangeAction blockType,
266  double& safeLatGapRight, double& safeLatGapLeft,
267  std::vector<CLeaderDist>* collectBlockers = 0) const;
268 
270  static bool overlap(double right, double left, double right2, double left2);
271 
273  static LaneChangeAction getLCA(int state, double latDist);
274 
277  int checkStrategicChange(int ret,
278  int laneOffset,
279  const MSLeaderDistanceInfo& leaders,
280  const MSLeaderDistanceInfo& neighLeaders,
281  const MSVehicle::LaneQ& curr,
282  const MSVehicle::LaneQ& neigh,
283  const MSVehicle::LaneQ& best,
284  int bestLaneOffset,
285  bool changeToBest,
286  double currentDist,
287  double neighDist,
288  double laDist,
289  double roundaboutBonus,
290  double latLaneDist,
291  bool checkOpposite,
292  double& latDist
293  );
294 
295 
297  int keepLatGap(int state,
298  const MSLeaderDistanceInfo& leaders,
299  const MSLeaderDistanceInfo& followers,
300  const MSLeaderDistanceInfo& blockers,
301  const MSLeaderDistanceInfo& neighLeaders,
302  const MSLeaderDistanceInfo& neighFollowers,
303  const MSLeaderDistanceInfo& neighBlockers,
304  const MSLane& neighLane,
305  int laneOffset,
306  double& latDist,
307  double& maneuverDist,
308  int& blocked);
309 
310 
312  void updateGaps(const MSLeaderDistanceInfo& others, double foeOffset, double oldCenter, double gapFactor,
313  double& surplusGapRight, double& surplusGapLeft, bool saveMinGap = false, double netOverlap = 0,
314  double latDist = 0,
315  std::vector<CLeaderDist>* collectBlockers = 0);
316 
318  double computeGapFactor(int state) const;
319 
321  double getWidth() const;
322 
324  void updateCFRelated(const MSLeaderDistanceInfo& vehicles, double foeOffset, bool leaders);
325 
327  double getSublaneWidth() {
329  }
330 
332  void commitManoeuvre(int blocked, int blockedFully,
333  const MSLeaderDistanceInfo& leaders,
334  const MSLeaderDistanceInfo& neighLeaders,
335  const MSLane& neighLane,
336  double maneuverDist);
337 
339  double commitFollowSpeed(double speed, double latDist, double secondsToLeaveLane, const MSLeaderDistanceInfo& leaders, double foeOffset) const;
340 
342  double forecastAverageSpeed(double vSafe, double vMax, double gap, double vLeader) const;
343 
345  double computeSpeedGain(double latDistSublane, double defaultNextSpeed) const;
346 
348  double getPosLat();
349 
351  double getLateralDrift();
352 
354  double getLeftBorder(bool checkOpposite = true) const;
355 
357  double getVehicleCenter() const;
358 
360  double getNeighRight(const MSLane& neighLane) const;
361 
362  /* @brief check whether vehicle speed is appropriate for the intended maneuver distance
363  * (rather than doing an orthgonal slide) */
364  bool preventSliding(double maneuverDist) const;
365 
367  inline bool wantsKeepRight(double keepRightProb) const;
368 
369 protected:
374 
375  /* @brief a value for tracking the probability of following the/"Rechtsfahrgebot"
376  * A larger negative value indicates higher probability for moving to the
377  * right (as in mySpeedGainProbability) */
379 
381  double myLeftSpace;
382 
383  /*@brief the speed to use when computing the look-ahead distance for
384  * determining urgency of strategic lane changes */
386 
389  std::vector<double> myLCAccelerationAdvices;
390 
392  std::vector<double> myExpectedSublaneSpeeds;
393 
396 
399 
402 
406 
408  std::set<const MSVehicle*> myCFRelated;
410 
412 
419  // @brief minimum lateral gap
420  double myMinGapLat;
421  // @brief willingness to encroach on other vehicles laterally (pushing them around)
422  double myPushy;
423  // @brief willingness to undercut longitudinal safe gaps
424  double myAssertive;
425  // @brief dynamic component of willingness for longitudinal gap reduction
426  double myImpatience;
428  // @brief time to reach maximum impatience in seconds
430  // @brief lateral acceleration
431  double myAccelLat;
432  // @brief distance to turn at which alignment should be adjusted to the turn direction
434  // @brief the factor by which the lookahead distance to the left differs from the lookahead to the right
436  // @brief the factor by which the speedGain-threshold for the leftdiffers from the threshold for the right
438  // @brief lane discipline factor
440  // @brief lookahead for speedGain in seconds
442  // @brief bounus factor staying on the inside of multi-lane roundabout
444  // @brief factor for cooperative speed adjustment
446  // time for unrestricted driving on the right to accept keepRight change
449 
451 
452  // @brief threshold value for changing to the right
454  // @brief threshold value for changing to the left
456  // @brief threshold value for accepting speed loss to achieve desired sublane alignment
458 
459  // @brief state of lane keeping imperfection
460  double mySigmaState;
462 
463 };
std::pair< const MSVehicle *, double > CLeaderDist
Definition: MSLeaderInfo.h:32
LaneChangeAction
The state of a vehicle's lane-change behavior.
@ LCA_AMBLOCKINGLEADER
@ LCA_AMBLOCKINGFOLLOWER_DONTBRAKE
@ LCA_AMBLOCKINGFOLLOWER
LaneChangeModel
T MAX2(T a, T b)
Definition: StdDefs.h:80
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:88
A lane change model developed by J. Erdmann.
Definition: MSLCM_SL2015.h:35
std::vector< double > myLCAccelerationAdvices
vector of LC-related acceleration recommendations Filled in wantsChange() and applied in patchSpeed()
Definition: MSLCM_SL2015.h:389
double mySafeLatDistRight
the lateral distance the vehicle can safely move in the currently considered direction
Definition: MSLCM_SL2015.h:404
static bool overlap(double right, double left, double right2, double left2)
return whether the given intervals overlap
double informLeaders(int blocked, int dir, const std::vector< CLeaderDist > &blockers, double remainingSeconds)
double myRoundaboutBonus
Definition: MSLCM_SL2015.h:443
void commitManoeuvre(int blocked, int blockedFully, const MSLeaderDistanceInfo &leaders, const MSLeaderDistanceInfo &neighLeaders, const MSLane &neighLane, double maneuverDist)
commit to lane change maneuvre potentially overriding safe speed
std::set< const MSVehicle * > myCFRelated
set of vehicles that are in a car-following relationship with ego (leader of followers)
Definition: MSLCM_SL2015.h:408
void prepareStep() override
double myKeepRightProbability
Definition: MSLCM_SL2015.h:378
double myMinImpatience
Definition: MSLCM_SL2015.h:427
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
Definition: MSLCM_SL2015.h:453
double informLeader(int blocked, int dir, const CLeaderDist &neighLead, double remainingSeconds)
double mySafeLatDistLeft
Definition: MSLCM_SL2015.h:405
double getSublaneWidth()
return the current sublane width (and return a sensible value when running without sublanes)
Definition: MSLCM_SL2015.h:327
MSLCM_SL2015(MSVehicle &v)
int checkStrategicChange(int ret, 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
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
Definition: MSLCM_SL2015.h:445
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(!)
Definition: MSLCM_SL2015.h:392
double getWidth() const
return the widht of this vehicle (padded for numerical stability)
bool myCanChangeFully
whether the current lane changing maneuver can be finished in a single step
Definition: MSLCM_SL2015.h:401
void addLCSpeedAdvice(const double vSafe)
Takes a vSafe (speed advice for speed in the next simulation step), converts it into an acceleration ...
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
Definition: MSLCM_SL2015.h:439
bool myDontBrake
flag to prevent speed adaptation by slowing down
Definition: MSLCM_SL2015.h:398
std::string getParameter(const std::string &key) const override
try to retrieve the given parameter from this device. Throw exception for unsupported key
void saveBlockerLength(const MSVehicle *blocker, int lcaCounter)
save space for vehicles which need to counter-lane-change
bool wantsKeepRight(double keepRightProb) const
check against thresholds
bool amBlockingFollower()
Definition: MSLCM_SL2015.h:198
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.
Definition: MSLCM_SL2015.h:43
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
Definition: MSLCM_SL2015.h:431
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...
double mySpeedGainProbabilityRight
a value for tracking the probability that a change to the right is beneficial
Definition: MSLCM_SL2015.h:371
double myLookAheadSpeed
Definition: MSLCM_SL2015.h:385
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 currentDistAllows(double dist, int laneOffset, double lookForwardDist)
Definition: MSLCM_SL2015.h:210
double myCooperativeParam
Definition: MSLCM_SL2015.h:414
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 myKeepRightAcceptanceTime
Definition: MSLCM_SL2015.h:447
double mySigmaState
Definition: MSLCM_SL2015.h:460
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
Definition: MSLCM_SL2015.h:415
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(!)
Definition: MSLCM_SL2015.h:395
double getOppositeSafetyFactor() const override
return factor for modifying the safety constraints for opposite-diretction overtaking of the car-foll...
StateAndDist decideDirection(StateAndDist sd1, StateAndDist sd2) const override
decide in which direction to move in case both directions are desirable
double myImpatience
Definition: MSLCM_SL2015.h:426
double myOppositeParam
Definition: MSLCM_SL2015.h:417
double myLeftSpace
Definition: MSLCM_SL2015.h:381
std::pair< double, int > Info
information regarding save velocity (unused) and state flags of the ego vehicle
Definition: MSLCM_SL2015.h:216
void msg(const CLeaderDist &cld, double speed, int state)
send a speed recommendation to the given vehicle
double myLookaheadLeft
Definition: MSLCM_SL2015.h:435
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()
Definition: MSLCM_SL2015.h:195
double myStrategicParam
Definition: MSLCM_SL2015.h:413
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
void * inform(void *info, MSVehicle *sender) override
double myMinGapLat
Definition: MSLCM_SL2015.h:420
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
double myTurnAlignmentDist
Definition: MSLCM_SL2015.h:433
double myLeadingBlockerLength
Definition: MSLCM_SL2015.h:380
void setOwnState(const int state) override
void informFollowers(int blocked, int dir, const std::vector< CLeaderDist > &blockers, double remainingSeconds, double plannedSpeed)
call informFollower for multiple followers
void saveBlockerLength(double length) override
reserve space at the end of the lane to avoid dead locks
Definition: MSLCM_SL2015.h:191
double mySpeedGainLookahead
Definition: MSLCM_SL2015.h:441
double _patchSpeed(const double min, const double wanted, const double max, const MSCFModel &cfModel)
virtual ~MSLCM_SL2015()
double mySpeedLossProbThreshold
Definition: MSLCM_SL2015.h:457
bool myCFRelatedReady
Definition: MSLCM_SL2015.h:409
double mySpeedGainProbabilityLeft
a value for tracking the probability that a change to the left is beneficial
Definition: MSLCM_SL2015.h:373
bool amBlockingFollowerNB()
Definition: MSLCM_SL2015.h:201
double myAssertive
Definition: MSLCM_SL2015.h:424
int checkBlockingVehicles(const MSVehicle *ego, const MSLeaderDistanceInfo &vehicles, double latDist, double foeOffset, bool leaders, LaneChangeAction blockType, double &safeLatGapRight, double &safeLatGapLeft, std::vector< CLeaderDist > *collectBlockers=0) const
check whether any of the vehicles overlaps with ego
double mySpeedGainRight
Definition: MSLCM_SL2015.h:437
static LaneChangeAction getLCA(int state, double latDist)
compute lane change action from desired lateral distance
double myChangeProbThresholdLeft
Definition: MSLCM_SL2015.h:455
void updateExpectedSublaneSpeeds(const MSLeaderDistanceInfo &ahead, int sublaneOffset, int laneIndex) override
update expected speeds for each sublane of the current edge
static CLeaderDist getLongest(const MSLeaderDistanceInfo &ldi)
get the longest vehicle in the given info
bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist)
Definition: MSLCM_SL2015.h:207
double myTimeToImpatience
Definition: MSLCM_SL2015.h:429
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
double myPushy
Definition: MSLCM_SL2015.h:422
bool amBlockingFollowerPlusNB()
Definition: MSLCM_SL2015.h:204
double myKeepRightParam
Definition: MSLCM_SL2015.h:416
double mySublaneParam
Definition: MSLCM_SL2015.h:418
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
double getWidth() const
Returns the lane's width.
Definition: MSLane.h:556
saves leader/follower vehicles and their distances relative to an ego vehicle
Definition: MSLeaderInfo.h:133
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:75
const MSLane * getLane() const
Returns the lane the vehicle is on.
Definition: MSVehicle.h:552
A structure representing the best lanes for continuing the current route starting at 'lane'.
Definition: MSVehicle.h:811