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-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 /****************************************************************************/
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>
40 #include <cassert>
41 
42 // ===========================================================================
43 // class declarations
44 // ===========================================================================
45 class OutputDevice;
46 
47 
48 // ===========================================================================
49 // class definitions
50 // ===========================================================================
81 public:
86  struct VehicleInfo {
89  VehicleInfo(std::string id, std::string type, double length, double minGap, const MSLane* entryLane, double entryOffset,
90  std::size_t currentOffsetIndex, double exitOffset, double distToDetectorEnd, bool onDetector) :
91  id(id),
92  type(type),
93  length(length),
94  minGap(minGap),
95  entryLaneID(entryLane->getID()),
96  entryOffset(entryOffset),
97  currentLane(entryLane),
98  currentOffsetIndex(currentOffsetIndex),
99  exitOffset(exitOffset),
100  distToDetectorEnd(distToDetectorEnd),
103  onDetector(onDetector),
104  hasEntered(false),
105  lastAccel(0),
106  lastSpeed(0),
107  lastPos(0) {
108  assert(exitOffset < 0);
109  }
110  virtual ~VehicleInfo() {};
112  std::string id;
114  std::string type;
116  double length;
118  double minGap;
120  std::string entryLaneID;
124  double entryOffset;
128  std::size_t currentOffsetIndex;
131  double exitOffset;
138 
144  double lastAccel;
146  double lastSpeed;
149  double lastPos;
150  };
151 
152  typedef std::map<std::string, VehicleInfo*> VehicleInfoMap;
153 
154 
155 private:
161  MoveNotificationInfo(std::string _vehID, double _oldPos, double _newPos, double _speed, double _accel, double _distToDetectorEnd, double _timeOnDetector, double _lengthOnDetector, double _timeLoss, bool _onDetector) :
162  id(_vehID),
163  oldPos(_oldPos),
164  newPos(_newPos),
165  speed(_speed),
166  accel(_accel),
167  distToDetectorEnd(_distToDetectorEnd),
168  timeOnDetector(_timeOnDetector),
169  lengthOnDetector(_lengthOnDetector),
170  timeLoss(_timeLoss),
171  onDetector(_onDetector) {}
172 
173  virtual ~MoveNotificationInfo() {};
174 
176  std::string id;
178  double oldPos;
180  double newPos;
182  double speed;
184  double accel;
192  double timeLoss;
195  };
196 
197 
198 
204  struct JamInfo {
206  std::vector<MoveNotificationInfo*>::const_iterator firstStandingVehicle;
207 
209  std::vector<MoveNotificationInfo*>::const_iterator lastStandingVehicle;
210  };
211 
212 
213 public:
214 
233  MSE2Collector(const std::string& id,
234  DetectorUsage usage, MSLane* lane, double startPos, double endPos, double length,
235  SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
236  const std::string& vTypes);
237 
238 
251  MSE2Collector(const std::string& id,
252  DetectorUsage usage, std::vector<MSLane*> lanes, double startPos, double endPos,
253  SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
254  const std::string& vTypes);
255 
256 
258  virtual ~MSE2Collector();
259 
265  virtual DetectorUsage getUsageType() const {
266  return myUsage;
267  }
268 
269 
270 
273 
291  virtual bool notifyMove(SUMOVehicle& veh, double oldPos, double newPos,
292  double newSpeed);
293 
294 
306  virtual bool notifyLeave(SUMOVehicle& veh, double lastPos, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
307 
308 
321  virtual bool notifyEnter(SUMOVehicle& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane);
323 
324 
325 
326 
327 
330 
339  virtual void detectorUpdate(const SUMOTime step);
340 
341 
348  virtual void writeXMLOutput(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime);
349 
350 
359  virtual void writeXMLDetectorProlog(OutputDevice& dev) const;
360 
362 
363 
368  double getStartPos() const {
369  return myStartPos;
370  }
371 
372 
377  double getEndPos() const {
378  return myEndPos;
379  }
380 
385  double getLength() const {
386  return myDetectorLength;
387  }
388 
389 
394  MSLane* getLastLane() const {
395  return myLastLane;
396  }
397 
398 
401  std::vector<MSLane*> getLanes();
402 
409  virtual void reset();
410 
411 
414 
416  int getCurrentVehicleNumber() const;
417 
419  double getCurrentOccupancy() const {
420  return myCurrentOccupancy;
421  }
422 
424  double getCurrentMeanSpeed() const {
425  return myCurrentMeanSpeed;
426  }
427 
429  double getCurrentMeanLength() const {
430  return myCurrentMeanLength;
431  }
432 
434  int getCurrentJamNumber() const {
435  return myCurrentJamNo;
436  }
437 
441  }
442 
446  }
447 
451  }
452 
456  }
457 
460  return myCurrentStartedHalts;
461  }
462 
471  }
472 
477  std::vector<std::string> getCurrentVehicleIDs() const;
478 
481  std::vector<VehicleInfo*> getCurrentVehicles() const;
482 
487  int getPassedVeh() {
489  }
490 
495  void subtractPassedVeh(int passed) {
496  myNumberOfEnteredVehicles -= passed;
497  }
498 
500 
501 
502 
503 
504 
508 
509  int getEstimatedCurrentVehicleNumber(double speedThreshold) const;
510 
512  double getEstimateQueueLength() const;
514 
515 
516 
517 private:
518 
526  bool checkJam(std::vector<MoveNotificationInfo*>::const_iterator mni, std::map<std::string, SUMOTime>& haltingVehicles, std::map<std::string, SUMOTime>& intervalHaltingVehicles);
527 
528 
536  void buildJam(bool isInJam, std::vector<MoveNotificationInfo*>::const_iterator mni, JamInfo*& currentJam, std::vector<JamInfo*>& jams);
537 
538 
543  void processJams(std::vector<JamInfo*>& jams, JamInfo* currentJam);
544 
554  void calculateTimeLossAndTimeOnDetector(const SUMOVehicle& veh, double oldPos, double newPos, const VehicleInfo& vi, double& timeOnDetector, double& timeLoss) const;
555 
560  void initAuxiliaries(std::vector<MSLane*>& lanes);
561 
564  void checkPositioning(bool posGiven = false, double desiredLength = 0.);
565 
568  static double snap(double value, double snapPoint, double snapDist);
569 
573 
574 
575 
586  std::vector<MSLane*> selectLanes(MSLane* endLane, double length, std::string dir);
587 
588 
591  void addDetectorToLanes(std::vector<MSLane*>& lanes);
592 
593 
596  void aggregateOutputValues();
597 
598 
606 
616  MoveNotificationInfo* makeMoveNotification(const SUMOVehicle& veh, double oldPos, double newPos, double newSpeed, const VehicleInfo& vehInfo) const;
617 
624  VehicleInfo* makeVehicleInfo(const SUMOVehicle& veh, const MSLane* enteredLane) const;
625 
634  static double calculateSegmentTimeLoss(double timespan, double initialSpeed, double accel, double vmax);
635 
639  return mni1->distToDetectorEnd < mni2->distToDetectorEnd;
640  }
641 
642 
643 private:
644 
647 
651  std::vector<std::string> myLanes;
653  std::vector<double> myOffsets;
659  double myStartPos;
661  double myEndPos;
664 
672 
673 
677  VehicleInfoMap myVehicleInfos;
678 
681  std::vector<MoveNotificationInfo*> myMoveNotifications;
682 
686  std::set<std::string> myLeftVehicles;
687 
689  std::map<std::string, SUMOTime> myHaltingVehicleDurations;
690 
692  std::map<std::string, SUMOTime> myIntervalHaltingVehicleDurations;
693 
695  std::vector<SUMOTime> myPastStandingDurations;
696 
698  std::vector<SUMOTime> myPastIntervalStandingDurations;
700 
701 
702 
710  double mySpeedSum;
734 
735 
746 
768 
769 
770 private:
773 
776 };
777 
778 
779 #endif
780 
781 /****************************************************************************/
782 
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:36
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.
An areal detector corresponding to a sequence of consecutive lanes.
Definition: MSE2Collector.h:80
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].
virtual bool notifyEnter(SUMOVehicle &veh, MSMoveReminder::Notification reason, const MSLane *enteredLane)
Adds the vehicle to known vehicles if not beyond the dector.
const std::string & getID() const
Returns the id.
Definition: Named.h:78
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.
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:86
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:89
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:60
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...
virtual bool notifyLeave(SUMOVehicle &veh, double lastPos, MSMoveReminder::Notification reason, const MSLane *enteredLane=0)
Removes a known vehicle due to its lane-change.
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.
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...
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
virtual bool notifyMove(SUMOVehicle &veh, double oldPos, double newPos, double newSpeed)
Adds/removes vehicles from the list of vehicles to regard.
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:78
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