Eclipse SUMO - Simulation of Urban MObility
MSLCM_LC2013.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 // A lane change model developed by D. Krajzewicz, J. Erdmann et al. between 2004 and 2013
20 /****************************************************************************/
21 #ifndef MSLCM_LC2013_h
22 #define MSLCM_LC2013_h
23 
24 
25 // ===========================================================================
26 // included modules
27 // ===========================================================================
28 #include <config.h>
29 
31 #include <vector>
32 
33 // INVALID_SPEED should be used when the construction of upper bound for the speed
34 // leads to no restrictions, e.g. during LC-messaging to followers or leaders.
35 // Currently either std::numeric_limits<...>.max() or -1 is used for this purpose in many places.
36 // TODO: implement this everywhere and remove workarounds for ballistic update in cases of possible '-1'-returns. Refs. #2577
37 #define INVALID_SPEED 299792458 + 1 // nothing can go faster than the speed of light!
38 
39 
40 // ===========================================================================
41 // class definitions
42 // ===========================================================================
49 public:
50 
52 
53  virtual ~MSLCM_LC2013();
54 
57  return LCM_LC2013;
58  }
59 
61  void initDerivedParameters();
62 
63  bool debugVehicle() const;
64 
73  int wantsChange(
74  int laneOffset,
75  MSAbstractLaneChangeModel::MSLCMessager& msgPass, int blocked,
76  const std::pair<MSVehicle*, double>& leader,
77  const std::pair<MSVehicle*, double>& neighLead,
78  const std::pair<MSVehicle*, double>& neighFollow,
79  const MSLane& neighLane,
80  const std::vector<MSVehicle::LaneQ>& preb,
81  MSVehicle** lastBlocked,
82  MSVehicle** firstBlocked);
83 
84  void* inform(void* info, MSVehicle* sender);
85 
96  double patchSpeed(const double min, const double wanted, const double max,
97  const MSCFModel& cfModel);
99  double _patchSpeed(const double min, const double wanted, const double max,
100  const MSCFModel& cfModel);
101 
102  void changed();
103 
104  double getSafetyFactor() const;
105 
106  double getOppositeSafetyFactor() const;
107 
108  void prepareStep();
109 
111  std::string getParameter(const std::string& key) const;
112 
114  void setParameter(const std::string& key, const std::string& value);
115 
117  double computeSpeedLat(double latDist, double& maneuverDist);
118 
122 
123 protected:
124 
126  int _wantsChange(
127  int laneOffset,
128  MSAbstractLaneChangeModel::MSLCMessager& msgPass, int blocked,
129  const std::pair<MSVehicle*, double>& leader,
130  const std::pair<MSVehicle*, double>& neighLead,
131  const std::pair<MSVehicle*, double>& neighFollow,
132  const MSLane& neighLane,
133  const std::vector<MSVehicle::LaneQ>& preb,
134  MSVehicle** lastBlocked,
135  MSVehicle** firstBlocked);
136 
137  /* @brief decide whether we will overtake or follow a blocking leader
138  * and inform it accordingly
139  * If we decide to follow, myVSafes will be extended
140  * returns the planned speed if following or -1 if overtaking */
142  int blocked, int dir,
143  const std::pair<MSVehicle*, double>& neighLead,
144  double remainingSeconds);
145 
148  int blocked, int dir,
149  const std::pair<MSVehicle*, double>& neighFollow,
150  double remainingSeconds,
151  double plannedSpeed);
152 
153 
154  /* @brief compute the distance to cover until a safe gap to the vehicle v in front is reached
155  * assuming constant velocities
156  * @param[in] follower the vehicle which overtakes
157  * @param[in] leader the vehicle to be overtaken
158  * @param[in] gap initial distance between front of follower and back of leader
159  * @param[in] leaderSpeed an assumed speed for the leader (default uses the current speed)
160  * @param[in] followerSpeed an assumed speed for the follower (default uses the current speed)
161  * @return the distance that the relative positions would have to change.
162  */
163  static double overtakeDistance(const MSVehicle* follower, const MSVehicle* leader, const double gap, double followerSpeed = INVALID_SPEED, double leaderSpeed = INVALID_SPEED);
164 
166  int slowDownForBlocked(MSVehicle** blocked, int state);
167 
168 
175  double getRoundaboutDistBonus(const MSVehicle::LaneQ& curr, const MSVehicle::LaneQ& neigh, const MSVehicle::LaneQ& best);
176 
178  void saveBlockerLength(MSVehicle* blocker, int lcaCounter);
179 
181  void adaptSpeedToPedestrians(const MSLane* lane, double& v);
182 
184  inline void saveBlockerLength(double length) {
186  };
187 
188  inline bool amBlockingLeader() {
189  return (myOwnState & LCA_AMBLOCKINGLEADER) != 0;
190  }
191  inline bool amBlockingFollower() {
192  return (myOwnState & LCA_AMBLOCKINGFOLLOWER) != 0;
193  }
194  inline bool amBlockingFollowerNB() {
196  }
197  inline bool amBlockingFollowerPlusNB() {
199  }
200  inline bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist) {
201  return dist / (abs(laneOffset)) < lookForwardDist;
202  }
203  inline bool currentDistAllows(double dist, int laneOffset, double lookForwardDist) {
204  return dist / abs(laneOffset) > lookForwardDist;
205  }
206 
213  void addLCSpeedAdvice(const double vSafe);
214 
215 protected:
216 
218  typedef std::pair<double, int> Info;
219 
222  /* @brief a value for tracking the probability of following the/"Rechtsfahrgebot"
223  * A larger negative value indicates higher probability for moving to the
224  * right (as in mySpeedGainProbability) */
226 
228  double myLeftSpace;
229 
230  /*@brief the speed to use when computing the look-ahead distance for
231  * determining urgency of strategic lane changes */
233 
236  std::vector<double> myLCAccelerationAdvices;
237 
238  bool myDontBrake; // XXX: myDontBrake is initialized as false and seems not to be changed anywhere... What's its purpose???
239 
241 
243  double myCooperativeParam; // in [0,1]
247 
248  // @brief the factor by which the lookahead distance to the left differs from the lookahead to the right
250  // @brief the factor by which the speedGain-threshold for the leftdiffers from the threshold for the right
252 
253  // @brief willingness to undercut longitudinal safe gaps
254  double myAssertive;
255 
256  const double myOvertakeRightParam; // allow overtaking right even though it is prohibited
257  const double myExperimentalParam1; // for feature testing
258 
260 
262 
263  // @brief willingness to encroach on other vehicles laterally (pushing them around)
267 };
268 
269 
270 #endif
271 
272 /****************************************************************************/
273 
MSLCM_LC2013::myStrategicParam
double myStrategicParam
Definition: MSLCM_LC2013.h:242
MSLCM_LC2013::getOppositeSafetyFactor
double getOppositeSafetyFactor() const
return factor for modifying the safety constraints for opposite-diretction overtaking of the car-foll...
Definition: MSLCM_LC2013.cpp:2081
MSLCM_LC2013::getAssumedDecelForLaneChangeDuration
double getAssumedDecelForLaneChangeDuration() const
Returns a deceleration value which is used for the estimation of the duration of a lane change.
Definition: MSLCM_LC2013.cpp:2071
MSLCM_LC2013::addLCSpeedAdvice
void addLCSpeedAdvice(const double vSafe)
Takes a vSafe (speed advice for speed in the next simulation step), converts it into an acceleration ...
Definition: MSLCM_LC2013.cpp:2053
MSLCM_LC2013::Info
std::pair< double, int > Info
information regarding save velocity (unused) and state flags of the ego vehicle
Definition: MSLCM_LC2013.h:218
MSLCM_LC2013::myLookAheadSpeed
double myLookAheadSpeed
Definition: MSLCM_LC2013.h:232
MSLane
Representation of a lane in the micro simulation.
Definition: MSLane.h:83
MSLCM_LC2013::myKeepRightProbability
double myKeepRightProbability
Definition: MSLCM_LC2013.h:225
MSLCM_LC2013::getSafetyFactor
double getSafetyFactor() const
return factor for modifying the safety constraints of the car-following model
Definition: MSLCM_LC2013.cpp:2076
MSLCM_LC2013::prepareStep
void prepareStep()
Definition: MSLCM_LC2013.cpp:1017
MSLCM_LC2013::amBlockingFollowerNB
bool amBlockingFollowerNB()
Definition: MSLCM_LC2013.h:194
MSLCM_LC2013::changed
void changed()
Definition: MSLCM_LC2013.cpp:1032
MSAbstractLaneChangeModel::MSLCMessager
A class responsible for exchanging messages between cars involved in lane-change interaction.
Definition: MSAbstractLaneChangeModel.h:52
LaneChangeModel
LaneChangeModel
Definition: SUMOXMLDefinitions.h:1298
LCA_AMBLOCKINGLEADER
Definition: SUMOXMLDefinitions.h:1281
MSLCM_LC2013::getModelID
LaneChangeModel getModelID() const
Returns the model's id.
Definition: MSLCM_LC2013.h:56
MSVehicle::LaneQ
A structure representing the best lanes for continuing the current route starting at 'lane'.
Definition: MSVehicle.h:811
MSLCM_LC2013::_wantsChange
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)
helper function for doing the actual work
Definition: MSLCM_LC2013.cpp:1049
MSLCM_LC2013::getRoundaboutDistBonus
double getRoundaboutDistBonus(const MSVehicle::LaneQ &curr, const MSVehicle::LaneQ &neigh, const MSVehicle::LaneQ &best)
Computes the artificial bonus distance for roundabout lanes this additional distance reduces the sens...
Definition: MSLCM_LC2013.cpp:1776
MSLCM_LC2013::amBlockingFollower
bool amBlockingFollower()
Definition: MSLCM_LC2013.h:191
MSLCM_LC2013::patchSpeed
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 ...
Definition: MSLCM_LC2013.cpp:188
MSLCM_LC2013::saveBlockerLength
void saveBlockerLength(MSVehicle *blocker, int lcaCounter)
save space for vehicles which need to counter-lane-change
Definition: MSLCM_LC2013.cpp:1984
MSLCM_LC2013::myChangeProbThresholdLeft
double myChangeProbThresholdLeft
Definition: MSLCM_LC2013.h:265
MSLCM_LC2013::mySpeedGainParam
double mySpeedGainParam
Definition: MSLCM_LC2013.h:244
MSLCM_LC2013::myAssertive
double myAssertive
Definition: MSLCM_LC2013.h:254
MSLCM_LC2013::wantsChange
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: MSLCM_LC2013.cpp:149
MSLCM_LC2013::myKeepRightParam
double myKeepRightParam
Definition: MSLCM_LC2013.h:245
MAX2
T MAX2(T a, T b)
Definition: StdDefs.h:80
MSLCM_LC2013::currentDistAllows
bool currentDistAllows(double dist, int laneOffset, double lookForwardDist)
Definition: MSLCM_LC2013.h:203
MSLCM_LC2013::debugVehicle
bool debugVehicle() const
whether the current vehicles shall be debugged
Definition: MSLCM_LC2013.cpp:143
MSLCM_LC2013::computeSpeedLat
double computeSpeedLat(double latDist, double &maneuverDist)
decides the next lateral speed (for continuous lane changing)
Definition: MSLCM_LC2013.cpp:2060
MSLCM_LC2013::overtakeDistance
static double overtakeDistance(const MSVehicle *follower, const MSVehicle *leader, const double gap, double followerSpeed=INVALID_SPEED, double leaderSpeed=INVALID_SPEED)
Definition: MSLCM_LC2013.cpp:431
MSLCM_LC2013::mySpeedGainProbability
double mySpeedGainProbability
a value for tracking the probability that a change to the offset with the same sign is beneficial
Definition: MSLCM_LC2013.h:221
MSLCM_LC2013::informFollower
void informFollower(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, int dir, const std::pair< MSVehicle *, double > &neighFollow, double remainingSeconds, double plannedSpeed)
decide whether we will try cut in before the follower or allow to be overtaken
Definition: MSLCM_LC2013.cpp:616
MSLCM_LC2013::slowDownForBlocked
int slowDownForBlocked(MSVehicle **blocked, int state)
compute useful slowdowns for blocked vehicles
Definition: MSLCM_LC2013.cpp:1928
MSLCM_LC2013::initDerivedParameters
void initDerivedParameters()
init cached parameters derived directly from model parameters
Definition: MSLCM_LC2013.cpp:136
MSLCM_LC2013::currentDistDisallows
bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist)
Definition: MSLCM_LC2013.h:200
MSLCM_LC2013::_patchSpeed
double _patchSpeed(const double min, const double wanted, const double max, const MSCFModel &cfModel)
Definition: MSLCM_LC2013.cpp:221
MSLCM_LC2013::myChangeProbThresholdRight
double myChangeProbThresholdRight
Definition: MSLCM_LC2013.h:264
LCA_AMBLOCKINGFOLLOWER_DONTBRAKE
Definition: SUMOXMLDefinitions.h:1286
MSLCM_LC2013::adaptSpeedToPedestrians
void adaptSpeedToPedestrians(const MSLane *lane, double &v)
react to pedestrians on the given lane
Definition: MSLCM_LC2013.cpp:2030
MSLCM_LC2013::myLCAccelerationAdvices
std::vector< double > myLCAccelerationAdvices
vector of LC-related acceleration recommendations Filled in wantsChange() and applied in patchSpeed()
Definition: MSLCM_LC2013.h:236
MSLCM_LC2013::myCooperativeParam
double myCooperativeParam
Definition: MSLCM_LC2013.h:243
MSLCM_LC2013::~MSLCM_LC2013
virtual ~MSLCM_LC2013()
Definition: MSLCM_LC2013.cpp:130
MSLCM_LC2013::myDontBrake
bool myDontBrake
Definition: MSLCM_LC2013.h:238
MSLCM_LC2013::mySpeedGainRight
double mySpeedGainRight
Definition: MSLCM_LC2013.h:251
MSLCM_LC2013::myOppositeParam
double myOppositeParam
Definition: MSLCM_LC2013.h:246
MSLCM_LC2013::myExperimentalParam1
const double myExperimentalParam1
Definition: MSLCM_LC2013.h:257
INVALID_SPEED
#define INVALID_SPEED
Definition: MSLCM_LC2013.h:37
MSLCM_LC2013::myOvertakeRightParam
const double myOvertakeRightParam
Definition: MSLCM_LC2013.h:256
MSAbstractLaneChangeModel::myOwnState
int myOwnState
The current state of the vehicle.
Definition: MSAbstractLaneChangeModel.h:614
MSLCM_LC2013::myLeftSpace
double myLeftSpace
Definition: MSLCM_LC2013.h:228
MSLCM_LC2013::myLookaheadLeft
double myLookaheadLeft
Definition: MSLCM_LC2013.h:249
MSCFModel
The car-following model abstraction.
Definition: MSCFModel.h:57
MSLCM_LC2013::getParameter
std::string getParameter(const std::string &key) const
try to retrieve the given parameter from this device. Throw exception for unsupported key
Definition: MSLCM_LC2013.cpp:2086
config.h
MSAbstractLaneChangeModel
Interface for lane-change models.
Definition: MSAbstractLaneChangeModel.h:46
MSLCM_LC2013
A lane change model developed by D. Krajzewicz, J. Erdmann et al. between 2004 and 2013.
Definition: MSLCM_LC2013.h:48
MSLCM_LC2013::inform
void * inform(void *info, MSVehicle *sender)
Definition: MSLCM_LC2013.cpp:410
MSLCM_LC2013::saveBlockerLength
void saveBlockerLength(double length)
reserve space at the end of the lane to avoid dead locks
Definition: MSLCM_LC2013.h:184
MSLCM_LC2013::amBlockingFollowerPlusNB
bool amBlockingFollowerPlusNB()
Definition: MSLCM_LC2013.h:197
MSLCM_LC2013::setParameter
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: MSLCM_LC2013.cpp:2109
MSLCM_LC2013::amBlockingLeader
bool amBlockingLeader()
Definition: MSLCM_LC2013.h:188
LCA_AMBLOCKINGFOLLOWER
Definition: SUMOXMLDefinitions.h:1282
LCM_LC2013
Definition: SUMOXMLDefinitions.h:1300
MSAbstractLaneChangeModel.h
MSLCM_LC2013::informLeader
double informLeader(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, int dir, const std::pair< MSVehicle *, double > &neighLead, double remainingSeconds)
Definition: MSLCM_LC2013.cpp:444
MSLCM_LC2013::myLeadingBlockerLength
double myLeadingBlockerLength
Definition: MSLCM_LC2013.h:227
MSLCM_LC2013::MSLCM_LC2013
MSLCM_LC2013(MSVehicle &v)
Definition: MSLCM_LC2013.cpp:99
MSVehicle
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:80