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 (C) 2001-2011 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 <vector>
#include <list>
#include <microsim/MSLane.h>
#include <microsim/MSMoveReminder.h>
#include <microsim/output/MSDetectorFileOutput.h>
#include <utils/common/UtilExceptions.h>
#include <utils/common/SUMOVehicle.h>


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


// ===========================================================================
// class definitions
// ===========================================================================
class MSE2Collector : public MSMoveReminder, public MSDetectorFileOutput {
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 notifyMove(SUMOVehicle& veh, SUMOReal oldPos, SUMOReal newPos,
                    SUMOReal newSpeed) throw();


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


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



    void detectorUpdate(const SUMOTime step) throw();




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


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


    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<SUMOVehicle*>::const_iterator firstStandingVehicle;

        std::list<SUMOVehicle*>::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 SUMOVehicle* v1, const SUMOVehicle* v2) throw() {
            const MSVehicle* const occ = myLane->getPartialOccupator();
            if (v1 == occ) {
                return true;
            }
            if (v2 == occ) {
                return false;
            }
            return v1->getPositionOnLane() > v2->getPositionOnLane();
        }

    private:
        by_vehicle_position_sorter& operator=(const by_vehicle_position_sorter&); // just to avoid a compiler warning
    private:
        const MSLane* const myLane;
    };


private:

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

    DetectorUsage myUsage;

    std::list<SUMOVehicle*> myKnownVehicles;

    std::map<SUMOVehicle*, SUMOTime> myHaltingVehicleDurations;

    std::map<SUMOVehicle*, SUMOTime> myIntervalHaltingVehicleDurations;

    std::vector<SUMOTime> myPastStandingDurations;

    std::vector<SUMOTime> 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

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