MSMeanData.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2024 German Aerospace Center (DLR) and others.
// This program and the accompanying materials are made available under the
// terms of the Eclipse Public License 2.0 which is available at
// https://www.eclipse.org/legal/epl-2.0/
// This Source Code may also be made available under the following Secondary
// Licenses when the conditions for such availability set forth in the Eclipse
// Public License 2.0 are satisfied: GNU General Public License, version 2
// or later which is available at
// https://www.gnu.org/licenses/old-licenses/gpl-2.0-standalone.html
// SPDX-License-Identifier: EPL-2.0 OR GPL-2.0-or-later
/****************************************************************************/
// Data collector for edges/lanes
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <set>
#include <list>
#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 SUMOTrafficObject;
 
typedef std::vector<MSEdge*> MSEdgeVector;
 
// ===========================================================================
// class definitions
// ===========================================================================
class MSMeanData : public MSDetectorFileOutput {
public:
    class MeanDataValues : public MSMoveReminder {
    public:
        MeanDataValues(MSLane* const lane, const double length, const bool doAdd, const MSMeanData* const parent);
 
        virtual ~MeanDataValues();
 
 
        virtual void reset(bool afterWrite = false) = 0;
 
        virtual void addTo(MeanDataValues& val) const = 0;
 
 
        virtual bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
 
 
        bool notifyMove(SUMOTrafficObject& veh, double oldPos,
                        double newPos, double newSpeed);
 
 
        virtual bool notifyLeave(SUMOTrafficObject& veh, double lastPos,
                                 MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
 
 
        virtual bool isEmpty() const;
 
 
        virtual void update();
 
        virtual void write(OutputDevice& dev, long long int attributeMask, const SUMOTime period,
                           const int numLanes, const double speedLimit, const double defaultTravelTime,
                           const int numVehicles = -1) const = 0;
 
        virtual double getSamples() const;
 
        double getTravelledDistance() const {
            return travelledDistance;
        }
 
        SUMOTime getResetTime() const {
            return resetTime;
        }
 
        double getLaneLength() const {
            return myLaneLength;
        }
 
        virtual double getAttributeValue(SumoXMLAttr a, const SUMOTime period, const double numLanes, const double speedLimit) const {
            UNUSED_PARAMETER(a);
            UNUSED_PARAMETER(period);
            UNUSED_PARAMETER(numLanes);
            UNUSED_PARAMETER(speedLimit);
            return 0;
        }
 
    protected:
        const MSMeanData* const myParent;
 
        const double myLaneLength;
 
        double sampleSeconds;
 
        double travelledDistance;
 
        SUMOTime resetTime;
    };
 
 
    class MeanDataValueTracker : public MeanDataValues {
    public:
        MeanDataValueTracker(MSLane* const lane, const double length,
                             const MSMeanData* const parent);
 
        virtual ~MeanDataValueTracker();
 
        void reset(bool afterWrite);
 
        void addTo(MSMeanData::MeanDataValues& val) const;
 
 
        void notifyMoveInternal(const SUMOTrafficObject& veh, const double frontOnLane, const double timeOnLane, const double meanSpeedFrontOnLane, const double meanSpeedVehicleOnLane, const double travelledDistanceFrontOnLane, const double travelledDistanceVehicleOnLane, const double meanLengthOnLane);
 
 
        bool notifyLeave(SUMOTrafficObject& veh, double lastPos, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
 
 
        bool notifyEnter(SUMOTrafficObject& veh, MSMoveReminder::Notification reason, const MSLane* enteredLane = 0);
 
        bool isEmpty() const;
 
        void write(OutputDevice& dev, long long int attributeMask, const SUMOTime period,
                   const int numLanes, const double speedLimit, const double defaultTravelTime,
                   const int numVehicles = -1) const;
 
        int getNumReady() const;
 
        void clearFirst();
 
        double getSamples() const;
 
    private:
        class TrackerEntry {
        public:
            TrackerEntry(MeanDataValues* const values)
                : myNumVehicleEntered(0), myNumVehicleLeft(0), myValues(values) {}
 
            virtual ~TrackerEntry() {
                delete myValues;
            }
 
            int myNumVehicleEntered;
 
            int myNumVehicleLeft;
 
            MeanDataValues* myValues;
        };
 
        std::map<const SUMOTrafficObject*, TrackerEntry*> myTrackedData;
 
        std::list<TrackerEntry*> myCurrentData;
 
    };
 
 
public:
    MSMeanData(const std::string& id,
               const SUMOTime dumpBegin, const SUMOTime dumpEnd,
               const bool useLanes, const bool withEmpty,
               const bool printDefaults, const bool withInternal,
               const bool trackVehicles, const int detectPersons,
               const double minSamples,
               const double maxTravelTime,
               const std::string& vTypes,
               const std::string& writeAttributes,
               const std::vector<MSEdge*>& edges,
               bool aggregate);
 
 
    virtual ~MSMeanData();
 
    void init();
 
 
    void writeXMLOutput(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime);
 
    virtual void writeXMLDetectorProlog(OutputDevice& dev) const;
 
    virtual void detectorUpdate(const SUMOTime step);
 
    double getMinSamples() const {
        return myMinSamples;
    }
 
    double getMaxTravelTime() const {
        return myMaxTravelTime;
    }
 
    bool isEdgeData() const {
        return myAmEdgeBased;
    }
 
    virtual std::vector<std::string> getAttributeNames() const {
        return std::vector<std::string>();
    }
 
    virtual double getAttributeValue(const MSLane* lane, SumoXMLAttr a, double defaultValue) const {
        UNUSED_PARAMETER(lane);
        UNUSED_PARAMETER(a);
        return defaultValue;
    }
 
protected:
    virtual MSMeanData::MeanDataValues* createValues(MSLane* const lane, const double length, const bool doAdd) const = 0;
 
    void resetOnly(SUMOTime stopTime);
 
    virtual std::string getEdgeID(const MSEdge* const edge);
 
    void writeEdge(OutputDevice& dev, const std::vector<MeanDataValues*>& edgeValues,
                   const MSEdge* const edge, SUMOTime startTime, SUMOTime stopTime);
 
 
    void writeAggregated(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime);
 
    virtual void openInterval(OutputDevice& dev, const SUMOTime startTime, const SUMOTime stopTime);
 
    virtual bool writePrefix(OutputDevice& dev, const MeanDataValues& values,
                             const SumoXMLTag tag, const std::string id) const;
 
 
protected:
    const std::vector<MeanDataValues*>* getEdgeValues(const MSEdge* edge) const;
 
protected:
    const double myMinSamples;
 
    const double myMaxTravelTime;
 
    std::vector<std::vector<MeanDataValues*> > myMeasures;
 
    const bool myDumpEmpty;
 
    const bool myAmEdgeBased;
 
private:
    static long long int initWrittenAttributes(const std::string writeAttributes, const std::string& id);
 
    const SUMOTime myDumpBegin, myDumpEnd;
 
    SUMOTime myInitTime;
 
    MSEdgeVector myEdges;
 
    std::map<const MSEdge*, int> myEdgeIndex;
 
    const bool myPrintDefaults;
 
    const bool myDumpInternal;
 
    const bool myTrackVehicles;
 
    const long long int myWrittenAttributes;
 
    const bool myAggregate;
 
    std::list< std::pair<SUMOTime, SUMOTime> > myPendingIntervals;
 
private:
    MSMeanData(const MSMeanData&);
 
    MSMeanData& operator=(const MSMeanData&);
 
};