SUMO - Simulation of Urban MObility
MSDriverState.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-2018 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 /****************************************************************************/
15 // A class representing a vehicle driver's current mental state
16 /****************************************************************************/
17 
18 
20 
21 
22 #ifndef MSDriverState_h
23 #define MSDriverState_h
24 
25 // ===========================================================================
26 // included modules
27 // ===========================================================================
28 #include <config.h>
29 
30 #include <memory>
31 #include <utils/common/SUMOTime.h>
33 
34 // ===========================================================================
35 // class declarations
36 // ===========================================================================
37 //class MSJunction;
38 //class MSLink;
39 //class MSVehicle;
40 //class MSLane;
41 //class MSPerson;
42 
43 
44 // ===========================================================================
45 // class definitions
46 // ===========================================================================
47 
48 
51 class OUProcess {
52 public:
54  OUProcess(double initialState, double timeScale, double noiseIntensity);
56  ~OUProcess();
57 
59  void step(double dt);
60 
62  void setTimeScale(double timeScale) {
63  myTimeScale = timeScale;
64  };
65 
67  void setNoiseIntensity(double noiseIntensity) {
68  myNoiseIntensity = noiseIntensity;
69  };
70 
72  void setState(double state) {
73  myState = state;
74  };
75 
76  inline double getNoiseIntensity() const {
77  return myNoiseIntensity;
78  };
79 
80  inline double getTimeScale() const {
81  return myTimeScale;
82  };
83 
84 
86  double getState() const;
87 
88 
89  static std::mt19937* getRNG() {
90  return &myRNG;
91  }
92 
93 private:
96  double myState;
97 
100  double myTimeScale;
101 
105 
107  static std::mt19937 myRNG;
108 };
109 
110 
115 
116 public:
118  virtual ~MSSimpleDriverState() {};
119 
120 
123  inline double getMinAwareness() const {
124  return myMinAwareness;
125  }
126 
127  inline double getInitialAwareness() const {
128  return myInitialAwareness;
129  }
130 
131  inline double getErrorTimeScaleCoefficient() const {
132  return myErrorTimeScaleCoefficient;
133  }
134 
135  inline double getErrorNoiseIntensityCoefficient() const {
136  return myErrorNoiseIntensityCoefficient;
137  }
138 
139  inline double getErrorTimeScale() const {
140  return myError.getTimeScale();
141  }
142 
143  inline double getErrorNoiseIntensity() const {
144  return myError.getNoiseIntensity();
145  }
146 
147  inline double getSpeedDifferenceErrorCoefficient() const {
148  return mySpeedDifferenceErrorCoefficient;
149  }
150 
151  inline double getHeadwayErrorCoefficient() const {
152  return myHeadwayErrorCoefficient;
153  }
154 
156  return mySpeedDifferenceChangePerceptionThreshold;
157  }
158 
159  inline double getHeadwayChangePerceptionThreshold() const {
160  return myHeadwayChangePerceptionThreshold;
161  }
162 
163  inline double getAwareness() const {
164  return myAwareness;
165  }
166 
167  inline double getErrorState() const {
168  return myError.getState();
169  };
171 
172 
175  inline void setMinAwareness(const double value) {
176  myMinAwareness = value;
177  }
178 
179  inline void setInitialAwareness(const double value) {
180  myInitialAwareness = value;
181  }
182 
183  inline void setErrorTimeScaleCoefficient(const double value) {
184  myErrorTimeScaleCoefficient = value;
185  }
186 
187  inline void setErrorNoiseIntensityCoefficient(const double value) {
188  myErrorNoiseIntensityCoefficient = value;
189  }
190 
191  inline void setSpeedDifferenceErrorCoefficient(const double value) {
192  mySpeedDifferenceErrorCoefficient = value;
193  }
194 
195  inline void setHeadwayErrorCoefficient(const double value) {
196  myHeadwayErrorCoefficient = value;
197  }
198 
199  inline void setSpeedDifferenceChangePerceptionThreshold(const double value) {
200  mySpeedDifferenceChangePerceptionThreshold = value;
201  }
202 
203  inline void setHeadwayChangePerceptionThreshold(const double value) {
204  myHeadwayChangePerceptionThreshold = value;
205  }
206 
207  void setAwareness(const double value);
208 
209  inline void setErrorState(const double state) {
210  myError.setState(state);
211  };
212 
213  inline void setErrorTimeScale(const double value) {
214  myError.setTimeScale(value);
215  }
216 
217  inline void setErrorNoiseIntensity(const double value) {
218  myError.setNoiseIntensity(value);
219  }
221 
223  void update();
224 
225 
228  void updateAssumedGaps();
229 
233 // /// @see myAccelerationError
234 // inline double getAppliedAcceleration(double desiredAccel) {
235 // return desiredAccel + myError.getState();
236 // };
237 
242  double getPerceivedSpeedDifference(const double trueSpeedDifference, const double trueGap, const void* objID = nullptr);
244  double getPerceivedHeadway(const double trueGap, const void* objID = nullptr);
246 
247  inline void lockDebug() {
248  myDebugLock = true;
249  }
250 
251  inline void unlockDebug() {
252  myDebugLock = false;
253  }
254 
255  inline bool debugLocked() const {
256  return myDebugLock;
257  }
258 
259 private:
260  // @brief Update the current step duration
261  void updateStepDuration();
262  // Update the error process
263  void updateError();
264 
265 private:
266 
269 
270  // @brief Driver's 'awareness' \in [0,1]
271  double myAwareness;
272  // @brief Minimal value for 'awareness' \in [0,1]
274  // @brief Initial value for 'awareness' \in [0,1]
276  // @brief Driver's 'error', @see TCI_Model
282 
291 // // @brief if a perception threshold is passed for some object, a flag is set to induce a reaction to the object
292 // std::map<void*, bool> myReactionFlag;
293 
297 
305 
306 
309  std::map<const void*, double> myAssumedGap;
311  std::map<const void*, double> myLastPerceivedSpeedDifference;
313 
316 };
317 
318 
319 
320 
321 
323 // * @brief An object representing a traffic item. Used for influencing
324 // * the task demand of the TCI car-following model.
325 // * @see MSCFModel_TCI
326 // */
327 //class MSDriverState {
328 //
329 //protected:
330 // /// @brief base class for VehicleCharacteristics, TLSCharacteristics, PedestrianCharacteristics, SpeedLimitCharacteristics, Junction Characteristics...
331 // /// @see TrafficItemType, @see MSCFModel_TCI
332 // struct MSTrafficItemCharacteristics {
333 // inline virtual ~MSTrafficItemCharacteristics() {};
334 // };
335 //
336 // // @brief Types of traffic items, @see TrafficItem
337 // enum MSTrafficItemType {
338 // TRAFFIC_ITEM_VEHICLE,
339 // TRAFFIC_ITEM_PEDESTRIAN,
340 // TRAFFIC_ITEM_SPEED_LIMIT,
341 // TRAFFIC_ITEM_JUNCTION
342 // };
343 //
344 // /** @class MSTrafficItem
345 // * @brief An object representing a traffic item. Used for influencing
346 // * the task demand of the TCI car-following model.
347 // * @see MSCFModel_TCI
348 // */
349 // struct MSTrafficItem {
350 // MSTrafficItem(MSTrafficItemType type, const std::string& id, std::shared_ptr<MSTrafficItemCharacteristics> data);
351 // static std::hash<std::string> hash;
352 // MSTrafficItemType type;
353 // size_t id_hash;
354 // std::shared_ptr<MSTrafficItemCharacteristics> data;
355 // double remainingIntegrationTime;
356 // double integrationDemand;
357 // double latentDemand;
358 // };
359 //
360 // struct JunctionCharacteristics : MSTrafficItemCharacteristics {
361 // JunctionCharacteristics(const MSJunction* junction, const MSLink* egoLink, double dist) :
362 // junction(junction), approachingLink(egoLink), dist(dist) {};
363 // const MSJunction* junction;
364 // const MSLink* approachingLink;
365 // double dist;
366 // };
367 //
368 // struct PedestrianCharacteristics : MSTrafficItemCharacteristics {
369 // PedestrianCharacteristics(const MSPerson* pedestrian, double dist) :
370 // pedestrian(pedestrian), dist(dist) {};
371 // const MSPerson* pedestrian;
372 // double dist;
373 // };
374 //
375 // struct SpeedLimitCharacteristics : MSTrafficItemCharacteristics {
376 // SpeedLimitCharacteristics(const MSLane* lane, double dist, double limit) :
377 // dist(dist), limit(limit), lane(lane) {};
378 // const MSLane* lane;
379 // double dist;
380 // double limit;
381 // };
382 //
383 // struct VehicleCharacteristics : MSTrafficItemCharacteristics {
384 // VehicleCharacteristics(const MSVehicle* foe, double longitudinalDist, double lateralDist, double relativeSpeed) :
385 // longitudinalDist(longitudinalDist), lateralDist(lateralDist), foe(foe), relativeSpeed(relativeSpeed) {};
386 // const MSVehicle* foe;
387 // double longitudinalDist;
388 // double lateralDist;
389 // double relativeSpeed;
390 // };
391 //
392 //
393 //public:
394 //
395 // MSDriverState(MSVehicle* veh);
396 // virtual ~MSDriverState() {};
397 //
398 // /// @name Interfaces to inform Driver Model about traffic items, which potentially
399 // /// influence the driving difficulty.
400 // /// @{
401 // /** @brief Informs about leader.
402 // */
403 // virtual void registerLeader(const MSVehicle* leader, double gap, double relativeSpeed, double latGap = -1.);
404 //
405 // /** @brief Informs about pedestrian.
406 // */
407 // virtual void registerPedestrian(const MSPerson* pedestrian, double gap);
408 //
409 // /** @brief Informs about upcoming speed limit reduction.
410 // */
411 // virtual void registerSpeedLimit(const MSLane* lane, double speedLimit, double dist);
412 //
413 // /** @brief Informs about upcoming junction.
414 // */
415 // virtual void registerJunction(MSLink* link, double dist);
416 //
417 // /** @brief Takes into account vehicle-specific factors for the driving demand
418 // * For instance, whether vehicle drives on an opposite direction lane, absolute speed, etc.
419 // */
420 // virtual void registerEgoVehicleState();
421 //
422 // /** @brief Trigger updates for the state variables according to the traffic situation
423 // * (present traffic items)
424 // */
425 // virtual void update();
426 // /// @}
427 //
428 //
429 // /// @name Methods to obtain the current error quantities to be used by the car-following model
430 // /// @see TCIModel
431 // /// @{
432 // /// @see myAccelerationError
433 // inline double getAppliedAcceleration(double desiredAccel) {
434 // return desiredAccel + myAccelerationError.getState();
435 // };
436 // /// @see mySpeedPerceptionError
437 // inline double getPerceivedSpeedDifference(double trueSpeedDifference) {
438 // return trueSpeedDifference + mySpeedPerceptionError.getState();
439 // };
440 // /// @see myHeadwayPerceptionError
441 // inline double getPerceivedHeadway(double trueGap) {
442 // return trueGap + myHeadwayPerceptionError.getState();
443 // };
444 // /// @see myActionStepLength
445 // inline double getActionStepLength(){
446 // return myActionStepLength;
447 // };
448 // /// @}
449 //
450 //
451 //private:
452 //
453 // /** @brief Updates the internal variables to track the time between
454 // * two calls to the state update (i.e., two action points). Needed for a consistent
455 // * evolution of the error processes.
456 // */
457 // void updateStepDuration();
458 //
459 // /** @brief Calculates a value for the task difficulty given the capability and the demand
460 // * and stores the result in myCurrentDrivingDifficulty.
461 // * @see difficultyFunction()
462 // */
463 // void calculateDrivingDifficulty();
464 //
465 //
466 // /** @brief Transformation of the quotient demand/capability to obtain the actual
467 // * difficulty value used to control driving performance.
468 // * @note The current implementation is a continuous piecewise affine function.
469 // * It has two regions with different slopes. A slight ascend, where the capability
470 // * is larger than the demand and a region of steeper ascend, where the demand
471 // * exceeds the capability.
472 // */
473 // double difficultyFunction(double demandCapabilityQuotient) const;
474 //
475 //
476 // /** @brief Updates the myTaskCapability in dependence of the myTaskDifficulty to model a reactive
477 // * level of attention. The characteristics of the process are determined by myHomeostasisDifficulty
478 // * and myCapabilityTimeScale.
479 // * @todo Review the implementation as simple exponential process.
480 // */
481 // void adaptTaskCapability();
482 //
483 //
484 // /// @name Updater for error processes.
485 // /// @{
486 // void updateAccelerationError();
487 // void updateSpeedPerceptionError();
488 // void updateHeadwayPerceptionError();
489 // void updateActionStepLength();
490 // /// @}
491 //
492 //
493 // /// @brief Updates the given error process
494 // void updateErrorProcess(OUProcess& errorProcess, double timeScaleCoefficient, double noiseIntensityCoefficient) const;
495 //
496 // /// @brief Initialize newly appeared traffic item
497 // void calculateLatentDemand(std::shared_ptr<MSTrafficItem> ti) const;
498 //
499 // /// @brief Calculate demand induced by the given junction
500 // double calculateLatentJunctionDemand(std::shared_ptr<JunctionCharacteristics> ch) const;
501 // /// @brief Calculate demand induced by the given pedestrian
502 // double calculateLatentPedestrianDemand(std::shared_ptr<PedestrianCharacteristics> ch) const;
503 // /// @brief Calculate demand induced by the given pedestrian
504 // double calculateLatentSpeedLimitDemand(std::shared_ptr<SpeedLimitCharacteristics> ch) const;
505 // /// @brief Calculate demand induced by the given vehicle
506 // double calculateLatentVehicleDemand(std::shared_ptr<VehicleCharacteristics> ch) const;
507 //
508 // /// @brief Calculate integration demand induced by the given junction
509 // double calculateJunctionIntegrationDemand(std::shared_ptr<JunctionCharacteristics> ch) const;
510 // /// @brief Calculate integration demand induced by the given pedestrian
511 // double calculatePedestrianIntegrationDemand(std::shared_ptr<PedestrianCharacteristics> ch) const;
512 // /// @brief Calculate integration demand induced by the given pedestrian
513 // double calculateSpeedLimitIntegrationDemand(std::shared_ptr<SpeedLimitCharacteristics> ch) const;
514 // /// @brief Calculate integration demand induced by the given vehicle
515 // double calculateVehicleIntegrationDemand(std::shared_ptr<VehicleCharacteristics> ch) const;
516 //
517 // /// @brief Register known traffic item to persist
518 // void updateItemIntegration(std::shared_ptr<MSTrafficItem> ti) const;
519 //
520 // /// @brief Determine the integration demand and duration for a newly encountered traffic item (updated in place)
521 // /// The integration demand takes effect during a short period after the first appearance of the item.
522 // void calculateIntegrationDemandAndTime(std::shared_ptr<MSTrafficItem> ti) const;
523 //
524 // /// @brief Calculate the integration time for an item approached with the given speed at given dist
525 // double calculateIntegrationTime(double dist, double speed) const;
526 //
527 // /// @brief Incorporate the item's demand into the total task demand.
528 // void integrateDemand(std::shared_ptr<MSTrafficItem> ti);
529 //
530 // /// @brief Called whenever the vehicle is notified about a traffic item encounter.
531 // void registerTrafficItem(std::shared_ptr<MSTrafficItem> ti);
532 //
533 //private:
534 //
535 // MSVehicle* myVehicle;
536 //
537 // /// @name Variables for tracking update instants
538 // /// @see updateStepDuration()
539 // /// @{
540 //
541 // /// @brief Elapsed time since the last state update
542 // double myStepDuration;
543 // /// @brief Time point of the last state update
544 // double myLastUpdateTime;
545 //
546 // /// @}
547 //
548 //
549 // /// @name Dynamical quantities for the driving performance
550 // /// @{
551 //
552 // /** @brief Task capability (combines static and dynamic factors specific to the driver and the situation,
553 // * total capability, attention, etc.). Follows myTaskDemand with some inertia (task-difficulty-homeostasis).
554 // */
555 // double myTaskCapability;
556 // double myMinTaskCapability, myMaxTaskCapability;
557 //
558 // /** @brief Task Demand (dynamic variable representing the total demand imposed on the driver by the driving situation and environment.
559 // * For instance, number, novelty and type of traffic participants in neighborhood, speed differences, road curvature,
560 // * headway to leader, number of lanes, traffic density, street signs, traffic lights)
561 // */
562 // double myTaskDemand;
563 // double myMaxTaskDemand;
564 //
565 // /** @brief Cached current value of the difficulty resulting from the combination of task capability and demand.
566 // * @see calculateDrivingDifficulty()
567 // */
568 // double myCurrentDrivingDifficulty;
569 // /// @brief Upper bound for myCurrentDrivingDifficulty
570 // double myMaxDifficulty;
571 // /** @brief Slopes for the dependence of the difficulty on the quotient of demand and capability.
572 // * @see difficultyFunction();
573 // */
574 // double mySubCriticalDifficultyCoefficient, mySuperCriticalDifficultyCoefficient;
575 //
576 // /// @}
577 //
578 // /// @name Field that reflect the current driving situation
579 // /// @{
580 // /// @brief Whether vehicle is driving on an opposite direction lane
581 // bool myAmOpposite;
582 // double myCurrentSpeed;
583 // double myCurrentAcceleration;
584 // /// @}
585 //
586 // /// @name Parameters for the dynamic adaptation of capability (attention) and demand
587 // /// @{
588 //
589 // /** @brief The desired value of the quotient myTaskDemand/myTaskCapability. Influences the fixed point of the
590 // * process myTaskCapability -> myTaskDemand, @see adaptTaskCapability()
591 // */
592 // double myHomeostasisDifficulty;
593 //
594 // /** @brief Determines the time scale for the adaptation process of task capability towards the
595 // * task difficulty.
596 // */
597 // double myCapabilityTimeScale;
598 //
599 // /** @brief Factor for the demand if driving on an opposite direction lane
600 // */
601 // double myOppositeDirectionDrivingDemandFactor;
602 //
603 // /// @}
604 //
605 //
606 //
607 // /** @brief Traffic items in the current neighborhood of the vehicle.
608 // */
609 // std::map<size_t, std::shared_ptr<MSTrafficItem> > myTrafficItems;
610 // std::map<size_t, std::shared_ptr<MSTrafficItem> > myNewTrafficItems;
611 //
612 // /// @name Actuation errors
613 // /// @{
614 //
615 // /** @brief Acceleration error. Modelled as an Ornstein-Uhlenbeck process.
616 // * @see updateAccelerationError()
617 // */
618 // OUProcess myAccelerationError;
619 // /// @brief Coefficient controlling the impact of driving difficulty on the time scale of the acceleration error process
620 // double myAccelerationErrorTimeScaleCoefficient;
621 // /// @brief Coefficient controlling the impact of driving difficulty on the noise intensity of the acceleration error process
622 // double myAccelerationErrorNoiseIntensityCoefficient;
623 //
624 // /// @brief Action step length (increases with task difficulty, is similar to reaction time)
625 // double myActionStepLength;
626 // /// @brief Proportionality factor of myActionStepLength and driving difficulty
627 // double myActionStepLengthCoefficient;
628 // /// @brief Bounds for the action step length
629 // double myMinActionStepLength, myMaxActionStepLength;
630 //
631 // /// @}
632 //
633 //
634 // /// @name Perception errors
635 // /// @{
636 //
637 // /** @brief Error of estimation of the relative speeds of neighboring vehicles
638 // */
639 // OUProcess mySpeedPerceptionError;
640 // /// @brief Coefficient controlling the impact of driving difficulty on the time scale of the relative speed error process
641 // double mySpeedPerceptionErrorTimeScaleCoefficient;
642 // /// @brief Coefficient controlling the impact of driving difficulty on the noise intensity of the relative speed error process
643 // double mySpeedPerceptionErrorNoiseIntensityCoefficient;
644 //
645 // /** @brief Error of estimation of the distance/headways of neighboring vehicles
646 // */
647 // OUProcess myHeadwayPerceptionError;
648 // /// @brief Coefficient controlling the impact of driving difficulty on the time scale of the headway error process
649 // double myHeadwayPerceptionErrorTimeScaleCoefficient;
650 // /// @brief Coefficient controlling the impact of driving difficulty on the noise intensity of the headway error process
651 // double myHeadwayPerceptionErrorNoiseIntensityCoefficient;
652 //
653 // /// @}
654 //};
655 
656 
657 
660 // static double myMinTaskCapability;
661 // static double myMaxTaskCapability;
662 // static double myMaxTaskDemand;
663 // static double myMaxDifficulty;
664 // static double mySubCriticalDifficultyCoefficient;
665 // static double mySuperCriticalDifficultyCoefficient;
666 // static double myHomeostasisDifficulty;
667 // static double myCapabilityTimeScale;
668 // static double myAccelerationErrorTimeScaleCoefficient;
669 // static double myAccelerationErrorNoiseIntensityCoefficient;
670 // static double myActionStepLengthCoefficient;
671 // static double myMinActionStepLength;
672 // static double myMaxActionStepLength;
673 // static double mySpeedPerceptionErrorTimeScaleCoefficient;
674 // static double mySpeedPerceptionErrorNoiseIntensityCoefficient;
675 // static double myHeadwayPerceptionErrorTimeScaleCoefficient;
676 // static double myHeadwayPerceptionErrorNoiseIntensityCoefficient;
677 // static double myOppositeDirectionDrivingFactor;
678 
679  // for MSSimpleDriverState
680  static double minAwareness;
681  static double initialAwareness;
687  static double headwayErrorCoefficient;
688 };
689 
690 
691 
692 #endif
693 
694 /****************************************************************************/
void setInitialAwareness(const double value)
double getState() const
Obtain the current state of the process.
double myLastUpdateTime
Time point of the last state update.
~OUProcess()
destructor
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:79
void setSpeedDifferenceChangePerceptionThreshold(const double value)
bool debugLocked() const
double getMinAwareness() const
void setMinAwareness(const double value)
void setErrorTimeScaleCoefficient(const double value)
double getAwareness() const
static double headwayChangePerceptionThreshold
void setNoiseIntensity(double noiseIntensity)
set the process&#39; noise intensity to a new value
Definition: MSDriverState.h:67
double myActionStepLength
action step length induced by awareness level
double myTimeScale
The time scale of the process.
static double minAwareness
void setState(double state)
set the process&#39; state to a new value
Definition: MSDriverState.h:72
static std::mt19937 * getRNG()
Definition: MSDriverState.h:89
double myHeadwayErrorCoefficient
double getInitialAwareness() const
static double initialAwareness
void setHeadwayChangePerceptionThreshold(const double value)
MSVehicle * myVehicle
Vehicle corresponding to this driver state.
OUProcess(double initialState, double timeScale, double noiseIntensity)
constructor
static double headwayErrorCoefficient
static double errorTimeScaleCoefficient
std::map< const void *, double > myLastPerceivedSpeedDifference
The last perceived speed differences to the corresponding objects.
An Ornstein-Uhlenbeck stochastic process.
Definition: MSDriverState.h:51
double myState
The current state of the process.
Definition: MSDriverState.h:96
static double speedDifferenceErrorCoefficient
void setErrorNoiseIntensity(const double value)
bool myDebugLock
Used to prevent infinite loops in debugging outputs,.
void setTimeScale(double timeScale)
set the process&#39; timescale to a new value
Definition: MSDriverState.h:62
double getErrorNoiseIntensity() const
double getSpeedDifferenceChangePerceptionThreshold() const
void setErrorTimeScale(const double value)
double getHeadwayChangePerceptionThreshold() const
double getNoiseIntensity() const
Definition: MSDriverState.h:76
static double speedDifferenceChangePerceptionThreshold
double getErrorState() const
void setHeadwayErrorCoefficient(const double value)
static std::mt19937 myRNG
Random generator for OUProcesses.
double getTimeScale() const
Definition: MSDriverState.h:80
double myErrorNoiseIntensityCoefficient
Coefficient controlling the impact of awareness on the noise intensity of the error process...
double getErrorTimeScaleCoefficient() const
std::map< const void *, double > myAssumedGap
The assumed gaps to different objects.
double myNoiseIntensity
The noise intensity of the process.
Informs about leader.
double getSpeedDifferenceErrorCoefficient() const
double mySpeedDifferenceErrorCoefficient
Scaling coefficients for the magnitude of errors.
double myErrorTimeScaleCoefficient
Coefficient controlling the impact of awareness on the time scale of the error process.
void setErrorNoiseIntensityCoefficient(const double value)
double mySpeedDifferenceChangePerceptionThreshold
void setSpeedDifferenceErrorCoefficient(const double value)
void step(double dt)
evolve for a time step of length dt.
double myHeadwayChangePerceptionThreshold
Thresholds above a change in the corresponding quantity is perceived.
static double errorNoiseIntensityCoefficient
virtual ~MSSimpleDriverState()
double getErrorNoiseIntensityCoefficient() const
Provides an interface to an error whose fluctuation is controlled via the driver&#39;s &#39;awareness&#39;...
void setErrorState(const double state)
double getHeadwayErrorCoefficient() const
double getErrorTimeScale() const