MSE2Collector.h

Go to the documentation of this file.

/****************************************************************************/
// An areal (along a single lane) detector
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright 2001-2010 DLR (http://www.dlr.de/) and contributors
/****************************************************************************/
//
//   This program 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 2 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 <microsim/MSMoveReminder.h>
#include <microsim/MSLane.h>
#include <microsim/output/MSDetectorFileOutput.h>
#include <utils/common/ToString.h>
#include <string>
#include <cassert>
#include <vector>
#include <limits>
#include <set>
#include <utils/iodevices/OutputDevice.h>
#include <utils/common/MsgHandler.h>
#include <utils/common/UtilExceptions.h>
#include <utils/common/Named.h>


// ===========================================================================
// class definitions
// ===========================================================================
class MSE2Collector : public Named, public MSMoveReminder, public MSDetectorFileOutput, public MSVehicleQuitReminded {
public:
    MSE2Collector(const std::string &id, DetectorUsage usage,
                  MSLane * const lane, SUMOReal startPos, SUMOReal detLength,
                  SUMOTime haltingTimeThreshold, SUMOReal haltingSpeedThreshold,
                  SUMOReal jamDistThreshold) throw();


    virtual ~MSE2Collector() throw();


    virtual DetectorUsage getUsageType() const throw() {
        return myUsage;
    }




    bool isStillActive(MSVehicle& veh, SUMOReal oldPos, SUMOReal newPos,
                       SUMOReal newSpeed) throw();


    void notifyLeave(MSVehicle& veh, bool isArrival, bool isLaneChange) throw();


    bool notifyEnter(MSVehicle& veh, bool isEmit, bool isLaneChange) throw();



    void update(SUMOTime currentTime) throw();




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


    void writeXMLDetectorProlog(OutputDevice &dev) const throw(IOError);




    void removeOnTripEnd(MSVehicle *veh) throw();


    SUMOReal getStartPos() const throw() {
        return myStartPos;
    }


    SUMOReal getEndPos() const throw() {
        return myEndPos;
    }


    void reset() throw();



    unsigned getCurrentVehicleNumber() const throw();

    SUMOReal getCurrentOccupancy() const throw();

    SUMOReal getCurrentMeanSpeed() const throw();

    SUMOReal getCurrentMeanLength() const throw();

    unsigned getCurrentJamNumber() const throw();

    unsigned getCurrentMaxJamLengthInVehicles() const throw();

    SUMOReal getCurrentMaxJamLengthInMeters() const throw();

    unsigned getCurrentJamLengthInVehicles() const throw();

    SUMOReal getCurrentJamLengthInMeters() const throw();

    unsigned getCurrentStartedHalts() const throw();


protected:
    struct JamInfo {
        std::list<MSVehicle*>::const_iterator firstStandingVehicle;

        std::list<MSVehicle*>::const_iterator lastStandingVehicle;
    };


    class by_vehicle_position_sorter {
    public:
        by_vehicle_position_sorter(const MSLane * const lane) throw()
                : myLane(lane) { }


        by_vehicle_position_sorter(const by_vehicle_position_sorter &s) throw()
                : myLane(s.myLane) { }


        int operator()(const MSVehicle *v1, const MSVehicle *v2) throw() {
            return v1->getPositionOnActiveMoveReminderLane(myLane)>v2->getPositionOnActiveMoveReminderLane(myLane);
        }

    private:
        const MSLane * const myLane;
    };


private:

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

    DetectorUsage myUsage;

    std::list<MSVehicle*> myKnownVehicles;

    std::map<MSVehicle*, SUMOReal> myHaltingVehicleDurations;

    std::map<MSVehicle*, SUMOReal> myIntervalHaltingVehicleDurations;

    std::vector<SUMOReal> myPastStandingDurations;

    std::vector<SUMOReal> myPastIntervalStandingDurations;



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



    SUMOReal myCurrentOccupancy;
    SUMOReal myCurrentMeanSpeed;
    SUMOReal myCurrentMeanLength;
    unsigned myCurrentJamNo;
    SUMOReal myCurrentMaxJamLengthInMeters;
    unsigned myCurrentMaxJamLengthInVehicles;
    SUMOReal myCurrentJamLengthInMeters;
    unsigned myCurrentJamLengthInVehicles;
    unsigned myCurrentStartedHalts;


private:
    MSE2Collector(const MSE2Collector&);

    MSE2Collector& operator=(const MSE2Collector&);


};


#endif

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