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-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 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) throw();

        virtual ~MeanDataValues() throw();


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

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


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


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


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


        bool vehicleApplies(const SUMOVehicle& veh) const throw();


        virtual bool isEmpty() const throw();


        virtual void update() throw();

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

        virtual SUMOReal getSamples() const throw();

    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) throw();

        virtual ~MeanDataValueTracker() throw();

        void reset(bool afterWrite) throw();

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


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


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


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

        bool isEmpty() const throw();

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

        size_t getNumReady() const throw();

        void clearFirst() throw();

        SUMOReal getSamples() const throw();

    private:
        class TrackerEntry {
        public:
            TrackerEntry(MeanDataValues* const values) throw()
                : 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) throw();


    virtual ~MSMeanData() throw();

    void init() throw();


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

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

    virtual void detectorUpdate(const SUMOTime step) throw();


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

    void resetOnly(SUMOTime stopTime) throw();

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

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

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

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