Line data Source code
1 : /****************************************************************************/
2 : // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
3 : // Copyright (C) 2001-2024 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 : /****************************************************************************/
14 : /// @file MSCFModel.h
15 : /// @author Tobias Mayer
16 : /// @author Daniel Krajzewicz
17 : /// @author Jakob Erdmann
18 : /// @author Michael Behrisch
19 : /// @date Mon, 27 Jul 2009
20 : ///
21 : // The car-following model abstraction
22 : /****************************************************************************/
23 : #pragma once
24 : #include <config.h>
25 :
26 : #include <cmath>
27 : #include <string>
28 : #include <utils/common/StdDefs.h>
29 : #include <utils/common/SUMOTime.h>
30 :
31 : #define INVALID_SPEED 299792458 + 1 // nothing can go faster than the speed of light!
32 : // Factor that the minimum emergency decel is increased by in corresponding situations
33 : #define EMERGENCY_DECEL_AMPLIFIER 1.2
34 :
35 : // ===========================================================================
36 : // class declarations
37 : // ===========================================================================
38 : class MSVehicleType;
39 : class MSVehicle;
40 : class MSLane;
41 : class MSPerson;
42 : class MSLink;
43 :
44 :
45 : // ===========================================================================
46 : // class definitions
47 : // ===========================================================================
48 : /**
49 : * @class MSCFModel
50 : * @brief The car-following model abstraction
51 : *
52 : * MSCFModel is an interface for different car following Models to implement.
53 : * It provides methods to compute a vehicles velocity for a simulation step.
54 : */
55 : class MSCFModel {
56 :
57 : public:
58 :
59 378 : class VehicleVariables {
60 : public:
61 : virtual ~VehicleVariables();
62 : };
63 :
64 : /** @brief Constructor
65 : * @param[in] vtype the type for which this model is built and also the parameter object to configure this model
66 : */
67 : MSCFModel(const MSVehicleType* vtype);
68 :
69 :
70 : /// @brief Destructor
71 : virtual ~MSCFModel();
72 :
73 :
74 : /** @enum CalcReason
75 : * @brief What the return value of stop/follow/free-Speed is used for
76 : */
77 : enum CalcReason {
78 : /// @brief the return value is used for calculating the next speed
79 : CURRENT,
80 : /// @brief the return value is used for calculating future speeds
81 : FUTURE,
82 : /// @brief the return value is used for calculating junction stop speeds
83 : CURRENT_WAIT,
84 : /// @brief the return value is used for lane change calculations
85 : LANE_CHANGE
86 : };
87 :
88 :
89 : /// @name Methods to override by model implementation
90 : /// @{
91 :
92 : /** @brief Applies interaction with stops and lane changing model
93 : * influences. Called at most once per simulation step (exactcly once per action step)
94 : * @param[in] veh The ego vehicle
95 : * @param[in] vPos The possible velocity
96 : * @return The velocity after applying interactions with stops and lane change model influences
97 : */
98 : virtual double finalizeSpeed(MSVehicle* const veh, double vPos) const;
99 :
100 :
101 : /// @brief apply custom speed adaptations within the given speed bounds
102 62119803 : virtual double patchSpeedBeforeLC(const MSVehicle* veh, double vMin, double vMax) const {
103 : UNUSED_PARAMETER(veh);
104 : UNUSED_PARAMETER(vMin);
105 62119803 : return vMax;
106 : }
107 :
108 : /// @brief apply speed adaptation on startup
109 : virtual double applyStartupDelay(const MSVehicle* veh, const double vMin, const double vMax, const SUMOTime addTime = 0) const;
110 :
111 :
112 : /** @brief Computes the vehicle's safe speed without a leader
113 : *
114 : * Returns the velocity of the vehicle in dependence to the length of the free street and the target
115 : * velocity at the end of the free range. If onInsertion is true, the vehicle may still brake
116 : * before the next movement.
117 : * @param[in] veh The vehicle (EGO)
118 : * @param[in] speed The vehicle's speed
119 : * @param[in] seen The look ahead distance
120 : * @param[in] maxSpeed The maximum allowed speed
121 : * @param[in] onInsertion whether speed at insertion is asked for
122 : * @param[in] usage What the return value is used for
123 : * @return EGO's safe speed
124 : */
125 : virtual double freeSpeed(const MSVehicle* const veh, double speed, double seen,
126 : double maxSpeed, const bool onInsertion = false, const CalcReason usage = CalcReason::CURRENT) const;
127 :
128 :
129 : /** @brief Computes the vehicle's follow speed (no dawdling)
130 : *
131 : * Returns the velocity of the vehicle in dependence to the vehicle's and its leader's values and the distance between them.
132 : * @param[in] veh The vehicle (EGO)
133 : * @param[in] speed The vehicle's speed
134 : * @param[in] gap2pred The (net) distance to the LEADER
135 : * @param[in] predSpeed The speed of LEADER
136 : * @param[in] usage What the return value is used for
137 : * @return EGO's safe speed
138 : */
139 : virtual double followSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed,
140 : double predMaxDecel, const MSVehicle* const pred = 0, const CalcReason usage = CalcReason::CURRENT) const = 0;
141 :
142 :
143 : /** @brief Computes the vehicle's safe speed (no dawdling)
144 : * This method is used during the insertion stage. Whereas the method
145 : * followSpeed returns the desired speed which may be lower than the safe
146 : * speed, this method only considers safety constraints
147 : *
148 : * Returns the velocity of the vehicle in dependence to the vehicle's and its leader's values and the distance between them.
149 : * @param[in] veh The vehicle (EGO)
150 : * @param[in] speed The vehicle's speed
151 : * @param[in] gap2pred The (net) distance to the LEADER
152 : * @param[in] predSpeed The speed of LEADER
153 : * @return EGO's safe speed
154 : */
155 : virtual double insertionFollowSpeed(const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel, const MSVehicle* const pred = 0) const;
156 :
157 :
158 : /** @brief Computes the vehicle's safe speed for approaching a non-moving obstacle (no dawdling)
159 : *
160 : * Returns the velocity of the vehicle when approaching a static object (such as the end of a lane) assuming no reaction time is needed.
161 : * @param[in] veh The vehicle (EGO)
162 : * @param[in] speed The vehicle's speed
163 : * @param[in] gap The (net) distance to the obstacle
164 : * @param[in] usage What the return value is used for
165 : * @return EGO's safe speed for approaching a non-moving obstacle
166 : * @todo generic Interface, models can call for the values they need
167 : */
168 : inline double stopSpeed(const MSVehicle* const veh, const double speed, double gap, const CalcReason usage = CalcReason::CURRENT) const {
169 38549778 : return stopSpeed(veh, speed, gap, myDecel, usage);
170 : }
171 :
172 : /** @brief Computes the vehicle's safe speed for approaching a non-moving obstacle (no dawdling)
173 : *
174 : * Returns the velocity of the vehicle when approaching a static object (such as the end of a lane) assuming no reaction time is needed.
175 : * @param[in] veh The vehicle (EGO)
176 : * @param[in] speed The vehicle's speed
177 : * @param[in] gap The (net) distance to the obstacle
178 : * @param[in] decel The desired deceleration rate
179 : * @param[in] usage What the return value is used for
180 : * @return EGO's safe speed for approaching a non-moving obstacle
181 : * @todo generic Interface, models can call for the values they need
182 : */
183 : virtual double stopSpeed(const MSVehicle* const veh, const double speed, double gap, double decel, const CalcReason usage = CalcReason::CURRENT) const = 0;
184 :
185 :
186 : /** @brief Computes the vehicle's safe speed for approaching an obstacle at insertion without constraints
187 : * due to acceleration capabilities and previous speeds.
188 : * @param[in] veh The vehicle (EGO)
189 : * @param[in] speed The vehicle's speed
190 : * @param[in] gap The (net) distance to the obstacle
191 : * @return EGO's safe speed for approaching a non-moving obstacle at insertion
192 : * @see stopSpeed() and insertionFollowSpeed()
193 : *
194 : */
195 : virtual double insertionStopSpeed(const MSVehicle* const veh, double speed, double gap) const;
196 :
197 : /** @brief Computes the vehicle's follow speed that avoids a collision for the given amount of time
198 : *
199 : * Returns the velocity of the vehicle in dependence to the vehicle's and its leader's values and the distance between them.
200 : * @param[in] veh The vehicle (EGO)
201 : * @param[in] speed The vehicle's speed
202 : * @param[in] gap2pred The (net) distance to the LEADER
203 : * @param[in] predSpeed The speed of LEADER
204 : * @param[in] predMaxDecel The maximum leader deceleration
205 : * @return EGO's safe speed
206 : */
207 : virtual double followSpeedTransient(double duration, const MSVehicle* const veh, double speed, double gap2pred, double predSpeed, double predMaxDecel) const;
208 :
209 : /** @brief Returns the maximum gap at which an interaction between both vehicles occurs
210 : *
211 : * "interaction" means that the LEADER influences EGO's speed.
212 : * @param[in] veh The EGO vehicle
213 : * @param[in] vL LEADER's speed
214 : * @return The interaction gap
215 : * @todo evaluate signature
216 : */
217 : virtual double interactionGap(const MSVehicle* const veh, double vL) const;
218 :
219 :
220 : /** @brief Returns the maximum velocity the CF-model wants to achieve in the next step
221 : * @param[in] maxSpeed The maximum achievable speed in the next step
222 : * @param[in] maxSpeedLane The maximum speed the vehicle wants to drive on this lane (Speedlimit*SpeedFactor)
223 : */
224 535964727 : virtual double maximumLaneSpeedCF(const MSVehicle* const veh, double maxSpeed, double maxSpeedLane) const {
225 535964727 : double result = MIN2(maxSpeed, maxSpeedLane);
226 535964727 : applyOwnSpeedPerceptionError(veh, result);
227 535964727 : return result;
228 : }
229 :
230 :
231 : /** @brief Returns the model's ID; the XML-Tag number is used
232 : * @return The model's ID
233 : */
234 : virtual int getModelID() const = 0;
235 :
236 :
237 : /** @brief Duplicates the car-following model
238 : * @param[in] vtype The vehicle type this model belongs to (1:1)
239 : * @return A duplicate of this car-following model
240 : */
241 : virtual MSCFModel* duplicate(const MSVehicleType* vtype) const = 0;
242 :
243 :
244 : /** @brief Returns model specific values which are stored inside a vehicle
245 : * and must be used with casting
246 : */
247 24544 : virtual VehicleVariables* createVehicleVariables() const {
248 24544 : return 0;
249 : }
250 : /// @}
251 :
252 :
253 : /** @brief Get the vehicle type's maximum acceleration [m/s^2]
254 : * @return The maximum acceleration (in m/s^2) of vehicles of this class
255 : */
256 : inline double getMaxAccel() const {
257 7257246640 : return myAccel;
258 : }
259 :
260 :
261 : /** @brief Get the vehicle type's maximal comfortable deceleration [m/s^2]
262 : * @return The maximal comfortable deceleration (in m/s^2) of vehicles of this class
263 : */
264 : inline double getMaxDecel() const {
265 7175602954 : return myDecel;
266 : }
267 :
268 :
269 : /** @brief Get the vehicle type's maximal physically possible deceleration [m/s^2]
270 : * @return The maximal physically possible deceleration (in m/s^2) of vehicles of this class
271 : */
272 : inline double getEmergencyDecel() const {
273 58162349 : return myEmergencyDecel;
274 : }
275 :
276 :
277 : /** @brief Get the vehicle type's apparent deceleration [m/s^2] (the one regarded by its followers
278 : * @return The apparent deceleration (in m/s^2) of vehicles of this class
279 : */
280 : inline double getApparentDecel() const {
281 1654260649 : return myApparentDecel;
282 : }
283 :
284 : /** @brief Get the vehicle type's startupDelay
285 : * @return The startupDelay
286 : */
287 : inline SUMOTime getStartupDelay() const {
288 13471606 : return myStartupDelay;
289 : }
290 :
291 : /** @brief Get the factor of minGap that must be maintained to avoid a collision event
292 : */
293 : inline double getCollisionMinGapFactor() const {
294 2103118899 : return myCollisionMinGapFactor;
295 : }
296 :
297 : /// @name Virtual methods with default implementation
298 : /// @{
299 :
300 : /** @brief Get the driver's imperfection
301 : * @return The imperfection of drivers of this class
302 : */
303 0 : virtual double getImperfection() const {
304 0 : return -1;
305 : }
306 :
307 :
308 : /** @brief Get the driver's desired headway [s]
309 : * @return The desired headway of this class' drivers in s
310 : */
311 244840276 : virtual double getHeadwayTime() const {
312 244840276 : return myHeadwayTime;
313 : }
314 :
315 : /// @brief whether startupDelay should be applied after stopping
316 13289427 : virtual bool startupDelayStopped() const {
317 13289427 : return false;
318 : }
319 : /// @}
320 :
321 :
322 :
323 :
324 : /// @name Currently fixed methods
325 : /// @{
326 :
327 : /** @brief Returns the maximum speed given the current speed
328 : *
329 : * The implementation of this method must take into account the time step
330 : * duration.
331 : *
332 : * Justification: Due to air brake or other influences, the vehicle's next maximum
333 : * speed may depend on the vehicle's current speed (given).
334 : *
335 : * @param[in] speed The vehicle's current speed
336 : * @param[in] veh The vehicle itself, for obtaining other values
337 : * @return The maximum possible speed for the next step
338 : */
339 : virtual double maxNextSpeed(double speed, const MSVehicle* const veh) const;
340 :
341 :
342 : /** @brief Returns the maximum speed given the current speed and regarding driving dynamics
343 : * @param[in] speed The vehicle's current speed
344 : * @param[in] speed The vehicle itself, for obtaining other values
345 : * @return The maximum possible speed for the next step taking driving dynamics into account
346 : */
347 870455 : inline virtual double maxNextSafeMin(double speed, const MSVehicle* const veh = 0) const {
348 870455 : return maxNextSpeed(speed, veh);
349 : }
350 :
351 :
352 : /** @brief Returns the minimum speed given the current speed
353 : * (depends on the numerical update scheme and its step width)
354 : * Note that it wouldn't have to depend on the numerical update
355 : * scheme if the semantics would rely on acceleration instead of velocity.
356 : *
357 : * @param[in] speed The vehicle's current speed
358 : * @param[in] speed The vehicle itself, for obtaining other values, if needed as e.g. road conditions.
359 : * @return The minimum possible speed for the next step
360 : */
361 : virtual double minNextSpeed(double speed, const MSVehicle* const veh = 0) const;
362 :
363 : /** @brief Returns the minimum speed after emergency braking, given the current speed
364 : * (depends on the numerical update scheme and its step width)
365 : * Note that it wouldn't have to depend on the numerical update
366 : * scheme if the semantics would rely on acceleration instead of velocity.
367 : *
368 : * @param[in] speed The vehicle's current speed
369 : * @param[in] speed The vehicle itself, for obtaining other values, if needed as e.g. road conditions.
370 : * @return The minimum possible speed for the next step
371 : */
372 : virtual double minNextSpeedEmergency(double speed, const MSVehicle* const veh = 0) const;
373 :
374 :
375 : /** @brief Returns the distance the vehicle needs to halt including driver's reaction time tau (i.e. desired headway),
376 : * assuming that during the reaction time, the speed remains constant
377 : * @param[in] speed The vehicle's current speed
378 : * @return The distance needed to halt
379 : */
380 : double brakeGap(const double speed) const {
381 1451883966 : return brakeGap(speed, myDecel, myHeadwayTime);
382 : }
383 :
384 : virtual double brakeGap(const double speed, const double decel, const double headwayTime) const;
385 :
386 : static double brakeGapEuler(const double speed, const double decel, const double headwayTime);
387 :
388 : static double freeSpeed(const double currentSpeed, const double decel, const double dist, const double maxSpeed, const bool onInsertion, const double actionStepLength);
389 :
390 : /** @brief Returns the minimum gap to reserve if the leader is braking at maximum (>=0)
391 : * @param[in] veh The vehicle itself, for obtaining other values
392 : * @param[in] pred The leader vehicle, for obtaining other values
393 : * @param[in] speed EGO's speed
394 : * @param[in] leaderSpeed LEADER's speed
395 : * @param[in] leaderMaxDecel LEADER's max. deceleration rate
396 : */
397 : virtual double getSecureGap(const MSVehicle* const veh, const MSVehicle* const /*pred*/, const double speed, const double leaderSpeed, const double leaderMaxDecel) const;
398 :
399 : virtual /** @brief Returns the velocity after maximum deceleration
400 : * @param[in] v The velocity
401 : * @return The velocity after maximum deceleration
402 : */
403 2016919 : inline double getSpeedAfterMaxDecel(double v) const {
404 2016919 : return MAX2(0., v - ACCEL2SPEED(myDecel));
405 : }
406 : /// @}
407 :
408 : /** @brief Computes the minimal time needed to cover a distance given the desired speed at arrival.
409 : * @param[in] dist Distance to be covered
410 : * @param[in] currentSpeed Actual speed of vehicle
411 : * @param[in] arrivalSpeed Desired speed at arrival
412 : */
413 : SUMOTime getMinimalArrivalTime(double dist, double currentSpeed, double arrivalSpeed) const;
414 :
415 :
416 : /** @brief Computes the time needed to travel a distance dist given an initial speed
417 : * and constant acceleration. The speed during traveling is assumed not to exceed the max speed.
418 : * @param[in] dist Distance to be covered (assumed >= 0.)
419 : * @param[in] speed Initial speed of vehicle
420 : * @param[in] accel Assumed acceleration until reaching maxspeed or speed=0.
421 : * @return Returns the estimated time needed to cover the given distance
422 : * If distance will never be covered with the given parameters INVALID_DOUBLE (from MSLink.h) is returned.
423 : */
424 : static double estimateArrivalTime(double dist, double speed, double maxSpeed, double accel);
425 :
426 : /** @brief Computes the time needed to travel a distance dist given an initial speed, arrival speed,
427 : * constant acceleration and deceleration. The speed during traveling is assumed not to exceed the max speed.
428 : * @param[in] dist Distance to be covered (assumed >= 0.)
429 : * @param[in] initialSpeed Initial speed of vehicle
430 : * @param[in] arrivalSpeed desired arrival speed of vehicle
431 : * @param[in] accel Assumed acceleration until reaching maxspeed.
432 : * @param[in] accel Assumed deceleration until reaching targetspeed.
433 : * @return Returns the estimated time needed to cover the given distance
434 : * If distance will never be covered with the given parameters INVALID_DOUBLE (from MSLink.h) is returned.
435 : * @note Currently, this is still a stub for actually very special situations in LC context:
436 : * It is assumed that 0==initialSpeed==arrivalSpeed<=maxspeed, accel==decel>0 (because currently
437 : * this is only used for lane change purposes, where lateral accel == lateral decel)
438 : */
439 : static double estimateArrivalTime(double dist, double initialSpeed, double arrivalSpeed, double maxSpeed, double accel, double decel);
440 :
441 : /** @brief Computes the acceleration needed to arrive not before the given time
442 : * @param[in] dist - the distance of the critical point
443 : * @param[in] time - the time after which an arrival at dist is allowed
444 : * @param[in] speed - the current speed
445 : * @return Returns the acceleration which would ensure an arrival at distance dist earliest for the given time
446 : */
447 : static double avoidArrivalAccel(double dist, double time, double speed, double maxDecel);
448 :
449 :
450 : /** @brief Computes the minimal possible arrival speed after covering a given distance
451 : * @param[in] dist Distance to be covered
452 : * @param[in] currentSpeed Actual speed of vehicle
453 : */
454 : double getMinimalArrivalSpeed(double dist, double currentSpeed) const;
455 :
456 : /** @brief Computes the minimal possible arrival speed after covering a given distance for Euler update
457 : * @param[in] dist Distance to be covered
458 : * @param[in] currentSpeed Actual speed of vehicle
459 : */
460 : double getMinimalArrivalSpeedEuler(double dist, double currentSpeed) const;
461 :
462 :
463 : /** @brief return the resulting gap if, starting with gap currentGap, two vehicles
464 : * continue with constant accelerations (velocities bounded by 0 and maxSpeed) for
465 : * a given timespan of length 'duration'.
466 : * @param[in] currentGap (pos(veh1) - pos(veh2) at start)
467 : * @param[in] v1 initial speed of vehicle 1
468 : * @param[in] v2 initial speed of vehicle 2
469 : * @param[in] a1 acceleration of vehicle 1
470 : * @param[in] a2 acceleration of vehicle 2
471 : * @param[in] maxV1 maximal speed of vehicle 1
472 : * @param[in] maxV2 maximal speed of vehicle 2
473 : * @param[in] duration time span for the process
474 : * @return estimated gap after 'duration' seconds
475 : */
476 : static double gapExtrapolation(const double duration, const double currentGap, double v1, double v2, double a1 = 0, double a2 = 0, const double maxV1 = std::numeric_limits<double>::max(), const double maxV2 = std::numeric_limits<double>::max());
477 :
478 : /**
479 : * @brief Calculates the time at which the position passedPosition has been passed
480 : * In case of a ballistic update, the possibility of a stop within a time step
481 : * requires more information about the last time-step than in case of the euler update
482 : * to determine the last position if the currentSpeed is zero.
483 : * @param[in] lastPos the position at time t=0 (must be < currentPos)
484 : * @param[in] passedPos the position for which the passing time is to be determined (has to lie within [lastPos, currentPos]!)
485 : * @param[in] currentPos the position at time t=TS (one time-step after lastPos) (must be > lastPos)
486 : * @param[in] lastSpeed the speed at moment t=0
487 : * @param[in] currentSpeed the speed at moment t=TS
488 : * @return time t in [0,TS] at which passedPos in [lastPos, currentPos] was passed.
489 : */
490 : static double passingTime(const double lastPos, const double passedPos, const double currentPos, const double lastSpeed, const double currentSpeed);
491 :
492 :
493 :
494 : /**
495 : * @brief Calculates the speed after a time t \in [0,TS]
496 : * given the initial speed and the distance traveled in an interval of step length TS.
497 : * @note If the acceleration were known, this would be much nicer, but in this way
498 : * we need to reconstruct it (for the ballistic update at least, where we assume that
499 : * a stop may occur within the interval)
500 : * @param[in] t time in [0,TS] for which the speed shall be determined
501 : * @param[in] oldSpeed speed before the last time step (referred to as t == 0)
502 : * @param[in] distance covered
503 : * @return speed at time t
504 : */
505 : static double speedAfterTime(const double t, const double oldSpeed, const double dist);
506 :
507 :
508 : /// @brief calculates the distance traveled after accelerating for time t
509 : virtual double distAfterTime(double t, double speed, double accel) const;
510 :
511 :
512 :
513 : /* @brief estimate speed while accelerating for the given distance
514 : * @param[in] dist The distance during which accelerating takes place
515 : * @param[in] v The initial speed
516 : * @param[in] accel The acceleration
517 : * XXX affected by ticket #860 (the formula is invalid for the Euler position update rule)
518 : * XXX (Leo) Migrated estimateSpeedAfterDistance() to MSCFModel from MSVehicle as Jakob suggested (removed inline property, because myType is fw-declared)
519 : */
520 : double estimateSpeedAfterDistance(const double dist, const double v, const double accel) const;
521 :
522 : /// @name Setter methods
523 : /// @{
524 :
525 : /** @brief Sets a new value for maximum acceleration [m/s^2]
526 : * @param[in] accel The new acceleration in m/s^2
527 : */
528 199 : virtual void setMaxAccel(double accel) {
529 199 : myAccel = accel;
530 199 : }
531 :
532 :
533 : /** @brief Sets a new value for maximal comfortable deceleration [m/s^2]
534 : * @param[in] decel The new deceleration in m/s^2
535 : */
536 113672 : virtual void setMaxDecel(double decel) {
537 114010 : myDecel = decel;
538 113672 : }
539 :
540 :
541 : /** @brief Sets a new value for maximal physically possible deceleration [m/s^2]
542 : * @param[in] decel The new deceleration in m/s^2
543 : */
544 42 : virtual void setEmergencyDecel(double decel) {
545 380 : myEmergencyDecel = decel;
546 42 : }
547 :
548 :
549 : /** @brief Sets a new value for the apparent deceleration [m/s^2]
550 : * @param[in] decel The new deceleration in m/s^2
551 : */
552 23 : virtual void setApparentDecel(double decel) {
553 23 : myApparentDecel = decel;
554 23 : }
555 :
556 : /** @brief Sets a new value for the factor of minGap that must be maintained to avoid a collision event
557 : * @param[in] factor The new minGap factor
558 : */
559 : inline void setCollisionMinGapFactor(const double factor) {
560 16 : myCollisionMinGapFactor = factor;
561 16 : }
562 :
563 : /** @brief Sets a new value for driver imperfection
564 : * @param[in] accel The new driver imperfection
565 : */
566 0 : virtual void setImperfection(double imperfection) {
567 : UNUSED_PARAMETER(imperfection);
568 0 : }
569 :
570 :
571 : /** @brief Sets a new value for desired headway [s]
572 : * @param[in] headwayTime The new desired headway (in s)
573 : */
574 8816 : virtual void setHeadwayTime(double headwayTime) {
575 9254 : myHeadwayTime = headwayTime;
576 8816 : }
577 : /// @}
578 :
579 : /** @brief Returns the maximum safe velocity for following the given leader
580 : * @param[in] gap2pred The (net) distance to the LEADER
581 : * @param[in] egoSpeed The FOLLOWERS's speed
582 : * @param[in] predSpeed The LEADER's speed
583 : * @param[in] predMaxDecel The LEADER's maximum deceleration
584 : * @param[in] onInsertion Indicator whether the call is triggered during vehicle insertion
585 : * @return the safe velocity
586 : */
587 : double maximumSafeFollowSpeed(double gap, double egoSpeed, double predSpeed, double predMaxDecel, bool onInsertion = false) const;
588 :
589 :
590 : /** @brief Returns the minimal deceleration for following the given leader safely
591 : * @param[in] gap The (net) distance to the LEADER
592 : * @param[in] egoSpeed The FOLLOWERS's speed
593 : * @param[in] predSpeed The LEADER's speed
594 : * @param[in] predMaxDecel The LEADER's maximum deceleration
595 : * @return The minimal deceleration b>0 that, if applied constantly until a full stop,
596 : * asserts that the vehicle does not crash into the leader.
597 : * @note If b > predMaxDecel, this function actually does not calculate the tangency for the trajectories, i.e. a double root for the gap,
598 : * but applies a simpler approach following the spirit of maximumSafeFollowSpeed, where the
599 : * leader's decel is assumed as maximum of its actual value and the followers decel.
600 : */
601 : double calculateEmergencyDeceleration(double gap, double egoSpeed, double predSpeed, double predMaxDecel) const;
602 :
603 :
604 : /** @brief Returns the maximum next velocity for stopping within gap
605 : * @param[in] gap The (net) distance to the desired stopping point
606 : * @param[in] decel The desired deceleration rate
607 : * @param[in] currentSpeed The current speed of the ego vehicle
608 : * @param[in] onInsertion Indicator whether the call is triggered during vehicle insertion
609 : * @param[in] headway The desired time headway to be included in the calculations (default argument -1 induces the use of myHeadway)
610 : * @param[in] relaxEmergency Whether emergency deceleration should be reduced (at the cost of staying in a dangerous situation for longer)
611 : */
612 : double maximumSafeStopSpeed(double gap, double decel, double currentSpeed, bool onInsertion = false, double headway = -1, bool relaxEmergency = true) const;
613 :
614 :
615 : /** @brief Returns the maximum next velocity for stopping within gap
616 : * when using the semi-implicit Euler update
617 : * @param[in] gap The (net) distance to the LEADER
618 : * @param[in] decel The desired deceleration rate
619 : * @param[in] onInsertion Indicator whether the call is triggered during vehicle insertion
620 : * @param[in] headway The desired time headway to be included in the calculations (-1 induces the use of myHeadway)
621 : */
622 : double maximumSafeStopSpeedEuler(double gap, double decel, bool onInsertion, double headway) const;
623 :
624 :
625 : /** @brief Returns the maximum next velocity for stopping within gap
626 : * when using the ballistic positional update.
627 : * @note This takes into account the driver's reaction time tau (i.e. the desired headway) and the car's current speed.
628 : * (The latter is required to calculate the distance covered in the following timestep.)
629 : * @param[in] gap The (net) distance to the desired stopping point
630 : * @param[in] decel The desired deceleration rate
631 : * @param[in] currentSpeed The current speed of the ego vehicle
632 : * @param[in] onInsertion Indicator whether the call is triggered during vehicle insertion
633 : * @param[in] headway The desired time headway to be included in the calculations (default argument -1 induces the use of myHeadway)
634 : * @return the safe velocity (to be attained at the end of the following time step) that assures the possibility of stopping within gap.
635 : * If a negative value is returned, the required stop has to take place before the end of the time step.
636 : */
637 : double maximumSafeStopSpeedBallistic(double gap, double decel, double currentSpeed, bool onInsertion = false, double headway = -1) const;
638 :
639 : /**
640 : * @brief try to get the given parameter for this carFollowingModel
641 : *
642 : * @param[in] veh the vehicle from which the parameter must be retrieved
643 : * @param[in] key the key of the parameter
644 : * @return the value of the requested parameter
645 : */
646 0 : virtual std::string getParameter(const MSVehicle* veh, const std::string& key) const {
647 : UNUSED_PARAMETER(veh);
648 : UNUSED_PARAMETER(key);
649 0 : return "";
650 : }
651 :
652 : /**
653 : * @brief try to set the given parameter for this carFollowingModel
654 : *
655 : * @param[in] veh the vehicle for which the parameter must be set
656 : * @param[in] key the key of the parameter
657 : * @param[in] value the value to be set for the given parameter
658 : */
659 5 : virtual void setParameter(MSVehicle* veh, const std::string& key, const std::string& value) const {
660 : UNUSED_PARAMETER(veh);
661 : UNUSED_PARAMETER(key);
662 : UNUSED_PARAMETER(value);
663 10 : throw InvalidArgument("Setting parameter '" + key + "' is not supported by carFollowModel");
664 : }
665 :
666 : protected:
667 :
668 : /** @brief Overwrites sped by the perceived values obtained from the vehicle's driver state,
669 : * @see MSCFModel_Krauss::freeSpeed()
670 : * @param[in] veh The vehicle (EGO)
671 : * @param[in, out] speed The vehicle's speed
672 : */
673 : void applyOwnSpeedPerceptionError(const MSVehicle* const veh, double& speed) const;
674 :
675 : /** @brief Overwrites gap2pred and predSpeed by the perceived values obtained from the vehicle's driver state,
676 : * @see MSCFModel_Krauss::stopSpeed() and MSCFModel_Krauss::followSpeed() for integration into a CF model
677 : * @param[in] veh The vehicle (EGO)
678 : * @param[in] speed The vehicle's speed
679 : * @param[in, out] gap2pred The (net) distance to the LEADER
680 : * @param[in, out] predSpeed The speed of LEADER
681 : * @param[in] pred The leading vehicle (LEADER)
682 : */
683 : void applyHeadwayAndSpeedDifferencePerceptionErrors(const MSVehicle* const veh, double speed, double& gap, double& predSpeed, double predMaxDecel, const MSVehicle* const pred) const;
684 :
685 : /** @brief Overwrites gap by the perceived value obtained from the vehicle's driver state
686 : * @param[in] veh The vehicle (EGO)
687 : * @param[in] speed The vehicle's speed
688 : * @param[in, out] gap The (net) distance to the obstacle
689 : */
690 : void applyHeadwayPerceptionError(const MSVehicle* const veh, double speed, double& gap) const;
691 :
692 :
693 : protected:
694 : /// @brief The type to which this model definition belongs to
695 : const MSVehicleType* myType;
696 :
697 : /// @brief The vehicle's maximum acceleration [m/s^2]
698 : double myAccel;
699 :
700 : /// @brief The vehicle's maximum deceleration [m/s^2]
701 : double myDecel;
702 : /// @brief The vehicle's maximum emergency deceleration [m/s^2]
703 : double myEmergencyDecel;
704 : /// @brief The vehicle's deceleration as expected by surrounding traffic [m/s^2]
705 : double myApparentDecel;
706 : /// @brief The factor of minGap that must be maintained to avoid a collision event
707 : double myCollisionMinGapFactor;
708 :
709 : /// @brief The driver's desired time headway (aka reaction time tau) [s]
710 : double myHeadwayTime;
711 :
712 : /// @brief The startup delay after halting [s]
713 : SUMOTime myStartupDelay;
714 :
715 :
716 :
717 : };
|
