MSMeanData.h

Go to the documentation of this file.

/****************************************************************************/
// Eclipse SUMO, Simulation of Urban MObility; see https://eclipse.dev/sumo
// Copyright (C) 2001-2026 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, const SumoXMLAttrMask& 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;
        }
 
        MeanDataValues* getSubData() {
            return mySubData;
        }
 
        void setSubData(MeanDataValues* subData) {
            mySubData = subData;
        }
 
    protected:
        const MSMeanData* const myParent;
 
        const double myLaneLength;
 
        double sampleSeconds;
 
        double travelledDistance;
 
        SUMOTime resetTime;
 
        MeanDataValues* mySubData = nullptr;
    };
 
 
    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, const SumoXMLAttrMask& 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*, std::shared_ptr<TrackerEntry> > myTrackedData;
 
        std::list<std::shared_ptr<TrackerEntry> > myCurrentData;
 
    };
 
 
public:
    MSMeanData(const std::string& id,
               const SUMOTime dumpBegin, const SUMOTime dumpEnd,
               const bool useLanes, const std::string& excludeEmpty, 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,
               AggregateType 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 = 0;
 
    double getAttributeValue(const MSLane* lane, SumoXMLAttr a, double defaultValue) const;
 
    const std::vector<MSMoveReminder*> getReminders() const;
 
    void setSubData(MSMeanData* subData) {
        mySubData = subData;
    }
 
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);
 
    void writeAggregatedTAZ(OutputDevice& dev, SUMOTime startTime, SUMOTime stopTime);
 
    virtual void openInterval(OutputDevice& dev, const SUMOTime startTime, const SUMOTime stopTime);
 
    virtual void writePrefix(OutputDevice& dev, const MeanDataValues& values,
                             const SumoXMLTag tag, const std::string id) const;
 
    const std::vector<MeanDataValues*>* getEdgeValues(const MSEdge* edge) const;
 
private:
    MSMeanData::MeanDataValues* createValuesSubData(MSLane* const lane, const double length, const bool doAdd) const;
 
protected:
    const double myMinSamples;
 
    const double myMaxTravelTime;
 
    std::vector<std::vector<MeanDataValues*> > myMeasures;
 
    bool myDumpEmpty = true;
 
    const bool myAmEdgeBased;
 
private:
    const SUMOTime myDumpBegin, myDumpEnd;
 
    SUMOTime myInitTime;
 
    MSEdgeVector myEdges;
 
    ConstMSEdgeVector myTAZ;
 
    std::map<const MSEdge*, int> myEdgeIndex;
 
    bool myPrintDefaults = false;
 
    bool myPrintModified = false;
 
    const bool myDumpInternal;
 
    const bool myTrackVehicles;
 
    const SumoXMLAttrMask myWrittenAttributes;
 
    const AggregateType myAggregate;
 
    MSMeanData* mySubData = nullptr;
 
    std::list< std::pair<SUMOTime, SUMOTime> > myPendingIntervals;
 
private:
    MSMeanData(const MSMeanData&);
 
    MSMeanData& operator=(const MSMeanData&);
 
};