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 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 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 bool doAdd, const std::set<std::string>* const vTypes=0) throw();

        virtual ~MeanDataValues() throw();


        virtual void reset() throw() = 0;

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


        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 SUMOReal length,
                           const int numVehicles=-1) const throw(IOError) = 0;

        virtual SUMOReal getSamples() const throw();

    protected:
        SUMOReal sampleSeconds;
    public:
        SUMOReal travelledDistance;

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

    };


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

        virtual ~MeanDataValueTracker() throw();

        void reset() throw();

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


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

        bool isEmpty() const throw();

        void write(OutputDevice &dev, const SUMOTime period,
                   const SUMOReal numLanes, const SUMOReal length,
                   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;

            void reset() {
                myNumVehicleEntered = 0;
                myNumVehicleLeft = 0;
                myValues->reset();
            }
        };

        std::map<MSVehicle*, 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 trackVehicles,
               const SUMOReal minSamples, const SUMOReal maxTravelTime,
               const std::set<std::string> vTypes) throw();


    virtual ~MSMeanData() throw();

    void init(const std::vector<MSEdge*> &edges, const bool withInternal) throw();


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

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

    void update() throw();


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

    void resetOnly(SUMOTime stopTime) throw();

    virtual 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;

private:
    const std::string myID;

    const bool myAmEdgeBased;

    const SUMOTime myDumpBegin, myDumpEnd;

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

    std::vector<MSEdge*> myEdges;

    const bool myDumpEmpty;

    const bool myTrackVehicles;

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

private:
    MSMeanData(const MSMeanData&);

    MSMeanData& operator=(const MSMeanData&);

};


#endif

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