Eclipse SUMO - Simulation of Urban MObility
MSAbstractLaneChangeModel.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2001-2019 German Aerospace Center (DLR) and others.
4 // This program and the accompanying materials
5 // are made available under the terms of the Eclipse Public License v2.0
6 // which accompanies this distribution, and is available at
7 // http://www.eclipse.org/legal/epl-v20.html
8 // SPDX-License-Identifier: EPL-2.0
9 /****************************************************************************/
19 // Interface for lane-change models
20 /****************************************************************************/
21 #ifndef MSAbstractLaneChangeModel_h
22 #define MSAbstractLaneChangeModel_h
23 
24 // ===========================================================================
25 // included modules
26 // ===========================================================================
27 #include <config.h>
28 
29 #include <microsim/MSGlobals.h>
30 #include <microsim/MSVehicle.h>
31 
32 class MSLane;
33 
34 // ===========================================================================
35 // used enumeration
36 // ===========================================================================
37 
38 // ===========================================================================
39 // class definitions
40 // ===========================================================================
46 public:
47 
51  class MSLCMessager {
52  public:
58  MSLCMessager(MSVehicle* leader, MSVehicle* neighLead, MSVehicle* neighFollow)
59  : myLeader(leader), myNeighLeader(neighLead),
60  myNeighFollower(neighFollow) { }
61 
62 
65 
66 
72  void* informLeader(void* info, MSVehicle* sender) {
73  assert(myLeader != 0);
74  return myLeader->getLaneChangeModel().inform(info, sender);
75  }
76 
77 
83  void* informNeighLeader(void* info, MSVehicle* sender) {
84  assert(myNeighLeader != 0);
85  return myNeighLeader->getLaneChangeModel().inform(info, sender);
86  }
87 
88 
94  void* informNeighFollower(void* info, MSVehicle* sender) {
95  assert(myNeighFollower != 0);
96  return myNeighFollower->getLaneChangeModel().inform(info, sender);
97  }
98 
99 
100  private:
107 
108  };
109 
110  struct StateAndDist {
111  // @brief LaneChangeAction flags
112  int state;
113  // @brief Lateral distance to be completed in the next step
114  double latDist;
115  // @brief Full lateral distance required for the completion of the envisioned maneuver
116  double maneuverDist;
117  // @brief direction that was checked
118  int dir;
119 
120  StateAndDist(int _state, double _latDist, double _targetDist, int _dir) :
121  state(_state),
122  latDist(_latDist),
123  maneuverDist(_targetDist),
124  dir(_dir) {}
125 
126  bool sameDirection(const StateAndDist& other) const {
127  return latDist * other.latDist > 0;
128  }
129  };
130 
132  void static initGlobalOptions(const OptionsCont& oc);
133 
139 
141  inline static bool haveLateralDynamics() {
143  }
144 
148  virtual LaneChangeModel getModelID() const = 0;
149 
151  static bool haveLCOutput() {
152  return myLCOutput;
153  }
154 
156  static bool outputLCStarted() {
157  return myLCStartedOutput;
158  }
159 
161  static bool outputLCEnded() {
162  return myLCEndedOutput;
163  }
164 
170 
172  virtual ~MSAbstractLaneChangeModel();
173 
174  inline int getOwnState() const {
175  return myOwnState;
176  }
177 
178  inline int getPrevState() const {
180  return myPreviousState2;
181  }
182 
183  virtual void setOwnState(const int state);
184 
186  void setManeuverDist(const double dist);
188  double getManeuverDist() const;
189  double getPreviousManeuverDist() const;
190 
192  virtual void updateSafeLatDist(const double travelledLatDist);
193 
194  const std::pair<int, int>& getSavedState(const int dir) const {
195  if (dir == -1) {
196  return mySavedStateRight;
197  } else if (dir == 0) {
198  return mySavedStateCenter;
199  } else {
200  return mySavedStateLeft;
201  }
202  }
203 
204  void saveLCState(const int dir, const int stateWithoutTraCI, const int state) {
205  const auto pair = std::make_pair(stateWithoutTraCI | getCanceledState(dir), state);
206  if (dir == -1) {
207  mySavedStateRight = pair;
208  } else if (dir == 0) {
209  mySavedStateCenter = pair;
210  } else {
211  mySavedStateLeft = pair;
212  }
213  }
214 
217  void saveNeighbors(const int dir, const MSLeaderDistanceInfo& followers, const MSLeaderDistanceInfo& leaders);
218 
221  void saveNeighbors(const int dir, const std::pair<MSVehicle* const, double>& follower, const std::pair<MSVehicle* const, double>& leader);
222 
224  void clearNeighbors();
225 
227  const std::shared_ptr<MSLeaderDistanceInfo> getFollowers(const int dir);
228 
230  const std::shared_ptr<MSLeaderDistanceInfo> getLeaders(const int dir);
231 
232  int& getCanceledState(const int dir) {
233  if (dir == -1) {
234  return myCanceledStateRight;
235  } else if (dir == 0) {
236  return myCanceledStateCenter;
237  } else {
238  return myCanceledStateLeft;
239  }
240  }
241 
243  bool isStrategicBlocked() const;
244 
245  void setFollowerGaps(CLeaderDist follower, double secGap);
246  void setLeaderGaps(CLeaderDist, double secGap);
247  void setOrigLeaderGaps(CLeaderDist, double secGap);
248  void setFollowerGaps(const MSLeaderDistanceInfo& vehicles);
249  void setLeaderGaps(const MSLeaderDistanceInfo& vehicles);
250  void setOrigLeaderGaps(const MSLeaderDistanceInfo& vehicles);
251 
252  virtual void prepareStep();
253 
258  virtual int wantsChange(
259  int laneOffset,
260  MSAbstractLaneChangeModel::MSLCMessager& msgPass, int blocked,
261  const std::pair<MSVehicle*, double>& leader,
262  const std::pair<MSVehicle*, double>& neighLead,
263  const std::pair<MSVehicle*, double>& neighFollow,
264  const MSLane& neighLane,
265  const std::vector<MSVehicle::LaneQ>& preb,
266  MSVehicle** lastBlocked,
267  MSVehicle** firstBlocked) {
268  UNUSED_PARAMETER(laneOffset);
269  UNUSED_PARAMETER(&msgPass);
270  UNUSED_PARAMETER(blocked);
271  UNUSED_PARAMETER(&leader);
272  UNUSED_PARAMETER(&neighLead);
273  UNUSED_PARAMETER(&neighFollow);
274  UNUSED_PARAMETER(&neighLane);
275  UNUSED_PARAMETER(&preb);
276  UNUSED_PARAMETER(lastBlocked);
277  UNUSED_PARAMETER(firstBlocked);
278  throw ProcessError("Method not implemented by model " + toString(myModel));
279  };
280 
281  virtual int wantsChangeSublane(
282  int laneOffset,
283  LaneChangeAction alternatives,
284  const MSLeaderDistanceInfo& leaders,
285  const MSLeaderDistanceInfo& followers,
286  const MSLeaderDistanceInfo& blockers,
287  const MSLeaderDistanceInfo& neighLeaders,
288  const MSLeaderDistanceInfo& neighFollowers,
289  const MSLeaderDistanceInfo& neighBlockers,
290  const MSLane& neighLane,
291  const std::vector<MSVehicle::LaneQ>& preb,
292  MSVehicle** lastBlocked,
293  MSVehicle** firstBlocked,
294  double& latDist, double& targetDistLat, int& blocked) {
295  UNUSED_PARAMETER(laneOffset);
296  UNUSED_PARAMETER(alternatives);
297  UNUSED_PARAMETER(&leaders);
298  UNUSED_PARAMETER(&followers);
299  UNUSED_PARAMETER(&blockers);
300  UNUSED_PARAMETER(&neighLeaders);
301  UNUSED_PARAMETER(&neighFollowers);
302  UNUSED_PARAMETER(&neighBlockers);
303  UNUSED_PARAMETER(&neighLane);
304  UNUSED_PARAMETER(&preb);
305  UNUSED_PARAMETER(lastBlocked);
306  UNUSED_PARAMETER(firstBlocked);
307  UNUSED_PARAMETER(latDist);
308  UNUSED_PARAMETER(targetDistLat);
309  UNUSED_PARAMETER(blocked);
310  throw ProcessError("Method not implemented by model " + toString(myModel));
311  }
312 
314  virtual void updateExpectedSublaneSpeeds(const MSLeaderDistanceInfo& ahead, int sublaneOffset, int laneIndex) {
315  UNUSED_PARAMETER(&ahead);
316  UNUSED_PARAMETER(sublaneOffset);
317  UNUSED_PARAMETER(laneIndex);
318  throw ProcessError("Method not implemented by model " + toString(myModel));
319  }
320 
323  UNUSED_PARAMETER(sd1);
324  UNUSED_PARAMETER(sd2);
325  throw ProcessError("Method not implemented by model " + toString(myModel));
326  }
327 
328  virtual void* inform(void* info, MSVehicle* sender) = 0;
329 
343  virtual double patchSpeed(const double min, const double wanted, const double max,
344  const MSCFModel& cfModel) = 0;
345 
346  /* @brief called once when the primary lane of the vehicle changes (updates
347  * the custom variables of each child implementation */
348  virtual void changed() = 0;
349 
350 
352  virtual double getSafetyFactor() const {
353  return 1.0;
354  }
355 
357  virtual double getOppositeSafetyFactor() const {
358  return 1.0;
359  }
360 
362  virtual bool debugVehicle() const {
363  return false;
364  }
365 
367  void changedToOpposite();
368 
369  void unchanged() {
370  if (myLastLaneChangeOffset > 0) {
372  } else if (myLastLaneChangeOffset < 0) {
374  }
375  }
376 
381  return myShadowLane;
382  }
383 
385  MSLane* getShadowLane(const MSLane* lane) const;
386 
388  MSLane* getShadowLane(const MSLane* lane, double posLat) const;
389 
391  void setShadowLane(MSLane* lane) {
392  myShadowLane = lane;
393  }
394 
395  const std::vector<MSLane*>& getShadowFurtherLanes() const {
396  return myShadowFurtherLanes;
397  }
398 
399  const std::vector<double>& getShadowFurtherLanesPosLat() const {
401  }
402 
407  return myTargetLane;
408  }
409 
410  const std::vector<MSLane*>& getFurtherTargetLanes() const {
411  return myFurtherTargetLanes;
412  }
413 
415  return myLastLaneChangeOffset;
416  }
417 
418 
420  inline bool pastMidpoint() const {
421  return myLaneChangeCompletion >= 0.5;
422  }
423 
425  SUMOTime remainingTime() const;
426 
438  virtual double estimateLCDuration(const double speed, const double remainingManeuverDist, const double decel) const;
439 
441  inline bool isChangingLanes() const {
442  return myLaneChangeCompletion < (1 - NUMERICAL_EPS);
443  }
444 
446  inline double getLaneChangeCompletion() const {
447  return myLaneChangeCompletion;
448  }
449 
451  inline int getLaneChangeDirection() const {
452  return myLaneChangeDirection;
453  }
454 
456  int getShadowDirection() const;
457 
459  double getAngleOffset() const;
460 
462  inline bool alreadyChanged() const {
463  return myAlreadyChanged;
464  }
465 
467  void resetChanged() {
468  myAlreadyChanged = false;
469  }
470 
472  bool startLaneChangeManeuver(MSLane* source, MSLane* target, int direction);
473 
475  void memorizeGapsAtLCInit();
476  void clearGapsAtLCInit();
477 
478  /* @brief continue the lane change maneuver and return whether the midpoint
479  * was passed in this step
480  */
481  bool updateCompletion();
482 
483  /* @brief update lane change shadow after the vehicle moved to a new lane */
484  void updateShadowLane();
485 
486  /* @brief update lane change reservations after the vehicle moved to a new lane
487  * @note The shadow lane should always be updated before updating the target lane. */
489 
490  /* @brief Determines the lane which the vehicle intends to enter during its current action step.
491  * targetDir is set to the offset of the returned lane with respect to the vehicle'a current lane. */
492  MSLane* determineTargetLane(int& targetDir) const;
493 
494  /* @brief finish the lane change maneuver
495  */
497 
498  /* @brief clean up all references to the shadow vehicle
499  */
500  void cleanupShadowLane();
501 
502  /* @brief clean up all references to the vehicle on its target lanes
503  */
504  void cleanupTargetLane();
505 
507  virtual void saveBlockerLength(double length) {
508  UNUSED_PARAMETER(length);
509  }
510 
512  myPartiallyOccupatedByShadow.push_back(lane);
513  }
514 
516  myNoPartiallyOccupatedByShadow.push_back(lane);
517  }
518 
520  void primaryLaneChanged(MSLane* source, MSLane* target, int direction);
521 
523  void laneChangeOutput(const std::string& tag, MSLane* source, MSLane* target, int direction, double maneuverDist = 0);
524 
526  virtual bool sublaneChangeCompleted(const double latDist) const {
527  UNUSED_PARAMETER(latDist);
528  throw ProcessError("Method not implemented by model " + toString(myModel));
529  }
530 
532  void setShadowApproachingInformation(MSLink* link) const;
534 
535  bool isOpposite() const {
536  return myAmOpposite;
537  }
538 
539  double getCommittedSpeed() const {
540  return myCommittedSpeed;
541  }
542 
544  double getSpeedLat() const {
545  return mySpeedLat;
546  }
547 
548  void setSpeedLat(double speedLat) {
549  mySpeedLat = speedLat;
550  }
551 
554  virtual double computeSpeedLat(double latDist, double& maneuverDist);
555 
558  virtual double getAssumedDecelForLaneChangeDuration() const;
559 
561  virtual std::string getParameter(const std::string& key) const {
562  throw InvalidArgument("Parameter '" + key + "' is not supported for laneChangeModel of type '" + toString(myModel) + "'");
563  }
564 
566  virtual void setParameter(const std::string& key, const std::string& value) {
567  UNUSED_PARAMETER(value);
568  throw InvalidArgument("Setting parameter '" + key + "' is not supported for laneChangeModel of type '" + toString(myModel) + "'");
569  }
570 
571 
574  void checkTraCICommands();
575 
576  static const double NO_NEIGHBOR;
577 
578 protected:
579  virtual bool congested(const MSVehicle* const neighLeader);
580 
581  virtual bool predInteraction(const std::pair<MSVehicle*, double>& leader);
582 
584  bool cancelRequest(int state, int laneOffset);
585 
586 
587 protected:
590 
597 
598  std::pair<int, int> mySavedStateRight;
599  std::pair<int, int> mySavedStateCenter;
600  std::pair<int, int> mySavedStateLeft;
604 
607  std::shared_ptr<MSLeaderDistanceInfo> myLeftFollowers;
608  std::shared_ptr<MSLeaderDistanceInfo> myLeftLeaders;
609  std::shared_ptr<MSLeaderDistanceInfo> myRightFollowers;
610  std::shared_ptr<MSLeaderDistanceInfo> myRightLeaders;
612 
614  double mySpeedLat;
615 
618 
621 
624 
628 
631 
634 
637  /* @brief Lanes that are partially (laterally) occupied by the back of the
638  * vehicle (analogue to MSVehicle::myFurtherLanes) */
639  std::vector<MSLane*> myShadowFurtherLanes;
640  std::vector<double> myShadowFurtherLanesPosLat;
641 
642 
651 
652  /* @brief Further upstream lanes that are affected by the vehicle's maneuver (analogue to MSVehicle::myFurtherLanes)
653  * @note If myTargetLane==nullptr, we may assume myFurtherTargetLanes.size()==0, otherwise we have
654  * myFurtherTargetLanes.size() == myVehicle.getFurtherLanes.size()
655  * Here it may occur that an element myFurtherTargetLanes[i]==nullptr if myFurtherLanes[i] has
656  * no parallel lane in the change direction.
657  * */
658  std::vector<MSLane*> myFurtherTargetLanes;
659 
662 
665 
667  std::vector<MSLane*> myPartiallyOccupatedByShadow;
668 
669  /* @brief list of lanes where there is no shadow vehicle partial occupator
670  * (when changing to a lane that has no predecessor) */
671  std::vector<MSLane*> myNoPartiallyOccupatedByShadow;
672 
676 
690 
694 
695  // @brief the maximum lateral speed when standing
697  // @brief the factor of maximum lateral speed to longitudinal speed
699  // @brief factor for lane keeping imperfection
700  double mySigma;
701 
702  /* @brief to be called by derived classes in their changed() method.
703  * If dir=0 is given, the current value remains unchanged */
704  void initLastLaneChangeOffset(int dir);
705 
708 
710  static bool myLCOutput;
711  static bool myLCStartedOutput;
712  static bool myLCEndedOutput;
713 
714 
715 private:
716  /* @brief information how long ago the vehicle has performed a lane-change,
717  * sign indicates direction of the last change
718  */
720 
722  mutable std::vector<MSLink*> myApproachedByShadow;
723 
726 
727 
728 private:
731 };
732 
733 
734 #endif
735 
736 /****************************************************************************/
737 
MSAbstractLaneChangeModel::getTargetLane
MSLane * getTargetLane() const
Returns the lane the vehicle has committed to enter during a sublane lane change.
Definition: MSAbstractLaneChangeModel.h:406
MSAbstractLaneChangeModel::myTargetLane
MSLane * myTargetLane
The target lane for the vehicle's current maneuver.
Definition: MSAbstractLaneChangeModel.h:650
MSAbstractLaneChangeModel::myShadowLane
MSLane * myShadowLane
A lane that is partially occupied by the front of the vehicle but that is not the primary lane.
Definition: MSAbstractLaneChangeModel.h:636
MSMoveReminder::NOTIFICATION_LANE_CHANGE
@ NOTIFICATION_LANE_CHANGE
The vehicle changes lanes (micro only)
Definition: MSMoveReminder.h:99
UNUSED_PARAMETER
#define UNUSED_PARAMETER(x)
Definition: StdDefs.h:31
MSAbstractLaneChangeModel::mySavedStateLeft
std::pair< int, int > mySavedStateLeft
Definition: MSAbstractLaneChangeModel.h:600
MSAbstractLaneChangeModel::StateAndDist::sameDirection
bool sameDirection(const StateAndDist &other) const
Definition: MSAbstractLaneChangeModel.h:126
MSAbstractLaneChangeModel::myAmOpposite
bool myAmOpposite
whether the vehicle is driving in the opposite direction
Definition: MSAbstractLaneChangeModel.h:725
MSAbstractLaneChangeModel::myPreviousManeuverDist
double myPreviousManeuverDist
Maneuver distance from the previous simulation step.
Definition: MSAbstractLaneChangeModel.h:630
MSAbstractLaneChangeModel::MSLCMessager::informNeighLeader
void * informNeighLeader(void *info, MSVehicle *sender)
Informs the leader on the desired lane.
Definition: MSAbstractLaneChangeModel.h:83
MSAbstractLaneChangeModel::setNoShadowPartialOccupator
void setNoShadowPartialOccupator(MSLane *lane)
Definition: MSAbstractLaneChangeModel.h:515
MSAbstractLaneChangeModel::~MSAbstractLaneChangeModel
virtual ~MSAbstractLaneChangeModel()
Destructor.
Definition: MSAbstractLaneChangeModel.cpp:136
MSAbstractLaneChangeModel::myLastFollowerSpeed
double myLastFollowerSpeed
Definition: MSAbstractLaneChangeModel.h:688
MSLane
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
MSAbstractLaneChangeModel::updateCompletion
bool updateCompletion()
Definition: MSAbstractLaneChangeModel.cpp:390
MSAbstractLaneChangeModel::myLastOrigLeaderSpeed
double myLastOrigLeaderSpeed
Definition: MSAbstractLaneChangeModel.h:689
MSAbstractLaneChangeModel::updateExpectedSublaneSpeeds
virtual void updateExpectedSublaneSpeeds(const MSLeaderDistanceInfo &ahead, int sublaneOffset, int laneIndex)
update expected speeds for each sublane of the current edge
Definition: MSAbstractLaneChangeModel.h:314
MSAbstractLaneChangeModel::cancelRequest
bool cancelRequest(int state, int laneOffset)
whether the influencer cancels the given request
Definition: MSAbstractLaneChangeModel.cpp:497
MSLeaderDistanceInfo
saves leader/follower vehicles and their distances relative to an ego vehicle
Definition: MSLeaderInfo.h:132
MSAbstractLaneChangeModel::myAllowOvertakingRight
static bool myAllowOvertakingRight
whether overtaking on the right is permitted
Definition: MSAbstractLaneChangeModel.h:707
MSAbstractLaneChangeModel::getSavedState
const std::pair< int, int > & getSavedState(const int dir) const
Definition: MSAbstractLaneChangeModel.h:194
DELTA_T
SUMOTime DELTA_T
Definition: SUMOTime.cpp:36
MSAbstractLaneChangeModel::myCanceledStateLeft
int myCanceledStateLeft
Definition: MSAbstractLaneChangeModel.h:603
MSAbstractLaneChangeModel::outputLCStarted
static bool outputLCStarted()
whether start of maneuvers shall be recorede
Definition: MSAbstractLaneChangeModel.h:156
NUMERICAL_EPS
#define NUMERICAL_EPS
Definition: config.h:148
MSAbstractLaneChangeModel::myLCStartedOutput
static bool myLCStartedOutput
Definition: MSAbstractLaneChangeModel.h:711
MSAbstractLaneChangeModel::StateAndDist::dir
int dir
Definition: MSAbstractLaneChangeModel.h:118
MSAbstractLaneChangeModel::setOrigLeaderGaps
void setOrigLeaderGaps(CLeaderDist, double secGap)
Definition: MSAbstractLaneChangeModel.cpp:880
MSAbstractLaneChangeModel::myLastLeaderSpeed
double myLastLeaderSpeed
speeds of surrounding vehicles at the time of lane change
Definition: MSAbstractLaneChangeModel.h:687
MSAbstractLaneChangeModel::getLaneChangeDirection
int getLaneChangeDirection() const
return the direction of the current lane change maneuver
Definition: MSAbstractLaneChangeModel.h:451
MSAbstractLaneChangeModel::MSLCMessager
A class responsible for exchanging messages between cars involved in lane-change interaction.
Definition: MSAbstractLaneChangeModel.h:51
LaneChangeModel
LaneChangeModel
Definition: SUMOXMLDefinitions.h:1303
MSAbstractLaneChangeModel::myLCOutput
static bool myLCOutput
whether to record lane-changing
Definition: MSAbstractLaneChangeModel.h:710
MSAbstractLaneChangeModel::setManeuverDist
void setManeuverDist(const double dist)
Updates the remaining distance for the current maneuver while it is continued within non-action steps...
Definition: MSAbstractLaneChangeModel.cpp:153
MSAbstractLaneChangeModel::setSpeedLat
void setSpeedLat(double speedLat)
Definition: MSAbstractLaneChangeModel.h:548
MSAbstractLaneChangeModel::myManeuverDist
double myManeuverDist
The complete lateral distance the vehicle wants to travel to finish its maneuver Only used by sublane...
Definition: MSAbstractLaneChangeModel.h:627
MSAbstractLaneChangeModel::StateAndDist
Definition: MSAbstractLaneChangeModel.h:110
MSAbstractLaneChangeModel::MSLCMessager::informLeader
void * informLeader(void *info, MSVehicle *sender)
Informs the leader on the same lane.
Definition: MSAbstractLaneChangeModel.h:72
MSAbstractLaneChangeModel::StateAndDist::StateAndDist
StateAndDist(int _state, double _latDist, double _targetDist, int _dir)
Definition: MSAbstractLaneChangeModel.h:120
MSAbstractLaneChangeModel::myShadowFurtherLanes
std::vector< MSLane * > myShadowFurtherLanes
Definition: MSAbstractLaneChangeModel.h:639
SUMOTime
long long int SUMOTime
Definition: SUMOTime.h:34
MSAbstractLaneChangeModel::myLastLeaderSecureGap
double myLastLeaderSecureGap
the minimum longitudinal distances to vehicles on the target lane that would be necessary for stringe...
Definition: MSAbstractLaneChangeModel.h:681
MSAbstractLaneChangeModel::setOwnState
virtual void setOwnState(const int state)
Definition: MSAbstractLaneChangeModel.cpp:140
MSAbstractLaneChangeModel::getSpeedLat
double getSpeedLat() const
return the lateral speed of the current lane change maneuver
Definition: MSAbstractLaneChangeModel.h:544
MSAbstractLaneChangeModel::myPartiallyOccupatedByShadow
std::vector< MSLane * > myPartiallyOccupatedByShadow
list of lanes where the shadow vehicle is partial occupator
Definition: MSAbstractLaneChangeModel.h:667
MSAbstractLaneChangeModel::resetChanged
void resetChanged()
reset the flag whether a vehicle already moved to false
Definition: MSAbstractLaneChangeModel.h:467
MSAbstractLaneChangeModel::myAlreadyChanged
bool myAlreadyChanged
whether the vehicle has already moved this step
Definition: MSAbstractLaneChangeModel.h:633
MSAbstractLaneChangeModel::setLeaderGaps
void setLeaderGaps(CLeaderDist, double secGap)
Definition: MSAbstractLaneChangeModel.cpp:871
MSAbstractLaneChangeModel::outputLCEnded
static bool outputLCEnded()
whether start of maneuvers shall be recorede
Definition: MSAbstractLaneChangeModel.h:161
MSAbstractLaneChangeModel::initLastLaneChangeOffset
void initLastLaneChangeOffset(int dir)
Definition: MSAbstractLaneChangeModel.cpp:506
MSAbstractLaneChangeModel::myLastLaneChangeOffset
SUMOTime myLastLaneChangeOffset
Definition: MSAbstractLaneChangeModel.h:719
MSAbstractLaneChangeModel::getLeaders
const std::shared_ptr< MSLeaderDistanceInfo > getLeaders(const int dir)
Returns the neighboring, lc-relevant leaders for the last step in the requested direction.
Definition: MSAbstractLaneChangeModel.cpp:231
MSAbstractLaneChangeModel::myFurtherTargetLanes
std::vector< MSLane * > myFurtherTargetLanes
Definition: MSAbstractLaneChangeModel.h:658
MSAbstractLaneChangeModel::myLastLateralGapLeft
double myLastLateralGapLeft
the minimum lateral gaps to other vehicles that were found when last changing to the left and right
Definition: MSAbstractLaneChangeModel.h:674
MSAbstractLaneChangeModel::myNoPartiallyOccupatedByShadow
std::vector< MSLane * > myNoPartiallyOccupatedByShadow
Definition: MSAbstractLaneChangeModel.h:671
MSAbstractLaneChangeModel::myLaneChangeCompletion
double myLaneChangeCompletion
progress of the lane change maneuver 0:started, 1:complete
Definition: MSAbstractLaneChangeModel.h:620
MSAbstractLaneChangeModel::myLastOrigLeaderGap
double myLastOrigLeaderGap
acutal and secure distance to closest leader vehicle on the original when performing lane change
Definition: MSAbstractLaneChangeModel.h:684
MSAbstractLaneChangeModel::StateAndDist::state
int state
Definition: MSAbstractLaneChangeModel.h:112
MSAbstractLaneChangeModel::updateTargetLane
MSLane * updateTargetLane()
Definition: MSAbstractLaneChangeModel.cpp:592
MSAbstractLaneChangeModel::isChangingLanes
bool isChangingLanes() const
return true if the vehicle currently performs a lane change maneuver
Definition: MSAbstractLaneChangeModel.h:441
MSAbstractLaneChangeModel::myApproachedByShadow
std::vector< MSLink * > myApproachedByShadow
links which are approached by the shadow vehicle
Definition: MSAbstractLaneChangeModel.h:722
MSGlobals::gLateralResolution
static double gLateralResolution
Definition: MSGlobals.h:84
MSVehicle.h
MSAbstractLaneChangeModel::getLastLaneChangeOffset
SUMOTime getLastLaneChangeOffset() const
Definition: MSAbstractLaneChangeModel.h:414
MSAbstractLaneChangeModel::myLastLeaderGap
double myLastLeaderGap
the actual minimum longitudinal distances to vehicles on the target lane
Definition: MSAbstractLaneChangeModel.h:678
MSAbstractLaneChangeModel::startLaneChangeManeuver
bool startLaneChangeManeuver(MSLane *source, MSLane *target, int direction)
start the lane change maneuver and return whether it continues
Definition: MSAbstractLaneChangeModel.cpp:278
MSAbstractLaneChangeModel::getAngleOffset
double getAngleOffset() const
return the angle offset during a continuous change maneuver
Definition: MSAbstractLaneChangeModel.cpp:672
MSAbstractLaneChangeModel::sublaneChangeCompleted
virtual bool sublaneChangeCompleted(const double latDist) const
whether the current change completes the manoeuvre
Definition: MSAbstractLaneChangeModel.h:526
MSAbstractLaneChangeModel::removeShadowApproachingInformation
void removeShadowApproachingInformation() const
Definition: MSAbstractLaneChangeModel.cpp:799
MSAbstractLaneChangeModel::StateAndDist::latDist
double latDist
Definition: MSAbstractLaneChangeModel.h:114
MSAbstractLaneChangeModel::mySavedStateRight
std::pair< int, int > mySavedStateRight
Definition: MSAbstractLaneChangeModel.h:598
MSAbstractLaneChangeModel::memorizeGapsAtLCInit
void memorizeGapsAtLCInit()
Control for resetting the memorized values for LC relevant gaps until the LC output is triggered in t...
Definition: MSAbstractLaneChangeModel.cpp:296
MSAbstractLaneChangeModel::myLastLateralGapRight
double myLastLateralGapRight
Definition: MSAbstractLaneChangeModel.h:675
MSAbstractLaneChangeModel::myLaneChangeDirection
int myLaneChangeDirection
direction of the lane change maneuver -1 means right, 1 means left
Definition: MSAbstractLaneChangeModel.h:623
MSAbstractLaneChangeModel::saveNeighbors
void saveNeighbors(const int dir, const MSLeaderDistanceInfo &followers, const MSLeaderDistanceInfo &leaders)
Saves the lane change relevant vehicles, which are currently on neighboring lanes in the given direct...
Definition: MSAbstractLaneChangeModel.cpp:179
MSAbstractLaneChangeModel::clearGapsAtLCInit
void clearGapsAtLCInit()
Definition: MSAbstractLaneChangeModel.cpp:301
MSAbstractLaneChangeModel::myLeftLeaders
std::shared_ptr< MSLeaderDistanceInfo > myLeftLeaders
Definition: MSAbstractLaneChangeModel.h:608
MSAbstractLaneChangeModel::getCanceledState
int & getCanceledState(const int dir)
Definition: MSAbstractLaneChangeModel.h:232
MSAbstractLaneChangeModel::myLastFollowerSecureGap
double myLastFollowerSecureGap
Definition: MSAbstractLaneChangeModel.h:682
MSAbstractLaneChangeModel::myRightLeaders
std::shared_ptr< MSLeaderDistanceInfo > myRightLeaders
Definition: MSAbstractLaneChangeModel.h:610
LaneChangeAction
LaneChangeAction
The state of a vehicle's lane-change behavior.
Definition: SUMOXMLDefinitions.h:1218
MSAbstractLaneChangeModel::MSAbstractLaneChangeModel
MSAbstractLaneChangeModel(MSVehicle &v, const LaneChangeModel model)
Constructor.
Definition: MSAbstractLaneChangeModel.cpp:94
MSAbstractLaneChangeModel::alreadyChanged
bool alreadyChanged() const
reset the flag whether a vehicle already moved to false
Definition: MSAbstractLaneChangeModel.h:462
MSAbstractLaneChangeModel::myMaxSpeedLatFactor
double myMaxSpeedLatFactor
Definition: MSAbstractLaneChangeModel.h:698
MSAbstractLaneChangeModel::getShadowLane
MSLane * getShadowLane() const
Returns the lane the vehicle's shadow is on during continuous/sublane lane change.
Definition: MSAbstractLaneChangeModel.h:380
MSAbstractLaneChangeModel::prepareStep
virtual void prepareStep()
Definition: MSAbstractLaneChangeModel.cpp:889
MSAbstractLaneChangeModel::myModel
const LaneChangeModel myModel
the type of this model
Definition: MSAbstractLaneChangeModel.h:664
MSAbstractLaneChangeModel::updateShadowLane
void updateShadowLane()
Definition: MSAbstractLaneChangeModel.cpp:515
MSAbstractLaneChangeModel::myCanceledStateRight
int myCanceledStateRight
Definition: MSAbstractLaneChangeModel.h:601
MSAbstractLaneChangeModel::build
static MSAbstractLaneChangeModel * build(LaneChangeModel lcm, MSVehicle &vehicle)
Factory method for instantiating new lane changing models.
Definition: MSAbstractLaneChangeModel.cpp:71
MSAbstractLaneChangeModel::myPreviousState2
int myPreviousState2
lane changing state from step before the previous simulation step
Definition: MSAbstractLaneChangeModel.h:596
MSAbstractLaneChangeModel::congested
virtual bool congested(const MSVehicle *const neighLeader)
Definition: MSAbstractLaneChangeModel.cpp:245
MSAbstractLaneChangeModel::cleanupShadowLane
void cleanupShadowLane()
Definition: MSAbstractLaneChangeModel.cpp:456
MSAbstractLaneChangeModel::wantsChangeSublane
virtual 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 &targetDistLat, int &blocked)
Definition: MSAbstractLaneChangeModel.h:281
MSAbstractLaneChangeModel::getParameter
virtual std::string getParameter(const std::string &key) const
try to retrieve the given parameter from this laneChangeModel. Throw exception for unsupported key
Definition: MSAbstractLaneChangeModel.h:561
ProcessError
Definition: UtilExceptions.h:39
MSVehicle::getLaneChangeModel
MSAbstractLaneChangeModel & getLaneChangeModel()
Definition: MSVehicle.cpp:4680
MSAbstractLaneChangeModel::setShadowApproachingInformation
void setShadowApproachingInformation(MSLink *link) const
set approach information for the shadow vehicle
Definition: MSAbstractLaneChangeModel.cpp:793
MSAbstractLaneChangeModel::MSLCMessager::myLeader
MSVehicle * myLeader
The leader on the informed vehicle's lane.
Definition: MSAbstractLaneChangeModel.h:102
MSAbstractLaneChangeModel::isOpposite
bool isOpposite() const
Definition: MSAbstractLaneChangeModel.h:535
MSAbstractLaneChangeModel::mySpeedLat
double mySpeedLat
the current lateral speed
Definition: MSAbstractLaneChangeModel.h:614
MSAbstractLaneChangeModel::getLaneChangeCompletion
double getLaneChangeCompletion() const
Get the current lane change completion ratio.
Definition: MSAbstractLaneChangeModel.h:446
MSAbstractLaneChangeModel::getSafetyFactor
virtual double getSafetyFactor() const
return factor for modifying the safety constraints of the car-following model
Definition: MSAbstractLaneChangeModel.h:352
MSGlobals.h
OptionsCont
A storage for options typed value containers)
Definition: OptionsCont.h:89
MSAbstractLaneChangeModel::getModelID
virtual LaneChangeModel getModelID() const =0
Returns the model's ID;.
MSAbstractLaneChangeModel::getShadowFurtherLanes
const std::vector< MSLane * > & getShadowFurtherLanes() const
Definition: MSAbstractLaneChangeModel.h:395
MSAbstractLaneChangeModel::myCanceledStateCenter
int myCanceledStateCenter
Definition: MSAbstractLaneChangeModel.h:602
MSAbstractLaneChangeModel::mySavedStateCenter
std::pair< int, int > mySavedStateCenter
Definition: MSAbstractLaneChangeModel.h:599
MSAbstractLaneChangeModel::MSLCMessager::informNeighFollower
void * informNeighFollower(void *info, MSVehicle *sender)
Informs the follower on the desired lane.
Definition: MSAbstractLaneChangeModel.h:94
MSAbstractLaneChangeModel::myLastFollowerGap
double myLastFollowerGap
Definition: MSAbstractLaneChangeModel.h:679
MSAbstractLaneChangeModel::getPreviousManeuverDist
double getPreviousManeuverDist() const
Definition: MSAbstractLaneChangeModel.cpp:174
MSAbstractLaneChangeModel::operator=
MSAbstractLaneChangeModel & operator=(const MSAbstractLaneChangeModel &s)
Invalidated assignment operator.
MSAbstractLaneChangeModel::getManeuverDist
double getManeuverDist() const
Returns the remaining unblocked distance for the current maneuver. (only used by sublane model)
Definition: MSAbstractLaneChangeModel.cpp:169
MSAbstractLaneChangeModel::myCommittedSpeed
double myCommittedSpeed
the speed when committing to a change maneuver
Definition: MSAbstractLaneChangeModel.h:617
MSAbstractLaneChangeModel::MSLCMessager::MSLCMessager
MSLCMessager(MSVehicle *leader, MSVehicle *neighLead, MSVehicle *neighFollow)
Constructor.
Definition: MSAbstractLaneChangeModel.h:58
MSAbstractLaneChangeModel::setParameter
virtual void setParameter(const std::string &key, const std::string &value)
try to set the given parameter for this laneChangeModel. Throw exception for unsupported key
Definition: MSAbstractLaneChangeModel.h:566
MSAbstractLaneChangeModel::haveLateralDynamics
static bool haveLateralDynamics()
whether any kind of lateral dynamics is active
Definition: MSAbstractLaneChangeModel.h:141
MSAbstractLaneChangeModel::remainingTime
SUMOTime remainingTime() const
Compute the remaining time until LC completion.
Definition: MSAbstractLaneChangeModel.cpp:777
MSAbstractLaneChangeModel::unchanged
void unchanged()
Definition: MSAbstractLaneChangeModel.h:369
MSAbstractLaneChangeModel::checkTraCICommands
void checkTraCICommands()
Check for commands issued for the vehicle via TraCI and apply the appropriate state changes For the s...
Definition: MSAbstractLaneChangeModel.cpp:810
MSAbstractLaneChangeModel::myShadowFurtherLanesPosLat
std::vector< double > myShadowFurtherLanesPosLat
Definition: MSAbstractLaneChangeModel.h:640
MSAbstractLaneChangeModel::inform
virtual void * inform(void *info, MSVehicle *sender)=0
MSAbstractLaneChangeModel::pastMidpoint
bool pastMidpoint() const
return whether the vehicle passed the midpoint of a continuous lane change maneuver
Definition: MSAbstractLaneChangeModel.h:420
MSAbstractLaneChangeModel::clearNeighbors
void clearNeighbors()
Clear info on neighboring vehicle from previous step.
Definition: MSAbstractLaneChangeModel.cpp:209
MSAbstractLaneChangeModel::changed
virtual void changed()=0
MSAbstractLaneChangeModel::setFollowerGaps
void setFollowerGaps(CLeaderDist follower, double secGap)
Definition: MSAbstractLaneChangeModel.cpp:862
MSAbstractLaneChangeModel::debugVehicle
virtual bool debugVehicle() const
whether the current vehicles shall be debugged
Definition: MSAbstractLaneChangeModel.h:362
toString
std::string toString(const T &t, std::streamsize accuracy=gPrecision)
Definition: ToString.h:47
MSAbstractLaneChangeModel::myMaxSpeedLatStanding
double myMaxSpeedLatStanding
Definition: MSAbstractLaneChangeModel.h:696
MSAbstractLaneChangeModel::MSLCMessager::myNeighLeader
MSVehicle * myNeighLeader
The leader on the lane the vehicle want to change to.
Definition: MSAbstractLaneChangeModel.h:104
MSAbstractLaneChangeModel::myCarFollowModel
const MSCFModel & myCarFollowModel
The vehicle's car following model.
Definition: MSAbstractLaneChangeModel.h:661
MSAbstractLaneChangeModel::estimateLCDuration
virtual double estimateLCDuration(const double speed, const double remainingManeuverDist, const double decel) const
Calculates the maximal time needed to complete a lane change maneuver if lcMaxSpeedLatFactor and lcMa...
Definition: MSAbstractLaneChangeModel.cpp:679
MSAbstractLaneChangeModel::saveBlockerLength
virtual void saveBlockerLength(double length)
reserve space at the end of the lane to avoid dead locks
Definition: MSAbstractLaneChangeModel.h:507
MSAbstractLaneChangeModel::myLCEndedOutput
static bool myLCEndedOutput
Definition: MSAbstractLaneChangeModel.h:712
MSAbstractLaneChangeModel::endLaneChangeManeuver
void endLaneChangeManeuver(const MSMoveReminder::Notification reason=MSMoveReminder::NOTIFICATION_LANE_CHANGE)
Definition: MSAbstractLaneChangeModel.cpp:401
InvalidArgument
Definition: UtilExceptions.h:56
MSAbstractLaneChangeModel::haveLCOutput
static bool haveLCOutput()
whether lanechange-output is active
Definition: MSAbstractLaneChangeModel.h:151
MSAbstractLaneChangeModel::updateSafeLatDist
virtual void updateSafeLatDist(const double travelledLatDist)
Updates the value of safe lateral distances (in SL2015) during maneuver continuation in non-action st...
Definition: MSAbstractLaneChangeModel.cpp:147
MSAbstractLaneChangeModel::predInteraction
virtual bool predInteraction(const std::pair< MSVehicle *, double > &leader)
Definition: MSAbstractLaneChangeModel.cpp:265
MSAbstractLaneChangeModel::myOwnState
int myOwnState
The current state of the vehicle.
Definition: MSAbstractLaneChangeModel.h:592
MSAbstractLaneChangeModel::NO_NEIGHBOR
static const double NO_NEIGHBOR
Definition: MSAbstractLaneChangeModel.h:576
MSAbstractLaneChangeModel::laneChangeOutput
void laneChangeOutput(const std::string &tag, MSLane *source, MSLane *target, int direction, double maneuverDist=0)
called once the vehicle ends a lane change manoeuvre (non-instant)
Definition: MSAbstractLaneChangeModel.cpp:331
MSAbstractLaneChangeModel::getPrevState
int getPrevState() const
Definition: MSAbstractLaneChangeModel.h:178
MSAbstractLaneChangeModel::saveLCState
void saveLCState(const int dir, const int stateWithoutTraCI, const int state)
Definition: MSAbstractLaneChangeModel.h:204
MSAbstractLaneChangeModel::StateAndDist::maneuverDist
double maneuverDist
Definition: MSAbstractLaneChangeModel.h:116
MSAbstractLaneChangeModel::isStrategicBlocked
bool isStrategicBlocked() const
Definition: MSAbstractLaneChangeModel.cpp:974
MSAbstractLaneChangeModel::patchSpeed
virtual double patchSpeed(const double min, const double wanted, const double max, const MSCFModel &cfModel)=0
Called to adapt the speed in order to allow a lane change. It uses information on LC-related desired ...
MSAbstractLaneChangeModel::MSLCMessager::~MSLCMessager
~MSLCMessager()
Destructor.
Definition: MSAbstractLaneChangeModel.h:64
MSAbstractLaneChangeModel::getCommittedSpeed
double getCommittedSpeed() const
Definition: MSAbstractLaneChangeModel.h:539
MSAbstractLaneChangeModel::wantsChange
virtual 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 method gets th...
Definition: MSAbstractLaneChangeModel.h:258
MSCFModel
The car-following model abstraction.
Definition: MSCFModel.h:56
MSAbstractLaneChangeModel::getOwnState
int getOwnState() const
Definition: MSAbstractLaneChangeModel.h:174
MSAbstractLaneChangeModel::getShadowDirection
int getShadowDirection() const
return the direction in which the current shadow lane lies
Definition: MSAbstractLaneChangeModel.cpp:572
config.h
MSAbstractLaneChangeModel::MSLCMessager::myNeighFollower
MSVehicle * myNeighFollower
The follower on the lane the vehicle want to change to.
Definition: MSAbstractLaneChangeModel.h:106
MSAbstractLaneChangeModel
Interface for lane-change models.
Definition: MSAbstractLaneChangeModel.h:45
MSAbstractLaneChangeModel::getOppositeSafetyFactor
virtual double getOppositeSafetyFactor() const
return factor for modifying the safety constraints for opposite-diretction overtaking of the car-foll...
Definition: MSAbstractLaneChangeModel.h:357
MSAbstractLaneChangeModel::myVehicle
MSVehicle & myVehicle
The vehicle this lane-changer belongs to.
Definition: MSAbstractLaneChangeModel.h:589
MSAbstractLaneChangeModel::cleanupTargetLane
void cleanupTargetLane()
Definition: MSAbstractLaneChangeModel.cpp:475
MSAbstractLaneChangeModel::myDontResetLCGaps
bool myDontResetLCGaps
Flag to prevent resetting the memorized values for LC relevant gaps until the LC output is triggered ...
Definition: MSAbstractLaneChangeModel.h:693
MSGlobals::gLaneChangeDuration
static SUMOTime gLaneChangeDuration
Definition: MSGlobals.h:81
MSAbstractLaneChangeModel::computeSpeedLat
virtual double computeSpeedLat(double latDist, double &maneuverDist)
decides the next lateral speed depending on the remaining lane change distance to be covered and upda...
Definition: MSAbstractLaneChangeModel.cpp:373
MSAbstractLaneChangeModel::determineTargetLane
MSLane * determineTargetLane(int &targetDir) const
Definition: MSAbstractLaneChangeModel.cpp:640
CLeaderDist
std::pair< const MSVehicle *, double > CLeaderDist
Definition: MSLeaderInfo.h:34
MSAbstractLaneChangeModel::decideDirection
virtual StateAndDist decideDirection(StateAndDist sd1, StateAndDist sd2) const
decide in which direction to move in case both directions are desirable
Definition: MSAbstractLaneChangeModel.h:322
MSAbstractLaneChangeModel::changedToOpposite
void changedToOpposite()
called when a vehicle changes between lanes in opposite directions
Definition: MSAbstractLaneChangeModel.cpp:856
MSAbstractLaneChangeModel::myPreviousState
int myPreviousState
lane changing state from the previous simulation step
Definition: MSAbstractLaneChangeModel.h:594
MSAbstractLaneChangeModel::myLastOrigLeaderSecureGap
double myLastOrigLeaderSecureGap
Definition: MSAbstractLaneChangeModel.h:685
MSAbstractLaneChangeModel::getShadowFurtherLanesPosLat
const std::vector< double > & getShadowFurtherLanesPosLat() const
Definition: MSAbstractLaneChangeModel.h:399
MSMoveReminder::Notification
Notification
Definition of a vehicle state.
Definition: MSMoveReminder.h:91
MSAbstractLaneChangeModel::getFollowers
const std::shared_ptr< MSLeaderDistanceInfo > getFollowers(const int dir)
Returns the neighboring, lc-relevant followers for the last step in the requested direction.
Definition: MSAbstractLaneChangeModel.cpp:218
MSAbstractLaneChangeModel::initGlobalOptions
static void initGlobalOptions(const OptionsCont &oc)
init global model parameters
Definition: MSAbstractLaneChangeModel.cpp:62
MSAbstractLaneChangeModel::getFurtherTargetLanes
const std::vector< MSLane * > & getFurtherTargetLanes() const
Definition: MSAbstractLaneChangeModel.h:410
MSAbstractLaneChangeModel::primaryLaneChanged
void primaryLaneChanged(MSLane *source, MSLane *target, int direction)
called once when the vehicles primary lane changes
Definition: MSAbstractLaneChangeModel.cpp:306
MSAbstractLaneChangeModel::getAssumedDecelForLaneChangeDuration
virtual double getAssumedDecelForLaneChangeDuration() const
Returns a deceleration value which is used for the estimation of the duration of a lane change.
Definition: MSAbstractLaneChangeModel.cpp:384
MSAbstractLaneChangeModel::setShadowPartialOccupator
void setShadowPartialOccupator(MSLane *lane)
Definition: MSAbstractLaneChangeModel.h:511
MSAbstractLaneChangeModel::setShadowLane
void setShadowLane(MSLane *lane)
set the shadow lane
Definition: MSAbstractLaneChangeModel.h:391
MSAbstractLaneChangeModel::myRightFollowers
std::shared_ptr< MSLeaderDistanceInfo > myRightFollowers
Definition: MSAbstractLaneChangeModel.h:609
MSAbstractLaneChangeModel::mySigma
double mySigma
Definition: MSAbstractLaneChangeModel.h:700
MSAbstractLaneChangeModel::myLeftFollowers
std::shared_ptr< MSLeaderDistanceInfo > myLeftFollowers
Cached info on lc-relevant neighboring vehicles.
Definition: MSAbstractLaneChangeModel.h:607
MSVehicle
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:79