MSE2Collector.h

Go to the documentation of this file.

/****************************************************************************/
// An areal (along a single lane) detector
/****************************************************************************/
// 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>

//Debug
//#define SWARM_DEBUG
#include <utils/common/SwarmDebug.h>

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


// ===========================================================================
// class definitions
// ===========================================================================
class MSE2Collector : public MSMoveReminder, public MSDetectorFileOutput {
public:
    struct VehicleInfo {
        VehicleInfo(std::string _id, std::string _type, SUMOReal _speed, SUMOReal _timeOnDet,
                    SUMOReal _lengthOnDet, SUMOReal _position, SUMOReal _lengthWithGap,
                    SUMOReal _accel, SUMOReal vmax, bool _stillOnDet) :
            id(_id),
            type(_type),
            speed(_speed),
            timeOnDet(_timeOnDet),
            lengthOnDet(_lengthOnDet),
            position(_position),
            lengthWithGap(_lengthWithGap),
            accel(_accel),
            timeLoss(vmax > 0 ? timeOnDet * (vmax - speed) / vmax : 0),
            accumulatedTimeLoss(timeLoss),
            stillOnDet(_stillOnDet) {}
        std::string id;
        std::string type;
        SUMOReal speed;
        SUMOReal timeOnDet;
        SUMOReal lengthOnDet;
        SUMOReal position;
        SUMOReal lengthWithGap;
        SUMOReal accel;
        SUMOReal timeLoss;
        SUMOReal accumulatedTimeLoss;
        bool stillOnDet;
    };


    MSE2Collector(const std::string& id, DetectorUsage usage,
                  MSLane* const lane, SUMOReal startPos, SUMOReal detLength,
                  SUMOTime haltingTimeThreshold, SUMOReal haltingSpeedThreshold,
                  SUMOReal jamDistThreshold,
                  const std::string& vTypes);

    MSE2Collector(const std::string& id, DetectorUsage usage,
                  MSLane* const lane, SUMOReal startPos, SUMOReal detLength,
                  SUMOTime haltingTimeThreshold, SUMOReal haltingSpeedThreshold,
                  SUMOReal jamDistThreshold,
                  const std::set<std::string>& vTypes);


    virtual ~MSE2Collector();


    virtual DetectorUsage getUsageType() const {
        return myUsage;
    }




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


    bool notifyLeave(SUMOVehicle& veh, SUMOReal lastPos, MSMoveReminder::Notification reason);


    bool notifyEnter(SUMOVehicle& veh, MSMoveReminder::Notification reason);



    void detectorUpdate(const SUMOTime step);




    void writeXMLOutput(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime);


    void writeXMLDetectorProlog(OutputDevice& dev) const;


    SUMOReal getStartPos() const {
        return myStartPos;
    }


    SUMOReal getEndPos() const {
        return myEndPos;
    }


    void reset();

    int getEstimatedCurrentVehicleNumber(SUMOReal speedThreshold) const;

    SUMOReal getEstimateQueueLength() const;


    int getCurrentVehicleNumber() const;

    SUMOReal getCurrentOccupancy() const;

    SUMOReal getCurrentMeanSpeed() const;

    SUMOReal getCurrentMeanLength() const;

    int getCurrentJamNumber() const;

    int getCurrentMaxJamLengthInVehicles() const;

    SUMOReal getCurrentMaxJamLengthInMeters() const;

    int getCurrentJamLengthInVehicles() const;

    SUMOReal getCurrentJamLengthInMeters() const;

    int getCurrentStartedHalts() const;

    int getCurrentHaltingNumber() const;

    std::vector<std::string> getCurrentVehicleIDs() const;
    const std::vector<VehicleInfo>& getCurrentVehicles() const;

    int getPassedVeh() {
        return myPassedVeh;
    }

    void subtractPassedVeh(int passed) {
        myPassedVeh -= passed;
    }

private:
    struct JamInfo {
        std::vector<VehicleInfo>::const_iterator firstStandingVehicle;

        std::vector<VehicleInfo>::const_iterator lastStandingVehicle;
    };



    SUMOReal myJamHaltingSpeedThreshold;
    SUMOTime myJamHaltingTimeThreshold;
    SUMOReal myJamDistanceThreshold;
    SUMOReal myStartPos;
    SUMOReal myEndPos;

    DetectorUsage myUsage;

    std::vector<VehicleInfo> myKnownVehicles;

    std::vector<VehicleInfo> myPreviousKnownVehicles;

    std::map<std::string, SUMOTime> myHaltingVehicleDurations;

    std::map<std::string, SUMOTime> myIntervalHaltingVehicleDurations;

    std::vector<SUMOTime> myPastStandingDurations;

    std::vector<SUMOTime> myPastIntervalStandingDurations;



    SUMOReal mySpeedSum;
    SUMOReal myStartedHalts;
    SUMOReal myJamLengthInMetersSum;
    int myJamLengthInVehiclesSum;
    SUMOReal myVehicleSamples;
    SUMOReal myTimeLossSum;
    int myTimeSamples;
    SUMOReal myOccupancySum;
    SUMOReal myMaxOccupancy;
    int myMeanMaxJamInVehicles;
    SUMOReal myMeanMaxJamInMeters;
    int myMaxJamInVehicles;
    SUMOReal myMaxJamInMeters;
    int myMeanVehicleNumber;
    int myMaxVehicleNumber;



    SUMOReal myCurrentOccupancy;
    SUMOReal myCurrentMeanSpeed;
    SUMOReal myCurrentMeanLength;
    int myCurrentJamNo;
    SUMOReal myCurrentMaxJamLengthInMeters;
    int myCurrentMaxJamLengthInVehicles;
    SUMOReal myCurrentJamLengthInMeters;
    int myCurrentJamLengthInVehicles;
    int myCurrentStartedHalts;
    int myCurrentHaltingsNumber;
    int myPassedVeh;


private:
    MSE2Collector(const MSE2Collector&);

    MSE2Collector& operator=(const MSE2Collector&);


};


#endif

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