Eclipse SUMO - Simulation of Urban MObility
MSE2Collector.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-2019 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 /****************************************************************************/
21 // An areal detector covering to a sequence of consecutive lanes
22 /****************************************************************************/
23 #ifndef MSE2Collector_h
24 #define MSE2Collector_h
25 
26 
27 // ===========================================================================
28 // included modules
29 // ===========================================================================
30 #include <config.h>
31 
32 #include <vector>
33 #include <list>
34 #include <microsim/MSLane.h>
35 #include <microsim/MSNet.h>
39 #include <cassert>
40 
41 // ===========================================================================
42 // class declarations
43 // ===========================================================================
44 class OutputDevice;
45 class SUMOVehicle;
46 class SUMOTrafficObject;
47 
48 
49 // ===========================================================================
50 // class definitions
51 // ===========================================================================
82 public:
87  struct VehicleInfo {
90  VehicleInfo(std::string id, std::string type, double length, double minGap, const MSLane* entryLane, double entryOffset,
91  std::size_t currentOffsetIndex, double exitOffset, double distToDetectorEnd, bool onDetector) :
92  id(id),
93  type(type),
94  length(length),
95  minGap(minGap),
96  entryLaneID(entryLane->getID()),
97  entryOffset(entryOffset),
98  currentLane(entryLane),
99  currentOffsetIndex(currentOffsetIndex),
100  exitOffset(exitOffset),
101  distToDetectorEnd(distToDetectorEnd),
104  onDetector(onDetector),
105  hasEntered(false),
106  lastAccel(0),
107  lastSpeed(0),
108  lastPos(0) {
109  assert(exitOffset < 0);
110  }
111  virtual ~VehicleInfo() {};
113  std::string id;
115  std::string type;
117  double length;
119  double minGap;
121  std::string entryLaneID;
125  double entryOffset;
129  std::size_t currentOffsetIndex;
132  double exitOffset;
139 
145  double lastAccel;
147  double lastSpeed;
150  double lastPos;
151  };
152 
153  typedef std::map<std::string, VehicleInfo*> VehicleInfoMap;
154 
155 
156 private:
162  MoveNotificationInfo(std::string _vehID, double _oldPos, double _newPos, double _speed, double _accel, double _distToDetectorEnd, double _timeOnDetector, double _lengthOnDetector, double _timeLoss, bool _onDetector) :
163  id(_vehID),
164  oldPos(_oldPos),
165  newPos(_newPos),
166  speed(_speed),
167  accel(_accel),
168  distToDetectorEnd(_distToDetectorEnd),
169  timeOnDetector(_timeOnDetector),
170  lengthOnDetector(_lengthOnDetector),
171  timeLoss(_timeLoss),
172  onDetector(_onDetector) {}
173 
174  virtual ~MoveNotificationInfo() {};
175 
177  std::string id;
179  double oldPos;
181  double newPos;
183  double speed;
185  double accel;
193  double timeLoss;
196  };
197 
198 
199 
205  struct JamInfo {
207  std::vector<MoveNotificationInfo*>::const_iterator firstStandingVehicle;
208 
210  std::vector<MoveNotificationInfo*>::const_iterator lastStandingVehicle;
211  };
212 
213 
214 public:
215 
234  MSE2Collector(const std::string& id,
235  DetectorUsage usage, MSLane* lane, double startPos, double endPos, double length,
236  SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
237  const std::string& vTypes);
238 
239 
252  MSE2Collector(const std::string& id,
253  DetectorUsage usage, std::vector<MSLane*> lanes, double startPos, double endPos,
254  SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
255  const std::string& vTypes);
256 
257 
259  virtual ~MSE2Collector();
260 
266  virtual DetectorUsage getUsageType() const {
267  return myUsage;
268  }
269 
270 
271 
274 
292  virtual bool notifyMove(SUMOTrafficObject& veh, double oldPos, double newPos,
293  double newSpeed);
294 
295 
307  virtual bool notifyLeave(SUMOTrafficObject& veh, double lastPos, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
308 
309 
322  virtual bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane);
324 
325 
326 
327 
328 
331 
340  virtual void detectorUpdate(const SUMOTime step);
341 
342 
349  virtual void writeXMLOutput(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime);
350 
351 
360  virtual void writeXMLDetectorProlog(OutputDevice& dev) const;
361 
363 
364 
369  double getStartPos() const {
370  return myStartPos;
371  }
372 
373 
378  double getEndPos() const {
379  return myEndPos;
380  }
381 
386  double getLength() const {
387  return myDetectorLength;
388  }
389 
390 
395  MSLane* getLastLane() const {
396  return myLastLane;
397  }
398 
399 
402  std::vector<MSLane*> getLanes();
403 
410  virtual void reset();
411 
412 
415 
417  int getCurrentVehicleNumber() const;
418 
420  double getCurrentOccupancy() const {
421  return myCurrentOccupancy;
422  }
423 
425  double getCurrentMeanSpeed() const {
426  return myCurrentMeanSpeed;
427  }
428 
430  double getCurrentMeanLength() const {
431  return myCurrentMeanLength;
432  }
433 
435  int getCurrentJamNumber() const {
436  return myCurrentJamNo;
437  }
438 
442  }
443 
447  }
448 
452  }
453 
457  }
458 
461  return myCurrentStartedHalts;
462  }
463 
472  }
473 
478  std::vector<std::string> getCurrentVehicleIDs() const;
479 
482  std::vector<VehicleInfo*> getCurrentVehicles() const;
483 
488  int getPassedVeh() {
490  }
491 
496  void subtractPassedVeh(int passed) {
497  myNumberOfEnteredVehicles -= passed;
498  }
499 
501 
502 
503 
504 
505 
509 
510  int getEstimatedCurrentVehicleNumber(double speedThreshold) const;
511 
513  double getEstimateQueueLength() const;
515 
516 
517 
518 private:
519 
527  bool checkJam(std::vector<MoveNotificationInfo*>::const_iterator mni, std::map<std::string, SUMOTime>& haltingVehicles, std::map<std::string, SUMOTime>& intervalHaltingVehicles);
528 
529 
537  void buildJam(bool isInJam, std::vector<MoveNotificationInfo*>::const_iterator mni, JamInfo*& currentJam, std::vector<JamInfo*>& jams);
538 
539 
544  void processJams(std::vector<JamInfo*>& jams, JamInfo* currentJam);
545 
555  void calculateTimeLossAndTimeOnDetector(const SUMOVehicle& veh, double oldPos, double newPos, const VehicleInfo& vi, double& timeOnDetector, double& timeLoss) const;
556 
561  void initAuxiliaries(std::vector<MSLane*>& lanes);
562 
565  void checkPositioning(bool posGiven = false, double desiredLength = 0.);
566 
569  static double snap(double value, double snapPoint, double snapDist);
570 
574 
575 
576 
587  std::vector<MSLane*> selectLanes(MSLane* endLane, double length, std::string dir);
588 
589 
592  void addDetectorToLanes(std::vector<MSLane*>& lanes);
593 
594 
597  void aggregateOutputValues();
598 
599 
607 
617  MoveNotificationInfo* makeMoveNotification(const SUMOVehicle& veh, double oldPos, double newPos, double newSpeed, const VehicleInfo& vehInfo) const;
618 
625  VehicleInfo* makeVehicleInfo(const SUMOVehicle& veh, const MSLane* enteredLane) const;
626 
635  static double calculateSegmentTimeLoss(double timespan, double initialSpeed, double accel, double vmax);
636 
640  return mni1->distToDetectorEnd < mni2->distToDetectorEnd;
641  }
642 
643 
644 private:
645 
648 
652  std::vector<std::string> myLanes;
654  std::vector<double> myOffsets;
660  double myStartPos;
662  double myEndPos;
665 
673 
674 
678  VehicleInfoMap myVehicleInfos;
679 
682  std::vector<MoveNotificationInfo*> myMoveNotifications;
683 
687  std::set<std::string> myLeftVehicles;
688 
690  std::map<std::string, SUMOTime> myHaltingVehicleDurations;
691 
693  std::map<std::string, SUMOTime> myIntervalHaltingVehicleDurations;
694 
696  std::vector<SUMOTime> myPastStandingDurations;
697 
699  std::vector<SUMOTime> myPastIntervalStandingDurations;
701 
702 
703 
711  double mySpeedSum;
735 
736 
747 
769 
770 
771 private:
774 
777 };
778 
779 
780 #endif
781 
782 /****************************************************************************/
783 
std::vector< double > myOffsets
The distances of the lane-beginnings from the detector start-point.
int myMaxVehicleNumber
The maximal number of vehicles located on the detector simultaneously since the last reset...
int myMeanMaxJamInVehicles
The mean jam length [#veh].
double lastAccel
Last value of the acceleration.
std::vector< SUMOTime > myPastIntervalStandingDurations
Halting durations of ended halts for the current interval [s].
std::vector< MoveNotificationInfo * >::const_iterator firstStandingVehicle
The first standing vehicle.
double myMeanMaxJamInMeters
The mean jam length [m].
long long int SUMOTime
Definition: SUMOTime.h:35
void addDetectorToLanes(std::vector< MSLane *> &lanes)
This adds the detector as a MoveReminder to the associated lanes.
std::vector< std::string > getCurrentVehicleIDs() const
Returns the IDs of the vehicles within the area.
bool onDetector
whether the vehicle is on the detector at the end of the current timestep
static bool compareMoveNotification(MoveNotificationInfo *mni1, MoveNotificationInfo *mni2)
double myMaxOccupancy
The maximum occupancy [%].
double lastSpeed
Last value of the speed.
int getCurrentJamLengthInVehicles() const
Returns the length of all jams in vehicles.
virtual ~MSE2Collector()
Destructor.
virtual bool notifyLeave(SUMOTrafficObject &veh, double lastPos, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Removes a known vehicle due to its lane-change.
An areal detector corresponding to a sequence of consecutive lanes.
Definition: MSE2Collector.h:81
MSE2Collector(const std::string &id, DetectorUsage usage, MSLane *lane, double startPos, double endPos, double length, SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold, const std::string &vTypes)
Constructor with given end position and detector length.
Internal representation of a jam.
int myCurrentMaxJamLengthInVehicles
The current maximum jam length in vehicles.
bool onDetector
whether the vehicle is on the detector at the end of the current timestep
double getEndPos() const
Returns the end position of the detector.
Values collected in notifyMove and needed in detectorUpdate() to calculate the accumulated quantities...
double lengthOnDetector
The length of the part of the vehicle on the detector at the end of the last time step...
double myTotalTimeLoss
The total amount of all time losses [time x vehicle] since the last reset.
Notification
Definition of a vehicle state.
double myVehicleSamples
double timeOnDetector
Time spent on the detector during the last integration step.
double newPos
Position after the last integration step (relative to the vehicle&#39;s entry lane on the detector) ...
double getLength() const
Returns the length of the detector.
std::vector< SUMOTime > myPastStandingDurations
Halting durations of ended halts [s].
double accel
Acceleration in the last integration step.
double getStartPos() const
Returns the begin position of the detector.
int myMeanVehicleNumber
The mean number of vehicles [#veh].
const std::string & getID() const
Returns the id.
Definition: Named.h:77
double totalTimeOnDetector
Accumulated time that this vehicle has spent on the detector since its last entry.
int myCurrentStartedHalts
The number of started halts in the last step.
std::size_t currentOffsetIndex
Index of currentLane in the detector&#39;s myLanes vector.
std::vector< VehicleInfo * > getCurrentVehicles() const
Returns the VehicleInfos for the vehicles currently on the detector.
std::vector< MoveNotificationInfo * > myMoveNotifications
Temporal storage for notifications from vehicles that did call the detector&#39;s notifyMove() in the las...
void initAuxiliaries(std::vector< MSLane *> &lanes)
Checks integrity of myLanes, adds internal-lane information, inits myLength, myFirstLane, myLastLane, myOffsets Called once at construction. myLanes should form a continuous sequence.
void aggregateOutputValues()
Aggregates and normalize some values for the detector output during detectorUpdate() ...
double myJamHaltingSpeedThreshold
A vehicle must driver slower than this to be counted as a part of a jam.
VehicleInfo * makeVehicleInfo(const SUMOVehicle &veh, const MSLane *enteredLane) const
Creates and returns a VehicleInfo (called at the vehicle&#39;s entry)
std::vector< std::string > myLanes
double mySpeedSum
The sum of collected vehicle speeds [m/s].
double minGap
vehicle&#39;s minGap
std::vector< MoveNotificationInfo * >::const_iterator lastStandingVehicle
The last standing vehicle.
virtual bool notifyMove(SUMOTrafficObject &veh, double oldPos, double newPos, double newSpeed)
Adds/removes vehicles from the list of vehicles to regard.
void checkPositioning(bool posGiven=false, double desiredLength=0.)
Adjusts positioning if the detector length is less than POSITION_EPS and tests some assertions...
void recalculateDetectorLength()
Updates the detector length after myStartPos and myEndPos have been modified.
double myJamDistanceThreshold
Two standing vehicles must be closer than this to be counted into the same jam.
int myTimeSamples
The current aggregation duration [#steps].
int getCurrentMaxJamLengthInVehicles() const
Returns the length in vehicles of the currently largest jam.
A VehicleInfo stores values that are tracked for the individual vehicles on the detector, e.g., accumulated timeloss. These infos are stored in myVehicles. If a vehicle leaves the detector (may it be temporarily), the entry in myVehicles is discarded, i.e. all information on the vehicle is reset.
Definition: MSE2Collector.h:87
double getCurrentMeanSpeed() const
Returns the mean vehicle speed of vehicles currently on the detector.
double myCurrentMeanLength
The current mean length.
static double snap(double value, double snapPoint, double snapDist)
Snaps value to snpPoint if they are closer than snapDist.
MSE2Collector & operator=(const MSE2Collector &)
Invalidated assignment operator.
VehicleInfo(std::string id, std::string type, double length, double minGap, const MSLane *entryLane, double entryOffset, std::size_t currentOffsetIndex, double exitOffset, double distToDetectorEnd, bool onDetector)
Definition: MSE2Collector.h:90
int myCurrentJamLengthInVehicles
The overall jam length in vehicles.
virtual void writeXMLDetectorProlog(OutputDevice &dev) const
Open the XML-output.
Representation of a vehicle.
Definition: SUMOVehicle.h:61
double oldPos
Position before the last integration step (relative to the vehicle&#39;s entry lane on the detector) ...
int myNumberOfSeenVehicles
The number of vehicles, present on the detector at the last reset.
int myJamLengthInVehiclesSum
The sum of jam lengths [#veh].
double myStartedHalts
The number of started halts [#].
double distToDetectorEnd
Distance left till the detector end after the last integration step (may become negative if the vehic...
std::vector< MSLane * > selectLanes(MSLane *endLane, double length, std::string dir)
This is called if no lane sequence is given to the constructor. Builds myLanes from the given informa...
double myJamLengthInMetersSum
The sum of jam lengths [m].
double myMaxJamInMeters
The max jam length [m].
MSLane * myFirstLane
The first lane of the detector&#39;s lane sequence.
std::string id
vehicle&#39;s ID
int getCurrentJamNumber() const
Returns the current number of jams.
double myDetectorLength
The total detector length.
std::vector< MSLane * > getLanes()
Returns a vector containing pointers to the lanes covered by the detector ordered from its first to i...
double myCurrentMeanSpeed
The current mean speed.
std::map< std::string, VehicleInfo * > VehicleInfoMap
int myCurrentJamNo
The current jam number.
const MSLane * currentLane
Lane, on which the vehicle currently resides (always the one for which the last notifyEnter was recei...
void processJams(std::vector< JamInfo *> &jams, JamInfo *currentJam)
Calculates aggregated values from the given jam structure, deletes all jam-pointers.
int getCurrentHaltingNumber() const
Returns the number of current haltings within the area.
Something on a lane to be noticed about vehicle movement.
std::map< std::string, SUMOTime > myIntervalHaltingVehicleDurations
Storage for halting durations of known vehicles (current interval)
MoveNotificationInfo(std::string _vehID, double _oldPos, double _newPos, double _speed, double _accel, double _distToDetectorEnd, double _timeOnDetector, double _lengthOnDetector, double _timeLoss, bool _onDetector)
double myCurrentMaxJamLengthInMeters
the current maximum jam length in meters
double myEndPos
The position the detector ends at on the last lane.
MSLane * myLastLane
The last lane of the detector&#39;s lane sequence.
SUMOTime myJamHaltingTimeThreshold
A vehicle must be that long beyond myJamHaltingSpeedThreshold to be counted as a part of a jam...
bool checkJam(std::vector< MoveNotificationInfo *>::const_iterator mni, std::map< std::string, SUMOTime > &haltingVehicles, std::map< std::string, SUMOTime > &intervalHaltingVehicles)
checks whether the vehicle stands in a jam
VehicleInfoMap myVehicleInfos
double accumulatedTimeLoss
Accumulated time loss that this vehicle suffered since it entered the detector.
bool hasEntered
Whether the vehicle has already entered the detector (don&#39;t count twice!)
double myStartPos
The position the detector starts at on the first lane.
virtual void detectorUpdate(const SUMOTime step)
Computes the detector values in each time step.
MSLane * getLastLane() const
Returns the id of the detector&#39;s last lane.
void subtractPassedVeh(int passed)
Subtract the number of vehicles indicated from passed from the sensor count.
Representation of a vehicle or person.
int getEstimatedCurrentVehicleNumber(double speedThreshold) const
Returns an estimate of the number of vehicles currently on the detector.
std::string type
vehicle&#39;s type
double getCurrentJamLengthInMeters() const
Returns the length of all jams in meters.
virtual void writeXMLOutput(OutputDevice &dev, SUMOTime startTime, SUMOTime stopTime)
Write the generated output to the given device.
DetectorUsage myUsage
Information about how this detector is used.
std::string entryLaneID
ID of the lane, on which the vehicle entered the detector.
double getCurrentMaxJamLengthInMeters() const
Returns the length in meters of the currently largest jam.
int getPassedVeh()
Returns the number of vehicles passed over the sensor (i.e. entered the sensor)
virtual void reset()
Resets all values.
void calculateTimeLossAndTimeOnDetector(const SUMOVehicle &veh, double oldPos, double newPos, const VehicleInfo &vi, double &timeOnDetector, double &timeLoss) const
Calculates the time spent on the detector in the last step and the timeloss suffered in the last step...
int getCurrentStartedHalts() const
Returns the length of all jams in meters.
std::map< std::string, SUMOTime > myHaltingVehicleDurations
Storage for halting durations of known vehicles (for halting vehicles)
virtual DetectorUsage getUsageType() const
Returns the detector&#39;s usage type.
int myMaxJamInVehicles
The max jam length [#veh].
int myNumberOfLeftVehicles
The number of vehicles, which have left the detector since the last reset.
double distToDetectorEnd
Distance left till the detector end after the last integration step (may become negative if the vehic...
virtual bool notifyEnter(SUMOTrafficObject &veh, MSMoveReminder::Notification reason, const MSLane *enteredLane)
Adds the vehicle to known vehicles if not beyond the dector.
double myOccupancySum
The sum of occupancies [%].
void integrateMoveNotification(VehicleInfo *vi, const MoveNotificationInfo *mni)
This updates the detector values and the VehicleInfo of a vehicle on the detector with the given Move...
Static storage of an output device and its base (abstract) implementation.
Definition: OutputDevice.h:64
double myCurrentJamLengthInMeters
The overall jam length in meters.
int myCurrentHaltingsNumber
The number of halted vehicles [#].
void buildJam(bool isInJam, std::vector< MoveNotificationInfo *>::const_iterator mni, JamInfo *&currentJam, std::vector< JamInfo *> &jams)
Either adds the vehicle to the end of an existing jam, or closes the last jam, and/or creates a new j...
static double calculateSegmentTimeLoss(double timespan, double initialSpeed, double accel, double vmax)
Calculates the time loss for a segment with constant vmax.
double timeLoss
timeloss during the last integration step
double myCurrentOccupancy
The current occupancy.
MoveNotificationInfo * makeMoveNotification(const SUMOVehicle &veh, double oldPos, double newPos, double newSpeed, const VehicleInfo &vehInfo) const
Creates and returns a MoveNotificationInfo containing detector specific information on the vehicle&#39;s ...
double speed
Speed after the last integration step.
std::set< std::string > myLeftVehicles
Keep track of vehicles that left the detector by a regular move along a junction (not lanechange...
double getCurrentMeanLength() const
Returns the mean vehicle length of vehicles currently on the detector.
Representation of a lane in the micro simulation.
Definition: MSLane.h:83
double getCurrentOccupancy() const
Returns the current detector occupancy.
int myNumberOfEnteredVehicles
Base of value-generating classes (detectors)
double getEstimateQueueLength() const
Returns an estimate of the lenght of the queue of vehicles currently stopped on the detector...
int getCurrentVehicleNumber() const
Returns the number of vehicles currently on the detector.
double length
vehicle&#39;s length