Eclipse SUMO - Simulation of Urban MObility
MSDevice_SSM.h
Go to the documentation of this file.
1 /****************************************************************************/
2 // Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.org/sumo
3 // Copyright (C) 2013-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 /****************************************************************************/
21 // An SSM-device logs encounters / conflicts of the carrying vehicle with other surrounding vehicles.
22 // XXX: Preliminary implementation. Use with care. Especially rerouting vehicles could be problematic.
23 /****************************************************************************/
24 #pragma once
25 #include <config.h>
26 
27 #include <queue>
28 #include "MSVehicleDevice.h"
29 #include <utils/common/SUMOTime.h>
31 #include <utils/geom/Position.h>
32 
33 
34 // ===========================================================================
35 // class declarations
36 // ===========================================================================
37 class SUMOVehicle;
38 class SUMOTrafficObject;
39 
40 
41 // ===========================================================================
42 // class definitions
43 // ===========================================================================
53 class MSCrossSection;
54 
55 class MSDevice_SSM : public MSVehicleDevice {
56 
57 private:
59  static std::set<MSDevice_SSM*, ComparatorNumericalIdLess>* myInstances;
60 
61 public:
65  // Other vehicle is closer than range, but not on a lane conflicting with the ego's route ahead
67  // Ego and foe vehicles' edges form a part of a consecutive sequence of edges
68  // This type may be specified further by ENCOUNTER_TYPE_FOLLOWING_LEADER or ENCOUNTER_TYPE_FOLLOWING_FOLLOWER
70  // Ego vehicle is on an edge that has a sequence of successors connected to the other vehicle's edge
72  // Other vehicle is on an edge that has a sequence of successors connected to the ego vehicle's current edge
74  // Other vehicle is on an edge that has a sequence of successors connected to the ego vehicle's current edge
76  // Ego and foe share an upcoming edge of their routes while the merging point for the routes is still ahead
77  // This type may be specified further by ENCOUNTER_TYPE_MERGING_LEADER or ENCOUNTER_TYPE_MERGING_FOLLOWER
79  // Other vehicle is on an edge that has a sequence of successors connected to an edge on the ego vehicle's route
80  // and the estimated arrival vehicle at the merge point is earlier for the ego than for the foe
82  // Other vehicle is on an edge that has a sequence of successors connected to an edge on the ego vehicle's route
83  // and the estimated arrival vehicle at the merge point is earlier for the foe than for the ego
85  // Vehicles' bestlanes lead to the same edge but to adjacent lanes
87  // Ego's and foe's routes have crossing edges
88  // This type may be specified further by ENCOUNTER_TYPE_CROSSING_LEADER or ENCOUNTER_TYPE_CROSSING_FOLLOWER
90  // Other vehicle is on an edge that has a sequence of successors leading to an internal edge that crosses the ego vehicle's edge at a junction
91  // and the estimated arrival vehicle at the merge point is earlier for the ego than for the foe
93  // Other vehicle is on an edge that has a sequence of successors leading to an internal edge that crosses the ego vehicle's edge at a junction
94  // and the estimated arrival vehicle at the merge point is earlier for the foe than for the ego
96  // The encounter is a possible crossing conflict, and the ego vehicle has entered the conflict area
98  // The encounter is a possible crossing conflict, and the foe vehicle has entered the conflict area
100  // The encounter has been a possible crossing conflict, but the ego vehicle has left the conflict area
102  // The encounter has been a possible crossing conflict, but the foe vehicle has left the conflict area
104  // The encounter has been a possible crossing conflict, and both vehicles have entered the conflict area (one must have already left, otherwise this must be a collision)
106  // The encounter has been a possible crossing conflict, but both vehicle have left the conflict area
108  // FOLLOWING_PASSED and MERGING_PASSED are reserved to achieve that these encounter types may be tracked longer (see updatePassedEncounter)
109  // The encounter has been a following situation, but is not active any more
111  // The encounter has been a merging situation, but is not active any more
113  // Ego vehicle and foe are driving in opposite directions towards each other on the same lane (or sequence of consecutive lanes)
115  // Collision (currently unused, might be differentiated further)
117  };
118 
119  static std::string encounterToString(EncounterType type) {
120  switch (type) {
122  return ("NOCONFLICT_AHEAD");
124  return ("FOLLOWING");
126  return ("FOLLOWING_FOLLOWER");
128  return ("FOLLOWING_LEADER");
130  return ("ON_ADJACENT_LANES");
131  case (ENCOUNTER_TYPE_MERGING):
132  return ("MERGING");
134  return ("MERGING_LEADER");
136  return ("MERGING_FOLLOWER");
138  return ("MERGING_ADJACENT");
140  return ("CROSSING");
142  return ("CROSSING_LEADER");
144  return ("CROSSING_FOLLOWER");
146  return ("EGO_ENTERED_CONFLICT_AREA");
148  return ("FOE_ENTERED_CONFLICT_AREA");
150  return ("EGO_LEFT_CONFLICT_AREA");
152  return ("FOE_LEFT_CONFLICT_AREA");
154  return ("BOTH_ENTERED_CONFLICT_AREA");
156  return ("BOTH_LEFT_CONFLICT_AREA");
158  return ("FOLLOWING_PASSED");
160  return ("MERGING_PASSED");
162  return ("ONCOMING");
164  return ("COLLISION");
165  }
166  return ("UNKNOWN");
167  };
168 
169 private:
172  class Encounter {
173  private:
176  struct Trajectory {
177  // positions
179  // lane IDs
180  std::vector<std::string> lane;
181  // lane positions
182  std::vector<double> lanePos;
183  // momentary speeds
185  };
190  double time;
198  double value;
199 
200  ConflictPointInfo(double time, Position x, EncounterType type, double ssmValue) :
201  time(time), pos(x), type(type), value(ssmValue) {};
202  };
203 
204  public:
206  Encounter(const MSVehicle* _ego, const MSVehicle* const _foe, double _begin, double extraTime);
208  ~Encounter();
209 
211  void add(double time, EncounterType type, Position egoX, std::string egoLane, double egoLanePos,
212  Position egoV, Position foeX, std::string foeLane, double foeLanePos, Position foeV,
213  Position conflictPoint, double egoDistToConflict, double foeDistToConflict, double ttc, double drac, std::pair<double, double> pet);
214 
216  std::size_t size() const {
217  return timeSpan.size();
218  }
219 
221  void resetExtraTime(double value);
223  void countDownExtraTime(double amount);
225  double getRemainingExtraTime() const;
226 
228  struct compare {
229  typedef bool value_type;
230  bool operator()(Encounter* e1, Encounter* e2) {
231  if (e1->begin == e2->begin) {
232  return e1->foeID > e2->foeID;
233  } else {
234  return e1->begin > e2->begin;
235  }
236  };
237  };
238 
239 
240 
241  public:
242  const MSVehicle* ego;
243  const MSVehicle* foe;
244  const std::string egoID;
245  const std::string foeID;
246  double begin, end;
248 
251 
256 
258  std::vector<double> timeSpan;
260  std::vector<int> typeSpan;
266  std::vector<double> egoDistsToConflict;
268  std::vector<double> foeDistsToConflict;
269 
274 
276  std::vector<double> TTCspan;
278  std::vector<double> DRACspan;
279 
280 // /// @brief Cross sections at which a PET shall be calculated for the corresponding vehicle
281 // std::vector<std::pair<std::pair<const MSLane*, double>, double> > egoPETCrossSections;
282 // std::vector<std::pair<std::pair<const MSLane*, double>, double> > foePETCrossSections;
283 
290 
293 
294  private:
300  };
301 
302 
321  double ttc;
322  double drac;
323  std::pair<double, double> pet;
324  std::pair<const MSLane*, double> egoConflictEntryCrossSection;
325  std::pair<const MSLane*, double> foeConflictEntryCrossSection;
326  };
327 
328 
332  struct FoeInfo {
333  virtual ~FoeInfo() {};
336  };
337  // TODO: consider introducing a class foeCollector, which holds the foe info content
338  // plus a vehicle container to be used in findSurrounding vehicles.
339  // findSurroundingVehicles() would then deliver a vector of such foeCollectors
340  // (one for each possible egoConflictLane) instead of a map vehicle->foeInfo
341  // This could be helpful to resolve the resolution for several different
342  // projected conflicts with the same foe.
343 
344 
350  const MSEdge* edge;
351  double pos;
352  double range;
355  };
356 
357  typedef std::priority_queue<Encounter*, std::vector<Encounter*>, Encounter::compare> EncounterQueue;
358  typedef std::vector<Encounter*> EncounterVector;
359  typedef std::map<const MSVehicle*, FoeInfo*> FoeInfoMap;
360 public:
361 
365  static void insertOptions(OptionsCont& oc);
366 
367 
378  static void buildVehicleDevices(SUMOVehicle& v, std::vector<MSVehicleDevice*>& into);
379 
380 
383  static const std::set<MSDevice_SSM*, ComparatorNumericalIdLess>& getInstances();
384 
386  static const std::set<const MSEdge*>& getEdgeFilter() {
387  return myEdgeFilter;
388  }
389 
395  void updateAndWriteOutput();
396 
398  std::string getParameter(const std::string& key) const;
399 
401  void setParameter(const std::string& key, const std::string& value);
402 
403 private:
404  void update();
405  void writeOutConflict(Encounter* e);
406 
408  static void toGeo(Position& x);
410  static void toGeo(PositionVector& x);
411 
412 public:
415  static void cleanup();
416 
417 
418 public:
420  ~MSDevice_SSM();
421 
422 
434  static void findSurroundingVehicles(const MSVehicle& veh, double range, FoeInfoMap& foeCollector);
435 
438  static void getUpstreamVehicles(const UpstreamScanStartInfo& scanStart, FoeInfoMap& foeCollector, std::set<const MSLane*>& seenLanes, const std::set<const MSJunction*>& routeJunctions);
439 
442  static void getVehiclesOnJunction(const MSJunction*, const MSLane* egoJunctionLane, double egoDistToConflictLane, const MSLane* const egoConflictLane, FoeInfoMap& foeCollector, std::set<const MSLane*>& seenLanes);
443 
444 
447 
457  bool notifyMove(SUMOTrafficObject& veh, double oldPos,
458  double newPos, double newSpeed);
459 
460 
470  bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
471 
472 
481  bool notifyLeave(SUMOTrafficObject& veh, double lastPos,
482  MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
484 
485 
487  const std::string deviceName() const {
488  return "ssm";
489  }
490 
497  void generateOutput(OutputDevice* tripinfoOut) const;
498 
499 
500 
501 private:
515  MSDevice_SSM(SUMOVehicle& holder, const std::string& id, std::string outputFilename, std::map<std::string, double> thresholds,
516  bool trajectories, double range, double extraTime, bool useGeoCoords, bool writePositions, bool writeLanesPositions);
517 
526  void processEncounters(FoeInfoMap& foes, bool forceClose = false);
527 
528 
533 
534 
535 
538  void createEncounters(FoeInfoMap& foes);
539 
540 
545  void computeGlobalMeasures();
546 
549  void resetEncounters();
550 
554  void flushConflicts(bool all = false);
555 
559  void flushGlobalMeasures();
560 
565  bool updateEncounter(Encounter* e, FoeInfo* foeInfo);
566 
577 
578 
589  EncounterType classifyEncounter(const FoeInfo* foeInfo, EncounterApproachInfo& eInfo) const;
590 
591 
597  static void determineConflictPoint(EncounterApproachInfo& eInfo);
598 
599 
609  static void estimateConflictTimes(EncounterApproachInfo& eInfo);
610 
611 
619 
620 
629  const MSLane* findFoeConflictLane(const MSVehicle* foe, const MSLane* egoConflictLane, double& distToConflictLane) const;
630 
633  void closeEncounter(Encounter* e);
634 
638 
643  void computeSSMs(EncounterApproachInfo& e) const;
644 
645 
649  void determinePET(EncounterApproachInfo& eInfo) const;
650 
651 
655  void determineTTCandDRAC(EncounterApproachInfo& eInfo) const;
656 
657 
661  double computeTTC(double gap, double followerSpeed, double leaderSpeed) const;
662 
663 
669  static double computeDRAC(double gap, double followerSpeed, double leaderSpeed);
670 
682  static double computeDRAC(const EncounterApproachInfo& eInfo);
683 
691  static std::string makeStringWithNAs(const std::vector<double>& v, const double NA);
692  static std::string makeStringWithNAs(const std::vector<double>& v, const std::vector<double>& NAs);
693  static std::string makeStringWithNAs(const PositionVector& v, const int precision);
694 
697  static std::string getOutputFilename(const SUMOVehicle& v, std::string deviceID);
698  static double getDetectionRange(const SUMOVehicle& v);
699  static double getExtraTime(const SUMOVehicle& v);
700  static bool useGeoCoords(const SUMOVehicle& v);
701  static bool writePositions(const SUMOVehicle& v);
702  static bool writeLanesPositions(const SUMOVehicle& v);
703  static bool requestsTrajectories(const SUMOVehicle& v);
704  static bool getMeasuresAndThresholds(const SUMOVehicle& v, std::string deviceID,
705  std::map<std::string, double>& thresholds);
707 
709  static void initEdgeFilter();
710 
711 
712 private:
717  std::map<std::string, double> myThresholds;
722  double myRange;
724  double myExtraTime;
735 
736 
746 
747 
748 
751  std::vector<double> myGlobalMeasuresTimeSpan;
755  std::vector<std::string> myGlobalMeasuresLaneIDs;
757  std::vector<double> myGlobalMeasuresLanesPositions;
759  std::vector<double> myBRspan;
761  std::vector<double> mySGAPspan;
763  std::vector<double> myTGAPspan;
766  std::pair<std::pair<double, Position>, double> myMaxBR;
767  std::pair<std::pair<std::pair<double, Position>, double>, std::string> myMinSGAP;
768  std::pair<std::pair<std::pair<double, Position>, double>, std::string> myMinTGAP;
771 
773  static std::set<const MSEdge*> myEdgeFilter;
775  static bool myEdgeFilterActive;
776 
779 
781  static std::set<std::string> createdOutputFiles;
782 
783 
790  SSM_WARN_RANGE = 1 << 3,
792  SSM_WARN_FILE = 1 << 5,
793  SSM_WARN_GEO = 1 << 6,
794  SSM_WARN_POS = 1 << 7,
795  SSM_WARN_LANEPOS = 1 << 8
796  };
797 
798 
799 
800 private:
803 
806 
807 
808 };
A simple description of a position on a lane (crossing of a lane)
An encounter is an episode involving two vehicles, which are closer to each other than some specified...
Definition: MSDevice_SSM.h:172
const MSVehicle * foe
Definition: MSDevice_SSM.h:243
EncounterType currentType
Definition: MSDevice_SSM.h:247
double foeConflictEntryTime
Times when the foe vehicle entered/left the conflict area. Currently only applies for crossing situat...
Definition: MSDevice_SSM.h:255
std::vector< double > foeDistsToConflict
Evolution of the foe vehicle's distance to the conflict point.
Definition: MSDevice_SSM.h:268
Encounter & operator=(const Encounter &)
Invalidated assignment operator.
std::vector< double > timeSpan
time points corresponding to the trajectories
Definition: MSDevice_SSM.h:258
std::vector< int > typeSpan
Evolution of the encounter classification (.
Definition: MSDevice_SSM.h:260
bool closingRequested
this flag is set by updateEncounter() or directly in processEncounters(), where encounters are closed...
Definition: MSDevice_SSM.h:292
std::vector< double > TTCspan
All values for TTC.
Definition: MSDevice_SSM.h:276
std::size_t size() const
Returns the number of trajectory points stored.
Definition: MSDevice_SSM.h:216
void resetExtraTime(double value)
resets remainingExtraTime to the given value
double remainingExtraTime
Remaining extra time (decreases after an encounter ended)
Definition: MSDevice_SSM.h:250
const MSVehicle * ego
Definition: MSDevice_SSM.h:242
PositionVector conflictPointSpan
Predicted location of the conflict: In case of MERGING and CROSSING: entry point to conflict area for...
Definition: MSDevice_SSM.h:273
ConflictPointInfo maxDRAC
Definition: MSDevice_SSM.h:287
void add(double time, EncounterType type, Position egoX, std::string egoLane, double egoLanePos, Position egoV, Position foeX, std::string foeLane, double foeLanePos, Position foeV, Position conflictPoint, double egoDistToConflict, double foeDistToConflict, double ttc, double drac, std::pair< double, double > pet)
add a new data point and update encounter type
const std::string foeID
Definition: MSDevice_SSM.h:245
ConflictPointInfo minTTC
Definition: MSDevice_SSM.h:286
void countDownExtraTime(double amount)
decreases myRemaingExtraTime by given amount in seconds
Trajectory foeTrajectory
Trajectory of the foe vehicle.
Definition: MSDevice_SSM.h:264
std::vector< double > egoDistsToConflict
Evolution of the ego vehicle's distance to the conflict point.
Definition: MSDevice_SSM.h:266
Trajectory egoTrajectory
Trajectory of the ego vehicle.
Definition: MSDevice_SSM.h:262
double egoConflictEntryTime
Times when the ego vehicle entered/left the conflict area. Currently only applies for crossing situat...
Definition: MSDevice_SSM.h:253
Encounter(const MSVehicle *_ego, const MSVehicle *const _foe, double _begin, double extraTime)
Constructor.
double getRemainingExtraTime() const
returns the remaining extra time
ConflictPointInfo PET
Definition: MSDevice_SSM.h:288
const std::string egoID
Definition: MSDevice_SSM.h:244
Encounter(const Encounter &)
Invalidated Constructor.
std::vector< double > DRACspan
All values for DRAC.
Definition: MSDevice_SSM.h:278
A device which collects info on the vehicle trip (mainly on departure and arrival)
Definition: MSDevice_SSM.h:55
bool myComputeDRAC
Definition: MSDevice_SSM.h:732
MSDevice_SSM(SUMOVehicle &holder, const std::string &id, std::string outputFilename, std::map< std::string, double > thresholds, bool trajectories, double range, double extraTime, bool useGeoCoords, bool writePositions, bool writeLanesPositions)
Constructor.
std::map< const MSVehicle *, FoeInfo * > FoeInfoMap
Definition: MSDevice_SSM.h:359
double myExtraTime
Extra time in seconds to be logged after a conflict is over.
Definition: MSDevice_SSM.h:724
void generateOutput(OutputDevice *tripinfoOut) const
Finalizes output. Called on vehicle removal.
std::pair< std::pair< std::pair< double, Position >, double >, std::string > myMinTGAP
Definition: MSDevice_SSM.h:768
bool myComputeTTC
Flags for switching on / off comutation of different SSMs, derived from myMeasures.
Definition: MSDevice_SSM.h:732
PositionVector myGlobalMeasuresPositions
All values for positions (coordinates)
Definition: MSDevice_SSM.h:753
bool myComputeSGAP
Definition: MSDevice_SSM.h:732
static std::set< std::string > createdOutputFiles
remember which files were created already (don't duplicate xml root-elements)
Definition: MSDevice_SSM.h:781
MSVehicle * myHolderMS
Definition: MSDevice_SSM.h:733
bool mySaveTrajectories
This determines whether the whole trajectories of the vehicles (position, speed, ssms) shall be saved...
Definition: MSDevice_SSM.h:720
bool updateEncounter(Encounter *e, FoeInfo *foeInfo)
Updates the encounter (adds a new trajectory point).
static bool requestsTrajectories(const SUMOVehicle &v)
static bool getMeasuresAndThresholds(const SUMOVehicle &v, std::string deviceID, std::map< std::string, double > &thresholds)
std::string getParameter(const std::string &key) const
try to retrieve the given parameter from this device. Throw exception for unsupported key
MSDevice_SSM & operator=(const MSDevice_SSM &)
Invalidated assignment operator.
bool myComputeTGAP
Definition: MSDevice_SSM.h:732
EncounterType classifyEncounter(const FoeInfo *foeInfo, EncounterApproachInfo &eInfo) const
Classifies the current type of the encounter provided some information on the opponents.
void computeSSMs(EncounterApproachInfo &e) const
Compute current values of the logged SSMs (myMeasures) for the given encounter 'e' and update 'e' acc...
static void buildVehicleDevices(SUMOVehicle &v, std::vector< MSVehicleDevice * > &into)
Build devices for the given vehicle, if needed.
void writeOutConflict(Encounter *e)
EncounterType
Different types of encounters corresponding to relative positions of the vehicles....
Definition: MSDevice_SSM.h:64
@ ENCOUNTER_TYPE_EGO_ENTERED_CONFLICT_AREA
ENCOUNTER_TYPE_EGO_ENTERED_CONFLICT_AREA.
Definition: MSDevice_SSM.h:97
@ ENCOUNTER_TYPE_FOE_LEFT_CONFLICT_AREA
ENCOUNTER_TYPE_FOE_LEFT_CONFLICT_AREA.
Definition: MSDevice_SSM.h:103
@ ENCOUNTER_TYPE_MERGING
ENCOUNTER_TYPE_MERGING.
Definition: MSDevice_SSM.h:78
@ ENCOUNTER_TYPE_MERGING_FOLLOWER
ENCOUNTER_TYPE_MERGING_FOLLOWER.
Definition: MSDevice_SSM.h:84
@ ENCOUNTER_TYPE_FOLLOWING_FOLLOWER
ENCOUNTER_TYPE_FOLLOWING_FOLLOWER.
Definition: MSDevice_SSM.h:71
@ ENCOUNTER_TYPE_FOLLOWING
ENCOUNTER_TYPE_FOLLOWING.
Definition: MSDevice_SSM.h:69
@ ENCOUNTER_TYPE_MERGING_LEADER
ENCOUNTER_TYPE_MERGING_LEADER.
Definition: MSDevice_SSM.h:81
@ ENCOUNTER_TYPE_FOLLOWING_PASSED
ENCOUNTER_TYPE_FOLLOWING_PASSED.
Definition: MSDevice_SSM.h:110
@ ENCOUNTER_TYPE_FOLLOWING_LEADER
ENCOUNTER_TYPE_FOLLOWING_LEADER.
Definition: MSDevice_SSM.h:73
@ ENCOUNTER_TYPE_BOTH_LEFT_CONFLICT_AREA
ENCOUNTER_TYPE_BOTH_LEFT_CONFLICT_AREA.
Definition: MSDevice_SSM.h:107
@ ENCOUNTER_TYPE_FOE_ENTERED_CONFLICT_AREA
ENCOUNTER_TYPE_FOE_ENTERED_CONFLICT_AREA.
Definition: MSDevice_SSM.h:99
@ ENCOUNTER_TYPE_ONCOMING
Definition: MSDevice_SSM.h:114
@ ENCOUNTER_TYPE_MERGING_PASSED
ENCOUNTER_TYPE_FOLLOWING_PASSED.
Definition: MSDevice_SSM.h:112
@ ENCOUNTER_TYPE_ON_ADJACENT_LANES
ENCOUNTER_TYPE_ON_ADJACENT_LANES.
Definition: MSDevice_SSM.h:75
@ ENCOUNTER_TYPE_EGO_LEFT_CONFLICT_AREA
ENCOUNTER_TYPE_EGO_LEFT_CONFLICT_AREA.
Definition: MSDevice_SSM.h:101
@ ENCOUNTER_TYPE_BOTH_ENTERED_CONFLICT_AREA
ENCOUNTER_TYPE_BOTH_ENTERED_CONFLICT_AREA.
Definition: MSDevice_SSM.h:105
@ ENCOUNTER_TYPE_NOCONFLICT_AHEAD
ENCOUNTER_TYPE_NOCONFLICT_AHEAD.
Definition: MSDevice_SSM.h:66
@ ENCOUNTER_TYPE_COLLISION
ENCOUNTER_TYPE_COLLISION.
Definition: MSDevice_SSM.h:116
@ ENCOUNTER_TYPE_CROSSING
ENCOUNTER_TYPE_CROSSING.
Definition: MSDevice_SSM.h:89
@ ENCOUNTER_TYPE_CROSSING_FOLLOWER
ENCOUNTER_TYPE_CROSSING_FOLLOWER.
Definition: MSDevice_SSM.h:95
@ ENCOUNTER_TYPE_MERGING_ADJACENT
ENCOUNTER_TYPE_MERGING_ADJACENT.
Definition: MSDevice_SSM.h:86
@ ENCOUNTER_TYPE_CROSSING_LEADER
ENCOUNTER_TYPE_CROSSING_LEADER.
Definition: MSDevice_SSM.h:92
std::priority_queue< Encounter *, std::vector< Encounter * >, Encounter::compare > EncounterQueue
Definition: MSDevice_SSM.h:357
static void initEdgeFilter()
initialize edge filter (once)
std::vector< double > myGlobalMeasuresLanesPositions
All values for positions on the lanes.
Definition: MSDevice_SSM.h:757
bool notifyMove(SUMOTrafficObject &veh, double oldPos, double newPos, double newSpeed)
Checks for waiting steps when the vehicle moves.
static void determineConflictPoint(EncounterApproachInfo &eInfo)
Calculates the (x,y)-coordinate for the eventually predicted conflict point and stores the result in ...
void storeEncountersExceedingMaxLength()
Closes encounters, whose duration exceeds the maximal encounter length. If it is classified as confli...
static double computeDRAC(double gap, double followerSpeed, double leaderSpeed)
Computes the DRAC (deceleration to avoid a collision) for a lead/follow situation as defined,...
EncounterQueue myPastConflicts
Past encounters that where qualified as conflicts and are not yet flushed to the output file.
Definition: MSDevice_SSM.h:744
static bool useGeoCoords(const SUMOVehicle &v)
static int issuedParameterWarnFlags
bitset storing info whether warning has already been issued about unset parameter (warn only once!...
Definition: MSDevice_SSM.h:785
void setParameter(const std::string &key, const std::string &value)
try to set the given parameter for this device. Throw exception for unsupported key
static bool myEdgeFilterInitialized
Definition: MSDevice_SSM.h:774
static const std::set< MSDevice_SSM *, ComparatorNumericalIdLess > & getInstances()
returns all currently existing SSM devices
void closeEncounter(Encounter *e)
Finalizes the encounter and calculates SSM values.
static std::string makeStringWithNAs(const std::vector< double > &v, const double NA)
make a string of a double vector and treat a special value as invalid ("NA")
static bool writePositions(const SUMOVehicle &v)
static double getDetectionRange(const SUMOVehicle &v)
static void cleanup()
Clean up remaining devices instances.
static void insertOptions(OptionsCont &oc)
Inserts MSDevice_SSM-options.
static const std::set< const MSEdge * > & getEdgeFilter()
return the edges where the SSM device should scan
Definition: MSDevice_SSM.h:386
double myRange
Detection range. For vehicles closer than this distance from the ego vehicle, SSMs are traced.
Definition: MSDevice_SSM.h:722
const MSLane * findFoeConflictLane(const MSVehicle *foe, const MSLane *egoConflictLane, double &distToConflictLane) const
Computes the conflict lane for the foe.
std::vector< std::string > myGlobalMeasuresLaneIDs
All values for lanes.
Definition: MSDevice_SSM.h:755
bool notifyLeave(SUMOTrafficObject &veh, double lastPos, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Called whenever the holder leaves a lane.
std::vector< Encounter * > EncounterVector
Definition: MSDevice_SSM.h:358
static void getUpstreamVehicles(const UpstreamScanStartInfo &scanStart, FoeInfoMap &foeCollector, std::set< const MSLane * > &seenLanes, const std::set< const MSJunction * > &routeJunctions)
Collects all vehicles within range 'range' upstream of the position 'pos' on the edge 'edge' into foe...
void createEncounters(FoeInfoMap &foes)
Makes new encounters for all given vehicles (these should be the ones entering the device's range in ...
bool qualifiesAsConflict(Encounter *e)
Tests if the SSM values exceed the threshold for qualification as conflict.
std::map< std::string, double > myThresholds
Definition: MSDevice_SSM.h:717
static std::string getOutputFilename(const SUMOVehicle &v, std::string deviceID)
void updateAndWriteOutput()
This is called once per time step in MSNet::writeOutput() and collects the surrounding vehicles,...
static std::set< MSDevice_SSM *, ComparatorNumericalIdLess > * myInstances
All currently existing SSM devices.
Definition: MSDevice_SSM.h:59
std::pair< std::pair< std::pair< double, Position >, double >, std::string > myMinSGAP
Definition: MSDevice_SSM.h:767
OutputDevice * myOutputFile
Output device.
Definition: MSDevice_SSM.h:778
static double getExtraTime(const SUMOVehicle &v)
EncounterVector myActiveEncounters
Definition: MSDevice_SSM.h:740
std::vector< double > myGlobalMeasuresTimeSpan
Definition: MSDevice_SSM.h:751
void computeGlobalMeasures()
Stores measures, that are not associated to a specific encounter as headways and brake rates.
static std::string encounterToString(EncounterType type)
Definition: MSDevice_SSM.h:119
double myOldestActiveEncounterBegin
begin time of the oldest active encounter
Definition: MSDevice_SSM.h:742
static void checkConflictEntryAndExit(EncounterApproachInfo &eInfo)
Checks whether ego or foe have entered or left the conflict area in the last step and eventually writ...
double computeTTC(double gap, double followerSpeed, double leaderSpeed) const
Computes the time to collision (in seconds) for two vehicles with a given initial gap under the assum...
void flushConflicts(bool all=false)
Writes out all past conflicts that have begun earlier than the oldest active encounter.
void determinePET(EncounterApproachInfo &eInfo) const
Discriminates between different encounter types and correspondingly determines the PET for those case...
static std::set< const MSEdge * > myEdgeFilter
spatial filter for SSM device output
Definition: MSDevice_SSM.h:773
static void toGeo(Position &x)
convert SUMO-positions to geo coordinates (in place)
static void findSurroundingVehicles(const MSVehicle &veh, double range, FoeInfoMap &foeCollector)
Returns all vehicles, which are within the given range of the given vehicle.
bool myWritePositions
Wether to print the positions for all timesteps.
Definition: MSDevice_SSM.h:728
void resetEncounters()
Closes all current Encounters and moves conflicts to myPastConflicts,.
std::pair< std::pair< double, Position >, double > myMaxBR
Extremal values for the global measures (as <<<time, Position>, value>, [leaderID]>-pairs)
Definition: MSDevice_SSM.h:766
std::vector< double > myBRspan
All values for brake rate.
Definition: MSDevice_SSM.h:759
void determineTTCandDRAC(EncounterApproachInfo &eInfo) const
Discriminates between different encounter types and correspondingly determines TTC and DRAC for those...
bool myUseGeoCoords
Whether to use the original coordinate system for output.
Definition: MSDevice_SSM.h:726
bool myWriteLanesPositions
Wether to print the lanes and positions for all timesteps and conflicts.
Definition: MSDevice_SSM.h:730
~MSDevice_SSM()
Destructor.
const std::string deviceName() const
return the name for this type of device
Definition: MSDevice_SSM.h:487
static bool myEdgeFilterActive
Definition: MSDevice_SSM.h:775
void flushGlobalMeasures()
Write out all non-encounter specific measures as headways and braking rates.
std::vector< double > myTGAPspan
All values for time gap.
Definition: MSDevice_SSM.h:763
static void getVehiclesOnJunction(const MSJunction *, const MSLane *egoJunctionLane, double egoDistToConflictLane, const MSLane *const egoConflictLane, FoeInfoMap &foeCollector, std::set< const MSLane * > &seenLanes)
Collects all vehicles on the junction into foeCollector.
static void estimateConflictTimes(EncounterApproachInfo &eInfo)
Estimates the time until conflict for the vehicles based on the distance to the conflict entry points...
bool notifyEnter(SUMOTrafficObject &veh, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Called whenever the holder enteres a lane.
void updatePassedEncounter(Encounter *e, FoeInfo *foeInfo, EncounterApproachInfo &eInfo)
Updates an encounter, which was classified as ENCOUNTER_TYPE_NOCONFLICT_AHEAD this may be the case be...
void processEncounters(FoeInfoMap &foes, bool forceClose=false)
Finds encounters for which the foe vehicle has disappeared from range. remainingExtraTime is decrease...
static bool writeLanesPositions(const SUMOVehicle &v)
std::vector< double > mySGAPspan
All values for space gap.
Definition: MSDevice_SSM.h:761
MSDevice_SSM(const MSDevice_SSM &)
Invalidated copy constructor.
A road/street connecting two junctions.
Definition: MSEdge.h:77
The base class for an intersection.
Definition: MSJunction.h:58
Representation of a lane in the micro simulation.
Definition: MSLane.h:82
Notification
Definition of a vehicle state.
Abstract in-vehicle device.
Representation of a vehicle in the micro simulation.
Definition: MSVehicle.h:75
A storage for options typed value containers)
Definition: OptionsCont.h:89
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:61
A point in 2D or 3D with translation and scaling methods.
Definition: Position.h:37
A list of positions.
Representation of a vehicle, person, or container.
Representation of a vehicle.
Definition: SUMOVehicle.h:60
ConflictPointInfo stores some information on a specific conflict point (used to store information on ...
Definition: MSDevice_SSM.h:188
EncounterType type
Type of the conflict.
Definition: MSDevice_SSM.h:196
double time
time point of the conflict
Definition: MSDevice_SSM.h:190
ConflictPointInfo(double time, Position x, EncounterType type, double ssmValue)
Definition: MSDevice_SSM.h:200
Position pos
Predicted location of the conflict: In case of MERGING and CROSSING: entry point to conflict area for...
Definition: MSDevice_SSM.h:194
double value
value of the corresponding SSM
Definition: MSDevice_SSM.h:198
A trajectory encloses a series of positions x and speeds v for one vehicle (the times are stored only...
Definition: MSDevice_SSM.h:176
std::vector< std::string > lane
Definition: MSDevice_SSM.h:180
Compares encounters regarding to their start time.
Definition: MSDevice_SSM.h:228
bool operator()(Encounter *e1, Encounter *e2)
Definition: MSDevice_SSM.h:230
Structure to collect some info on the encounter needed during ssm calculation by various functions.
Definition: MSDevice_SSM.h:304
std::pair< const MSLane *, double > foeConflictEntryCrossSection
Definition: MSDevice_SSM.h:325
std::pair< const MSLane *, double > egoConflictEntryCrossSection
Definition: MSDevice_SSM.h:324
std::pair< double, double > pet
Definition: MSDevice_SSM.h:323
const MSLane * egoConflictLane
Definition: MSDevice_SSM.h:333
Auxiliary structure used to handle upstream scanning start points Upstream scan has to be started aft...
Definition: MSDevice_SSM.h:347
UpstreamScanStartInfo(const MSEdge *edge, double pos, double range, double egoDistToConflictLane, const MSLane *egoConflictLane)
Definition: MSDevice_SSM.h:348