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-2022 German Aerospace Center (DLR) and others.
4// This program and the accompanying materials are made available under the
5// terms of the Eclipse Public License 2.0 which is available at
6// https://www.eclipse.org/legal/epl-2.0/
7// This Source Code may also be made available under the following Secondary
8// Licenses when the conditions for such availability set forth in the Eclipse
9// Public License 2.0 are satisfied: GNU General Public License, version 2
10// or later which is available at
11// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
12// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
13/****************************************************************************/
22// A lane change model developed by D. Krajzewicz, J. Erdmann et al. between 2004 and 2013
23/****************************************************************************/
24#pragma once
25#include <config.h>
26
28#include <vector>
29
30// INVALID_SPEED should be used when the construction of upper bound for the speed
31// leads to no restrictions, e.g. during LC-messaging to followers or leaders.
32// Currently either std::numeric_limits<...>.max() or -1 is used for this purpose in many places.
33// TODO: implement this everywhere and remove workarounds for ballistic update in cases of possible '-1'-returns. Refs. #2577
34#define INVALID_SPEED 299792458 + 1 // nothing can go faster than the speed of light!
35
36
37// ===========================================================================
38// class definitions
39// ===========================================================================
46public:
47
49
50 virtual ~MSLCM_LC2013();
51
53 LaneChangeModel getModelID() const override {
55 }
56
59
60 bool debugVehicle() const override;
61
70 int wantsChange(
71 int laneOffset,
72 MSAbstractLaneChangeModel::MSLCMessager& msgPass, int blocked,
73 const std::pair<MSVehicle*, double>& leader,
74 const std::pair<MSVehicle*, double>& follower,
75 const std::pair<MSVehicle*, double>& neighLead,
76 const std::pair<MSVehicle*, double>& neighFollow,
77 const MSLane& neighLane,
78 const std::vector<MSVehicle::LaneQ>& preb,
79 MSVehicle** lastBlocked,
80 MSVehicle** firstBlocked) override;
81
82 void* inform(void* info, MSVehicle* sender) override;
83
94 double patchSpeed(const double min, const double wanted, const double max,
95 const MSCFModel& cfModel) override;
96
97 void changed() override;
98
99 void resetState() override;
100
101 double getSafetyFactor() const override;
102
103 double getOppositeSafetyFactor() const override;
104
105 void prepareStep() override;
106
107 double getExtraReservation(int bestLaneOffset) const override;
108
110 std::string getParameter(const std::string& key) const override;
111
113 void setParameter(const std::string& key, const std::string& value) override;
114
116 double computeSpeedLat(double latDist, double& maneuverDist, bool urgent) const override;
117
120 double getAssumedDecelForLaneChangeDuration() const override;
121
122protected:
123
125 double _patchSpeed(double min, const double wanted, double max,
126 const MSCFModel& cfModel);
127
129 int _wantsChange(
130 int laneOffset,
131 MSAbstractLaneChangeModel::MSLCMessager& msgPass, int blocked,
132 const std::pair<MSVehicle*, double>& leader,
133 const std::pair<MSVehicle*, double>& follower,
134 const std::pair<MSVehicle*, double>& neighLead,
135 const std::pair<MSVehicle*, double>& neighFollow,
136 const MSLane& neighLane,
137 const std::vector<MSVehicle::LaneQ>& preb,
138 MSVehicle** lastBlocked,
139 MSVehicle** firstBlocked);
140
141 /* @brief decide whether we will overtake or follow a blocking leader
142 * and inform it accordingly
143 * If we decide to follow, myVSafes will be extended
144 * returns the planned speed if following or -1 if overtaking */
146 int blocked, int dir,
147 const std::pair<MSVehicle*, double>& neighLead,
148 double remainingSeconds);
149
152 int blocked, int dir,
153 const std::pair<MSVehicle*, double>& neighFollow,
154 double remainingSeconds,
155 double plannedSpeed);
156
157
158 /* @brief compute the distance to cover until a safe gap to the vehicle v in front is reached
159 * assuming constant velocities
160 * @param[in] follower the vehicle which overtakes
161 * @param[in] leader the vehicle to be overtaken
162 * @param[in] gap initial distance between front of follower and back of leader
163 * @param[in] leaderSpeed an assumed speed for the leader (default uses the current speed)
164 * @param[in] followerSpeed an assumed speed for the follower (default uses the current speed)
165 * @return the distance that the relative positions would have to change.
166 */
167 static double overtakeDistance(const MSVehicle* follower, const MSVehicle* leader, const double gap, double followerSpeed = INVALID_SPEED, double leaderSpeed = INVALID_SPEED);
168
170 int slowDownForBlocked(MSVehicle** blocked, int state);
171
173 double anticipateFollowSpeed(const std::pair<MSVehicle*, double>& leaderDist, double dist, double vMax, bool acceleratingLeader);
174
176 void adaptSpeedToPedestrians(const MSLane* lane, double& v);
177
179 bool saveBlockerLength(double length, double foeLeftSpace) override;
180
181 inline bool amBlockingLeader() {
182 return (myOwnState & LCA_AMBLOCKINGLEADER) != 0;
183 }
184 inline bool amBlockingFollower() {
185 return (myOwnState & LCA_AMBLOCKINGFOLLOWER) != 0;
186 }
187 inline bool amBlockingFollowerNB() {
189 }
192 }
193 inline bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist) {
194 return dist / (abs(laneOffset)) < lookForwardDist;
195 }
196 inline bool currentDistAllows(double dist, int laneOffset, double lookForwardDist) {
197 return dist / abs(laneOffset) > lookForwardDist;
198 }
199
206 void addLCSpeedAdvice(const double vSafe);
207
208protected:
209
211 typedef std::pair<double, int> Info;
212
215 /* @brief a value for tracking the probability of following the/"Rechtsfahrgebot"
216 * A larger negative value indicates higher probability for moving to the
217 * right (as in mySpeedGainProbability) */
219
222
223 /*@brief the speed to use when computing the look-ahead distance for
224 * determining urgency of strategic lane changes */
226
229 std::vector<double> myLCAccelerationAdvices;
230
231 bool myDontBrake; // XXX: myDontBrake is initialized as false and seems not to be changed anywhere... What's its purpose???
232
234
236 double myCooperativeParam; // in [0,1]
240
241 // @brief the factor by which the lookahead distance to the left differs from the lookahead to the right
243 // @brief the factor by which the speedGain-threshold for the leftdiffers from the threshold for the right
245
246 // @brief willingness to undercut longitudinal safe gaps
248 // @brief lookahead for speedGain in seconds
250 // @brief bounus factor staying on the inside of multi-lane roundabout
252 // @brief factor for cooperative speed adjustment
254
255 // time for unrestricted driving on the right to accept keepRight change
257
258 // @brief speed difference factor for overtaking the leader on the neighbor lane before changing to that lane
260
261 // for feature testing
263
265
267
268 // @brief willingness to encroach on other vehicles laterally (pushing them around)
272};
#define INVALID_SPEED
Definition: MSLCM_LC2013.h:34
@ LCA_AMBLOCKINGLEADER
@ LCA_AMBLOCKINGFOLLOWER_DONTBRAKE
@ LCA_AMBLOCKINGFOLLOWER
LaneChangeModel
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.
The car-following model abstraction.
Definition: MSCFModel.h:55
A lane change model developed by D. Krajzewicz, J. Erdmann et al. between 2004 and 2013.
Definition: MSLCM_LC2013.h:45
bool currentDistAllows(double dist, int laneOffset, double lookForwardDist)
Definition: MSLCM_LC2013.h:196
int wantsChange(int laneOffset, MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, const std::pair< MSVehicle *, double > &leader, const std::pair< MSVehicle *, double > &follower, const std::pair< MSVehicle *, double > &neighLead, const std::pair< MSVehicle *, double > &neighFollow, const MSLane &neighLane, const std::vector< MSVehicle::LaneQ > &preb, MSVehicle **lastBlocked, MSVehicle **firstBlocked) override
Called to examine whether the vehicle wants to change using the given laneOffset. This method gets th...
bool amBlockingLeader()
Definition: MSLCM_LC2013.h:181
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 computeSpeedLat(double latDist, double &maneuverDist, bool urgent) const override
decides the next lateral speed (for continuous lane changing)
double myOvertakeDeltaSpeedFactor
Definition: MSLCM_LC2013.h:259
bool amBlockingFollowerNB()
Definition: MSLCM_LC2013.h:187
double myLookAheadSpeed
Definition: MSLCM_LC2013.h:225
double getExtraReservation(int bestLaneOffset) const override
reserve extra space for unseen blockers when more tnan one lane change is required
bool debugVehicle() const override
whether the current vehicles shall be debugged
double myStrategicParam
Definition: MSLCM_LC2013.h:235
double myRoundaboutBonus
Definition: MSLCM_LC2013.h:251
double getAssumedDecelForLaneChangeDuration() const override
Returns a deceleration value which is used for the estimation of the duration of a lane change.
double mySpeedGainLookahead
Definition: MSLCM_LC2013.h:249
const double myExperimentalParam1
Definition: MSLCM_LC2013.h:262
double patchSpeed(const double min, const double wanted, const double max, const MSCFModel &cfModel) override
Called to adapt the speed in order to allow a lane change. It uses information on LC-related desired ...
void initDerivedParameters()
init cached parameters derived directly from model parameters
LaneChangeModel getModelID() const override
Returns the model's id.
Definition: MSLCM_LC2013.h:53
double myCooperativeParam
Definition: MSLCM_LC2013.h:236
std::vector< double > myLCAccelerationAdvices
vector of LC-related acceleration recommendations Filled in wantsChange() and applied in patchSpeed()
Definition: MSLCM_LC2013.h:229
MSLCM_LC2013(MSVehicle &v)
double myChangeProbThresholdRight
Definition: MSLCM_LC2013.h:269
double anticipateFollowSpeed(const std::pair< MSVehicle *, double > &leaderDist, double dist, double vMax, bool acceleratingLeader)
anticipate future follow speed for the given leader
std::string getParameter(const std::string &key) const override
try to retrieve the given parameter from this device. Throw exception for unsupported key
void setParameter(const std::string &key, const std::string &value) override
try to set the given parameter for this laneChangeModel. Throw exception for unsupported key
double myCooperativeSpeed
Definition: MSLCM_LC2013.h:253
bool amBlockingFollower()
Definition: MSLCM_LC2013.h:184
double informLeader(MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, int dir, const std::pair< MSVehicle *, double > &neighLead, double remainingSeconds)
double _patchSpeed(double min, const double wanted, double max, const MSCFModel &cfModel)
double mySpeedGainParam
Definition: MSLCM_LC2013.h:237
double myLookaheadLeft
Definition: MSLCM_LC2013.h:242
double myLeadingBlockerLength
Definition: MSLCM_LC2013.h:220
std::pair< double, int > Info
information regarding save velocity (unused) and state flags of the ego vehicle
Definition: MSLCM_LC2013.h:211
void prepareStep() override
double getSafetyFactor() const override
return factor for modifying the safety constraints of the car-following model
int slowDownForBlocked(MSVehicle **blocked, int state)
compute useful slowdowns for blocked vehicles
double myLeftSpace
Definition: MSLCM_LC2013.h:221
double myOppositeParam
Definition: MSLCM_LC2013.h:239
bool amBlockingFollowerPlusNB()
Definition: MSLCM_LC2013.h:190
double myKeepRightProbability
Definition: MSLCM_LC2013.h:218
double myKeepRightParam
Definition: MSLCM_LC2013.h:238
bool currentDistDisallows(double dist, int laneOffset, double lookForwardDist)
Definition: MSLCM_LC2013.h:193
void adaptSpeedToPedestrians(const MSLane *lane, double &v)
react to pedestrians on the given lane
virtual ~MSLCM_LC2013()
double getOppositeSafetyFactor() const override
return factor for modifying the safety constraints for opposite-diretction overtaking of the car-foll...
void resetState() override
double mySpeedGainRight
Definition: MSLCM_LC2013.h:244
double myKeepRightAcceptanceTime
Definition: MSLCM_LC2013.h:256
double myAssertive
Definition: MSLCM_LC2013.h:247
bool saveBlockerLength(double length, double foeLeftSpace) override
reserve space at the end of the lane to avoid dead locks
void changed() override
double mySpeedGainProbability
a value for tracking the probability that a change to the offset with the same sign is beneficial
Definition: MSLCM_LC2013.h:214
double myChangeProbThresholdLeft
Definition: MSLCM_LC2013.h:270
void * inform(void *info, MSVehicle *sender) override
void addLCSpeedAdvice(const double vSafe)
Takes a vSafe (speed advice for speed in the next simulation step), converts it into an acceleration ...
int _wantsChange(int laneOffset, MSAbstractLaneChangeModel::MSLCMessager &msgPass, int blocked, const std::pair< MSVehicle *, double > &leader, const std::pair< MSVehicle *, double > &follower, const std::pair< MSVehicle *, double > &neighLead, const std::pair< MSVehicle *, double > &neighFollow, const MSLane &neighLane, const std::vector< MSVehicle::LaneQ > &preb, MSVehicle **lastBlocked, MSVehicle **firstBlocked)
helper function for doing the actual work
static double overtakeDistance(const MSVehicle *follower, const MSVehicle *leader, const double gap, double followerSpeed=INVALID_SPEED, double leaderSpeed=INVALID_SPEED)
Representation of a lane in the micro simulation.
Definition: MSLane.h:84
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:77