MSE2Collector.h

Go to the documentation of this file.

/****************************************************************************/
// An areal detector covering to a sequence of consecutive lanes
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.dlr.de/
// Copyright (C) 2001-2017 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This file is part of SUMO.
//   SUMO is free software: you can redistribute it and/or modify
//   it under the terms of the GNU General Public License as published by
//   the Free Software Foundation, either version 3 of the License, or
//   (at your option) any later version.
//
/****************************************************************************/
#ifndef MSE2Collector_h
#define MSE2Collector_h


// ===========================================================================
// included modules
// ===========================================================================
#ifdef _MSC_VER
#include <windows_config.h>
#else
#include <config.h>
#endif

#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 <utils/vehicle/SUMOVehicle.h>
#include <cassert>

// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;


// ===========================================================================
// 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, bool _onDetector) :
            id(_vehID),
            oldPos(_oldPos),
            newPos(_newPos),
            speed(_speed),
            accel(_accel),
            distToDetectorEnd(_distToDetectorEnd),
            timeOnDetector(_timeOnDetector),
            lengthOnDetector(_lengthOnDetector),
            timeLoss(_timeLoss),
            onDetector(_onDetector) {}

        virtual ~MoveNotificationInfo() {};

        std::string id;
        double oldPos;
        double newPos;
        double speed;
        double accel;
        double distToDetectorEnd;
        double timeOnDetector;
        double lengthOnDetector;
        double timeLoss;
        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& vTypes);


    MSE2Collector(const std::string& id,
                  DetectorUsage usage, std::vector<MSLane*> lanes, double startPos, double endPos,
                  SUMOTime haltingTimeThreshold, double haltingSpeedThreshold, double jamDistThreshold,
                  const std::string& vTypes);


    virtual ~MSE2Collector();

    virtual DetectorUsage getUsageType() const {
        return myUsage;
    }




    virtual bool notifyMove(SUMOVehicle& veh, double oldPos, double newPos,
                            double newSpeed);


    virtual bool notifyLeave(SUMOVehicle& veh, double lastPos, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);


    virtual bool notifyEnter(SUMOVehicle& 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;



    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;
    }

    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;
    }







    int getEstimatedCurrentVehicleNumber(double speedThreshold) const;

    double getEstimateQueueLength() const;



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 SUMOVehicle& 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 SUMOVehicle& veh, double oldPos, double newPos, double newSpeed, const VehicleInfo& vehInfo) const;

    VehicleInfo* makeVehicleInfo(const SUMOVehicle& 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;
    }


private:

    DetectorUsage myUsage;

    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 myCurrentOccupancy;
    double myCurrentMeanSpeed;
    double myCurrentMeanLength;
    int myCurrentJamNo;
    double myCurrentMaxJamLengthInMeters;
    int myCurrentMaxJamLengthInVehicles;
    double myCurrentJamLengthInMeters;
    int myCurrentJamLengthInVehicles;
    int myCurrentStartedHalts;
    int myCurrentHaltingsNumber;


private:
    MSE2Collector(const MSE2Collector&);

    MSE2Collector& operator=(const MSE2Collector&);
};


#endif

/****************************************************************************/