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 
double myLeadingBlockerLength
Definition: MSLCM_LC2013.h:227
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 ...
double getAssumedDecelForLaneChangeDuration() const
Returns a deceleration value which is used for the estimation of the duration of a lane change...
void saveBlockerLength(MSVehicle *blocker, int lcaCounter)
save space for vehicles which need to counter-lane-change
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:80
MSLCM_LC2013(MSVehicle &v)
double getSafetyFactor() const
return factor for modifying the safety constraints of the car-following model
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...
bool amBlockingFollower()
Definition: MSLCM_LC2013.h:191
bool amBlockingFollowerNB()
Definition: MSLCM_LC2013.h:194
double myKeepRightProbability
Definition: MSLCM_LC2013.h:225
The car-following model abstraction.
Definition: MSCFModel.h:57
void addLCSpeedAdvice(const double vSafe)
Takes a vSafe (speed advice for speed in the next simulation step), converts it into an acceleration ...
double myChangeProbThresholdLeft
Definition: MSLCM_LC2013.h:265
double myLookAheadSpeed
Definition: MSLCM_LC2013.h:232
double myAssertive
Definition: MSLCM_LC2013.h:254
double myStrategicParam
Definition: MSLCM_LC2013.h:242
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
double myKeepRightParam
Definition: MSLCM_LC2013.h:245
void initDerivedParameters()
init cached parameters derived directly from model parameters
T MAX2(T a, T b)
Definition: StdDefs.h:80
double _patchSpeed(const double min, const double wanted, const double max, const MSCFModel &cfModel)
std::pair< double, int > Info
information regarding save velocity (unused) and state flags of the ego vehicle
Definition: MSLCM_LC2013.h:218
double computeSpeedLat(double latDist, double &maneuverDist)
decides the next lateral speed (for continuous lane changing)
LaneChangeModel getModelID() const
Returns the model&#39;s id.
Definition: MSLCM_LC2013.h:56
bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist)
Definition: MSLCM_LC2013.h:200
bool debugVehicle() const
whether the current vehicles shall be debugged
A class responsible for exchanging messages between cars involved in lane-change interaction.
LaneChangeModel
static double overtakeDistance(const MSVehicle *follower, const MSVehicle *leader, const double gap, double followerSpeed=INVALID_SPEED, double leaderSpeed=INVALID_SPEED)
A lane change model developed by D. Krajzewicz, J. Erdmann et al. between 2004 and 2013...
Definition: MSLCM_LC2013.h:48
double mySpeedGainParam
Definition: MSLCM_LC2013.h:244
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
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
double mySpeedGainRight
Definition: MSLCM_LC2013.h:251
double myOppositeParam
Definition: MSLCM_LC2013.h:246
bool currentDistAllows(double dist, int laneOffset, double lookForwardDist)
Definition: MSLCM_LC2013.h:203
const double myExperimentalParam1
Definition: MSLCM_LC2013.h:257
int slowDownForBlocked(MSVehicle **blocked, int state)
compute useful slowdowns for blocked vehicles
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...
const double myOvertakeRightParam
Definition: MSLCM_LC2013.h:256
A structure representing the best lanes for continuing the current route starting at &#39;lane&#39;...
Definition: MSVehicle.h:811
int myOwnState
The current state of the vehicle.
std::vector< double > myLCAccelerationAdvices
vector of LC-related acceleration recommendations Filled in wantsChange() and applied in patchSpeed()...
Definition: MSLCM_LC2013.h:236
double myLeftSpace
Definition: MSLCM_LC2013.h:228
double myLookaheadLeft
Definition: MSLCM_LC2013.h:249
double myChangeProbThresholdRight
Definition: MSLCM_LC2013.h:264
void adaptSpeedToPedestrians(const MSLane *lane, double &v)
react to pedestrians on the given lane
void saveBlockerLength(double length)
reserve space at the end of the lane to avoid dead locks
Definition: MSLCM_LC2013.h:184
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 myCooperativeParam
Definition: MSLCM_LC2013.h:243
virtual ~MSLCM_LC2013()
std::string getParameter(const std::string &key) const
try to retrieve the given parameter from this device. Throw exception for unsupported key ...
bool amBlockingFollowerPlusNB()
Definition: MSLCM_LC2013.h:197
double informLeader(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, int dir, const std::pair< MSVehicle *, double > &neighLead, double remainingSeconds)
void * inform(void *info, MSVehicle *sender)
Representation of a lane in the micro simulation.
Definition: MSLane.h:83
#define INVALID_SPEED
Definition: MSLCM_LC2013.h:37
Interface for lane-change models.
bool amBlockingLeader()
Definition: MSLCM_LC2013.h:188
double getOppositeSafetyFactor() const
return factor for modifying the safety constraints for opposite-diretction overtaking of the car-foll...