MESegment.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
/****************************************************************************/
// A single mesoscopic segment (cell)
/****************************************************************************/
#pragma once
#include <config.h>
 
#include <vector>
#include <cassert>
#include <utils/common/SUMOVehicleClass.h>
#include <utils/common/Named.h>
#include <utils/common/SUMOTime.h>
#include <microsim/MSMoveReminder.h>
 
 
// ===========================================================================
// class declarations
// ===========================================================================
class SUMOVehicle;
class MSEdge;
class MSLink;
class MSDetectorFileOutput;
class MSVehicleControl;
class MEVehicle;
class OutputDevice;
 
 
// ===========================================================================
// class definitions
// ===========================================================================
class MESegment : public Named {
public:
    static const double DO_NOT_PATCH_JAM_THRESHOLD;
    static const int PARKING_QUEUE = -1;
    static const std::string OVERRIDE_TLS_PENALTIES;
 
    struct MesoEdgeType {
        SUMOTime tauff;
        SUMOTime taufj;
        SUMOTime taujf;
        SUMOTime taujj;
        double jamThreshold;
        bool junctionControl;
        double tlsPenalty;
        double tlsFlowPenalty;
        SUMOTime minorPenalty;
        bool overtaking;
        double edgeLength;
        double lookahead;
    };
 
 
protected:
    class Queue {
    public:
        Queue(const SVCPermissions permissions) : myPermissions(permissions) {}
        inline int size() const {
            return (int)myVehicles.size();
        }
        inline const std::vector<MEVehicle*>& getVehicles() const {
            return myVehicles;
        }
        MEVehicle* remove(MEVehicle* v);
        inline std::vector<MEVehicle*>& getModifiableVehicles() {
            return myVehicles;
        }
        inline double getOccupancy() const {
            return myOccupancy;
        }
        inline void setOccupancy(const double occ) {
            myOccupancy = occ;
        }
        inline bool allows(SUMOVehicleClass vclass) const {
            return (myPermissions & vclass) == vclass;
        }
 
        inline SUMOTime getEntryBlockTime() const {
            return myEntryBlockTime;
        }
 
        inline void setEntryBlockTime(SUMOTime entryBlockTime) {
            myEntryBlockTime = entryBlockTime;
        }
 
        inline SUMOTime getBlockTime() const {
            return myBlockTime;
        }
        inline void setBlockTime(SUMOTime t) {
            myBlockTime = t;
        }
 
        inline void setPermissions(SVCPermissions p) {
            myPermissions = p;
        }
 
        void addDetector(MSMoveReminder* data);
 
        void addReminders(MEVehicle* veh) const;
 
    private:
        SVCPermissions myPermissions;
 
        std::vector<MEVehicle*> myVehicles;
 
        double myOccupancy = 0.;
 
        SUMOTime myEntryBlockTime = SUMOTime_MIN;
 
        SUMOTime myBlockTime = -1;
 
        std::vector<MSMoveReminder*> myDetectorData;
 
    };
 
public:
    MESegment(const std::string& id,
              const MSEdge& parent, MESegment* next,
              const double length, const double speed,
              const int idx,
              const bool multiQueue,
              const MesoEdgeType& edgeType);
 
    void initSegment(const MesoEdgeType& edgeType, const MSEdge& parent, const double capacity);
 
 
    void addDetector(MSMoveReminder* data, int queueIndex = -1);
 
    // void removeDetector(MSMoveReminder* data);
 
    void prepareDetectorForWriting(MSMoveReminder& data, int queueIndex = -1);
 
    SUMOTime hasSpaceFor(const MEVehicle* const veh, const SUMOTime entryTime, int& qIdx, const bool init = false) const;
 
    virtual void updateEntryBlockTime(SUMOTime /*time*/) {}
 
    virtual std::string getQueueExtraState(int /*qIdx*/) const {
        return "";
    }
    virtual void loadQueueExtraState(int /*qIdx*/, const std::string& /*state*/, SUMOTime /*offset*/) {}
 
    bool initialise(MEVehicle* veh, SUMOTime time);
 
    inline int getCarNumber() const {
        return myNumVehicles;
    }
 
    inline int numQueues() const {
        return (int)myQueues.size();
    }
    inline const std::vector<MEVehicle*>& getQueue(int index) const {
        assert(index < (int)myQueues.size());
        return myQueues[index].getVehicles();
    }
 
    inline SUMOTime getQueueBlockTime(int index) const {
        assert(index < (int)myQueues.size());
        return myQueues[index].getBlockTime();
    }
 
    inline int getIndex() const {
        return myIndex;
    }
 
    inline MESegment* getNextSegment() const {
        return myNextSegment;
    }
 
    inline double getLength() const {
        return myLength;
    }
 
    inline double getCapacity() const {
        return myCapacity;
    }
 
    inline double getBruttoOccupancy() const {
        double occ = 0.;
        for (const Queue& q : myQueues) {
            occ += q.getOccupancy();
        }
        return occ;
    }
 
    inline double getRelativeOccupancy() const {
        return getBruttoOccupancy() / myCapacity;
    }
 
    inline double getRelativeJamThreshold() const {
        return myJamThreshold / myCapacity;
    }
 
    double getMeanSpeed(bool useCache) const;
 
    void resetCachedSpeeds();
 
    inline double getMeanSpeed() const {
        return getMeanSpeed(true);
    }
 
 
    void writeVehicles(OutputDevice& of) const;
 
    MEVehicle* removeCar(MEVehicle* v, SUMOTime leaveTime, const MSMoveReminder::Notification reason);
 
    MSLink* getLink(const MEVehicle* veh, bool tlsPenalty = false) const;
 
    bool isOpen(const MEVehicle* veh) const;
 
    virtual void send(MEVehicle* veh, MESegment* const next, const int nextQIdx, SUMOTime time, const MSMoveReminder::Notification reason);
 
    void receive(MEVehicle* veh, const int qIdx, SUMOTime time, const bool isDepart = false, const bool isTeleport = false, const bool newEdge = false);
 
 
    bool vaporizeAnyCar(SUMOTime currentTime, const MSDetectorFileOutput* filter);
 
    inline const MSEdge& getEdge() const {
        return myEdge;
    }
 
 
    void setSpeed(double newSpeed, SUMOTime currentTime, double jamThresh = DO_NOT_PATCH_JAM_THRESHOLD, int qIdx = -1);
 
    SUMOTime getEventTime() const;
 
    inline double getEventTimeSeconds() const {
        return STEPS2TIME(getEventTime());
    }
 
    inline double getLastHeadwaySeconds() const {
        return STEPS2TIME(myLastHeadway);
    }
 
    inline SUMOTime getLastHeadway() const {
        return myLastHeadway;
    }
 
    void setLastHeadway(SUMOTime headway) {
        myLastHeadway = headway;
    }
 
    inline double getEntryBlockTimeSeconds() const {
        SUMOTime t = SUMOTime_MAX;
        for (const Queue& q : myQueues) {
            t = MIN2(t, q.getEntryBlockTime());
        }
        return STEPS2TIME(t);
    }
 
    double getWaitingSeconds() const;
 
 
    void saveState(OutputDevice& out) const;
 
    void clearState();
 
    void loadState(const std::vector<SUMOVehicle*>& vehs, const SUMOTime blockTime, const SUMOTime entryBlockTime, const int queIdx);
 
 
    std::vector<const MEVehicle*> getVehicles() const;
 
    double getFlow() const;
 
    static inline bool isInvalid(const MESegment* segment) {
        return segment == nullptr || segment == &myVaporizationTarget;
    }
 
    SUMOTime getNextInsertionTime(SUMOTime earliestEntry) const;
 
    inline int remainingVehicleCapacity(const double vehLength) const {
        int cap = 0;
        for (const Queue& q : myQueues) {
            if (q.getOccupancy() == 0. && myQueueCapacity < vehLength) {
                // even small segments can hold at least one vehicle
                cap += 1;
            } else {
                cap += (int)((myQueueCapacity - q.getOccupancy()) / vehLength);
            }
        }
        return cap;
    }
 
    inline SUMOTime getMinimumHeadwayTime() const {
        return myTau_ff;
    }
 
    void addReminders(MEVehicle* veh) const;
 
    SUMOTime getLinkPenalty(const MEVehicle* veh) const;
 
    void updatePermissions();
 
    void overrideTLSPenalty() {
        myTLSPenalty = false;
    }
 
    inline SUMOTime getMinTauWithVehLength(double lengthWithGap, double vehicleTau) const {
        return (SUMOTime)((double)myTau_ff * vehicleTau + lengthWithGap * myTau_length);
    }
 
    inline SUMOTime getTauWithVehLength(int qIdx, double lengthWithGap, double vehicleTau) const {
        assert(qIdx >= 0 && qIdx < (int)myQueues.size());
        const SUMOTime tau = myQueues[qIdx].getOccupancy() < myJamThreshold ? myTau_ff : myTau_jf;
        return tauWithVehLength(tau, lengthWithGap, vehicleTau);
    }
 
protected:
    bool overtake();
 
    void setSpeedForQueue(double newSpeed, SUMOTime currentTime,
                          SUMOTime blockTime, const std::vector<MEVehicle*>& vehs);
 
    SUMOTime newArrival(const MEVehicle* const v, double newSpeed, SUMOTime currentTime);
 
    bool hasBlockedLeader() const;
 
    void recomputeJamThreshold(double jamThresh);
 
    double jamThresholdForSpeed(double speed, double jamThresh) const;
 
    bool limitedControlOverride(const MSLink* link) const;
 
    inline SUMOTime tauWithVehLength(SUMOTime tau, double lengthWithGap, double vehicleTau) const {
        return (SUMOTime)((double)tau * vehicleTau + lengthWithGap * myTau_length);
    }
 
    SUMOTime getTauJJ(double nextQueueSize, double nextQueueCapacity, double nextJamThreshold) const;
 
    virtual SUMOTime computeHeadway(Queue& q, const Queue& qNext, const MESegment* const next, const MEVehicle* veh) const;
 
    virtual bool hasSpaceForInsertion(const Queue& q, int qIdx, double newOccupancy, SUMOTime entryTime) const;
 
    typedef std::map<std::pair<const MSEdge*, std::vector<int> >, std::vector<std::pair<double, int> > > SearchedMap;
 
    void addDownstreamFollowers(const MSEdge& edge, const std::vector<int>& reach, const double dist, const double lookahead, const int depth, SearchedMap& searched);
 
protected:
    const MSEdge& myEdge;
 
    MESegment* myNextSegment;
 
    const double myLength;
 
    const int myIndex;
 
 
    SUMOTime myTau_ff, myTau_fj, myTau_jf, myTau_jj;
 
    bool myTLSPenalty;
 
    bool myCheckMinorPenalty; // for legacy compatibility (#7802, 7804)
    SUMOTime myMinorPenalty;
 
    bool myJunctionControl;
 
    bool myOvertaking;
 
    double myTau_length;
 
    double myCapacity = 0.;
 
    double myQueueCapacity = 0.;
 
    double myJamThreshold;
 
    std::vector<Queue> myQueues;
 
    int myNumVehicles;
 
    std::map<const MSEdge*, int> myFollowerMap;
 
    int myLookahead = 1;
 
    SUMOTime myLastHeadway;
 
    /* @brief segment for signifying vaporization. This segment has invalid
     * data and should only be used as a unique pointer */
    static MSEdge myDummyParent;
    static MESegment myVaporizationTarget;
 
    static SVCPermissions myMultiModalWarnings;
 
    mutable double myMeanSpeed;
 
    mutable SUMOTime myLastMeanSpeedUpdate;
 
private:
    MESegment(const MESegment&);
 
    MESegment& operator=(const MESegment&);
 
    MESegment(const std::string& id);
};