MSE2Collector.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2025 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// An areal detector covering to a sequence of consecutive lanes
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <list>
#include <microsim/MSLane.h>
#include <microsim/MSNet.h>
#include <microsim/MSMoveReminder.h>
#include <microsim/output/MSDetectorFileOutput.h>
#include <utils/common/UtilExceptions.h>
#include <cassert>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
class SUMOVehicle;
class SUMOTrafficObject;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSE2Collector : public MSMoveReminder, public MSDetectorFileOutput {
public:
    struct VehicleInfo {
        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) :
            id(id),
            type(type),
            length(length),
            minGap(minGap),
            entryLaneID(entryLane->getID()),
            entryOffset(entryOffset),
            currentLane(entryLane),
            currentOffsetIndex(currentOffsetIndex),
            exitOffset(exitOffset),
            distToDetectorEnd(distToDetectorEnd),
            totalTimeOnDetector(0.),
            accumulatedTimeLoss(0.),
            onDetector(onDetector),
            hasEntered(false),
            lastAccel(0),
            lastSpeed(0),
            lastPos(0) {
            assert(exitOffset < 0);
        }
        virtual ~VehicleInfo() {};
        std::string id;
        std::string type;
        double length;
        double minGap;
        std::string entryLaneID;
        double entryOffset;
        const MSLane* currentLane;
        std::size_t currentOffsetIndex;
        double exitOffset;
        double distToDetectorEnd;
        double totalTimeOnDetector;
        double accumulatedTimeLoss;
 
        bool onDetector;
        bool hasEntered;
        double lastAccel;
        double lastSpeed;
        double lastPos;
    };
 
    typedef std::map<std::string, VehicleInfo*> VehicleInfoMap;
 
 
private:
    struct MoveNotificationInfo {
        MoveNotificationInfo(std::string _vehID, double _oldPos, double _newPos, double _speed, double _accel, double _distToDetectorEnd, double _timeOnDetector, double _lengthOnDetector, double _timeLoss, double _waitingTime, bool _onDetector) :
            id(_vehID),
            oldPos(_oldPos),
            newPos(_newPos),
            speed(_speed),
            accel(_accel),
            distToDetectorEnd(_distToDetectorEnd),
            timeOnDetector(_timeOnDetector),
            lengthOnDetector(_lengthOnDetector),
            timeLoss(_timeLoss),
            waitingTime(_waitingTime),
            onDetector(_onDetector) {}
 
        virtual ~MoveNotificationInfo() {};
 
        std::string id;
        double oldPos;
        double newPos;
        double speed;
        double accel;
        double distToDetectorEnd;
        double timeOnDetector;
        double lengthOnDetector;
        double timeLoss;
        double waitingTime;
        bool onDetector;
    };
 
 
 
    struct JamInfo {
        std::vector<MoveNotificationInfo*>::const_iterator firstStandingVehicle;
 
        std::vector<MoveNotificationInfo*>::const_iterator lastStandingVehicle;
    };
 
 
public:
 
    MSE2Collector(const std::string& id,
                  DetectorUsage usage, MSLane* lane, double startPos, double endPos, double length,
                  SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
                  const std::string name, const std::string& vTypes,
                  const std::string& nextEdges,
                  int detectPersons);
 
 
    MSE2Collector(const std::string& id,
                  DetectorUsage usage, std::vector<MSLane*> lanes, double startPos, double endPos,
                  SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
                  const std::string name, const std::string& vTypes,
                  const std::string& nextEdges,
                  int detectPersons);
 
 
    virtual ~MSE2Collector();
 
    virtual DetectorUsage getUsageType() const {
        return myUsage;
    }
 
 
 
 
    virtual bool notifyMove(SUMOTrafficObject& veh, double oldPos, double newPos,
                            double newSpeed);
 
 
    virtual bool notifyLeave(SUMOTrafficObject& veh, double lastPos, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
 
 
    virtual bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane);
 
 
 
 
 
 
    virtual void detectorUpdate(const SUMOTime step);
 
 
    virtual void writeXMLOutput(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime);
 
 
    virtual void writeXMLDetectorProlog(OutputDevice& dev) const;
 
 
    const std::string& getName() {
        return myName;
    }
 
    double getStartPos() const {
        return myStartPos;
    }
 
 
    double getEndPos() const {
        return myEndPos;
    }
 
    double getLength() const {
        return myDetectorLength;
    }
 
 
    MSLane* getLastLane() const {
        return myLastLane;
    }
 
 
    std::vector<MSLane*> getLanes();
 
    virtual void reset();
 
 
 
    int getCurrentVehicleNumber() const;
 
    double getCurrentOccupancy() const {
        return myCurrentOccupancy;
    }
 
    double getCurrentMeanSpeed() const {
        return myCurrentMeanSpeed;
    }
 
    double getCurrentMeanLength() const {
        return myCurrentMeanLength;
    }
 
    int getCurrentJamNumber() const {
        return myCurrentJamNo;
    }
 
    int getCurrentMaxJamLengthInVehicles() const {
        return myCurrentMaxJamLengthInVehicles;
    }
 
    double getCurrentMaxJamLengthInMeters() const {
        return myCurrentMaxJamLengthInMeters;
    }
 
    int getCurrentJamLengthInVehicles() const {
        return myCurrentJamLengthInVehicles;
    }
 
    double getCurrentJamLengthInMeters() const {
        return myCurrentJamLengthInMeters;
    }
 
    double getCurrentJamDuration() const {
        return myCurrentJamDuration;
    }
 
    int getCurrentStartedHalts() const {
        return myCurrentStartedHalts;
    }
 
    int getCurrentHaltingNumber() const {
        return myCurrentHaltingsNumber;
    }
 
    std::vector<std::string> getCurrentVehicleIDs() const;
 
    std::vector<VehicleInfo*> getCurrentVehicles() const;
 
    int getPassedVeh() {
        return myNumberOfEnteredVehicles;
    }
 
    void subtractPassedVeh(int passed) {
        myNumberOfEnteredVehicles -= passed;
    }
 
 
 
 
    double getIntervalOccupancy() const {
        return myTimeSamples != 0 ? myOccupancySum / (double) myTimeSamples : 0;
    }
    double getIntervalMeanSpeed() const {
        return myVehicleSamples != 0 ? mySpeedSum / myVehicleSamples : -1;
    }
    double getIntervalMeanTimeLoss() const {
        return myNumberOfSeenVehicles != 0 ? myTotalTimeLoss / myNumberOfSeenVehicles : -1;
    }
    double getIntervalMaxJamLengthInMeters() const {
        return myMaxJamInMeters;
    }
    int getIntervalVehicleNumber() const {
        return myNumberOfSeenVehicles;
    }
 
    double getLastIntervalOccupancy() const {
        return myPreviousMeanOccupancy;
    }
    double getLastIntervalMeanSpeed() const {
        return myPreviousMeanSpeed;
    }
    double getLastIntervalMeanTimeLoss() const {
        return myPreviousMeanTimeLoss;
    }
    double getLastIntervalMaxJamLengthInMeters() const {
        return myPreviousMaxJamLengthInMeters;
    }
    int getLastIntervalVehicleNumber() const {
        return myPreviousNumberOfSeenVehicles;
    }
 
 
 
 
    int getEstimatedCurrentVehicleNumber(double speedThreshold) const;
 
    double getEstimateQueueLength() const;
 
 
    virtual void setVisible(bool /*show*/) {};
 
    virtual void clearState(SUMOTime step);
 
    void overrideVehicleNumber(int num);
 
    double getOverrideVehNumber() const {
        return myOverrideVehNumber;
    }
private:
 
    bool checkJam(std::vector<MoveNotificationInfo*>::const_iterator mni, std::map<std::string, SUMOTime>& haltingVehicles, std::map<std::string, SUMOTime>& intervalHaltingVehicles);
 
 
    void buildJam(bool isInJam, std::vector<MoveNotificationInfo*>::const_iterator mni, JamInfo*& currentJam, std::vector<JamInfo*>& jams);
 
 
    void processJams(std::vector<JamInfo*>& jams, JamInfo* currentJam);
 
    void calculateTimeLossAndTimeOnDetector(const SUMOTrafficObject& veh, double oldPos, double newPos, const VehicleInfo& vi, double& timeOnDetector, double& timeLoss) const;
 
    void initAuxiliaries(std::vector<MSLane*>& lanes);
 
    void checkPositioning(bool posGiven = false, double desiredLength = 0.);
 
    static double snap(double value, double snapPoint, double snapDist);
 
    void recalculateDetectorLength();
 
 
 
    std::vector<MSLane*> selectLanes(MSLane* endLane, double length, std::string dir);
 
 
    void addDetectorToLanes(std::vector<MSLane*>& lanes);
 
 
    void aggregateOutputValues();
 
 
    void integrateMoveNotification(VehicleInfo* vi, const MoveNotificationInfo* mni);
 
    MoveNotificationInfo* makeMoveNotification(const SUMOTrafficObject& veh, double oldPos, double newPos, double newSpeed, const VehicleInfo& vehInfo) const;
 
    VehicleInfo* makeVehicleInfo(const SUMOTrafficObject& veh, const MSLane* enteredLane) const;
 
    static double calculateSegmentTimeLoss(double timespan, double initialSpeed, double accel, double vmax);
 
    static bool compareMoveNotification(MoveNotificationInfo* mni1, MoveNotificationInfo* mni2) {
        return mni1->distToDetectorEnd < mni2->distToDetectorEnd;
    }
 
    void notifyMovePerson(MSTransportable* p, int dir, double pos);
 
private:
 
    DetectorUsage myUsage;
 
    const std::string myName;
    std::vector<std::string> myLanes;
    std::vector<double> myOffsets;
    MSLane* myFirstLane;
    MSLane* myLastLane;
    double myStartPos;
    double myEndPos;
    double myDetectorLength;
 
    double myJamHaltingSpeedThreshold;
    SUMOTime myJamHaltingTimeThreshold;
    double myJamDistanceThreshold;
 
 
    VehicleInfoMap myVehicleInfos;
 
    std::vector<MoveNotificationInfo*> myMoveNotifications;
 
    std::set<std::string> myLeftVehicles;
 
    std::map<std::string, SUMOTime> myHaltingVehicleDurations;
 
    std::map<std::string, SUMOTime> myIntervalHaltingVehicleDurations;
 
    std::vector<SUMOTime> myPastStandingDurations;
 
    std::vector<SUMOTime> myPastIntervalStandingDurations;
 
 
 
    double myVehicleSamples;
    double myTotalTimeLoss;
    double mySpeedSum;
    double myStartedHalts;
    double myJamLengthInMetersSum;
    int myJamLengthInVehiclesSum;
    int myTimeSamples;
    double myOccupancySum;
    double myMaxOccupancy;
    int myMeanMaxJamInVehicles;
    double myMeanMaxJamInMeters;
    int myMaxJamInVehicles;
    double myMaxJamInMeters;
    int myMeanVehicleNumber;
 
 
    int myNumberOfEnteredVehicles;
    int myNumberOfSeenVehicles;
    int myNumberOfLeftVehicles;
    int myMaxVehicleNumber;
 
    double myCurrentVehicleSamples;
    double myCurrentOccupancy;
    double myCurrentMeanSpeed;
    double myCurrentMeanTimeLoss;
    double myCurrentMeanLength;
    int myCurrentJamNo;
    double myCurrentMaxJamLengthInMeters;
    int myCurrentMaxJamLengthInVehicles;
    double myCurrentJamLengthInMeters;
    int myCurrentJamLengthInVehicles;
    double myCurrentJamDuration;
    int myCurrentStartedHalts;
    int myCurrentHaltingsNumber;
 
    double myPreviousMeanOccupancy;
    double myPreviousMeanSpeed;
    double myPreviousMeanTimeLoss;
    double myPreviousMaxJamLengthInMeters;
    int myPreviousNumberOfSeenVehicles;
 
    int myOverrideVehNumber;
 
private:
    MSE2Collector(const MSE2Collector&);
 
    MSE2Collector& operator=(const MSE2Collector&);
};