MSMeanData.h

Go to the documentation of this file.

/****************************************************************************/
// Data collector for edges/lanes
/****************************************************************************/
// SUMO, Simulation of Urban MObility; see http://sumo.sourceforge.net/
// Copyright (C) 2001-2012 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 MSMeanData_h
#define MSMeanData_h


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

#include <vector>
#include <set>
#include <list>
#include <cassert>
#include <limits>
#include <microsim/output/MSDetectorFileOutput.h>
#include <microsim/MSMoveReminder.h>
#include <utils/common/SUMOTime.h>


// ===========================================================================
// class declarations
// ===========================================================================
class OutputDevice;
class MSEdge;
class MSLane;
class SUMOVehicle;


// ===========================================================================
// class definitions
// ===========================================================================
class MSMeanData : public MSDetectorFileOutput {
public:
    class MeanDataValues : public MSMoveReminder {
    public:
        MeanDataValues(MSLane* const lane, const SUMOReal length, const bool doAdd, const std::set<std::string>* const vTypes = 0) ;

        virtual ~MeanDataValues() ;


        virtual void reset(bool afterWrite = false) = 0;

        virtual void addTo(MeanDataValues& val) const = 0;


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


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


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


        bool vehicleApplies(const SUMOVehicle& veh) const ;


        virtual bool isEmpty() const ;


        virtual void update() ;

        virtual void write(OutputDevice& dev, const SUMOTime period,
                           const SUMOReal numLanes,
                           const int numVehicles = -1) const = 0;

        virtual SUMOReal getSamples() const ;

    protected:
        const SUMOReal myLaneLength;

        SUMOReal sampleSeconds;
    public:
        SUMOReal travelledDistance;

    private:
        const std::set<std::string>* const myVehicleTypes;

    };


    class MeanDataValueTracker : public MeanDataValues {
    public:
        MeanDataValueTracker(MSLane* const lane, const SUMOReal length,
                             const std::set<std::string>* const vTypes = 0,
                             const MSMeanData* const parent = 0) ;

        virtual ~MeanDataValueTracker() ;

        void reset(bool afterWrite) ;

        void addTo(MSMeanData::MeanDataValues& val) const ;


        void notifyMoveInternal(SUMOVehicle& veh, SUMOReal timeOnLane, SUMOReal speed) ;


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


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

        bool isEmpty() const ;

        void write(OutputDevice& dev, const SUMOTime period,
                   const SUMOReal numLanes,
                   const int numVehicles = -1) const;

        size_t getNumReady() const ;

        void clearFirst() ;

        SUMOReal getSamples() const ;

    private:
        class TrackerEntry {
        public:
            TrackerEntry(MeanDataValues* const values)
                : myNumVehicleEntered(0), myNumVehicleLeft(0), myValues(values) {}

            int myNumVehicleEntered;

            int myNumVehicleLeft;

            MeanDataValues* myValues;
        };

        std::map<SUMOVehicle*, TrackerEntry*> myTrackedData;

        std::list<TrackerEntry*> myCurrentData;

        const MSMeanData* myParent;

    };


public:
    MSMeanData(const std::string& id,
               const SUMOTime dumpBegin, const SUMOTime dumpEnd,
               const bool useLanes, const bool withEmpty, const bool withInternal,
               const bool trackVehicles,
               const SUMOReal minSamples, const SUMOReal maxTravelTime,
               const std::set<std::string> vTypes) ;


    virtual ~MSMeanData() ;

    void init() ;


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

    void writeXMLDetectorProlog(OutputDevice& dev) const;

    virtual void detectorUpdate(const SUMOTime step) ;


protected:
    virtual MSMeanData::MeanDataValues* createValues(MSLane* const lane, const SUMOReal length, const bool doAdd) const = 0;

    void resetOnly(SUMOTime stopTime) ;

    void writeEdge(OutputDevice& dev, const std::vector<MeanDataValues*> &edgeValues,
                   MSEdge* edge, SUMOTime startTime, SUMOTime stopTime);

    bool writePrefix(OutputDevice& dev, const MeanDataValues& values,
                     const std::string prefix) const;

protected:
    const SUMOReal myMinSamples;

    const SUMOReal myMaxTravelTime;

    const std::set<std::string> myVehicleTypes;

    std::vector<std::vector<MeanDataValues*> > myMeasures;

private:
    const bool myAmEdgeBased;

    const SUMOTime myDumpBegin, myDumpEnd;

    std::vector<MSEdge*> myEdges;

    const bool myDumpEmpty;

    const bool myDumpInternal;

    const bool myTrackVehicles;

    std::list< std::pair<SUMOTime, SUMOTime> > myPendingIntervals;

private:
    MSMeanData(const MSMeanData&);

    MSMeanData& operator=(const MSMeanData&);

};


#endif

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