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