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-2020 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 
44  return LCM_SL2015;
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);
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>& neighLead,
84  const std::pair<MSVehicle*, double>& neighFollow,
85  const MSLane& neighLane,
86  const std::vector<MSVehicle::LaneQ>& preb,
87  MSVehicle** lastBlocked,
88  MSVehicle** firstBlocked);
89 
90  void* inform(void* info, MSVehicle* sender);
91 
102  double patchSpeed(const double min, const double wanted, const double max,
103  const MSCFModel& cfModel);
105  double _patchSpeed(const double min, const double wanted, const double max,
106  const MSCFModel& cfModel);
107 
108  void changed();
109 
110  double getSafetyFactor() const;
111 
112  void prepareStep();
113 
115  bool debugVehicle() const;
116 
117  void setOwnState(const int state);
118 
121  virtual void updateSafeLatDist(const double travelledLatDist);
122 
124  std::string getParameter(const std::string& key) const;
125 
127  void setParameter(const std::string& key, const std::string& value);
128 
131  double computeSpeedLat(double latDist, double& maneuverDist) const;
132 
133 protected:
134 
137  int laneOffset,
138  LaneChangeAction alternatives,
139  const MSLeaderDistanceInfo& leaders,
140  const MSLeaderDistanceInfo& followers,
141  const MSLeaderDistanceInfo& blockers,
142  const MSLeaderDistanceInfo& neighLeaders,
143  const MSLeaderDistanceInfo& neighFollowers,
144  const MSLeaderDistanceInfo& neighBlockers,
145  const MSLane& neighLane,
146  const std::vector<MSVehicle::LaneQ>& preb,
147  MSVehicle** lastBlocked,
148  MSVehicle** firstBlocked,
149  double& latDist, double& maneuverDist, int& blocked);
150 
151 
152  /* @brief decide whether we will overtake or follow blocking leaders
153  * and inform them accordingly (see informLeader)
154  * If we decide to follow, myVSafes will be extended
155  * returns the planned speed if following or -1 if overtaking */
156  double informLeaders(int blocked, int dir,
157  const std::vector<CLeaderDist>& blockers,
158  double remainingSeconds);
159 
161  void informFollowers(int blocked, int dir,
162  const std::vector<CLeaderDist>& blockers,
163  double remainingSeconds,
164  double plannedSpeed);
165 
166  /* @brief decide whether we will overtake or follow a blocking leader
167  * and inform it accordingly
168  * If we decide to follow, myVSafes will be extended
169  * returns the planned speed if following or -1 if overtaking */
170  double informLeader(int blocked, int dir,
171  const CLeaderDist& neighLead,
172  double remainingSeconds);
173 
175  void informFollower(int blocked, int dir,
176  const CLeaderDist& neighFollow,
177  double remainingSeconds,
178  double plannedSpeed);
179 
180 
182  int slowDownForBlocked(MSVehicle** blocked, int state);
183 
185  void saveBlockerLength(const MSVehicle* blocker, int lcaCounter);
186 
188  inline void saveBlockerLength(double length) {
190  };
191 
192  inline bool amBlockingLeader() {
193  return (myOwnState & LCA_AMBLOCKINGLEADER) != 0;
194  }
195  inline bool amBlockingFollower() {
196  return (myOwnState & LCA_AMBLOCKINGFOLLOWER) != 0;
197  }
198  inline bool amBlockingFollowerNB() {
200  }
201  inline bool amBlockingFollowerPlusNB() {
203  }
204  inline bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist) {
205  return dist / (abs(laneOffset)) < lookForwardDist;
206  }
207  inline bool currentDistAllows(double dist, int laneOffset, double lookForwardDist) {
208  return dist / abs(laneOffset) > lookForwardDist;
209  }
210 
211 
213  typedef std::pair<double, int> Info;
214 
221  void addLCSpeedAdvice(const double vSafe);
222 
224  void updateExpectedSublaneSpeeds(const MSLeaderDistanceInfo& ahead, int sublaneOffset, int laneIndex);
225 
228 
230  static int lowest_bit(int changeReason);
231 
232 protected:
233 
235  void msg(const CLeaderDist& cld, double speed, int state);
236 
238  int computeSublaneShift(const MSEdge* prevEdge, const MSEdge* curEdge);
239 
241  static CLeaderDist getLongest(const MSLeaderDistanceInfo& ldi);
242 
244  static CLeaderDist getSlowest(const MSLeaderDistanceInfo& ldi);
245 
247  int checkBlocking(const MSLane& neighLane, double& latDist, double maneuverDist, int laneOffset,
248  const MSLeaderDistanceInfo& leaders,
249  const MSLeaderDistanceInfo& followers,
250  const MSLeaderDistanceInfo& blockers,
251  const MSLeaderDistanceInfo& neighLeaders,
252  const MSLeaderDistanceInfo& neighFollowers,
253  const MSLeaderDistanceInfo& neighBlockers,
254  std::vector<CLeaderDist>* collectLeadBlockers = 0,
255  std::vector<CLeaderDist>* collectFollowBlockers = 0,
256  bool keepLatGapManeuver = false,
257  double gapFactor = 0,
258  int* retBlockedFully = 0);
259 
261  int checkBlockingVehicles(const MSVehicle* ego, const MSLeaderDistanceInfo& vehicles,
262  double latDist, double foeOffset, bool leaders, LaneChangeAction blockType,
263  double& safeLatGapRight, double& safeLatGapLeft,
264  std::vector<CLeaderDist>* collectBlockers = 0) const;
265 
267  static bool overlap(double right, double left, double right2, double left2);
268 
270  static LaneChangeAction getLCA(int state, double latDist);
271 
274  int checkStrategicChange(int ret,
275  int laneOffset,
276  const std::vector<MSVehicle::LaneQ>& preb,
277  const MSLeaderDistanceInfo& leaders,
278  const MSLeaderDistanceInfo& neighLeaders,
279  int currIdx,
280  int bestLaneOffset,
281  bool changeToBest,
282  double currentDist,
283  double neighDist,
284  double laDist,
285  double roundaboutBonus,
286  double latLaneDist,
287  double& latDist
288  );
289 
290 
292  int keepLatGap(int state,
293  const MSLeaderDistanceInfo& leaders,
294  const MSLeaderDistanceInfo& followers,
295  const MSLeaderDistanceInfo& blockers,
296  const MSLeaderDistanceInfo& neighLeaders,
297  const MSLeaderDistanceInfo& neighFollowers,
298  const MSLeaderDistanceInfo& neighBlockers,
299  const MSLane& neighLane,
300  int laneOffset,
301  double& latDist,
302  double& maneuverDist,
303  int& blocked);
304 
305 
307  void updateGaps(const MSLeaderDistanceInfo& others, double foeOffset, double oldCenter, double gapFactor,
308  double& surplusGapRight, double& surplusGapLeft, bool saveMinGap = false, double netOverlap = 0,
309  double latDist = 0,
310  std::vector<CLeaderDist>* collectBlockers = 0);
311 
313  double computeGapFactor(int state) const;
314 
316  double getWidth() const;
317 
319  void updateCFRelated(const MSLeaderDistanceInfo& vehicles, double foeOffset, bool leaders);
320 
322  double getSublaneWidth() {
324  }
325 
327  void commitManoeuvre(int blocked, int blockedFully,
328  const MSLeaderDistanceInfo& leaders,
329  const MSLeaderDistanceInfo& neighLeaders,
330  const MSLane& neighLane,
331  double maneuverDist);
332 
334  double commitFollowSpeed(double speed, double latDist, double secondsToLeaveLane, const MSLeaderDistanceInfo& leaders, double foeOffset) const;
335 
337  double computeSpeedGain(double latDistSublane, double defaultNextSpeed) const;
338 
340  double getPosLat();
341 
343  double getLateralDrift();
344 
345 protected:
350 
351  /* @brief a value for tracking the probability of following the/"Rechtsfahrgebot"
352  * A larger negative value indicates higher probability for moving to the
353  * right (as in mySpeedGainProbability) */
355 
357  double myLeftSpace;
358 
359  /*@brief the speed to use when computing the look-ahead distance for
360  * determining urgency of strategic lane changes */
362 
365  std::vector<double> myLCAccelerationAdvices;
366 
368  std::vector<double> myExpectedSublaneSpeeds;
369 
372 
375 
378 
382 
384  std::set<const MSVehicle*> myCFRelated;
386 
388 
394  // @brief willingness to encroach on other vehicles laterally (pushing them around)
395  double myPushy;
396  // @brief willingness to undercut longitudinal safe gaps
397  double myAssertive;
398  // @brief dynamic component of willingness for longitudinal gap reduction
399  double myImpatience;
401  // @brief time to reach maximum impatience in seconds
403  // @brief lateral acceleration
404  double myAccelLat;
405  // @brief distance to turn at which alignment should be adjusted to the turn direction
407  // @brief the factor by which the lookahead distance to the left differs from the lookahead to the right
409  // @brief the factor by which the speedGain-threshold for the leftdiffers from the threshold for the right
411  // @brief lane discipline factor
413  // @brief lookahead for speedGain in seconds
415  // @brief bounus factor staying on the inside of multi-lane roundabout
417  // @brief factor for cooperative speed adjustment
420 
422 
423  // @brief threshold value for changing to the right
425  // @brief threshold value for changing to the left
427  // @brief threshold value for accepting speed loss to achieve desired sublane alignment
429 
430  // @brief state of lane keeping imperfection
431  double mySigmaState;
433 
434 };
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
@ LCM_SL2015
T MAX2(T a, T b)
Definition: StdDefs.h:79
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:82
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:365
double mySafeLatDistRight
the lateral distance the vehicle can safely move in the currently considered direction
Definition: MSLCM_SL2015.h:380
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:416
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:384
void setOwnState(const int state)
double myKeepRightProbability
Definition: MSLCM_SL2015.h:354
double myMinImpatience
Definition: MSLCM_SL2015.h:400
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 myChangeProbThresholdRight
Definition: MSLCM_SL2015.h:424
double informLeader(int blocked, int dir, const CLeaderDist &neighLead, double remainingSeconds)
double mySafeLatDistLeft
Definition: MSLCM_SL2015.h:381
double getSublaneWidth()
return the current sublane width (and return a sensible value when running without sublanes)
Definition: MSLCM_SL2015.h:322
MSLCM_SL2015(MSVehicle &v)
double patchSpeed(const double min, const double wanted, const double max, const MSCFModel &cfModel)
Called to adapt the speed in order to allow a lane change. It uses information on LC-related desired ...
int computeSublaneShift(const MSEdge *prevEdge, const MSEdge *curEdge)
compute shift so that prevSublane + shift = newSublane
double myCooperativeSpeed
Definition: MSLCM_SL2015.h:418
StateAndDist decideDirection(StateAndDist sd1, StateAndDist sd2) const
decide in which direction to move in case both directions are desirable
void updateExpectedSublaneSpeeds(const MSLeaderDistanceInfo &ahead, int sublaneOffset, int laneIndex)
update expected speeds for each sublane of the current edge
void * inform(void *info, MSVehicle *sender)
std::vector< double > myExpectedSublaneSpeeds
expected travel speeds on all sublanes on the current edge(!)
Definition: MSLCM_SL2015.h:368
int checkStrategicChange(int ret, int laneOffset, const std::vector< MSVehicle::LaneQ > &preb, const MSLeaderDistanceInfo &leaders, const MSLeaderDistanceInfo &neighLeaders, int currIdx, int bestLaneOffset, bool changeToBest, double currentDist, double neighDist, double laDist, double roundaboutBonus, double latLaneDist, double &latDist)
compute strategic lane change actions TODO: Better documentation, refs #2
double getWidth() const
return the widht of this vehicle (padded for numerical stability)
LaneChangeModel getModelID() const
Returns the model's id.
Definition: MSLCM_SL2015.h:43
bool myCanChangeFully
whether the current lane changing maneuver can be finished in a single step
Definition: MSLCM_SL2015.h:377
void addLCSpeedAdvice(const double vSafe)
Takes a vSafe (speed advice for speed in the next simulation step), converts it into an acceleration ...
void prepareStep()
double myLaneDiscipline
Definition: MSLCM_SL2015.h:412
bool myDontBrake
flag to prevent speed adaptation by slowing down
Definition: MSLCM_SL2015.h:374
void saveBlockerLength(const MSVehicle *blocker, int lcaCounter)
save space for vehicles which need to counter-lane-change
bool amBlockingFollower()
Definition: MSLCM_SL2015.h:195
std::string getParameter(const std::string &key) const
try to retrieve the given parameter from this device. Throw exception for unsupported key
void updateCFRelated(const MSLeaderDistanceInfo &vehicles, double foeOffset, bool leaders)
find leaders/followers that are already in a car-following relationship with ego
double myAccelLat
Definition: MSLCM_SL2015.h:404
double mySpeedGainProbabilityRight
a value for tracking the probability that a change to the right is beneficial
Definition: MSLCM_SL2015.h:347
double myLookAheadSpeed
Definition: MSLCM_SL2015.h:361
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:207
double myCooperativeParam
Definition: MSLCM_SL2015.h:390
double computeSpeedGain(double latDistSublane, double defaultNextSpeed) const
compute speedGain when moving by the given amount
double getSafetyFactor() const
return factor for modifying the safety constraints of the car-following model
double mySigmaState
Definition: MSLCM_SL2015.h:431
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:391
const MSEdge * myLastEdge
expected travel speeds on all sublanes on the current edge(!)
Definition: MSLCM_SL2015.h:371
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)
Called to examine whether the vehicle wants to change with the given laneOffset (using the sublane mo...
void saveBlockerLength(double length)
reserve space at the end of the lane to avoid dead locks
Definition: MSLCM_SL2015.h:188
double myImpatience
Definition: MSLCM_SL2015.h:399
double myLeftSpace
Definition: MSLCM_SL2015.h:357
std::pair< double, int > Info
information regarding save velocity (unused) and state flags of the ego vehicle
Definition: MSLCM_SL2015.h:213
virtual void updateSafeLatDist(const double travelledLatDist)
Updates the value of safe lateral distances (mySafeLatDistLeft and mySafeLatDistRight) during maneuve...
void msg(const CLeaderDist &cld, double speed, int state)
send a speed recommendation to the given vehicle
double myLookaheadLeft
Definition: MSLCM_SL2015.h:408
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:192
double myStrategicParam
Definition: MSLCM_SL2015.h:389
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
int wantsChange(int laneOffset, MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, const std::pair< MSVehicle *, double > &leader, const std::pair< MSVehicle *, double > &neighLead, const std::pair< MSVehicle *, double > &neighFollow, const MSLane &neighLane, const std::vector< MSVehicle::LaneQ > &preb, MSVehicle **lastBlocked, MSVehicle **firstBlocked)
Called to examine whether the vehicle wants to change using the given laneOffset (this is a wrapper a...
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
double myTurnAlignmentDist
Definition: MSLCM_SL2015.h:406
double myLeadingBlockerLength
Definition: MSLCM_SL2015.h:356
void informFollowers(int blocked, int dir, const std::vector< CLeaderDist > &blockers, double remainingSeconds, double plannedSpeed)
call informFollower for multiple followers
double mySpeedGainLookahead
Definition: MSLCM_SL2015.h:414
bool debugVehicle() const
whether the current vehicles shall be debugged
double _patchSpeed(const double min, const double wanted, const double max, const MSCFModel &cfModel)
virtual ~MSLCM_SL2015()
double mySpeedLossProbThreshold
Definition: MSLCM_SL2015.h:428
bool myCFRelatedReady
Definition: MSLCM_SL2015.h:385
double mySpeedGainProbabilityLeft
a value for tracking the probability that a change to the left is beneficial
Definition: MSLCM_SL2015.h:349
bool amBlockingFollowerNB()
Definition: MSLCM_SL2015.h:198
double myAssertive
Definition: MSLCM_SL2015.h:397
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:410
static LaneChangeAction getLCA(int state, double latDist)
compute lane change action from desired lateral distance
void setParameter(const std::string &key, const std::string &value)
try to set the given parameter for this laneChangeModel. Throw exception for unsupported key
double myChangeProbThresholdLeft
Definition: MSLCM_SL2015.h:426
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:204
double computeSpeedLat(double latDist, double &maneuverDist) const
decides the next lateral speed depending on the remaining lane change distance to be covered and upda...
double myTimeToImpatience
Definition: MSLCM_SL2015.h:402
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:395
bool amBlockingFollowerPlusNB()
Definition: MSLCM_SL2015.h:201
double myKeepRightParam
Definition: MSLCM_SL2015.h:392
double mySublaneParam
Definition: MSLCM_SL2015.h:393
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
double getWidth() const
Returns the lane's width.
Definition: MSLane.h:555
saves leader/follower vehicles and their distances relative to an ego vehicle
Definition: MSLeaderInfo.h:130
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:550